Disabling tab pages on a Tab Control

Sometimes there can be a requirement, which we have to prevent users from accessing certain tab pages on a tab control. But there’s no straight forward method provided on the Visual Studio IDE (2005,2008 or 2010). But we can do that easily.

Add a tab control to your windows application. (tabControl1)

Add few tabs and few controls to each tab.

Now we’ll disable one tab using the following code on the form’s load event:

tabControl1.TabPages[2].Enabled = false;

** Please note : Though it does not list the ‘Enabled’ property on intellisense, it’s available.

Now if you run the application you can see, that all the controls in tab page 3 are dissabled.

But if we want to prevent from users accessing that tab, we can use this coding on tab controls selecting event (Not the page, but the control’s)

private void tabControl1_Selecting(object sender, TabControlCancelEventArgs e)
{
    if (!e.TabPage.Enabled)
    {
        e.Cancel = true;
    }
}

Now if you run the application and try to select that tab page, you will not be able to do so..

Show an image saved in a SQL Table on an ASP.Net Image Control

In a previous entry I have shown, how to store images to a database table. Now I will show you how to retrieve it and show it on a ASP.Net Image control. There is no straight forward method showing it like “ImageControl.Image = ImageStream….” How ever it can be achieved using a Generic Handler.

Add a ‘Generic Handler’ to your ASP.Net web application. And in this example I will name it as ‘getImageFromDB.ashx’. By default IHttpHandler will be implemented. (ProcessRequest and IsReusable methods will be implemented). And I will add another method called ‘GetImage’ and alter the ‘ProcessRequest’ method. And the finished handler should similar to this:

   1: using System;

   2: using System.Drawing;

   3: using System.Drawing.Imaging;

   4: using System.IO;

   5: using System.Web;

   6: using System.Data;

   7: using System.Data.SqlClient;

   8:  

   9: namespace MyWebApplication

  10: {

  11:    

  12:     public class getImageFromDB : IHttpHandler

  13:     {

  14:         public void ProcessRequest(HttpContext context)

  15:         {

  16:             context.Response.Clear();

  17:  

  18:             if (!String.IsNullOrEmpty(context.Request.QueryString["empID"]))

  19:             {

  20:                 int id = Int32.Parse(context.Request.QueryString["empID"]);

  21:  

  22:                 Image image = GetImage(id);

  23:  

  24:                 context.Response.ContentType = "image/jpeg";

  25:                 image.Save(context.Response.OutputStream, ImageFormat.Jpeg);

  26:             }

  27:             else

  28:             {

  29:                 context.Response.ContentType = "text/html";

  30:                 context.Response.Write("<p>Need a valid id</p>");

  31:             }

  32:         }

  33:  

  34:         public bool IsReusable

  35:         {

  36:             get

  37:             {

  38:                 return false;

  39:             }

  40:         }

  41:  

  42:         private Image GetImage(int empID)

  43:         {

  44:  

  45:             MemoryStream memoryStream = new MemoryStream();

  46:             //Retrieve image from Database to a memeory stream. If you are using a different method, use it and assign the data to the 'memoryStream' variable.

  47:  

  48:             string connectionString = "Password=PWD;Persist Security Info=True;User ID=USER;Initial Catalog=SampleDatabase;Data Source=SQLSERVER";

  49:             using (SqlConnection sqlConnection = new SqlConnection(connectionString))

  50:             {

  51:                 using (SqlCommand sqlCommand = new SqlCommand("SELECT emp_id, emp_name, emp_image FROM Employee where emp_id = " + empID.ToString(), sqlConnection))

  52:                 {

  53:                     sqlConnection.Open();

  54:                     SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();

  55:  

  56:                     if (sqlDataReader.HasRows)

  57:                     {

  58:                         sqlDataReader.Read();

  59:                         byte[] btImage = (byte[])sqlDataReader["emp_image"];

  60:  

  61:                         memoryStream = new MemoryStream(btImage, false);

  62:                     }

  63:                 }

  64:                 sqlConnection.Close();

  65:             }

  66:             return Image.FromStream(memoryStream);

  67:         }

  68:     }

  69: }

And you can call the handler and display the image, using the following syntax :

   1: private void GetImageFromDatabase(int empID)

   2: {

   3:     imageControl.ImageUrl = "getImageFromDB.ashx?empID=" + empID.ToString();

   4: }

Saving an image to a SQL Database Table

Sometimes it’s not the best of method, to store images in to the database, since it’ll take lot of database space. But there are times, that it’s the only option on your list.
To this sample I will be using the following SQL Table.

   1: CREATE TABLE [dbo].[Employee](

   2:     [emp_id] [int] NOT NULL,

   3:     [emp_name] [varchar](50) NOT NULL,

   4:     [emp_image] [image] NULL

   5: ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]

When inserting data use the following syntax:

   1: string fileName = @"D:\MyImage.jpg";

   2: string connectionString = "Password=PWD;Persist Security Info=True;User ID=USER;Initial Catalog=DATABASE;Data Source=SQLSERVER";

   3: using (SqlConnection sqlConnection = new SqlConnection(connectionString))

   4: {

   5:  

   6:     FileInfo finfo = new FileInfo(fileName);

   7:  

   8:     byte[] btImage = new byte[finfo.Length];

   9:     FileStream fStream = finfo.OpenRead();

  10:  

  11:     fStream.Read(btImage, 0, btImage.Length);

  12:     fStream.Close();

  13:  

  14:  

  15:     using (SqlCommand sqlCommand = new SqlCommand("INSERT INTO Employee (emp_id, emp_name, emp_image) VALUES(@emp_id, @emp_name, @emp_image)", sqlConnection))

  16:     {

  17:  

  18:         sqlCommand.Parameters.AddWithValue("@emp_id", 2);

  19:         sqlCommand.Parameters.AddWithValue("@emp_name", "Employee Name");

  20:         SqlParameter imageParameter = new SqlParameter("@emp_image", SqlDbType.Image);

  21:         imageParameter.Value = btImage;

  22:  

  23:         sqlCommand.Parameters.Add(imageParameter);

  24:  

  25:  

  26:         sqlConnection.Open();

  27:         sqlCommand.ExecuteNonQuery();

  28:         sqlConnection.Close();

  29:     }

  30:  

  31: }

Changing App.config contents at runtime

Sometimes it is required to change the contents of ‘App.config’ file. Assume if we are allowing user to override things like taxrates, which we keep on the ‘App.config’.
On the App.config, we have a key ‘TaxRate’ which has the value ‘15’.

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:     <appSettings>

   4:         <add key="TaxRate" value="15"/>

   5:     </appSettings>

   6: </configuration>

And we have to change it to ‘20’. We can use the following syntax:

   1: Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);

   2: AppSettingsSection appSection = config.AppSettings;

   3:  

   4: appSection.Settings["TaxRate"].Value = "20";

   5: config.Save(ConfigurationSaveMode.Modified,false);

   6:  

   7: ConfigurationManager.RefreshSection("appSettings");

   8: string zVal = ConfigurationManager.AppSettings["TaxRate"];

**Please note : The changes are temporary, when running on debug mode. But will be permanent when run using the built application (Executable)

Using FileSystemWatcher to monitor multiple directories

In a previous example I have showed how to use ‘FileSystemWatcher’ class to monitor a directory. But there are times that we need to monitor multiple directories and if any changes are available, invoke a given method.

We can do that by using this method. First create a class. We’ll call this class ‘Watcher’

   1: public class Watcher

   2:     {

   3:  

   4:         public string Directory { get; set; }

   5:         public string  Filter { get; set; }

   6:  

   7:  

   8:         private Delegate _changeMethod;

   9:  

  10:         public Delegate ChangeMethod

  11:         {

  12:             get { return _changeMethod; }

  13:             set { _changeMethod = value; }

  14:         }

  15:         

  16:         FileSystemWatcher fileSystemWatcher = new FileSystemWatcher();

  17:  

  18:         public Watcher(string directory, string filter, Delegate invokeMethod)

  19:         {

  20:             this._changeMethod = invokeMethod;

  21:             this.Directory = directory;

  22:             this.Filter = Filter;

  23:         }

  24:  

  25:  

  26:         public void StartWatch()

  27:         {

  28:             

  29:             

  30:             fileSystemWatcher.Filter = this.Filter;

  31:             fileSystemWatcher.Path = this.Directory;

  32:             fileSystemWatcher.EnableRaisingEvents = true;

  33:  

  34:             fileSystemWatcher.Changed += new FileSystemEventHandler(fileSystemWatcher_Changed);

  35:         }

  36:  

  37:         void fileSystemWatcher_Changed(object sender, FileSystemEventArgs e)

  38:         {

  39:             if (_changeMethod != null)

  40:             {

  41:                 _changeMethod.DynamicInvoke(sender, e);

  42:             }

  43:         }

  44:     }

And we can use it to monitor multiple directories as shown below (for this example I have used a console application and I am only considering the change event):

   1: class Program

   2:     {

   3:         delegate void invokeMethodDelegate(object sender, FileSystemEventArgs e);

   4:  

   5:         static void Main(string[] args)

   6:         {

   7:             

   8:             invokeMethodDelegate mymethod = new invokeMethodDelegate(InvokeMethod);

   9:             Watcher w1 = new Watcher(@"C:\Directory1", "*.*", mymethod);

  10:             w1.StartWatch();

  11:  

  12:             Watcher w2 = new Watcher(@"D:\Directory2", "*.*", mymethod);

  13:             w2.StartWatch();

  14:  

  15:             string zRetVal = Console.ReadLine();

  16:  

  17:            

  18:         }

  19:  

  20:         static  void InvokeMethod(object sender, FileSystemEventArgs e)

  21:         {

  22:             Console.WriteLine("Change in file {0}", e.FullPath);

  23:         }

  24:     }