public static RegistryKey OpenBaseKey(RegistryHive registryHive, RegistryHiveType registryType, bool bWritable = false)
{
UIntPtr hiveKey = _hiveKeys[registryHive];
if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major > 5)
{
RegistryAccessMask flags = RegistryAccessMask.QueryValue | RegistryAccessMask.EnumerateSubKeys | _accessMasks[registryType];
if (bWritable)
{
flags |= (RegistryAccessMask.SetValue | RegistryAccessMask.CreateSubKey);
}
IntPtr keyHandlePointer = IntPtr.Zero;
int result = RegOpenKeyEx(hiveKey, String.Empty, 0, (uint)flags, out keyHandlePointer);
if (result == 0)
{
var safeRegistryHandleType = typeof(SafeHandleZeroOrMinusOneIsInvalid).Assembly.GetType("Microsoft.Win32.SafeHandles.SafeRegistryHandle");
var safeRegistryHandleConstructor = safeRegistryHandleType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(IntPtr), typeof(bool) }, null); // .NET < 4
if (safeRegistryHandleConstructor == null)
{
safeRegistryHandleConstructor = safeRegistryHandleType.GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new[] { typeof(IntPtr), typeof(bool) }, null); // .NET >= 4
}
var keyHandle = safeRegistryHandleConstructor.Invoke(new object[] { keyHandlePointer, true });
var net3Constructor = typeof(RegistryKey).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { safeRegistryHandleType, typeof(bool) }, null);
var net4Constructor = typeof(RegistryKey).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(IntPtr), typeof(bool), typeof(bool), typeof(bool), typeof(bool) }, null);
object key;
if (net4Constructor != null)
{
key = net4Constructor.Invoke(new object[] { keyHandlePointer, true, false, false, hiveKey == _hiveKeys[RegistryHive.PerformanceData] });
}
else if (net3Constructor != null)
{
key = net3Constructor.Invoke(new object[] { keyHandle, true });
}
else
{
var keyFromHandleMethod = typeof(RegistryKey).GetMethod("FromHandle", BindingFlags.Static | BindingFlags.Public, null, new[] { safeRegistryHandleType }, null);
key = keyFromHandleMethod.Invoke(null, new object[] { keyHandle });
}
var field = typeof(RegistryKey).GetField("keyName", BindingFlags.Instance | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(key, String.Empty);
}
return((RegistryKey)key);
}
else if (result == 2) // The key does not exist.
{
return(null);
}
throw new Win32Exception(result);
}
throw new PlatformNotSupportedException("The platform or operating system must be Windows 2000 or later.");
}
public static GenericRegistryValue get_value(RegistryHiveType hive, string subKeyPath, string registryValue)
{
var hiveActual = (RegistryHive)Enum.Parse(typeof(RegistryHive), hive.to_string(), ignoreCase: true);
IList <RegistryKey> keyLocations = new List <RegistryKey>();
if (Environment.Is64BitOperatingSystem)
{
keyLocations.Add(RegistryKey.OpenBaseKey(hiveActual, RegistryView.Registry64));
}
keyLocations.Add(RegistryKey.OpenBaseKey(hiveActual, RegistryView.Registry32));
GenericRegistryValue value = null;
foreach (var topLevelRegistryKey in keyLocations)
{
using (topLevelRegistryKey)
{
var key = topLevelRegistryKey.OpenSubKey(subKeyPath, RegistryKeyPermissionCheck.ReadSubTree, RegistryRights.ReadKey);
if (key != null)
{
value = FaultTolerance.try_catch_with_logging_exception(
() =>
{
if (key.GetValueNames().Contains(registryValue, StringComparer.InvariantCultureIgnoreCase))
{
return(new GenericRegistryValue
{
Name = registryValue,
ParentKeyName = key.Name,
Type = (RegistryValueKindType)Enum.Parse(typeof(RegistryValueKindType), key.GetValueKind(registryValue).to_string(), ignoreCase: true),
Value = key.get_value_as_string(registryValue),
});
}
return(null);
},
"Could not get registry value '{0}' from key '{1}'".format_with(registryValue, key.Name),
logWarningInsteadOfError: true);
if (value != null)
{
break;
}
}
}
}
return(value);
}
public static GenericRegistryValue get_value(RegistryHiveType hive, string subKeyPath, string registryValue)
{
var hiveActual = (RegistryHive)Enum.Parse(typeof(RegistryHive), hive.to_string(), ignoreCase: true);
IList<RegistryKey> keyLocations = new List<RegistryKey>();
if (Environment.Is64BitOperatingSystem)
{
keyLocations.Add(RegistryKey.OpenBaseKey(hiveActual, RegistryView.Registry64));
}
keyLocations.Add(RegistryKey.OpenBaseKey(hiveActual, RegistryView.Registry32));
GenericRegistryValue value = null;
foreach (var topLevelRegistryKey in keyLocations)
{
using (topLevelRegistryKey)
{
var key = topLevelRegistryKey.OpenSubKey(subKeyPath, RegistryKeyPermissionCheck.ReadSubTree, RegistryRights.ReadKey);
if (key != null)
{
value = FaultTolerance.try_catch_with_logging_exception(
() =>
{
if (key.GetValueNames().Contains(registryValue, StringComparer.InvariantCultureIgnoreCase))
{
return new GenericRegistryValue
{
Name = registryValue,
ParentKeyName = key.Name,
Type = (RegistryValueKindType)Enum.Parse(typeof(RegistryValueKindType), key.GetValueKind(registryValue).to_string(), ignoreCase: true),
Value = key.get_value_as_string(registryValue),
};
}
return null;
},
"Could not get registry value '{0}' from key '{1}'".format_with(registryValue, key.Name),
logWarningInsteadOfError: true);
if (value != null) break;
}
}
}
return value;
}
// For 3.5 compat. Taken from https://stackoverflow.com/questions/26217199/what-are-some-alternatives-to-registrykey-openbasekey-in-net-3-5
public static RegistryKey?OpenBaseKey(RegistryHive registryHive, RegistryHiveType registryType)
{
var _hiveKeys = new Dictionary <RegistryHive, UIntPtr>
{
{ RegistryHive.ClassesRoot, new UIntPtr(0x80000000u) },
{ RegistryHive.CurrentConfig, new UIntPtr(0x80000005u) },
{ RegistryHive.CurrentUser, new UIntPtr(0x80000001u) },
{ RegistryHive.DynData, new UIntPtr(0x80000006u) },
{ RegistryHive.LocalMachine, new UIntPtr(0x80000002u) },
{ RegistryHive.PerformanceData, new UIntPtr(0x80000004u) },
{ RegistryHive.Users, new UIntPtr(0x80000003u) }
};
var _accessMasks = new Dictionary <RegistryHiveType, RegistryAccessMask>
{
{ RegistryHiveType.X64, RegistryAccessMask.Wow6464 },
{ RegistryHiveType.X86, RegistryAccessMask.WoW6432 }
};
if (Environment.OSVersion.Platform != PlatformID.Win32NT || Environment.OSVersion.Version.Major <= 5)
{
throw new PlatformNotSupportedException(
"The platform or operating system must be Windows XP or later.");
}
var hiveKey = _hiveKeys[registryHive];
var flags = RegistryAccessMask.QueryValue | RegistryAccessMask.EnumerateSubKeys | _accessMasks[registryType];
var result = Advapi32.RegOpenKeyEx(hiveKey, string.Empty, 0, (uint)flags, out var keyHandlePointer);
if (result == 0)
{
var safeRegistryHandleType = typeof(SafeHandleZeroOrMinusOneIsInvalid).Assembly.GetType("Microsoft.Win32.SafeHandles.SafeRegistryHandle");
var safeRegistryHandleConstructor = safeRegistryHandleType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(IntPtr), typeof(bool) }, null); // .NET < 4
if (safeRegistryHandleConstructor == null)
{
safeRegistryHandleConstructor = safeRegistryHandleType.GetConstructor(
BindingFlags.Instance | BindingFlags.Public, null, new[] { typeof(IntPtr), typeof(bool) },
null); // .NET >= 4
}
var keyHandle = safeRegistryHandleConstructor.Invoke(new object[] { keyHandlePointer, true });
var net3Constructor = typeof(RegistryKey).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { safeRegistryHandleType, typeof(bool) }, null);
var net4Constructor = typeof(RegistryKey).GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(IntPtr), typeof(bool), typeof(bool), typeof(bool), typeof(bool) }, null);
object key;
if (net4Constructor != null)
{
key = net4Constructor.Invoke(new object[] { keyHandlePointer, true, false, false, hiveKey == _hiveKeys[RegistryHive.PerformanceData] });
}
else if (net3Constructor != null)
{
key = net3Constructor.Invoke(new object[] { keyHandle, true });
}
else
{
var keyFromHandleMethod = typeof(RegistryKey).GetMethod("FromHandle", BindingFlags.Static | BindingFlags.Public, null, new[] { safeRegistryHandleType }, null);
key = keyFromHandleMethod.Invoke(null, new object[] { keyHandle });
}
var field = typeof(RegistryKey).GetField("keyName", BindingFlags.Instance | BindingFlags.NonPublic);
if (field != null)
{
field.SetValue(key, string.Empty);
}
return((RegistryKey)key);
}
if (result == 2) // NOT_FOUND
{
return(null);
}
throw new Win32Exception(result);
}
public static byte[]? GetBinaryValue(RegistryHive hive, string path, string value, RegistryHiveType view = RegistryHiveType.X64)
{
var regValue = GetValue(hive, path, value, view);
return((byte[]?)regValue?.Value);
}
public static uint?GetDwordValue(RegistryHive hive, string path, string value, RegistryHiveType view = RegistryHiveType.X64)
{
var regValue = GetValue(hive, path, value, view);
if (regValue == null)
{
return(null);
}
if (uint.TryParse($"{regValue.Value}", out var output))
{
return(output);
}
try
{
// for big values
return(unchecked ((uint)((int)regValue.Value)));
}
catch
{
return(null);
}
}
public static string?GetStringValue(RegistryHive hive, string path, string value, RegistryHiveType view = RegistryHiveType.X64)
{
var regValue = GetValue(hive, path, value, view);
return(regValue?.Value.ToString());
}
private static RegistryKeyValue?GetValue(RegistryHive hive, string path, string value, RegistryHiveType view = RegistryHiveType.X64)
{
var regKey = OpenBaseKey(hive, view)?.OpenSubKey(path, RegistryKeyPermissionCheck.Default, RegistryRights.QueryValues);
var regKeyValue = regKey?.GetValue(value);
if (regKey == null || regKeyValue == null)
{
return(null);
}
var kind = regKey.GetValueKind(value);
return(new RegistryKeyValue(
path,
kind,
regKeyValue
));
}
