Namespace and Root Hives

Accessing the Windows Registry in C# requires the Microsoft.Win32 namespace. This namespace exposes the Registry and RegistryKey clases, which provide the foundational APIs for reading and modifying system configuration data. The Registry class contains static properties representing the seven root hives, such as CurrentUser, LocalMachine, and ClassesRoot.

using Microsoft.Win32;

// Select the target root hive
RegistryKey baseHive = Registry.LocalMachine;

Managing Registry Keys

Registry keys function as directory structrues. You can create, open, or remove them using the methods provided by the RegistryKey clas. Path separators must be properly escaped or enclosed in verbatim strings. Best practice dictates wrapping key operations in using blocks to ensure unmanaged handles are released promptly.

using (RegistryKey rootHive = Registry.LocalMachine)
{
    // Create a new subkey (automatically creates missing parent keys)
    using (RegistryKey appKey = rootHive.CreateSubKey(@"SOFTWARE\MyApplication"))
    {
        // Key is now initialized
    }

    // Open an existing key with write permissions
    using (RegistryKey writableKey = rootHive.OpenSubKey(@"SOFTWARE\MyApplication", writable: true))
    {
        if (writableKey != null)
        {
            // Create a nested subkey
            writableKey.CreateSubKey("Modules");
        }
    }

    // Remove a subkey (second parameter throws if missing; omit to suppress)
    rootHive.DeleteSubKey(@"SOFTWARE\MyApplication\TempConfig", throwOnMissingSubKey: false);
}

Reading and Writing Values

Once a key is successfully opened, you can store, retrieve, or remove associated values. Values are stored as key-value pairs within a specific registry key. The SetValue method automatically creates the value if it does not exist, or overwrites it if it does.

using (RegistryKey targetKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\MyApplication", writable: true))
{
    if (targetKey != null)
    {
        // Write or update a value with explicit type declaration
        targetKey.SetValue("LicenseKey", "ABCD-EFGH-IJKL-MNOP", RegistryValueKind.String);

        // Retrieve a value safely using null-coalescing
        object rawData = targetKey.GetValue("LicenseKey");
        string configurationData = rawData?.ToString() ?? string.Empty;

        // Remove a specific value entry
        targetKey.DeleteValue("LegacySetting");
    }
}

Existence Verification

Before modifying or deleting entries, verifying their existence prevents runtime exceptions. The following utility methods demonstrate efficient validation techniques using built-in collection methods and culture-insensitive string comparison.

/// <summary>
/// Determines whether a specific subkey exists within a parent key.
/// </summary>
public static bool SubKeyExists(RegistryKey parentKey, string targetSubKey)
{
    if (parentKey == null || string.IsNullOrWhiteSpace(targetSubKey))
        return false;

    foreach (string existingKey in parentKey.GetSubKeyNames())
    {
        if (existingKey.Equals(targetSubKey, StringComparison.OrdinalIgnoreCase))
            return true;
    }
    return false;
}

/// <summary>
/// Determines whether a specific value name is present in a registry key.
/// </summary>
public static bool ValueExists(RegistryKey containerKey, string targetValue)
{
    if (containerKey == null || string.IsNullOrWhiteSpace(targetValue))
        return false;

    return containerKey.GetValueNames().Contains(targetValue, StringComparer.OrdinalIgnoreCase);
}