It’s a common requirement for a software developer to have to access the Windows Registry. Many applications store their settings within the registry, not to mention Windows itself. So in this article I will show you how to do this, and also how to create and delete registry keys.
Although many applications use the registry for storing their settings and configurations, nowadays it’s not the recommended practise any more. Instead you should store your application’s settings in an XML file – such as the Settings.settings file in your C# project. If you don’t know what the Settings.settings file is I wrote an article on it which you can read here – Using the Settings file in C#.
Before you start testing any code which manipulates the registry be sure you know exactly what you’re editing. Changing, or even worse, deleting registry keys and values which are used by Windows can cause it to fail to load, and you would have to try to restore Windows back or maybe even reinstall it completely. So don’t say you haven’t been warned!
On the positive side, the registry manipulation we will be looking at in this article will not affect Windows so it is quite safe if you follow my examples.
The Registry and the RegistryKey Classes
These are the classes we will be using to manipulate the registry. They are both found under the
Microsoft.Win32 namespace so you will have to add it to your project to use the classes.
Registry class provides us with objects that represent the root keys in the Windows registry. It also contains static methods to access key and value pairs but we will not be using these in this article. The root key representations are as follows:
|Registry Value||Class Property|
RegistryKey class represents a key-level node in the Windows registry and this is the class we will be making the most use of.
Creating Keys and Values
So let’s start by creating a
RegistryKey object which represents HKEY_LOCAL_MACHINE.
// Create an instance of HKEY_LOCAL_MACHINE registry key RegistryKey parentKey = Registry.LocalMachine;
Next we are going to create another
RegistryKey object which represents the SOFTWARE key found under HKEY_LOCAL_MACHINE. We are passing
true as the second parameter to the
OpenSubKey method. This is to indicate that we require write access on that registry key. If we pass
false, the key will be read only.
// Open the SOFTWARE registry sub key under the HKEY_LOCAL_MACHINE parent key RegistryKey softwareKey = parentKey.OpenSubKey("SOFTWARE", true);
Next we are going to create our own key under the SOFTWARE key. For this example I called it DaveOnC#.
// Create a DaveOnC# registry sub key under the SOFTWARE key RegistryKey subKey = softwareKey.CreateSubKey("DaveOnC#");
Now let’s add a few values to our sub key DaveOnC#. Let’s add a name value and two other values for storing URLs and set their value type to
// Add values to DaveOnC# sub key subKey.SetValue("Name", "David Azzopardi", RegistryValueKind.String); subKey.SetValue("WebsitePrimary", "http://www.daveoncsharp.com", RegistryValueKind.String); subKey.SetValue("WebsiteSecondary", "http://www.daveoncsharp.net", RegistryValueKind.String);
If you have got to this point, once you open a registry editor tool such as regedit.exe, you will be able to see the key DaveOnC# we created and if you click on that key you will see the three values we just created as well.
Now let’s create a sub key under the DaveOnC# key, and let’s call it “Top Articles”.
// Create a Top Articles registry sub key under the DaveOnC# key RegistryKey articlesSubKey = subKey.CreateSubKey("Top Articles");
Next we’ll add a few values to the Top Articles key. As you will see in the below code, we are not passing
RegistryValueKind.String to the
SetValue method this time. This is because the
SetValue assumes the value is of type
string when no
RegistryValueKind is passed as a parameter, so we can avoid typing it.
Personally I would take the extra effort and type it in full. There are two main reasons why I would do this:
- It makes the code easier to read because nothing is open to interpretation since everything is written down.
- If Microsoft ever decide to change the default value type, or the meaning of the parameters accepted by the
SetValuemethod, the code will fail on compilation and not at runtime, therefore making it easier to spot the error. It is highly unlikely this will happen though.
// Add values to Top Articles sub key articlesSubKey.SetValue("The MessageBox Explained", "http://www.daveoncsharp.com/2009/06/the-messagebox-explained/"); articlesSubKey.SetValue("File Comparison in C# – Part 1", "http://www.daveoncsharp.com/2009/07/file-comparison-in-csharp-part-1/"); articlesSubKey.SetValue("File Comparison in C# – Part 2", "http://www.daveoncsharp.com/2009/07/file-comparison-in-csharp-part-2/"); articlesSubKey.SetValue("File Comparison in C# – Part 3", "http://www.daveoncsharp.com/2009/07/file-comparison-in-csharp-part-3/"); articlesSubKey.SetValue("C# Chat Application Over Asynchronous UDP Sockets – Part 1, The Server", "http://www.daveoncsharp.com/2009/08/csharp-chat-application-over-asynchronous-udp-sockets-part-1/"); articlesSubKey.SetValue("C# Chat Application Over Asynchronous UDP Sockets – Part 2, The Client", "http://www.daveoncsharp.com/2009/08/csharp-chat-application-over-asynchronous-udp-sockets-part-2/"); articlesSubKey.SetValue("Create a Screen Saver Using C# – Part 1", "http://www.daveoncsharp.com/2009/08/create-a-screen-saver-using-csharp-part-1/"); articlesSubKey.SetValue("Create a Screen Saver Using C# – Part 2", "http://www.daveoncsharp.com/2009/08/create-a-screen-saver-using-csharp-part-2/");
If you were to look at the registry again (from regedit.exe) you will now see that we have a new sub key under DaveOnC# called Top Articles, and it contains the values we just created above.
If you export the DaveOnC# key from regedit.exe you should end up with something like this:
Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\DaveOnC#] "Name"="David Azzopardi" "WebsitePrimary"="http://www.daveoncsharp.com" "WebsiteSecondary"="http://www.daveoncsharp.net" [HKEY_LOCAL_MACHINE\SOFTWARE\DaveOnC#\Top Articles] "The MessageBox Explained"="http://www.daveoncsharp.com/2009/06/the-messagebox-explained/" "File Comparison in C# – Part 1"="http://www.daveoncsharp.com/2009/07/file-comparison-in-csharp-part-1/" "File Comparison in C# – Part 2"="http://www.daveoncsharp.com/2009/07/file-comparison-in-csharp-part-2/" "File Comparison in C# – Part 3"="http://www.daveoncsharp.com/2009/07/file-comparison-in-csharp-part-3/" "C# Chat Application Over Asynchronous UDP Sockets – Part 1, The Server"="http://www.daveoncsharp.com/2009/08/csharp-chat-application-over-asynchronous-udp-sockets-part-1/" "C# Chat Application Over Asynchronous UDP Sockets – Part 2, The Client"="http://www.daveoncsharp.com/2009/08/csharp-chat-application-over-asynchronous-udp-sockets-part-2/" "Create a Screen Saver Using C# – Part 1"="http://www.daveoncsharp.com/2009/08/create-a-screen-saver-using-csharp-part-1/" "Create a Screen Saver Using C# – Part 2"="http://www.daveoncsharp.com/2009/08/create-a-screen-saver-using-csharp-part-2/"
Deleting Keys and Values
To delete a value is quite straight forward. Let’s delete the WebsiteSecondary value from the DaveOnC# key.
// Delete the WebsiteSecondary value subKey.DeleteValue("WebsiteSecondary");
Now let’s delete all that we have created so far:
// Delete the parent registry key softwareKey.DeleteSubKeyTree("DaveOnC#");
And if you open regedit.exe again you will see that all the work you just did has vanished :). It is that easy to delete a registry key with all its values! So imagine how easy it is to delete something by mistake… be careful when deleting from the registry.
Finally, we must remember to close all the RegistryKey objects we created.
// Close RegistryKey objects articlesSubKey.Close(); subKey.Close(); softwareKey.Close(); parentKey.Close();
Accessing the Registry in Windows Vista
Because of the added security features in Windows Vista you cannot access the registry by just using the above code. You must add an app.manifest file to your application. I explained how to use the
requestedExecutionLevel section of the manifest file in my previous post – Writing To The Windows Event Log Using C#, so you can have a look towards the end of that article if you want to know a little bit more about the manifest file.
What’s important for this example is that we must edit the
requestedExecutionLevel section in the manifest file to look like the below, so that our application will run with administrative rights under an administrator account:
<requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
And that brings us to the end of this article.
If you liked this article subscribe to my full feed rss so that you will receive new articles automatically in your rss reader. Also, please feel free to leave your comments below or if you want you can contact me directly from my Contact Page.
Stay tuned for more articles soon.