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# Snippet - The Many Uses Of The Using Keyword [Beginner]

What is the first thing that pops into your mind when you think of the using keyword for C#? Probably those lines that always appear at the top of C# code files - the lines that import types from other namespaces into your code. But while that is the most common use of the using keyword, it is not the only one. Today we are going to take a look at the different uses of the using keyword and what they are useful for. The Using Directive There are two main categories of use for the using keyword - as a "Using Directive" and as a "Using Statement". The lines at the top of a C# file are directives, but that is not the only place they can go. They can also go inside of a namespace block, but they have to be before any other elements declared in the namespace (i.e., you can't add a using statement after a class declaration). Namespace Importing This is by far the most common use of the keyword - it is rare that you see a C# file that does not h
Post a 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