Click here to Skip to main content
Click here to Skip to main content

A class for reading and writing the Windows Registry using VB.NET

, 24 Jun 2004 CPOL
Rate this:
Please Sign up or sign in to vote.
Reading and writing the Windows Registry overcoming the restrictions imposed by GetSetting and SaveSetting.

Introduction

This article shows you how to code a class for reading and writing to the Windows Registry using VB.NET. This class has proven to be useful in several of my projects.

The Registry

Along with the release of Windows 95, the concept of the Registry was introduced. The Registry is one of the Windows architecture components. It replaces the old .INI files that were used to store important information about applications in previous versions of Windows. For example, each application could have its .INI file to store the initial dimensions and position of its main window, user names and passwords used, the last four files that were opened, and all sort of preferences and settings. There were mounds of .INI files everywhere. So, Windows 95 implemented the Registry, a central and unique location to store all the system and application settings.

The Registry is compounded by six keys (five in Windows NT/2000 and XP because these Operating Systems don't have the Hkey_Dyn_Data key). Two of these six keys are basic, the other four are derived from these two (in fact they are aliases of the other two). The organization of the Registry is represented by the following figure:

Hierarchy of the Windows Registry

Fig. 1 - Hierarchy of the Windows Registry

To check this, you can go to the Start button of Windows, click Run ..., then type regedit and press Enter. The Registry Editor will appear. In the left panel, you will see the six keys I was talking about.

Registry Editor

Fig. 2 - Registry Editor

Each key starts with the word HKEY, which stands for Key Handle. We are going to call these keys, key roots. Each key root has subkeys. Each key root is related to one aspect of the configuration data, like the user or computer-dependent settings.

  • HKEY_CLASSES_ROOT: This branch of the Registry contains all the names of the registered file types and their properties. In other words, the information saved here ensures the right program opens when you double-click a file in Windows Explorer. This key is an alias of the HKEY_LOCAL_MACHINE\Software subkey.
  • HKEY_CURRENT_USER: This key contains the configuration information about the user who is currently logged on. The user profile is stored here: user's folders, screen colors and Control Panel settings. This branch is an alias of the HKEY_USERS key.
  • HKEY_LOCAL_MACHINE: Contains configuration information related to the computer for all users.
  • HKEY_USERS: This branch stores all the user profiles on the computer.
  • HKEY_CURRENT_CONFIG: This key has information about the hardware profile used by the local computer at system startup.
  • HKEY_DYN_DATA: This key is available only in Windows 9x/ME. Some information in Windows 98 must be stored in the RAM because it requires fast modification and can't wait for the Registry to flush to the hard disk. All this data can be found under this key root. This branch is an alias of Hkey_Local_Machine \Configs.

Coding the class CRegistry

GetSetting and SaveSetting are functions that allow you to read and write to the Registry. But they only let you read and write in the HKEY_CURRENT_USER\Software\VB and VBA keys. In your projects, you may want to write where the pros do: in HKEY_CURRENT_USER\Software\. Hence we won't use these functions, but a fantastic object from Win32 that knows no limit. Let's see.

First, you import the Microsoft.Win32 namespace. This allows you to use the Registry object which represents the Windows Registry and its methods for handling its basic operations. You know the class will have properties and methods, the properties are going to be the six main keys described above, the values of which you can access for specifying the path you need to read or write to. The methods we need will be the following: one for creating a subkey (or several nested subkeys) inside any of the main keys, one for deleting a subkey, one for writing, one for reading, and one for deleting data in the Registry.

Well, here are the public properties. Since you are likely to use them from outside the class - for passing the full path of your settings - these have to be public.

Public ReadOnly Property HKeyLocalMachine() As RegistryKey
    Get  
        Return Registry.LocalMachine 
    End Get 
End Property


Public ReadOnly Property HkeyClassesRoot() As RegistryKey 
    Get 
        Return Registry.ClassesRoot
    End Get 
End Property

//..and so on until you have the six keys
//.
//.

Public ReadOnly Property HKeyDynData() As RegistryKey
    Get 
        Return Registry.DynData
    End Get 
End Property

Let's get into the methods. We are going to write the CreateSubKey method, which we will use for creating new subkeys inside any of the six main keys in the Registry.

Public Function CreateSubKey(ByVal ParentKey As RegistryKey, _
                             ByVal SubKey As String) As Boolean 
    Try
        'create the specified subkey 
        ParentKey.CreateSubKey(SubKey)
        Return True 
    Catch e As Exception
        Return False
    End Try
End Function

Now, you may be wondering how to use this method. Let's suppose you want to create another subkey inside the HKEY_LOCAL_MACHINE\Software subkey, which is actually the path where software vendors store their application's settings. If you run the Registry Editor again and take a look at this subkey (HKEY_LOCAL_MACHINE\Software), chances are you will find a plethora of subkeys, each one with the name of a software firm, like Adobe, Apple Computer, McAfee, Microsoft, Novell, etc. So let's create our very own software brand subkey inside, like MySoftCorp. The only thing you got to do is throw a couple of lines like these:

'We are assuming our class is called CRegistry  
Dim objReg As New CRegistry
objReg.CreateSubKey(objReg.HKeyLocalMachine, "Software\MySoftCorp")

After this call, there should be a new subkey inside HKEY_LOCAL_MACHINE\Software called MySoftCorp. All our methods are going to return True if they are successful, otherwise they return False. Here you can create more subkeys, one for each application. If your company develops two applications, an accounting app and a stock market app, each application should install its own subkey inside HKEY_LOCAL_MACHINE\Software\MySoftCorp. For example, you would have HKEY_LOCAL_MACHINE\Software\MySoftCorp\AccountingApp and HKEY_LOCAL_MACHINE\Software\MySoftCorp\StockMarketApp. We could also create more than one subkey at once if we call the method like this:

objReg.CreateSubKey(objReg.HKeyLocalMachine, _
                     "Software\MySoftCorp\AccountingApp")

The second method is for deleting a subkey. The code is as follows:

Public Function DeleteSubKey(ByVal ParentKey As RegistryKey, _
                             ByVal SubKey As String) As Boolean 
        Try 
            'destroys the subkey and returns a False when the subkey doesn't 
            'exist 
            ParentKey.DeleteSubKey(SubKey, False)
            Return True
        Catch e As Exception
            Return False
        End Try
End Function

We already have the mechanisms to create all the subkeys we need, but we need to write a method for creating and storing values inside a subkey. Look into any subkey, for example HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion. You can see a bunch of values in the right panel. Each value has a name, a type, and data. The possible data types are the following: REG_SZ (can be a string or boolean), REG_EXPAND_SZ (variable length text string), REG_DWORD (a 32-bit integer), or REG_MULTI_SZ (array of text strings). To create a new value name and assign a value to it, we need the key, the subkey(s), the name of the value we want to create, and the value itself (data). Here is the code for the WriteValue method:

Public Function WriteValue(ByVal ParentKey As RegistryKey, _
                           ByVal SubKey As String, _
                           ByVal ValueName As String, _
                           ByVal Value As Object) As Boolean 
    Dim Key As RegistryKey

    Try 
        'Open the given subkey 
        Key = ParentKey.OpenSubKey(SubKey, True)
        
        If Key Is Nothing Then 'when subkey doesn't exist create it 
            Key = ParentKey.CreateSubKey(SubKey)
        End If 

        'Once we have a handle to the key, set the value(the data) 
        Key.SetValue(ValueName, Value)

        Return True 
    Catch e As Exception
        Return False
    End Try 
End Function

Note: we declared Value as Object in the parameters of the method so that we can pass a string or a numeric value and the call to Key.SetValue() will write the value using the matching data type in the Registry. Therefore we are not required to specify which data type our value is going to be. Cool, huh? Check this example for creating a string or a numeric value:

Dim strUsrName As String = "Sinhue"
'this value will be created as a REG_SZ(string) 
objReg.WriteValue(objReg.HKeyLocalMachine, _
                  "Software\MySoftCorp\StockMarketApp", _
                  "UserName", strUsrName)

Dim intMaxDocs As Integer = 10
'this value will be created as an REG_DWORD(integer) 
objReg.WriteValue(objReg.HKeyLocalMachine, _
                  "Software\MySoftCorp\StockMarketApp", _
                  "MaxDocsOpened", intMaxDocs)

Next I'm going to show you a method for reading data from a value. As you will see, the parameters are the same. We're going to return the data in the Value parameter, which is declared as a parameter by reference.

Public Function ReadValue(ByVal ParentKey As RegistryKey, _
                          ByVal SubKey As String, _
                          ByVal ValueName As String, _
                          ByRef Value As Object) As Boolean 
    Dim Key As RegistryKey

    Try
        'open the given subkey
        Key = ParentKey.OpenSubKey(SubKey, True)
        
        If Key Is Nothing Then 'when the key doesn't exist throw an 
                               'exception 
            Throw New Exception("the subkey doens't exist")
        End If 

        'Get the value 
        Value = Key.GetValue(ValueName)

        Return True 
    Catch e As Exception 
        Return False 
    End Try
End Function

Finally, we're going to add a method for deleting a value name:

Public Function DeleteValue(ByVal ParentKey As RegistryKey, _
                                ByVal SubKey As String, _
                                ByVal ValueName As String) As Boolean 
    Dim Key As RegistryKey

    Try 
        'open the given subkey 
        Key = ParentKey.OpenSubKey(SubKey, True)

        'when the key exists then delete the value 
        If Not Key Is Nothing Then 
            Key.DeleteValue(ValueName)
            Return True 
        Else 
            Return False
        End If
    Catch e As Exception
        Return False
    End Try

End Function

Conclusion

Well, that's all there is to it. I have provided you with source code for the class, plus a method for getting all the subkeys inside a given subkey. I converted this class into a DLL that I add to my projects whenever I want to access the Windows Registry. Undoubtedly, there are plenty of improvements that could be made to the code. I hope you find it useful as much as I have.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Sinhue Baez
Web Developer
Mexico Mexico
Sinhue Baez is a systems engineer. He started with computers in 1990, since then, he has programmed in BASIC, C/C++, COBOL, Pascal, Visual Basic, Java, Visual C++ and currently he is working using VB .NET and C#.
In his spare time he likes to code videogame demos with Visual C++ and Direct X.
He works as a project leader developing software for the production area of a food company.
Currently he is studying his master degree in Management Engineering.
He enjoys playing basketball, running and writing short stories.

Comments and Discussions

 
GeneralThis class doesn't work properly in Windows VISTA Pinmemberdaweinst14-Aug-07 12:00 
GeneralRe: This class doesn't work properly in Windows VISTA PinmemberKarandeep Malik28-Jul-08 22:15 
This won't work in VISTA because VISTA has a different way of storing registries
GeneralRe: This class doesn't work properly in Windows VISTA PinmemberKarandeep Malik28-Jul-08 22:16 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.141223.1 | Last Updated 25 Jun 2004
Article Copyright 2004 by Sinhue Baez
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid