Skip to main content

C# Snippet Tutorial - Editing the Windows Registry [Beginner]


In this tutorial, I'm going to go through the code required to edit the Windows registry using C#. This will include creating new keys and values as well as modifying existing ones.

The registry is a great way to save information between application launches. Many applications use the registry to save information about dialog sizes and placements. That way the user doesn't have to resize and move dialogs every time the program starts.

Let's start by creating a new registry key. The first thing we need to decide is where to put our new key. If you bring up the Registry Editor - type "regedit" in the run bar, you'll notice the registry looks a lot like a file explorer. "Computer" is the root node with several child folders branching from it.

Most software packages will have a registry key inside
HKEY\_LOCAL\_MACHINE-\>SOFTWARE

These keys are available no matter who is logged in and is a good place to stick general application values. Let's put a key in this folder called "My Registry Key".
Registry.LocalMachine.CreateSubKey("SOFTWARE\\My Registry Key");
 
Registry is a class located in theMicrosoft.Win32 namespace. Registry.LocalMachine means where going to be modifying the HKEY_LOCAL_MACHINE registry key. We passed in "SOFTWARE\\My Registry Key" to CreateSubKey because we wanted our new key created inside the "SOFTWARE" key. CreateSubKey has the option to take more arguments - mostly dealing with access and security, but they're not important for this tutorial.

If you open the Registry Editor again, you'll now see you're new key. A key without any values is pretty useless, so let's add a string value to it.
RegistryKey myKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\My Registry Key", true);

myKey.SetValue("My String Value", "Test Value", RegistryValueKind.String);
 
The OpenSubKey method is called to get a reference to our newly created key. It takes the path to the key, which is the same as when creating it, and it takes a boolean indicating whether or not we want to open it writable. Since we want to add a new value to this key, we want to set this to true.

Next, we simply call SetValue to create our new value. The SetValue function takes the name of the value as the first argument, the actual value as the second, and the type of value as the third. The RegistryValueKind enumeration has lots of different kinds of data, so most primitive types can be stored in the registry. If the value you're trying to set doesn't exist yet (like in this case), SetValue will create it for you.

Now let's look at how to get values back out of the registry. It's very similar to setting values and equally as easy.
RegistryKey myKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\My Registry Key", false);

string myValue = (string)myKey.GetValue("My String Value");
//myValue now equals "Test Value"
 
We get a reference to our key exactly like we did before except this time we pass false for the writable argument. A call to GetValue is then made to retrieve the value from the registry. This function returns an object, so it must first be cast to your desired type - in this case string. It's always wise to check that the return value is not null before casting it since it is possible that the registry value you're trying to read doesn't exist.

That's all the code required to read and write to the Windows registry using .NET and C#.
Labels:

Comments

Post a Comment

Popular posts from this blog

C# Snippet - Shuffling a Dictionary [Beginner]

Randomizing something can be a daunting task, especially with all the algorithms out there. However, sometimes you just need to shuffle things up, in a simple, yet effective manner. Today we are going to take a quick look at an easy and simple way to randomize a dictionary, which is most likely something that you may be using in a complex application. The tricky thing about ordering dictionaries is that...well they are not ordered to begin with. Typically they are a chaotic collection of key/value pairs. There is no first element or last element, just elements. This is why it is a little tricky to randomize them. Before we get started, we need to build a quick dictionary. For this tutorial, we will be doing an extremely simple string/int dictionary, but rest assured the steps we take can be used for any kind of dictionary you can come up with, no matter what object types you use. Dictionary < String , int > origin = new Dictionary < string , int >(); ...
1 comment
Read more

C# WPF Printing Part 2 - Pagination [Intermediate]

About two weeks ago, we had a tutorial here at SOTC on the basics of printing in WPF . It covered the standard stuff, like popping the print dialog, and what you needed to do to print visuals (both created in XAML and on the fly). But really, that's barely scratching the surface - any decent printing system in pretty much any application needs to be able to do a lot more than that. So today, we are going to take one more baby step forward into the world of printing - we are going to take a look at pagination. The main class that we will need to do pagination is the DocumentPaginator . I mentioned this class very briefly in the previous tutorial, but only in the context of the printing methods on PrintDialog , PrintVisual (which we focused on last time) and PrintDocument (which we will be focusing on today). This PrintDocument function takes a DocumentPaginator to print - and this is why we need to create one. Unfortunately, making a DocumentPaginator is not as easy as...
Post a Comment
Read more

C# WPF Tutorial - Implementing IScrollInfo [Advanced]

The ScrollViewer in WPF is pretty handy (and quite flexible) - especially when compared to what you had to work with in WinForms ( ScrollableControl ). 98% of the time, I can make the ScrollViewer do what I need it to for the given situation. Those other 2 percent, though, can get kind of hairy. Fortunately, WPF provides the IScrollInfo interface - which is what we will be talking about today. So what is IScrollInfo ? Well, it is a way to take over the logic behind scrolling, while still maintaining the look and feel of the standard ScrollViewer . Now, first off, why in the world would we want to do that? To answer that question, I'm going to take a an example from a tutorial that is over a year old now - Creating a Custom Panel Control . In that tutorial, we created our own custom WPF panel (that animated!). One of the issues with that panel though (and the WPF WrapPanel in general) is that you have to disable the horizontal scrollbar if you put the panel in a ScrollV...
Post a Comment
Read more