Copy and Rename Registry Keys

• Download demo and source code - 26.05 KB

Background

One day I was writing some code and had the need to work with the Windows registry.  I was so happy that I was coding in .NET using C#. "How I love the framework", I was saying to myself. Then all of the sudden, I found that a critical method was missing. I found that I could not simply call a method in the framework to rename a registry key.

To my further amazement, I was surprised that I could not find a code snippet to help do this. I saw a challenge and I was on a mission.

So that is the story of why I wrote this code.

Overview

There is not much code to this at all.  In fact there is more code in the test form that demonstrates the utility.

Basically what you will find is a solution that contains a form and a class file written in C#. The form has code that sets up and runs the test. The utility code that does the registry key renaming is in a class file named RegistryUtilities.cs.

The utility contains two public methods:

• CopyKey
• RenameSubKey

The process of renaming a registry key is actually a recursive copy of all the values and sub keys and then a delete of the original key.  So when you call RenameSubKey, it actually calls CopyKey. The real work is done in the private method: RecurseCopyKey.

RecurseCopyKey is responsible for copying all the values and sub keys to a new sub key.  The new sub key is placed at the same level in the tree as the one being copied.

Blah, blah, blah… You'll probably get more from seeing the code than from reading anything more I could write here.

The Demo

There is a demo available for download.  If you run the demo, it creates a new registry key under local user and then renames it.

The Code

Here is a copy of the entire RegistryUtilities.cs file:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;

// RenameRegistryKey © Copyright 2006 Active Computing
namespace RenameRegistryKey
{
    public class RegistryUtilities
    {
        /// <summary>
        /// Renames a subkey of the passed in registry key since 
        /// the Framework totally forgot to include such a handy feature.
        /// </summary>
        /// <param name="regKey">The RegistryKey that contains the subkey 
        /// you want to rename (must be writeable)</param>
        /// <param name="subKeyName">The name of the subkey that you want to rename
        /// </param>
        /// <param name="newSubKeyName">The new name of the RegistryKey</param>
        /// <returns>True if succeeds</returns>
        public bool RenameSubKey(RegistryKey parentKey, 
			string subKeyName, string newSubKeyName)
        {
            CopyKey(parentKey, subKeyName, newSubKeyName);
            parentKey.DeleteSubKeyTree(subKeyName);
            return true;
        }

        /// <summary>
        /// Copy a registry key.  The parentKey must be writeable.
        /// </summary>
        /// <param name="parentKey"></param>
        /// <param name="keyNameToCopy"></param>
        /// <param name="newKeyName"></param>
        /// <returns></returns>
        public bool CopyKey(RegistryKey parentKey, 
			string keyNameToCopy, string newKeyName)
        {
            //Create new key
            RegistryKey destinationKey = parentKey.CreateSubKey(newKeyName);

            //Open the sourceKey we are copying from
            RegistryKey sourceKey = parentKey.OpenSubKey(keyNameToCopy);

            RecurseCopyKey(sourceKey, destinationKey);

            return true;
        }

        private void RecurseCopyKey(RegistryKey sourceKey, RegistryKey destinationKey)
        {
            //copy all the values
            foreach (string valueName in sourceKey.GetValueNames())
            {        
                object objValue = sourceKey.GetValue(valueName);
                RegistryValueKind valKind = sourceKey.GetValueKind(valueName);
                destinationKey.SetValue(valueName, objValue, valKind);
            }

            //For Each subKey 
            //Create a new subKey in destinationKey 
            //Call myself 
            foreach (string sourceSubKeyName in sourceKey.GetSubKeyNames())
            {
                RegistryKey sourceSubKey = sourceKey.OpenSubKey(sourceSubKeyName);
                RegistryKey destSubKey = destinationKey.CreateSubKey(sourceSubKeyName);
                RecurseCopyKey(sourceSubKey, destSubKey);
            }
        }
    }
}

I hope this is useful for you.

History

• 11^th November, 2006: Initial post