Most often when reading the selected item of a bound combobox you will need more information than just the selected text or the selected index of the combo. For example, if you have a combobox bound to a user table in your database, you will most probably want to have the full user name displayed in the combobox, but when a user is selected you will want to work with the user code or user id. In this case the combo’s selected index is of no use and neither is the display text. You need a way to be able to retrieve the user code when a user is selected.

Fortunately, this is quite easy to accomplish. All we need to do is bind our combobox to a list of KeyValuePair objects. In this article I am going to show you how to do exactly that.

To start off create a form which looks similar to the below one:

Now in the Form_Load event handler we must add the following code:

private void MainForm_Load(object sender, EventArgs e)
{
    // Create a List to store our KeyValuePairs
    List<KeyValuePair<string, string>> data = new List<KeyValuePair<string, string>>();

    // Add data to the List
    data.Add(new KeyValuePair<string, string>("p1", "Joe"));
    data.Add(new KeyValuePair<string, string>("p2", "David"));
    data.Add(new KeyValuePair<string, string>("p3", "Keith"));
    data.Add(new KeyValuePair<string, string>("p4", "Andrew"));
    data.Add(new KeyValuePair<string, string>("p5", "Maria"));
    
    // Clear the combobox
    cboData.DataSource = null;
    cboData.Items.Clear();

    // Bind the combobox
    cboData.DataSource = new BindingSource(data, null);
    cboData.DisplayMember = "Value";
    cboData.ValueMember = "Key";
}

In the first line of code we are creating a List object to store our KeyValuePair objects. The KeyValuePair class can be very useful since it allows you to create a pair of objects of any type, one of which is the key and the other is the value. What this means is that you can have an object of type string paired with a key of type integer for example. Or you could have a value of type MyClass with a key of type string. The combinations are limitless.

As you can see in the code, we are creating a KeyValuePair where both the key and the value are strings. We are then adding data to the List object by creating KeyValuePair instances and adding them to our List. Next we are clearing the combobox as a precaution (just in case it was populated with something already), and finally we are binding the combobox to the List.

The last two lines of the above code are critical for your binding to work correctly. We must tell the combo which is the DisplayMember and which is the ValueMember of our KeyValuePair so that it will know which object from the pair to display and which to use as the key.

Once you have created the above code run your project and you will see that the combobox is populated with the above names. The key value however cannot be seen, so let’s create some code to visually see the selected key.

Subscribe to the SelectedIndexChanged event of your combobox and add the following code:

private void cboData_SelectedIndexChanged(object sender, EventArgs e)
{
    // Get the selected item in the combobox
    KeyValuePair<string, string> selectedPair = (KeyValuePair<string, string>)cboData.SelectedItem;
    
    // Show selected information on screen
    lblSelectedKey.Text = selectedPair.Key;
    lblSelectedValue.Text = selectedPair.Value;
}

What we are doing here is retrieving the combo’s selected item and converting it to a KeyValuePair object. Then from our KeyValuePair object we are accessing the Key and the Value properties and assigning them to the labels on our form.

Now if you run the application again you should have something like the following, and as you can see the key and value are being displayed in our labels.

Now using this technique you can easily bind a combobox and have one value displayed while another value is used as your key.

I hope you found this useful.
Dave.

What is an escape sequence? Well, put simply, an escape sequence is a series of special characters which are interpreted by the compiler as a command. In other words, they suspend the normal processing to perform some special function.

In C#, escape sequences are represented by a ‘\’ (backslash) followed by a letter or a combination of digits.

The following table represents the most common escape sequences used in C#.

Examples

1. In the below code we are escaping the backslash in the path string.

   string path = "C:\\Program Files\\Microsoft";

   The result would look like this: C:\Program Files\Microsoft

2. In the below code we are adding a carriage return and a new line by using the \r\n escape sequences together.

   MessageBox.Show("Hello from...\r\nhttp://www.daveoncsharp.com", 
                   "Escape Sequences", 
                   MessageBoxButtons.OK, 
                   MessageBoxIcon.Information);

   The result will be a message box with the message string split on two lines as shown below.

   

I hope you found this useful. Feel free to visit this blog often for more similar articles.

Dave.

In this article I am going to show you how to programmatically retrieve data from a MySQL database using the MySqlDataAdapter and the MySqlDataReader classes. Both these classes are available once you install the MySQL Connector for .NET which can be downloaded from here: MySQL Connectors.

For this example we need a database with some test data. MySQL has an sql script which creates a set of tables with world country information. I will be using these tables for this example so I suggest you download this script and run it on your MySQL database. Once done, you will have added the following three tables to your database.

Connecting to a MySQL Database

To retrieve data from a MySQL database you must obviously connect to the database first. If you do not know how to do this check out my article called Connecting to a MySQL Database Programmatically.

Retrieving Data Using MySqlDataAdapter

In the below code we are retrieving all the data in the country table and populating a DataTable using the MySqlDataAdapter. Then we are binding the DataTable instance to a DataGridView on the form.

private void btnPopulateGrid_Click(object sender, EventArgs e)
{
    MySqlConnection conn = null;
    MySqlCommand cmd = null;
    DataTable dataTable = new DataTable();

    try
    {
        string sql = "SELECT * FROM country ORDER BY name ASC";

        conn = new MySqlConnection(Properties.Settings.Default.ConnectionString);

        cmd = new MySqlCommand(sql, conn);

        conn.Open();

        using (MySqlDataAdapter da = new MySqlDataAdapter(cmd))
        {
            da.Fill(dataTable);
        }

        dataGridView.DataSource = dataTable;
        dataGridView.DataMember = dataTable.TableName;
    }
    catch (Exception ex)
    {
        MessageBox.Show(string.Format("An error occurred {0}", ex.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    finally
    {
        if (conn != null) conn.Close();
    }
}

When the code is run, it will populate the DataGridView as shown below.

Retrieving Data Using MySqlDataReader

With the MySqlDataReader we have a little more work to do than we did with the MySqlDataAdapter, but there is also an advantage to using it, which is speed. The DataReader retrieves data faster than the DataAdapter because it is a read-only, forward-only stream of data. So if you just want to read data from the database and display it somewhere in your application, I would suggest you go with the DataReader. It is true that you have to code more to use it but it is worth the extra effort.

The below code is selecting specific data for the country Malta using the DataReader.

private void btnPopulateLabels_Click(object sender, EventArgs e)
{
    MySqlConnection conn = null;
    MySqlCommand cmd = null;
    MySqlDataReader reader = null;

    try
    {
        string sql = "SELECT name, continent, region, surfacearea FROM country WHERE code = 'MLT'";

        conn = new MySqlConnection(Properties.Settings.Default.ConnectionString);
        cmd = new MySqlCommand(sql, conn);

        conn.Open();

        reader = cmd.ExecuteReader();

        while (reader.Read())
        {
            lblCountryCode.Text = "MLT";
            lblName.Text = reader.GetString("name");
            lblContinent.Text = reader.GetString("continent");
            lblRegion.Text = reader.GetString("region");
            lblSurfaceArea.Text = string.Format("{0:0.00}", reader.GetFloat("surfacearea"));
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show(string.Format("An error occurred {0}", ex.Message), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    finally
    {
        if (reader != null) reader.Close();
        if (conn != null) conn.Close();
    }
}

The most significant part of this code is the while loop. This code will keep iterating until the DataReader finishes reading the data stream. It retrieves records one by one so within each iteration you have access to the fields you selected.

If your sql query returned no records, the Read() method of the DataReader will return false, therefore the code within the while loop will not execute.

When the above code is run, it will populate the form below:

I hope you found this article useful. Stay tuned for more soon.

Dave

Microsoft Visual Studio lets you create a database connection using its IDE, and it’s quite powerful as well, but personally I prefer to create my database connections programmatically. When creating my connection’s code manually I find it easier to follow the code, plus it can be easier to debug as well. I am by no means saying that this is the best way to connect to a database – it’s just my personal preference.

In this article I will show you how to connect to a MySQL database programmatically through C#.

Why MySQL?

I personally like working with MySQL because it’s freely available under the GPL License. I have also been working with MySQL from version 4 (and that’s around 6 years now) so by now I am quite used to it. If you would like to install MySQL you can find it here: MySQL Community Server

The Connection String

Every database has its own specific connection string, and since there are so many different databases out there, it’s impossible to remember each connection string by heart. That is why I use ConnectionStrings.com to refresh my memory. It’s a great resource with connection strings for probably every type of database you can think of.

For this example we will be using the standard connection string which assumes MySQL is accessible on the default port of 3306. You can check out other MySQL connection strings here: Connection strings for MySQL

SERVER=myServerAddress; DATABASE=myDataBase; UID=myUsername; PWD=myPassword;

So, if MySQL was installed locally, and we had a database called testdb, and a MySQL database user called testuser with password testpass, the connection string would look like this:

SERVER=localhost; DATABASE=testdb; UID=testuser; PWD=testpass;

The Connection Code

To connect to MySQL we need to download and install the MySQL Connector for .NET which can be found here: MySQL Connectors. This is basically the MySQL standardized database driver for .NET platforms.

Once installed you will have access to the MySQL classes from .NET, but to use them you must first reference them. So from within your project navigate to the Add Reference window and select the MySql.Data .NET component. This will add it to you project and now you should be able to access the MySql.Data.MySqlClient namespace, which we will be using to connect to the database.

The actual code used to connect to the database is very simple. As long as we have access to the MySqlConnection class which is in the MySql.Data.MySqlClient namespace, we should be able to connect as shown in the below code:

string connStr = "SERVER=localhost;" +
                 "DATABASE=testdb;" +
                 "UID=testuser;" +
                 "PWD=testpass;";

MySqlConnection conn = new MySqlConnection(connStr);

conn.Open();

// Read/Write to and from your database here

conn.Close();

Since the connection string is an application setting and usually only changes per installation of your application, I would recommend placing the connection string in the Settings.settings file. If you do not know what this file is you can check out my article on Using the Settings file in C#.

If you were to place your connection string there you would then be able to access it from anywhere throughout your code by calling Properties.Settings.Default.ConnectionString.

Below is how your database connection code looks now:

MySqlConnection conn = new MySqlConnection(Properties.Settings.Default.ConnectionString);

conn.Open();

// Read/Write to and from your database here

conn.Close();

I hope you found this article useful. Stay tuned because I will soon be talking about how to retrieve data from MySQL.

Dave

I have added a new page to this blog called ASCII Codes, which can be accessed from the navigation bar at the top of the page. This new page is intended as a reference guide which you can use to look up an ascii code’s decimal, hexadecimal, and html values. There is also a description of each code and obviously the symbol represented by each ascii code.

Please feel free to use this page for what it is intended to be – your ascii reference guide.

Dave

What are system events? Well, basically they are events raised by the operating system when a user performs an action which affects the operating environment.

System events are accessible through the Microsoft.Win32.SystemEvents class.

SystemEvents Events

Below is a list of all the system events found within the SystemEvents class.

Note: Some of these system events may not be raised on Windows Vista.

Example Application

As an example let’s create a simple Windows Forms Application and place two buttons and a textbox on the main form. The buttons are going to subscribe and unsubscribe from the system events and the textbox is going to display the captured event details.

In our application we are going to listen for the following four system events: InstalledFontsChanged, DisplaySettingsChanged, TimeChanged, and UserPreferenceChanged. The code for this is shown below:

private bool eventHandlersCreated;

private void btnStartListening_Click(object sender, EventArgs e)
{
    this.StartListening();
}

private void btnStopListening_Click(object sender, EventArgs e)
{
    this.StopListening();
}

private void StartListening()
{
    Microsoft.Win32.SystemEvents.InstalledFontsChanged += new EventHandler(FontHandler);
    Microsoft.Win32.SystemEvents.DisplaySettingsChanged += new EventHandler(ScreenHandler);
    Microsoft.Win32.SystemEvents.TimeChanged += new EventHandler(TimeHandler);
    Microsoft.Win32.SystemEvents.UserPreferenceChanged += new Microsoft.Win32.UserPreferenceChangedEventHandler(PreferenceChangedHandler);

    this.eventHandlersCreated = true;
}

private void StopListening()
{
    Microsoft.Win32.SystemEvents.InstalledFontsChanged -= new EventHandler(FontHandler);
    Microsoft.Win32.SystemEvents.DisplaySettingsChanged -= new EventHandler(ScreenHandler);
    Microsoft.Win32.SystemEvents.TimeChanged -= new EventHandler(TimeHandler);
    Microsoft.Win32.SystemEvents.UserPreferenceChanged -= new Microsoft.Win32.UserPreferenceChangedEventHandler(PreferenceChangedHandler);

    this.eventHandlersCreated = false;
}

As you can see in the StartListening and StopListening methods we are subscribing and unsibscribing to the system events. Each event handler delegate is calling a particular method, and these methods are shown below:

private void FontHandler(object sender, EventArgs e)
{
    txtStatus.Text += string.Format("Installed fonts changed. {0}", Environment.NewLine);
}

private void PreferenceChangedHandler(object sender, Microsoft.Win32.UserPreferenceChangedEventArgs e)
{
    txtStatus.Text += string.Format("You changed a setting: {0} {1}", e.Category.ToString(), Environment.NewLine);
}

private void ScreenHandler(object sender, EventArgs e)
{
    txtStatus.Text += string.Format("Screen resolution changed. {0}", Environment.NewLine);
}

private void TimeHandler(object sender, EventArgs e)
{
    txtStatus.Text += string.Format("System time changed. {0}", Environment.NewLine);
}

If you were to run this application and then go and change the screen resolution for example, the DisplaySettingsChanged event will fire and its delegate will call our ScreenHandler method, and you will see the text Screen resolution changed in the textbox.

Below is a screenshot of our application:

Note: Since these system events are static events, you must make sure you detach your event handlers when disposing your application, or you will end up with memory leaks!

To take care of this memory leak potential problem, when closing our application we are calling the StopListening method to unsubscribe from the event handlers.

private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
{
    if (this.eventHandlersCreated)
        this.StopListening();
}

Another Note: Do not perform time-consuming processing on the same thread that raises a system event handler because it might prevent other applications from functioning.

If your application must perform time-consuming processes, do the processing on a separate worker thread and not on the same thread which raises the system events. If you want more information on worker threads you can have a look at my articles – Create a Worker Thread for your Windows Form in C# and Using the BackgroundWorker Component in C#.

I hope you found this useful. Thanks for reading.

Dave

The Microsoft.NET Framework contains a component called the ServiceController. It is designed to allow you to control a Windows Service. With this component you can easily start, stop, and pause services, and you can also retrieve information on the service such as its display name and status among others.

In this article I am going to show you how to use this ServiceController component and also how to enumerate the services running on your pc.

Enumerating Windows Services

To get a list of services running on a pc, we need to use the System.ServiceProcess.ServiceController class. The below code is using a static method called GetServices to return an array of ServiceController objects. Then the array is iterated and we are displaying the services’ information in a ListView component.

private void GetServices()
{
    try
    {
        lstServices.Items.Clear();

        ServiceController[] svcs = ServiceController.GetServices();

        foreach (ServiceController svc in svcs)
        {
            ListViewItem item = new ListViewItem();
            item.Text = svc.DisplayName;
            item.SubItems.Add(svc.ServiceName);
            item.SubItems.Add(svc.Status.ToString());

            lstServices.Items.Add(item);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message, ex.Source, MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

The below screenshot shows our ListView populated with the Windows services.

Controlling Windows Services

Now that we have a list of all the services running on our pc, we can use the ServiceController component to control any one of them.

To assign one of the selected services in the ListView to the ServiceController we must set the ServiceName property as shown below:

private void lstServices_SelectedIndexChanged(object sender, EventArgs e)
{
    if (lstServices.SelectedItems.Count > 0)
        this.serviceController.ServiceName = lstServices.SelectedItems[0].SubItems[1].Text.Trim();
}

Next we are using the Stop and Start methods of the ServiceController component to control the selected service. The code for this can be seen below:

private void btnStop_Click(object sender, EventArgs e)
{
    if (this.serviceController.CanStop)
    {
        this.serviceController.Stop();
        this.GetServices();
    }
}

private void btnStart_Click(object sender, EventArgs e)
{
    this.serviceController.Start();
    this.GetServices();
}

After we stop or start the selected service we are calling our GetServices method to re-populate the ListView so that we can see the updated statuses of our services.

The app.manifest File

Since we are accessing parts of the Windows operating system which require administrative privelages, we must add an app.manifest file to our project and set the requestedExecutionLevel to requireAdministrator if we are to run this code on Windows Vista or later.

<requestedExecutionLevel level="requireAdministrator" uiAccess="false" />

I have already covered how to create and use an app.manifest file in a previous article, so if you want further information you can check it out here: Writing To The Windows Event Log Using C#

Those are the basics that you need to know to control a Windows Service.

I hope you found this article useful. Stay tuned for more soon.

Dave

What exactly is a temporary file? Put simply, a temporary file is a file used by an application for storing temporary data. There is no fixed rule which specifies what this data should be, but generally temporary files (or temp files) are used for storing ‘work data‘. For example Microsoft Office uses temp files to store backups of documents being created or edited. Other applications might use temp files to store large amounts of data which would otherwise occupy too much memory. Basically, it is up to the developer to decide what should be kept within his/her application’s temp files.

In Microsoft Windows, temp files end with the .tmp extension and by default are stored in C:\Users\[username]\AppData\Local\Temp.

The .NET Framework makes creating and using temp files a breeze, so let me show you how to use them.

Create a new Console Application and add a method called CreateTmpFile. In this method we will use the System.IO.Path class to create our temp file.

private static string CreateTmpFile()
{
    string fileName = string.Empty;

    try
    {
        // Get the full name of the newly created Temporary file. 
        // Note that the GetTempFileName() method actually creates
        // a 0-byte file and returns the name of the created file.
        fileName = Path.GetTempFileName();

        // Craete a FileInfo object to set the file's attributes
        FileInfo fileInfo = new FileInfo(fileName);

        // Set the Attribute property of this file to Temporary. 
        // Although this is not completely necessary, the .NET Framework is able 
        // to optimize the use of Temporary files by keeping them cached in memory.
        fileInfo.Attributes = FileAttributes.Temporary;

        Console.WriteLine("TEMP file created at: " + fileName);
    }
    catch (Exception ex)
    {
       Console.WriteLine("Unable to create TEMP file or set its attributes: " + ex.Message);
    }

    return fileName;
}

As you can see in the above code we are calling the GetTempFileName method of the Path class to create our temp file. When called, this method will automatically create the temp file in the correct folder according to your version of Windows. Then we are creating a FileInfo object and setting the Temporary attribute of our temp file. You can work without setting this attribute, but it is recommended to set it since the .NET Framework will optimize the way it uses your temp file if set.

And that’s all you need to do to create a temp file. The temp file’s name is automatically generated and looks something like this: tmpBD28.tmp.

Now let’s write some data to our temp file:

private static void UpdateTmpFile(string tmpFile)
{
    try
    {
        // Write to the temp file.
        StreamWriter streamWriter = File.AppendText(tmpFile);
        streamWriter.WriteLine("Hello from www.daveoncsharp.com!");
        streamWriter.Flush();
        streamWriter.Close();

        Console.WriteLine("TEMP file updated.");
    }
    catch (Exception ex)
    {
        Console.WriteLine("Error writing to TEMP file: " + ex.Message);
    }
}

As you can see all we are doing here is opening the temp file using the StreamWriter class and then writing to it. It’s just like writing to a normal text file.

To read from the temp file is quite similar:

private static void ReadTmpFile(string tmpFile)
{
    try
    {
        // Read from the temp file.
        StreamReader myReader = File.OpenText(tmpFile);
        Console.WriteLine("TEMP file contents: " + myReader.ReadToEnd());
        myReader.Close();
    }
    catch (Exception ex)
    {
        Console.WriteLine("Error reading TEMP file: " + ex.Message);
    }
}

Once you’re done using the temp file you need to delete it or else it will obviously remain there, and over time these files will end up filling your temp folder.

private static void DeleteTmpFile(string tmpFile)
{
    try
    {
        // Delete the temp file (if it exists)
        if (File.Exists(tmpFile))
        {
            File.Delete(tmpFile);
            Console.WriteLine("TEMP file deleted.");
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("Error deleteing TEMP file: " + ex.Message);
    }
}

Once you create all the above methods, you can call them for testing purposes as shown below:

static void Main(string[] args)
{
    string tmpFile = CreateTmpFile();
    UpdateTmpFile(tmpFile);
    ReadTmpFile(tmpFile);
    DeleteTmpFile(tmpFile);

    Console.ReadLine();
}

Another useful method within the Path class is the GetTempPath() method. This returns the path of the current system’s temporary folder, which you might want when working with temp files.

I hope you found this article useful. Feel free to add comments or ask any questions below.

Dave

In this article I am going to show you how to monitor a folder for changes. A reason why you might want to do this is for example if you want to keep two files in different locations in sync. When the original file is changed it would trigger an event and you can update the copy in the other location with the updated original file.

The .NET framework provides a component called the FileSystemWatcher which is designed to do exactly what its name suggests – watch the file system for changes. Let’s create an example which uses this component.

Create a new Windows Forms Application project and design a form which looks similar to the one below:

Then add a FileSystemWatcher component to your form from the Components Toolbox in Visual Studio.

Next we’ll configure the FileSystemWatcher and start monitoring a folder in the Monitor button’s event handler. The code for this is shown below:

private void btnMonitor_Click(object sender, EventArgs e)
{
    try
    {
        // Watch for changes on this path
        fileSystemWatcher.Path = txtPath.Text.Trim();
        
        // Watch for changes on all files
        fileSystemWatcher.Filter = "*.*";

        // Also watch for changes within sub directories
        fileSystemWatcher.IncludeSubdirectories = true;

        // Begin watching
        fileSystemWatcher.EnableRaisingEvents = true;
    }
    catch (Exception ex)
    {
        MessageBox.Show("An error occurred: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

As you can see the code is quite self explanatory. We are starting the FileSystemWatcher by setting its EnableRaisingEvents property to true.

Next we must subscribe to its four events – the Changed, Created, Deleted, and Renamed events.

private void fileSystemWatcher_Changed(object sender, FileSystemEventArgs e)
{
    txtStatus.Text = string.Format("{0} {1} changed. {2}", 
                                   txtStatus.Text, 
                                   e.FullPath, 
                                   Environment.NewLine);
}

private void fileSystemWatcher_Created(object sender, FileSystemEventArgs e)
{
    txtStatus.Text = string.Format("{0} {1} created. {2}", 
                                   txtStatus.Text, 
                                   e.FullPath, 
                                   Environment.NewLine);
}

private void fileSystemWatcher_Deleted(object sender, FileSystemEventArgs e)
{
    txtStatus.Text = string.Format("{0} {1} deleted. {2}", 
                                   txtStatus.Text, 
                                   e.FullPath, 
                                   Environment.NewLine);
}

private void fileSystemWatcher_Renamed(object sender, RenamedEventArgs e)
{
    txtStatus.Text = string.Format("{0} {1} renamed. {2}", 
                                   txtStatus.Text, 
                                   e.FullPath, 
                                   Environment.NewLine);
}

When each of the above events fires, we are updating the main textbox (txtStatus) with some text which describes the event. A screenshot of this can be seen below:

As you can see from the screenshot above, whenever a file is added the FileSystemWatcher is firing a change event for the folder and two more for the file. If many files are added to that directory at once our application could easily be swamped by an unceasing series of events. That’s where the NotifyFilter property comes in.

The NotifyFilter property allows you indicate which type of changes you want to monitor. It can be set using any combination of the following values from the NotifyFilters enumeration:

public enum NotifyFilters
{
    // The name of the file.
    FileName = 1,
    // The name of the directory.
    DirectoryName = 2,
    // The attributes of the file or folder.
    Attributes = 4,
    // The size of the file or folder.
    Size = 8,
    // The date the file or folder last had anything written to it.
    LastWrite = 16,
    // The date the file or folder was last opened.
    LastAccess = 32,
    // The time the file or folder was created.
    CreationTime = 64,
    // The security settings of the file or folder.
    Security = 256,
}

You can combine these values using bitwise arithmetic as shown below:

fileSystemWatcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size;

This line of code is telling the FileSystemWatcher to only watch for changes to file names and file sizes. If one of these changes occurs the fileSystemWatcher_Changed event will fire. If, for example, a change to a file attribute occurs, such as a file is set to read-only, the change event will not fire. For it to fire we must add NotifyFilters.Attributes to the NotifyFilter values.

Now you should have a clear understanding of how to monitor the file system for changes using the .NET FileSystemWatcher component.

If you liked this article you can subscribe to my full RSS feed here. Please feel free to leave any questions or comments below.

Dave

In this post I am going to show you a few different ways how you can format a decimal number (float, double, or decimal).

Setting the Maximum Allowed Decimal Places

To format your numbers to a maximum of two decimal places use the format string {0:0.##} as shown in the below example:

string.Format("{0:0.##}", 256.583); // "256.58"
string.Format("{0:0.##}", 256.586); // "256.59"
string.Format("{0:0.##}", 256.58);  // "256.58"
string.Format("{0:0.##}", 256.5);   // "256.5"
string.Format("{0:0.##}", 256.0);   // "256"

Setting a Fixed Amount of Decimal Places

This is similar to the above example but instead of hashes (‘#’) in our format string we are going to use zeroes (’0′) as shown below:

string.Format("{0:0.00}", 256.583); // "256.58"
string.Format("{0:0.00}", 256.586); // "256.59"
string.Format("{0:0.00}", 256.58);  // "256.58"
string.Format("{0:0.00}", 256.5);   // "256.50"
string.Format("{0:0.00}", 256.0);   // "256.00"

The Thousand Separator

To format your decimal number using the thousand separator, use the format string {0:0,0} as shown in the below example:

string.Format("{0:0,0.00}", 1234256.583); // "1,234,256.58"
string.Format("{0:0,0}", 1234256.583);    // "1,234,257"

Setting a Fixed Amount of Digits Before the Decimal Point

To set a minimum amount of three digits before the decimal point use the format string {0:000.##}.

string.Format("{0:00.000}", 1.2345);    // "01.235"
string.Format("{0:000.000}", 12.345);   // "012.345"
string.Format("{0:0000.000}", 123.456); // "0123.456"

Alignment

To specify alignment to the Format method you must write your format string as shown below. Note we are using a comma (‘,’) to specify the number of characters used for alignment.

{0,[no. of chars]} and if you want to pad with zeroes {0,[no. of chars]:00.00}

string.Format("{0,7:##.00}", 2.356);  // "   2.36"
string.Format("{0,-7:##.00}", 2.356); // "2.36   "
string.Format("{0,7:00.00}", 2.356);  // "  02.36"
string.Format("{0,-7:00.00}", 2.356); // "02.36  "

Positive Numbers, Negative Numbers, and Zero

You can include different formats for positive numbers, negative numbers, and zero by using the semicolon character (‘;’).

Format string:
{0:[positive];[negative];[zero]}

string.Format("{0:000.000;(000.000);zero}", 23.43);  // "023.430"
string.Format("{0:000.000;(000.000);zero}", -23.43); // "(023.430)"
string.Format("{0:000.000;(000.000);zero}", 0.0);    // "zero"

Some Pre-Defined Formats

string.Format("{0:C}", 1532.236);  // "£1,532.24"
string.Format("{0:C}", -1532.236); // "-£1,532.24"
string.Format("{0:E}", 1532.236);  // "1.532236E+003"
string.Format("{0:E}", -1532.236); // "-1.532236E+003"
string.Format("{0:F}", 1532.24);   // "1532.24"
string.Format("{0:F}", -1532.24);  // "-1532.24"
string.Format("{0:G}", 1532.236);  // "1532.236"
string.Format("{0:G}", -1532.236); // "-1532.236"
string.Format("{0:N}", 1532.236);  // "1,532.24"
string.Format("{0:N}", -1532.236); // "-1,532.24"
string.Format("{0:P}", 0.1532);    // "15.32 %"
string.Format("{0:P}", -0.1532);   // "-15.32 %"
string.Format("{0:R}", 1532.236);  // "1532.236"
string.Format("{0:R}", -1532.236); // "-1532.236"

Happy formatting.
Dave