MessageBox using YesNo Button

With the previous post you could see that MessageBox class is very powerful and contains a lot of options for the static method Show. Now we will see in more detail how to implement the functionalities of a Dialog containing a YesNo Button.

When you give the user that option, it is obvious that the behavior of the Yes Button must be different from the No so you must set this.

Let's proceed to write an example. This C# code example has basicly 2 functions: when the Dialog popus up, the user must select between the Yes or No options. If the Yes is selected, the application exits. If the No button is clicked, a Dialog will appear. So here is the code:

private void button1_Click(object sender, EventArgs e)
{
DialogResult result;
result = MessageBox.Show("Are you sure you want to exit?", "Application 1", MessageBoxButtons.YesNo);

if (result == DialogResult.No) {
MessageBox.Show("App won´t close");
}

if (result == DialogResult.Yes) {
this.Dispose();
}
}

If there are more options that the user can choose from, a switch statment could be a better option:

witch (result)
{

case DialogResult.No:
MessageBox.Show("App won´t close");
break;

case DialogResult.Yes:
this.Dispose();
break;

default:
break;

}

Result when executing:

MessageBox Tuning in C#

MessageBox class is used when you want to show some kind of information or when the application needs user intervention.
This class contains static methods that help to interactuate with users. All you have to do is set the correct parameters of the show method. Some are: title, a proper message, icons, botons, quantities and more.

The show method returns a DialogResult type value that will need to be evaluated in order to make future actions, for example, open another dialog window.

Let’s look at some examples now:

I´ll start by creating a Windows From. Next, I´ll add 5 Buttons controls to the form and create a click event for all of them. On the click event method I created different messageBoxs for each one. Let’s analize them:

-For the button0, the code line is:

MessageBox.Show(this, "Hello", "Title Button0");

Nothing really complicated here. This creates a simple dialog with the text Hello, owner this and title Title Button0.

-For the button1, the code line is:

MessageBox.Show("Abort, Retry, Ignore example", "Title 1", MessageBoxButtons.AbortRetryIgnore);

This is a little more interesting. We indicated here that the title would be Title 1, the message Abort, Retry, Ignore example and the Button for this specific dialog is the AbortRetryIgnore Button, the same one you see in most windows applications.

-For the button2, the code line is:

MessageBox.Show(this, "Error on button2, Continue?" , "Title2", MessageBoxButtons.YesNo , MessageBoxIcon.Error);

This is very similar to the previus one: Owner this, title Title2, message Error on button2, Continue? , Button YesNo and Icon Error. This will create a dialog that contains both options Yes and No, and also an Error Icon located left of the message will appear.

-For the button3, the code line is:

MessageBox.Show("Warning", "Button3 Title", MessageBoxButtons.OK, MessageBoxIcon.Warning);

Similar to the others but now the Button is the Ok button and the Icon Warning will apear. So the purpose of this is to indicate an error, warning or a message that the user must see and give the only option of clicking the OK button.

-For the button4, the code line is:

MessageBox.Show(this, "Warning", "Button4 title", MessageBoxButtons.RetryCancel, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button3);

Here the Button is the usual RetryCancel, the Icon Asterisk and the DefautlButton indicated to Button3. This defines the constat button.

Writing Registry keys

We saw before how to read a registry key. Writing is similar and also accomplished by the RegistryKey object. C# .Net provides very easy methods under this object to write keys.

Be aware that the registry is a key part of an Operating System so you should know exactly what you are doing before actually doing it. Check every single line of the code written. On this example I’ll show you below, I will create a couple of keys with its proper folder too. By doing this I can be sure that any other registry key would be overwritten.

Take a look now at this example:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;

namespace WritingRegKeys
{
class Program
{
static void Main(string[] args)
{

RegistryKey RegKeyWrite = Registry.CurrentUser;
RegKeyWrite = RegKeyWrite.CreateSubKey
("Software\\MySoftware\\SubKeys");
RegKeyWrite.SetValue("Try", "True");
RegKeyWrite.SetValue("NumberValue", 1);

RegKeyWrite.Close();

RegistryKey RegKeyRead = Registry.CurrentUser;
RegKeyRead = RegKeyRead.OpenSubKey("Software\\MySoftware\\SubKeys");
Object regTry = RegKeyRead.GetValue("Try");
Object regNumber = RegKeyRead.GetValue("NumberValue");
RegKeyRead.Close();
Console.WriteLine("Try value: " + (String)regTry + " - - NumberValue: " + regNumber);

}
}
}

You can see that after creating the RegistryKey object I also created a subkey with the CreateSubKey method. This will generate another “subfolder” under MySoftware.

The Complete root is: HKEY_CURRENT_USER\Software\MySoftware\SubKeys.

With the RegKeyWrite.SetValue you have to specify the name of that key and the actual values you want to be stored. You can see that the fist value to be stored is a String and the second a Numeric value.

You can try this by reading the keys created above. That why the RegKeyRead Object is also created. Then we just open the SubKey and ask the values for the Try key and the NumberValue key. Run the code and the Console should look something like this:

When you execute the code, a new registry should be created. So let’s take a look at the registry to see if this is true. Open regedit to see the changes.

Accessing the Registry for reading keys in C#

C# contains class object that make the job of manipulating the registry very easy.
Also, the registry is indexed that make much faster the reading job.

Ok, let’s now proceed to read from the registry.
First you need to make the import of the Microsoft.Win32 namespace that contains the registry access functions.
The second important thing you need to use RegistryKey object to make the actual reading.

Let’s now write a small piece of code to see how this works.

using System;
using System.Text;
using Microsoft.Win32;

namespace RegRead
{

class Program
{

static void Main(string[] args)
{

//Example 1
RegistryKey RegKey = Registry.LocalMachine;
RegKey = RegKey.OpenSubKey(
"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\1");
Object cpuName = RegKey.GetValue("ProcessorNameString");
Console.WriteLine("Your CPU name is:" + cpuName);

Console.WriteLine("");

//Example 2
RegistryKey RegKey2 = Registry.CurrentUser;
RegKey2 = RegKey2.OpenSubKey("Printers");
Object printerName = RegKey2.GetValue("DeviceOld");
Console.WriteLine("Your Printer name is: " + printerName);

Console.Read();
}
}
}

The first thing you need to do is to import the Microsoft.Win32 namespace.
Then, if you look at the definition of the instance of the RegistryKey object, you will see that it is pointing to Local Machine, which means that the HKEY_LOCAL_MACHINE folder will be enable for reading.
(To open the Registry editor just go to start->Run: regedit).
After this step, we simple need to find the folders/subfolders where the key is located and read it.

The second example is pretty much the same. The only major difference is that the
HKEY_CURRENT_USER folder will be available.