C# 4 and .NET 4

eading and Writing to the registry ❘ 809
The most obvious difference is in how you open a registry key at a given location in the registry. The
Registry class does not have any public constructor that you can use, nor does it have any methods that let
you go directly to a key, given its name. Instead, you are expected to browse down to that key from the top
of the relevant hive. If you want to instantiate a RegistryKey object, the only way is to start off with the
appropriate static property of Registry, and work down from there. So, for example, if you want to read
some data in the HKLM/Software/Microsoft key, you would get a reference to it like this:
RegistryKey hklm = Registry.LocalMachine;
RegistryKey hkSoftware = hklm.OpenSubKey("Software");
RegistryKey hkMicrosoft = hkSoftware.OpenSubKey("Microsoft");
A registry key accessed in this way will give you read-only access. If you want to write to the key (that
includes writing to its values or creating or deleting direct children of it), you need to use another override
to OpenSubKey, which takes a second parameter, of type bool, that indicates whether you want read-write
access to the key. For example, if you want to be able to modify the Microsoft key (and assuming that you
are a system administrator with permission to do this), you would write this:
RegistryKey hklm = Registry.LocalMachine;
RegistryKey hkSoftware = hklm.OpenSubKey("Software");
RegistryKey hkMicrosoft = hkSoftware.OpenSubKey("Microsoft", true);
Incidentally, because this key contains information used by Microsoft’s applications, in most cases you
probably shouldn’t be modifying this particular key.
The OpenSubKey() method is the one you call if you are expecting the key to be present. If the key isn’t
there, it returns a null reference. If you want to create a key, you should use the CreateSubKey() method
(which automatically gives you read-write access to the key through the reference returned):
RegistryKey hklm = Registry.LocalMachine;
RegistryKey hkSoftware = hklm.OpenSubKey("Software");
RegistryKey hkMine = hkSoftware.CreateSubKey("MyOwnSoftware");
The way that CreateSubKey() works is quite interesting. It creates the key if it does not already exist,
but if it does exist, it quietly returns a RegistryKey instance that represents the existing key. The reason
for the method behaving in this manner has to do with how you normally use the registry. The registry,
overall, contains long-term data such as configuration information for Windows and for various
applications. It is not very common, therefore, that you find yourself in a situation where you need to
explicitly create a key.
What is much more common is that your application needs to make sure that some data is present in the
registry — in other words, create the relevant keys if they do not already exist, but do nothing if they
do. CreateSubKey() fills that need perfectly. Unlike the situation with FileInfo.Open(), for example,
there is no chance with CreateSubKey() of accidentally removing any data. If deleting registry keys is
your intention, you will need to call the RegistryKey.DeleteSubKey() method. This makes sense given
the importance of the registry to Windows. The last thing you want is to completely break Windows
accidentally by deleting a couple of important keys while you are debugging your C# registry calls!
After you have located the registry key you want to read or modify, you can use the SetValue() or
GetValue() methods to set or get at the data in it. Both of these methods take a string giving the name of
the value as a parameter, and SetValue() requires an additional object reference containing details of the
value. Because the parameter is defined as an object reference, it can actually be a reference to any class you
want. SetValue() will decide from the type of class actually supplied whether to set the value as a REG_SZ,
REG_DWORD or REG_BINARY value. For example:
RegistryKey hkMine = HkSoftware.CreateSubKey("MyOwnSoftware");
hkMine.SetValue("MyStringValue", "Hello World");
hkMine.SetValue("MyIntValue", 20);
This code sets the key with two values: MyStringValue will be of type REG_SZ, and MyIntValue will be of
type REG_DWORD. These are the only two types you will consider here and use in the example presented later.
www.it-ebooks.info