public static CleanupHandler InitializeHandler(string VolumeCacheName, string TargetDriveLetter)
{
var evcProps = new CleanupHandler()
{
DefaultName = VolumeCacheName
};
using (var rKey = Registry.LocalMachine.OpenSubKey(VolumeCacheStoreKey + VolumeCacheName, false))
{
// StateFlags specify if a particular handler was used last time Disk Cleanup ran as Administrator
evcProps.StateFlag = (int)rKey.GetValue("StateFlags", 0) == 0 ? false : true;
evcProps.HandlerGuid = new Guid((string)rKey.GetValue(null));
object evcInstance;
// This is needed due to Data Driven Cleaner {C0E13E61-0CC6-11d1-BBB6-0060978B2AE6} always throwing E_NOTIMPLEMENTED on <= Windows 7
try { evcInstance = Activator.CreateInstance(Type.GetTypeFromCLSID(evcProps.HandlerGuid)); }
catch
{
//System.Windows.Forms.MessageBox.Show(evcProps.HandlerGuid.ToString(), "Failed to load provider");
return(null);
}
// Check if newer interface with InitializeEx is available
if (evcInstance is IEmptyVolumeCache2 ex2Instance)
{
int initRes = ex2Instance.InitializeEx(rKey.Handle.DangerousGetHandle(), TargetDriveLetter, VolumeCacheName, out IntPtr ppwszDisplayName, out IntPtr ppwszDescription, out IntPtr ppwszBtnText, out uint pdwFlags);
// Discard handler if initialization failed
if (initRes != 0)
{
try { ex2Instance.Deactivate(out uint dummy); } catch { }
Marshal.FinalReleaseComObject(ex2Instance);
return(null);
}
evcProps.DisplayName = Marshal.PtrToStringAuto(ppwszDisplayName);
evcProps.Description = Marshal.PtrToStringAuto(ppwszDescription);
evcProps.ButtonText = Marshal.PtrToStringAuto(ppwszBtnText);
evcProps.Flags = (HandlerFlags)pdwFlags;
evcProps.Instance = ex2Instance;
}
else
{
// It appears that only the old interface is available
IEmptyVolumeCache vcInstance = (IEmptyVolumeCache)evcInstance;
int initRes = vcInstance.Initialize(rKey.Handle.DangerousGetHandle(), TargetDriveLetter, out IntPtr ppwszDisplayName, out IntPtr ppwszDescription, out uint pdwFlags);
// Discard handler if initialization failed
if (initRes != 0)
{
try { vcInstance.Deactivate(out uint dummy); } catch { }
Marshal.FinalReleaseComObject(vcInstance);
return(null);
}
evcProps.DisplayName = Marshal.PtrToStringAuto(ppwszDisplayName);
evcProps.Description = Marshal.PtrToStringAuto(ppwszDescription);
evcProps.Flags = (HandlerFlags)pdwFlags;
evcProps.Instance = vcInstance;
}
evcProps.IconHint = rKey.GetValue("IconPath", null);
if (evcProps.IconHint == null)
{
// Icons can sometimes be provided by the DefaultIcon of a handler's class
RegistryKey hkrKey = Registry.ClassesRoot.OpenSubKey(string.Format("CLSID\\{{{0}}}\\DefaultIcon", evcProps.HandlerGuid));
if (hkrKey != null)
{
evcProps.IconHint = (string)hkrKey.GetValue(null);
hkrKey.Close();
}
}
evcProps.PreProcHint = (string)rKey.GetValue("PreCleanupString", null);
evcProps.PostProcHint = (string)rKey.GetValue("CleanupString", null);
#region Multi-Type registry value to uint loader
object optValObj = rKey.GetValue("Flags");
if (optValObj != null)
{
RegistryValueKind optValKind = rKey.GetValueKind("Flags");
uint optVal = 0;
switch (optValKind)
{
case RegistryValueKind.Binary:
optVal = BitConverter.ToUInt32((byte[])optValObj, 0);
break;
case RegistryValueKind.DWord:
optVal = (uint)(int)optValObj;
break;
}
if (optVal > 0)
{
evcProps.DataDrivenFlags = (DDCFlags)optVal;
}
}
optValObj = rKey.GetValue("Priority");
if (optValObj != null)
{
RegistryValueKind optValKind = rKey.GetValueKind("Priority");
uint optVal = 0;
switch (optValKind)
{
case RegistryValueKind.Binary:
optVal = BitConverter.ToUInt32((byte[])optValObj, 0);
break;
case RegistryValueKind.DWord:
optVal = (uint)(int)optValObj;
break;
}
if (optVal > 0)
{
evcProps.Priority = optVal;
}
}
#endregion
// Multiple paths strike again, we check if there's a Property Bag or PE resource contain strings in case we still have none loaded
if (evcProps.DisplayName == null)
{
string optionalValue = (string)rKey.GetValue("PropertyBag", null);
if (optionalValue != null)
{
IPropertyBag pbInstance = (IPropertyBag)Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid(optionalValue)));
object bagContent = "";
if (pbInstance.Read("display", ref bagContent, IntPtr.Zero) == 0)
{
evcProps.DisplayName = (string)bagContent;
}
if (pbInstance.Read("Description", ref bagContent, IntPtr.Zero) == 0)
{
evcProps.Description = (string)bagContent;
}
if (pbInstance.Read("AdvancedButtonText", ref bagContent, IntPtr.Zero) == 0)
{
evcProps.ButtonText = (string)bagContent;
}
Marshal.FinalReleaseComObject(pbInstance);
return(evcProps);
}
optionalValue = (string)rKey.GetValue("display", null);
if (optionalValue != null)
{
StringBuilder strBld = new StringBuilder(513);
NativeMethods.SHLoadIndirectString(optionalValue, strBld, 513, IntPtr.Zero);
evcProps.DisplayName = strBld.ToString();
optionalValue = (string)rKey.GetValue("Description", null);
strBld.Clear();
NativeMethods.SHLoadIndirectString(optionalValue, strBld, 513, IntPtr.Zero);
evcProps.Description = strBld.ToString();
optionalValue = (string)rKey.GetValue("AdvancedButtonText", null);
strBld.Clear();
NativeMethods.SHLoadIndirectString(optionalValue, strBld, 513, IntPtr.Zero);
evcProps.ButtonText = strBld.ToString();
return(evcProps);
}
}
}
if (evcProps.DisplayName == null)
{
evcProps.DisplayName = VolumeCacheName;
}
return(evcProps);
}
private static void SetPolicyRegistryKey(string path, string name, object value, RegistryValueKind kind)
{
const string keyPath = @"Software\Microsoft\Windows\CurrentVersion\Group Policy Objects";
using (var rk = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Default))
{
List<string> certKeys;
using (var srk = rk.OpenSubKey(keyPath))
{
if (srk == null)
{
throw new ApplicationException("无法打开注册表项:" + keyPath);
}
certKeys = srk.GetSubKeyNames().Where(x => x.EndsWith("Machine")).Select(x => string.Format("{0}\\{1}\\{2}", keyPath, x, path))
//.Where(x => rk.OpenSubKey(x) == null)
.ToList();
}
foreach (var key in certKeys)
{
using (var skey = rk.CreateSubKey(key))
{
if (skey != null) skey.SetValue(name, value, kind);
}
}
}
}
private static int RegEnumValue (IntPtr keyBase,
int index, StringBuilder nameBuffer,
ref int nameLength, IntPtr reserved,
ref RegistryValueKind type, IntPtr data, IntPtr dataLength)
{
throw new System.NotImplementedException();
}
public bool set(String key, String val, RegistryValueKind type)
{
RegistryKey reg;
int result = 1;
string[] keysplit = (key).Split(System.IO.Path.DirectorySeparatorChar);
string root = keysplit[0];
string name = keysplit[keysplit.Length - 1];
string path = key.Replace(root + @"\", "").Replace(@"\" + name, "");
switch (root)
{
case "HKCU":
reg = Registry.CurrentUser;
break;
case "HKLM":
reg = Registry.LocalMachine;
break;
default:
return false;
}
reg = reg.CreateSubKey(path);
if (reg == null) result = 0;
reg.SetValue(name, val, type);
object regObj = reg.GetValue(name);
if (regObj == null) result = 0;
reg.Close();
reg = null;
if (result == 0) return false; else return true;
}
/// <summary>
/// Constructs a key value pair with the given valueName, valueObject, and valueKind.
/// Sets valueKind to RegistryValueKind.Unknown which will cause any call to RegistryKey.SetValue to attempt to dynamically derive the type from the actual type of the ValueObject.
/// </summary>
public RegValueSpec(string valueName, object valueObject, RegistryValueKind valueKind)
: this()
{
ValueName = valueName;
ValueObject = valueObject;
ValueKind = valueKind;
}
public static object ConvertUIntToValueForRegistryIfNeeded(object value, RegistryValueKind kind)
{
if (kind == RegistryValueKind.DWord)
{
try
{
value = BitConverter.ToInt32(BitConverter.GetBytes(Convert.ToUInt32(value, CultureInfo.InvariantCulture)), 0);
}
catch (OverflowException)
{
}
return value;
}
if (kind == RegistryValueKind.QWord)
{
try
{
value = BitConverter.ToInt64(BitConverter.GetBytes(Convert.ToUInt64(value, CultureInfo.InvariantCulture)), 0);
}
catch (OverflowException)
{
}
}
return value;
}
static extern uint RegQueryValueEx( UIntPtr hKey, string lpValueName, IntPtr lpReserved, out RegistryValueKind lpType, StringBuilder lpData, ref int lpcbData);
public void RegSzOddByteLength(RegistryValueKind kind, byte[] contents)
{
const string TestValueName = "CorruptData2";
SafeRegistryHandle handle = TestRegistryKey.Handle;
int ret = Interop.mincore.RegSetValueEx(handle, TestValueName, 0,
kind, contents, contents.Length);
Assert.Equal(0, ret);
try
{
object o = TestRegistryKey.GetValue(TestValueName);
string s;
if (kind == RegistryValueKind.MultiString)
{
Assert.IsType<string[]>(o);
var strings = (string[])o;
Assert.Equal(1, strings.Length);
s = strings[0];
}
else
{
Assert.IsType<string>(o);
s = (string)o;
}
Assert.Equal(2, s.Length);
Assert.Equal(0x506, s[0]);
Assert.Equal(0x6, s[1]);
}
finally
{
TestRegistryKey.DeleteValue(TestValueName);
}
}
public static object ConvertValueToUIntFromRegistryIfNeeded(string name, object value, RegistryValueKind kind)
{
try
{
if (kind == RegistryValueKind.DWord)
{
value = (int) value;
if (((int) value) < 0)
{
value = BitConverter.ToUInt32(BitConverter.GetBytes((int) value), 0);
}
return value;
}
if (kind == RegistryValueKind.QWord)
{
value = (long) value;
if (((long) value) < 0L)
{
value = BitConverter.ToUInt64(BitConverter.GetBytes((long) value), 0);
}
}
}
catch (IOException)
{
}
return value;
}
public static void PutObjectValue(string key, string valuename, string value, bool bHKLM, RegistryValueKind kind = RegistryValueKind.Unknown)
{
using (RegistryKey regkey = bHKLM ? Registry.LocalMachine.CreateSubKey(key) : Registry.CurrentUser.CreateSubKey(key))
{
regkey.SetValue(valuename, value, kind);
}
}
internal static extern int RegSetValueEx(
SafeRegistryHandle hKey,
String lpValueName,
int Reserved,
RegistryValueKind dwType,
String lpData,
int cbData);
public static object ConvertValueToUIntFromRegistryIfNeeded(string name, object value, RegistryValueKind kind)
{
try
{
// Workaround for CLR bug that doesn't support full range of DWORD or QWORD
if (kind == RegistryValueKind.DWord)
{
value = (int)value;
if ((int)value < 0)
{
value = BitConverter.ToUInt32(BitConverter.GetBytes((int)value), 0);
}
}
else if (kind == RegistryValueKind.QWord)
{
value = (long)value;
if ((long)value < 0)
{
value = BitConverter.ToUInt64(BitConverter.GetBytes((long)value), 0);
}
}
}
catch (System.IO.IOException)
{
// This is expected if the value does not exist.
}
return value;
}
public RegistryValueSnapshot(string name, string value, RegistryValueKind type)
: this()
{
this.Name = name;
this.Value = value;
this.Type = type;
}
public SetWindowsRegistryValueOperation(WindowsRegistryRoot root, string key, string valueName, string valueData, RegistryValueKind valueKind)
{
_root = root;
_key = key;
_valueName = valueName;
_valueData = valueData;
_valueKind = valueKind;
}
internal AddinKeyValue(WatchController root, AddinKey parent, string valueName, RegistryValueKind valueKind, object value)
{
_root = root;
_parent = parent;
_valueName = valueName;
_valueKind = valueKind;
_value = value;
}
public ValueForm(string name, RegistryValueKind type, object value)
: this()
{
this.IsEdit = true;
this.ValueName = name;
this.ValueType = type;
this.ValueValue = value;
}
public RegChange(RegOperations regOp, RegBasekeys regBase, string subKey, bool is32BitKey)
{
RegOperation = regOp;
RegBasekey = regBase;
SubKey = subKey;
RegValueKind = RegistryValueKind.String;
Is32BitKey = is32BitKey;
}
public ConfigRegistryItem(ConfigEngine engine, string itemName, string path, string name, object value, RegistryValueKind kind)
: base(engine, itemName)
{
_path = path;
_name = name;
_value = value;
_kind = kind;
}
public UtilsRegistryEntry Add(RegistryValueKind kind, object value)
{
RegistryKey key = _parent.Open(true);
string[] names = key.GetValueNames();
string name = GetNewStringValueName(names, kind.ToString());
key.SetValue(name, value, kind);
key.Close();
return new UtilsRegistryEntry(_parent, name);
}
private uint RegSetValueExACallback(IntPtr hKey, string lpValueName, int lpReserved, RegistryValueKind dwType, IntPtr lpData, uint cbData)
{
bool tempBuffer = false;
if (dwType == RegistryValueKind.String && lpData != IntPtr.Zero) tempBuffer = FilterWriteBuffer(ref lpData, ref cbData, unicode: false);
uint result = UnsafeNativeMethods.RegSetValueExA(hKey, lpValueName, lpReserved, dwType, lpData, cbData);
if (tempBuffer) Marshal.FreeHGlobal(lpData);
return result;
}
public CreateRegistryValueTask(string serverName, RegistryHive hive, string key, string valueName, RegistryValueKind valueType, object value)
{
ServerName = serverName;
Hive = hive;
Key = key;
_valueName = valueName;
_valueType = valueType;
_value = value;
}
public void SetValueWithUnknownValueKind(int testIndex, object testValue, RegistryValueKind expectedValueKind)
{
string valueName = "Testing_" + testIndex.ToString();
Registry.SetValue(_testRegistryKey.Name, valueName, testValue, RegistryValueKind.Unknown);
Assert.Equal(testValue.ToString(), _testRegistryKey.GetValue(valueName).ToString());
Assert.Equal(expectedValueKind, _testRegistryKey.GetValueKind(valueName));
_testRegistryKey.DeleteValue(valueName);
}
internal void CreateComponentValue(RegistryKey componentKey, string name, object value, RegistryValueKind kind)
{
if (null == componentKey)
throw new ArgumentNullException("Unable to find specified registry key.");
if (componentKey.GetValue(name, null) != null && componentKey.GetValueKind(name) != kind)
componentKey.DeleteValue(name, false);
componentKey.SetValue(name, value, kind);
}
public void SetValueWithExpandStringValueKind(int testIndex, object testValue, RegistryValueKind expectedValueKind)
{
string valueName = "Testing_" + testIndex.ToString();
expectedValueKind = RegistryValueKind.ExpandString;
Registry.SetValue(TestRegistryKey.Name, valueName, testValue, expectedValueKind);
Assert.Equal(testValue.ToString(), TestRegistryKey.GetValue(valueName).ToString());
Assert.Equal(expectedValueKind, TestRegistryKey.GetValueKind(valueName));
TestRegistryKey.DeleteValue(valueName);
}
public RegChange(RegOperations regOp, RegBasekeys regBase, string subKey, bool is32BitKey, string valueName, object valueData, RegistryValueKind valueType)
{
RegOperation = regOp;
RegBasekey = regBase;
SubKey = subKey;
ValueData = valueData;
ValueName = valueName;
RegValueKind = valueType;
Is32BitKey = is32BitKey;
}
public static void SetValue(string keyName, string valueName, object value, RegistryValueKind valueKind)
{
string subKeyName;
RegistryKey basekey = GetBaseKeyFromKeyName(keyName, out subKeyName);
using (RegistryKey key = basekey.CreateSubKey(subKeyName))
{
Debug.Assert(key != null, "An exception should be thrown if failed!");
key.SetValue(valueName, value, valueKind);
}
}
/// <remarks>引用组件来自:https://bitbucket.org/MartinEden/local-policy/overview </remarks>
private static void SetPolicyKey(string path, string name, object value, RegistryValueKind kind)
{
var gpo = new ComputerGroupPolicyObject();
using (var machine = gpo.GetRootRegistryKey(GroupPolicySection.Machine))
{
using (var cerKey = machine.CreateSubKey(path))
{
if (cerKey != null) cerKey.SetValue(name, value, kind);
}
}
gpo.Save();
}
private uint RegQueryValueExACallback(IntPtr hKey, string lpValueName, IntPtr lpReserved, out RegistryValueKind dwType, IntPtr lpData, ref uint cbData)
{
string filteredData = GetFilteredValue(hKey, lpValueName);
if (filteredData == null)
{ // Pass call through unmodified
return UnsafeNativeMethods.RegQueryValueExA(hKey, lpValueName, lpReserved, out dwType, lpData, ref cbData);
}
else
{ // Write filtered result to buffer
dwType = RegistryValueKind.String;
return WriteStringToBuffer(lpData, ref cbData, false, filteredData);
}
}
internal void CreateComponentValue(SingletonSettings.RegisterMode mode, string key, string name, object value, RegistryValueKind kind)
{
RegistryKey componentKey;
if (mode == SingletonSettings.RegisterMode.System)
componentKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(key, true);
else
componentKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(_userBypass + key, true);
if (null == componentKey)
throw new ArgumentOutOfRangeException("Unable to find specified registry key.");
CreateComponentValue(componentKey, name, value, kind);
}
/// <summary>
/// Записывает в реестр бинарные данные
/// </summary>
/// <param name="keyName">Имя ключа</param>
/// <param name="path">Путь к ключу (HKCU\\software\\)</param>
/// <param name="value">Значение</param>
/// <param name="registryValueKind">Тип</param>
public static void SetBinaryValue(string keyName, string path, object value, RegistryValueKind registryValueKind)
{
RegistryKey regKey = Registry.CurrentUser.CreateSubKey("software\\" + path);
if (regKey == null)
{
DebugHelper.WriteLogEntry("Не удалось сохранить значение " + keyName + " в реестр");
}
else
{
regKey.SetValue(keyName, value, registryValueKind);
regKey.Close();
}
}
protected static string GetRegistryKeyDisplayString(RegistryHive hive, string key,
string valueName = null, RegistryValueKind valueKind = RegistryValueKind.None)
{
var result = new StringBuilder();
result.AppendFormat(@"{0}\{1}", hive.AsRegistryHiveString(), key);
if (string.IsNullOrEmpty(valueName))
return result.ToString();
result.AppendFormat(@"\{0}", valueName);
if (valueKind == RegistryValueKind.None)
return result.ToString();
result.AppendFormat(@":{0}", valueKind.AsRegistryValueTypeString());
return result.ToString();
}
/// <summary>
/// Create a new registry handler description
/// </summary>
/// <param name="keyName"></param>
/// <param name="valueName"></param>
/// <param name="valueKind"></param>
public RegistrySettingHandlerDescription(string keyName, string valueName, RegistryValueKind valueKind) : base(HandlerKind.Registry)
{
KeyName = keyName;
ValueName = valueName;
ValueKind = valueKind;
}
public static void SetPolicySetting(string registryInformation, string settingValue, RegistryValueKind registryValueKind)
{
string valueName;
GroupPolicySection section;
string key = Key(registryInformation, out valueName, out section);
// Thread must be STA
Exception exception = null;
var t = new Thread(() =>
{
try
{
var gpo = new ComputerGroupPolicyObject();
using (RegistryKey rootRegistryKey = gpo.GetRootRegistryKey(section))
{
// Data can't be null so we can use this value to indicate key must be delete
if (settingValue == null)
{
using (RegistryKey subKey = rootRegistryKey.OpenSubKey(key, true))
{
if (subKey != null)
{
subKey.DeleteValue(valueName);
}
}
}
else
{
using (RegistryKey subKey = rootRegistryKey.CreateSubKey(key))
{
subKey.SetValue(valueName, settingValue, registryValueKind);
}
}
}
gpo.Save();
}
catch (Exception ex)
{
exception = ex;
}
});
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
if (exception != null)
{
throw exception;
}
}
private static int SetValue(UIntPtr rootKey, string Path, string Name, object Value, RegistryValueKind RegType, Platform hive)
{
GCHandle gch = new GCHandle();
IntPtr ptr;
int Size;
// So we have to figure out the type
if ((RegType == RegistryValueKind.Unknown))
{
switch (Value.GetType().ToString())
{
case "System.String":
RegType = RegistryValueKind.String;
break;
case "System.Int32":
RegType = RegistryValueKind.DWord;
break;
case "System.Int64":
RegType = RegistryValueKind.QWord;
break;
case "System.String[]":
RegType = RegistryValueKind.MultiString;
break;
case "System.Byte[]":
RegType = RegistryValueKind.Binary;
break;
default:
RegType = RegistryValueKind.String;
Value = Value.ToString();
break;
}
}
switch (RegType)
{
case RegistryValueKind.Binary:
{
byte[] temp = (byte[])
Value;
Size = temp.Length;
gch = GCHandle.Alloc(temp, GCHandleType.Pinned);
ptr = Marshal.UnsafeAddrOfPinnedArrayElement(temp, 0);
}
break;
case RegistryValueKind.DWord:
{
int temp = (int)Value;
Size = 4;
ptr = Marshal.AllocHGlobal(Size);
Marshal.WriteInt32(ptr, 0, temp);
}
break;
case RegistryValueKind.ExpandString:
{
string temp = Value.ToString();
Size = ((temp.Length + 1) * Marshal.SystemDefaultCharSize);
ptr = Marshal.StringToHGlobalAuto(temp);
}
break;
case RegistryValueKind.MultiString:
{
string[] lines = (string[])Value;
// Calculate the total size, including the terminating null
Size = 0;
foreach (string s in lines)
{
Size += (s.Length + 1) * Marshal.SystemDefaultCharSize;
}
Size += Marshal.SystemDefaultCharSize;
ptr = Marshal.AllocHGlobal(Size);
int index = 0;
foreach (string s in lines)
{
IntPtr tempPtr;
char[] tempArray = s.ToCharArray();
tempPtr = new IntPtr(ptr.ToInt64() + index);
Marshal.Copy(tempArray, 0, tempPtr, tempArray.Length);
index += (tempArray.Length + 1) * Marshal.SystemDefaultCharSize;
}
}
break;
case RegistryValueKind.QWord:
{
long temp = (long)Value;
Size = 8;
ptr = Marshal.AllocHGlobal(Size);
Marshal.WriteInt64(ptr, 0, temp);
}
break;
case RegistryValueKind.String:
{
string temp = Value.ToString();
Size = ((temp.Length + 1) * Marshal.SystemDefaultCharSize);
ptr = Marshal.StringToHGlobalAuto(temp);
}
break;
default:
throw new ApplicationException("Registry type of " + RegType + " is not supported");
}
// let's do it!
UIntPtr hKey = UIntPtr.Zero;
uint sam = KEY_SET_VALUE;
if ((GetPlatform() == Platform.X64))
{
if (Platform.X64 == hive)
{
sam |= KEY_WOW64_64KEY;
}
else if (Platform.X86 == hive)
{
sam |= KEY_WOW64_32KEY;
}
}
int HRES = 0;
HRES = RegOpenKeyEx(rootKey, Path, 0, sam, out hKey);
if (HRES == 0)
{
HRES = RegSetValueEx(hKey, Name, 0, RegType, ptr, Size);
if ((HRES != 0))
{
throw new Win32Exception(HRES);
}
// clean up
if (gch.IsAllocated)
{
gch.Free();
}
else
{
Marshal.FreeHGlobal(ptr);
}
RegCloseKey(hKey);
}
return(HRES);
}
public static extern bool SetupDiGetCustomDeviceProperty(SafeDeviceInfoSetHandle DeviceInfoSet, ref SP_DEVINFO_DATA DeviceInfoData, string CustomPropertyName, DICUSTOMDEVPROP Flags, out RegistryValueKind PropertyRegDataType, Byte[] PropertyBuffer, int PropertyBufferSize, out int RequiredSize);
private void SetValueCore(string name, Object value, RegistryValueKind valueKind)
{
// TODO: Implement this
throw new PlatformNotSupportedException();
}
// This dummy method is added to have the same implemenatation of Registry class.
// Its not being used anywhere.
public void SetValue(string name, object value, RegistryValueKind valueKind)
{
}
public static bool TryWriteRegistryKey(string path, string name, object value, RegistryValueKind kind)
{
try
{
// Use current user, no need for admin permissions
RegistryKey key = Registry.CurrentUser.OpenSubKey(path, true);
if (key == null)
{
key = CreateRegistryPath(Registry.CurrentUser, path);
}
key.SetValue(name, value, kind);
return(true);
}
catch {
return(false);
}
}
private static int MapRegistryValueKind(RegistryValueKind registryValueKind)
{
return((int)registryValueKind);
}
public void SetValue(string name, object value, RegistryValueKind valueKind)
{
this.SetDirty();
if (name == null)
{
name = string.Empty;
}
switch (valueKind)
{
case RegistryValueKind.String:
if (value is string)
{
this.values[name] = value;
return;
}
goto IL_186;
case RegistryValueKind.ExpandString:
if (value is string)
{
this.values[name] = new ExpandString((string)value);
return;
}
goto IL_186;
case RegistryValueKind.Binary:
if (value is byte[])
{
this.values[name] = value;
return;
}
goto IL_186;
case RegistryValueKind.DWord:
if (value is long && (long)value < 2147483647L && (long)value > -2147483648L)
{
this.values[name] = (int)((long)value);
return;
}
if (value is int)
{
this.values[name] = value;
return;
}
goto IL_186;
case RegistryValueKind.MultiString:
if (value is string[])
{
this.values[name] = value;
return;
}
goto IL_186;
case RegistryValueKind.QWord:
if (value is int)
{
this.values[name] = (long)((int)value);
return;
}
if (value is long)
{
this.values[name] = value;
return;
}
goto IL_186;
}
throw new ArgumentException("unknown value", "valueKind");
IL_186:
throw new ArgumentException("Value could not be converted to specified type", "valueKind");
}
// Метод-инициализатор экземпляра класса
private void CreateRegistryEntry(string Path, string Name, string Value, RegistryValueTypes Type, bool DeletePath, bool DeleteName)
{
// Переменные
char[] pathSplitters = new char[] { '\\' };
char[] valuesSplitters = new char[] { '\"', '[', ']' };
// Контроль пути
string[] values = Path.Split(valuesSplitters, StringSplitOptions.RemoveEmptyEntries);
if (values.Length != 1) // Означает наличие недопустимых символов или пустую строку
{
return;
}
pathMustBeDeleted = (values[0].Substring(0, 1) == "-"); // Раздел помечен на удаление
string s = values[0];
if (pathMustBeDeleted)
{
s = values[0].Substring(1);
}
pathMustBeDeleted |= DeletePath;
values = s.Split(pathSplitters, StringSplitOptions.RemoveEmptyEntries); // Убираем лишние слэшы
if (values.Length < 1) // Такого не должно случиться, но вдруг там только слэшы и были
{
return;
}
if (values[0] == Registry.ClassesRoot.Name)
{
valueMasterKey = Registry.ClassesRoot;
}
/*else if (values[0] == Registry.CurrentConfig.Name)
* valueMasterKey = Registry.CurrentConfig;
* else if (values[0] == Registry.CurrentUser.Name)
* valueMasterKey = Registry.CurrentUser;
* else if (values[0] == Registry.LocalMachine.Name)
* valueMasterKey = Registry.LocalMachine;
* else if (values[0] == Registry.Users.Name)
* valueMasterKey = Registry.Users;*/// Остальные разделы запрещены областью применения программы
else
{
return; // Если корневой раздел не является допустимым
}
// Пересобираем путь
valuePath = values[0];
for (int i = 1; i < values.Length; i++)
{
valuePath += (pathSplitters[0].ToString() + values[i]);
}
// Если путь помечен на удаление, остальные параметры можно (и нужно) проигнорировать
if (pathMustBeDeleted)
{
isValid = true;
return;
}
// Контроль имени
values = Name.Split(valuesSplitters, StringSplitOptions.RemoveEmptyEntries);
if (values.Length == 0) // Пустая строка здесь допустима - для значения по умолчанию
{
valueName = "";
}
else if (values.Length > 1)
{
return; // Означает наличие недопустимых символов или пустую строку
}
else
{
valueName = values[0];
}
if (valueName.Contains(pathSplitters[0].ToString()))
{
return;
}
if (valueName == "@")
{
valueName = "";
}
// Контроль значения (может содержать любые символы; предполагается, что кавычки уже удалены)
if ((Value == "-") || DeleteName) // Параметр помечен на удаление
{
nameMustBeDeleted = isValid = true;
valueObject = "-";
return;
}
// Проверка на наличие спецификации типа
if (Value.StartsWith("hex:"))
{
valueType = RegistryValueTypes.REG_BINARY;
}
if (Value.StartsWith("dword:"))
{
valueType = RegistryValueTypes.REG_DWORD;
}
if (Value.StartsWith("hex(2):"))
{
valueType = RegistryValueTypes.REG_EXPAND_SZ;
}
if (Value.StartsWith("hex(7):"))
{
valueType = RegistryValueTypes.REG_MULTI_SZ;
}
if (Value.StartsWith("hex(0):"))
{
valueType = RegistryValueTypes.REG_NONE;
}
if (Value.StartsWith("hex(b):"))
{
valueType = RegistryValueTypes.REG_QWORD;
}
// Обработка значения в зависимости от типа данных
switch (valueType)
{
case RegistryValueTypes.REG_SZ:
valueObject = Value;
break;
case RegistryValueTypes.REG_DWORD:
try
{
valueObject = (Int32.Parse(Value.Substring(6), NumberStyles.HexNumber)).ToString();
}
catch
{
return;
}
break;
case RegistryValueTypes.REG_QWORD:
try
{
Int64 a = Int64.Parse(Value.Substring(7).Replace(",", ""), NumberStyles.HexNumber);
a = (ExcludeByte(a, 0) << 56) | (ExcludeByte(a, 1) << 48) |
(ExcludeByte(a, 2) << 40) | (ExcludeByte(a, 3) << 32) |
(ExcludeByte(a, 4) << 24) | (ExcludeByte(a, 5) << 16) |
(ExcludeByte(a, 6) << 8) | ExcludeByte(a, 7);
valueObject = a.ToString();
}
catch
{
return;
}
break;
default:
return; // Остальные типы мы пока обрабатывать не умеем
}
// Переопределение, если указано (делается позже остального, чтобы не вынуждать значения,
// пропущенные через базу, обрабатываться снова)
if (Type != RegistryValueTypes.REG_SZ)
{
// Установка типа
valueType = Type;
switch (valueType)
{
case RegistryValueTypes.REG_BINARY:
valueTypeAsKind = RegistryValueKind.Binary;
break;
case RegistryValueTypes.REG_DWORD:
valueTypeAsKind = RegistryValueKind.DWord;
break;
case RegistryValueTypes.REG_EXPAND_SZ:
valueTypeAsKind = RegistryValueKind.ExpandString;
break;
case RegistryValueTypes.REG_MULTI_SZ:
valueTypeAsKind = RegistryValueKind.MultiString;
break;
case RegistryValueTypes.REG_NONE:
valueTypeAsKind = RegistryValueKind.None;
break;
case RegistryValueTypes.REG_QWORD:
valueTypeAsKind = RegistryValueKind.QWord;
break;
}
// Постконтроль значения (запрет на подстановку не-чисел в числовые типы)
try
{
if (valueType == RegistryValueTypes.REG_QWORD)
{
Int64 a = Int64.Parse(valueObject);
}
if (valueType == RegistryValueTypes.REG_DWORD)
{
Int32 b = Int32.Parse(valueObject);
}
}
catch
{
return;
}
}
// Завершено
isValid = true;
}
/// <summary>
/// Writes specified value to the registry.
/// </summary>
/// <param name="path">Full registry key (minus root) that will contain the value.</param>
/// <param name="valueName">Name of the value within key that will be written.</param>
/// <param name="value">Value to be written</param>
public void Write(string path, string valueName, object value)
{
RegistryKey key = Registry.ClassesRoot;
RegistryKey lastKey = key;
string[] parts = path.Split('\\');
if (parts == null || parts.Length == 0)
{
return;
}
for (int x = 0; x < parts.Length; x++)
{
key = key.OpenSubKey(parts[x], true);
if (key == null)
{
key = lastKey.CreateSubKey(parts[x]);
}
if (x == parts.Length - 1)
{
if (value is string)
{
key.SetValue(valueName, value.ToString());
}
else if (value is uint || value.GetType().IsEnum)
{
object o = key.GetValue(valueName, null);
if (o == null)
{
key.SetValue(valueName, value, RegistryValueKind.DWord);
}
else
{
RegistryValueKind kind = key.GetValueKind(valueName);
if (kind == RegistryValueKind.DWord)
{
key.SetValue(valueName, value, RegistryValueKind.DWord);
}
else if (kind == RegistryValueKind.Binary)
{
uint num = (uint)value;
byte[] b = new byte[4];
b[0] = (byte)((num & 0x000000FF) >> 0);
b[1] = (byte)((num & 0x0000FF00) >> 1);
b[2] = (byte)((num & 0x00FF0000) >> 2);
b[3] = (byte)((num & 0xFF000000) >> 3);
b[0] = (byte)((num & 0x000000FF) >> 0);
b[1] = (byte)((num & 0x0000FF00) >> 8);
b[2] = (byte)((num & 0x00FF0000) >> 16);
b[3] = (byte)((num & 0xFF000000) >> 24);
key.SetValue(valueName, b, RegistryValueKind.Binary);
}
else if (kind == RegistryValueKind.String)
{
key.SetValue(valueName, "x" + ((uint)value).ToString("X8"));
}
}
}
else if (value is Guid)
{
key.SetValue(valueName, ((Guid)value).ToString("B"));
}
}
lastKey = key;
}
if (key != null)
{
key.Close();
}
}
private static extern int RegQueryValueEx(IntPtr keyBase,
string valueName, IntPtr reserved, ref RegistryValueKind type,
ref long data, ref int dataSize);
private static extern int RegSetValueEx(IntPtr keyBase,
string valueName, IntPtr reserved, RegistryValueKind type,
ref long data, int rawDataLength);
/// <summary>
/// 设置注册表值(HKEY_CLASSES_ROOT)
/// </summary>
/// <param name="regeditKey">注册表项</param>
/// <param name="regeditName">注册表键</param>
/// <param name="regeditValue">数据</param>
/// <param name="valueKind">RegistryValueKind 枚举</param>
/// <returns></returns>
public static bool SetValueClassesRoot(string regeditKey, string regeditName, object regeditValue, RegistryValueKind valueKind = RegistryValueKind.None)
{
return(SetValue(RegeditTypeEnum.HKEY_CLASSES_ROOT, regeditKey, regeditName, regeditValue, valueKind));
}
/// <summary>
/// Méthode qui permet d'écrire une valeur qui aura pour contenu une chaîne de caractères
/// </summary>
/// <param name="path">Chemin pour écrire la valeur à ajouter</param>
/// <param name="valueName">Nom de la valeur à ajouter</param>
/// <param name="value">Contenu de la valeur à ajouter</param>
/// <param name="valueKind">Type de la valeur à ajouter</param>
/// <param name="rV">Type de registre (32 ou 64 bits)</param>
public static void EcrireRegistre(string path, string valueName, string value, RegistryValueKind valueKind, RegistryView rV)
{
var baseReg = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, rV); //Ouvre un nouveau RegistryKey qui représente la clé demandée sur l'ordinateur local avec la vue spécifiée.
var reg = baseReg.CreateSubKey(path); //Création d'une variable avec le chemin spécifié
try
{
reg = baseReg.OpenSubKey(path, true); //On tente d'ouvrir la sous-clé avec le chemin indiqué
if (reg == null)
{
baseReg.CreateSubKey(path); //Si il est impossible d'ouvrir cette sous-clé, on la crée
}
reg.SetValue(valueName, value, valueKind); //Ensuite on défini la valeur, le nom et le type de la valeur pour cette sous-clé
}
catch (Exception er)
{
MessageBox.Show(er.Message, "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Stop); //En cas d'erreur, on affiche un message
}
finally
{
baseReg.Close();
}
}
public unsafe void SetValue(String name, Object value, RegistryValueKind valueKind)
{
if (value == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
}
if (name != null && name.Length > MaxValueLength)
{
throw new ArgumentException(SR.Arg_RegValStrLenBug);
}
if (!Enum.IsDefined(typeof(RegistryValueKind), valueKind))
{
throw new ArgumentException(SR.Arg_RegBadKeyKind, nameof(valueKind));
}
EnsureWriteable();
if (valueKind == RegistryValueKind.Unknown)
{
// this is to maintain compatibility with the old way of autodetecting the type.
// SetValue(string, object) will come through this codepath.
valueKind = CalculateValueKind(value);
}
int ret = 0;
try
{
switch (valueKind)
{
case RegistryValueKind.ExpandString:
case RegistryValueKind.String:
{
String data = value.ToString();
ret = Win32Native.RegSetValueEx(hkey,
name,
0,
valueKind,
data,
checked (data.Length * 2 + 2));
break;
}
case RegistryValueKind.MultiString:
{
// Other thread might modify the input array after we calculate the buffer length.
// Make a copy of the input array to be safe.
string[] dataStrings = (string[])(((string[])value).Clone());
int sizeInBytes = 0;
// First determine the size of the array
//
for (int i = 0; i < dataStrings.Length; i++)
{
if (dataStrings[i] == null)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSetStrArrNull);
}
sizeInBytes = checked (sizeInBytes + (dataStrings[i].Length + 1) * 2);
}
sizeInBytes = checked (sizeInBytes + 2);
byte[] basePtr = new byte[sizeInBytes];
fixed(byte *b = basePtr)
{
IntPtr currentPtr = new IntPtr((void *)b);
// Write out the strings...
//
for (int i = 0; i < dataStrings.Length; i++)
{
// Assumes that the Strings are always null terminated.
String.InternalCopy(dataStrings[i], currentPtr, (checked (dataStrings[i].Length * 2)));
currentPtr = new IntPtr((long)currentPtr + (checked (dataStrings[i].Length * 2)));
*(char *)(currentPtr.ToPointer()) = '\0';
currentPtr = new IntPtr((long)currentPtr + 2);
}
*(char *)(currentPtr.ToPointer()) = '\0';
currentPtr = new IntPtr((long)currentPtr + 2);
ret = Win32Native.RegSetValueEx(hkey,
name,
0,
RegistryValueKind.MultiString,
basePtr,
sizeInBytes);
}
break;
}
case RegistryValueKind.None:
case RegistryValueKind.Binary:
byte[] dataBytes = (byte[])value;
ret = Win32Native.RegSetValueEx(hkey,
name,
0,
(valueKind == RegistryValueKind.None ? Win32Native.REG_NONE : RegistryValueKind.Binary),
dataBytes,
dataBytes.Length);
break;
case RegistryValueKind.DWord:
{
// We need to use Convert here because we could have a boxed type cannot be
// unboxed and cast at the same time. I.e. ((int)(object)(short) 5) will fail.
int data = Convert.ToInt32(value, System.Globalization.CultureInfo.InvariantCulture);
ret = Win32Native.RegSetValueEx(hkey,
name,
0,
RegistryValueKind.DWord,
ref data,
4);
break;
}
case RegistryValueKind.QWord:
{
long data = Convert.ToInt64(value, System.Globalization.CultureInfo.InvariantCulture);
ret = Win32Native.RegSetValueEx(hkey,
name,
0,
RegistryValueKind.QWord,
ref data,
8);
break;
}
}
}
catch (OverflowException)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSetMismatchedKind);
}
catch (InvalidOperationException)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSetMismatchedKind);
}
catch (FormatException)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSetMismatchedKind);
}
catch (InvalidCastException)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_RegSetMismatchedKind);
}
if (ret == 0)
{
SetDirty();
}
else
{
Win32Error(ret, null);
}
}
// レジストリキーをコピー
private void CopyRegistryKey(string source, string destination)
{
Action <RegistryKey, RegistryKey> copyRegKey = null;
copyRegKey = (srcKey, dstKey) =>
{
foreach (string paramName in srcKey.GetValueNames())
{
RegistryValueKind valueKind = srcKey.GetValueKind(paramName);
dstKey.SetValue(
paramName,
valueKind == RegistryValueKind.ExpandString ?
srcKey.GetValue(paramName, "", RegistryValueOptions.DoNotExpandEnvironmentNames) :
srcKey.GetValue(paramName),
valueKind);
}
foreach (string keyName in srcKey.GetSubKeyNames())
{
using (RegistryKey subSrcKey = srcKey.OpenSubKey(keyName, false))
using (RegistryKey subDstKey = dstKey.CreateSubKey(keyName, true))
{
try
{
copyRegKey(subSrcKey, subDstKey);
}
catch (System.Security.SecurityException)
{
Console.WriteLine("アクセス拒否：SecurityException\r\n" + keyName);
}
catch (UnauthorizedAccessException)
{
Console.WriteLine("アクセス拒否：UnauthorizedAccessException\r\n" + keyName);
}
catch (ArgumentException)
{
// 無効なValueKindのレジストリ値への対策
// reg copyコマンドでコピー実行
using (Process proc = new Process())
{
proc.StartInfo.FileName = "reg.exe";
proc.StartInfo.Arguments = $@"copy ""{subSrcKey.ToString()}"" ""{subDstKey.ToString()}"" /s /f";
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.Start();
proc.WaitForExit();
}
}
}
}
};
// テスト自動生成
TestGenerator.RegistryKey(source);
TestGenerator.RegistryKey(destination);
using (RegistryKey sourceKey = RegistryControl.GetRegistryKey(source, false, true))
using (RegistryKey destinationKey = RegistryControl.GetRegistryKey(destination, true, true))
{
copyRegKey(sourceKey, destinationKey);
// コピー元を削除する場合
sourceKey.DeleteSubKeyTree("");
}
}
/// <summary>
/// Retrieves the part of the sqlUserInstance.dll from the registry
/// </summary>
/// <param name="errorState">In case the dll path is not found, the error is set here.</param>
/// <returns></returns>
private string GetUserInstanceDllPath(out LocalDBErrorState errorState)
{
string dllPath = null;
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(LocalDBInstalledVersionRegistryKey))
{
if (key == null)
{
errorState = LocalDBErrorState.NO_INSTALLATION;
return(null);
}
Version zeroVersion = new Version();
Version latestVersion = zeroVersion;
foreach (string subKey in key.GetSubKeyNames())
{
Version currentKeyVersion;
if (!Version.TryParse(subKey, out currentKeyVersion))
{
errorState = LocalDBErrorState.INVALID_CONFIG;
return(null);
}
if (latestVersion.CompareTo(currentKeyVersion) < 0)
{
latestVersion = currentKeyVersion;
}
}
// If no valid versions are found, then error out
if (latestVersion.Equals(zeroVersion))
{
errorState = LocalDBErrorState.INVALID_CONFIG;
return(null);
}
// Use the latest version to get the DLL path
using (RegistryKey latestVersionKey = key.OpenSubKey(latestVersion.ToString()))
{
object instanceAPIPathRegistryObject = latestVersionKey.GetValue(InstanceAPIPathValueName);
if (instanceAPIPathRegistryObject == null)
{
errorState = LocalDBErrorState.NO_SQLUSERINSTANCEDLL_PATH;
return(null);
}
RegistryValueKind valueKind = latestVersionKey.GetValueKind(InstanceAPIPathValueName);
if (valueKind != RegistryValueKind.String)
{
errorState = LocalDBErrorState.INVALID_SQLUSERINSTANCEDLL_PATH;
return(null);
}
dllPath = (string)instanceAPIPathRegistryObject;
errorState = LocalDBErrorState.NONE;
return(dllPath);
}
}
}
private void SetValue(string keyId, string valueName, int valueValue, RegistryValueKind kind)
{
Registry.SetValue(keyId, valueName, valueValue, kind);
Console.WriteLine($"Setting {valueName} to {valueValue}");
}
private string ProceedExportResult(object reg)
{
StringBuilder result = new StringBuilder();
bool useSystem = Settings.Mode == SingletonSettings.RegisterMode.System;
string rootKey = useSystem ? "[HKEY_LOCAL_MACHINE\\" : "[HKEY_CURRENT_USER\\";
bool firstFlag = true;
IEnumerable list = reg as IEnumerable;
if (null != list)
{
foreach (object item in list)
{
Type itemType = item.GetType();
if (firstFlag)
{
firstFlag = false;
}
else
{
result.AppendLine(String.Empty);
}
string key = itemType.InvokeMember("Key",
BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance,
null, item, new object[0]) as string;
if (null != key)
{
if (key.StartsWith("\\"))
{
key = key.Substring("\\".Length);
}
result.AppendLine(String.Format("{0}{1}]", rootKey, key));
}
IEnumerable values = itemType.InvokeMember("Value",
BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance,
null, item, new object[0]) as IEnumerable;
if (values != null)
{
foreach (object value in values)
{
Type valueType = value.GetType();
string name = valueType.InvokeMember("Name", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance, null, value, new object[0]) as string;
object val = valueType.InvokeMember("Value", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance, null, value, new object[0]);
RegistryValueKind kind = (RegistryValueKind)valueType.InvokeMember("Kind", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance, null, value, new object[0]);
if (String.IsNullOrWhiteSpace(name))
{
name = "@";
}
else
{
name = "\"" + name + "\"";
}
switch (kind)
{
case RegistryValueKind.String:
result.AppendLine(String.Format("{0}=\"{1}\"", name, null != val ? val.ToString() : String.Empty));
break;
case RegistryValueKind.ExpandString:
result.AppendLine(String.Format("{0}={1}", name, null != val ? RegValueConverter.EncryptExpandString(val.ToString(), 13) : String.Empty));
break;
case RegistryValueKind.MultiString:
if (val is string[])
{
result.AppendLine(String.Format("{0}={1}", name, null != val ? RegValueConverter.EncryptMultiString(val as string[]) : String.Empty));
}
break;
case RegistryValueKind.Binary:
if (val is byte[])
{
result.AppendLine(String.Format("{0}={1}", name, null != val ? RegValueConverter.EncryptBinary(val as byte[]) : String.Empty));
}
break;
case RegistryValueKind.DWord:
result.AppendLine(String.Format("{0}=dword:{1}", name, RegValueConverter.ToDwordString(val)));
break;
case RegistryValueKind.QWord:
result.AppendLine(String.Format("{0}={1}", name, RegValueConverter.EncryptQ(Convert.ToInt64(val))));
break;
case RegistryValueKind.Unknown:
case RegistryValueKind.None:
default:
break;
}
}
}
}
}
if (result.Length == 0)
{
return(null);
}
else
{
return(Environment.NewLine + "; --- Custom Export ---" + Environment.NewLine + result.ToString());
}
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="value"></param>
/// <param name="valueType"></param>
public RegistryNameValuePair(string name, object value, RegistryValueKind valueType)
: this(name, value)
{
_valueType = valueType;
}
public static extern bool SetupDiGetDeviceRegistryProperty(SafeDeviceInfoSetHandle DeviceInfoSet, ref SP_DEVINFO_DATA DeviceInfoData, SPDRP Property, out RegistryValueKind PropertyRegDataType, byte[] PropertyBuffer, int PropertyBufferSize, out int RequiredSize);
private unsafe void SetValueCore(string name, object value, RegistryValueKind valueKind)
{
int ret = 0;
try
{
switch (valueKind)
{
case RegistryValueKind.ExpandString:
case RegistryValueKind.String:
{
string data = value.ToString();
ret = Interop.Advapi32.RegSetValueEx(_hkey,
name,
0,
valueKind,
data,
checked (data.Length * 2 + 2));
break;
}
case RegistryValueKind.MultiString:
{
// Other thread might modify the input array after we calculate the buffer length.
// Make a copy of the input array to be safe.
string[] dataStrings = (string[])(((string[])value).Clone());
// First determine the size of the array
//
// Format is null terminator between strings and final null terminator at the end.
// e.g. str1\0str2\0str3\0\0
//
int sizeInChars = 1; // no matter what, we have the final null terminator.
for (int i = 0; i < dataStrings.Length; i++)
{
if (dataStrings[i] == null)
{
ThrowHelper.ThrowArgumentException(SR.Arg_RegSetStrArrNull);
}
sizeInChars = checked (sizeInChars + (dataStrings[i].Length + 1));
}
int sizeInBytes = checked (sizeInChars * sizeof(char));
// Write out the strings...
//
char[] dataChars = new char[sizeInChars];
int destinationIndex = 0;
for (int i = 0; i < dataStrings.Length; i++)
{
int length = dataStrings[i].Length;
dataStrings[i].CopyTo(0, dataChars, destinationIndex, length);
destinationIndex += (length + 1); // +1 for null terminator, which is already zero-initialized in new array.
}
ret = Interop.Advapi32.RegSetValueEx(_hkey,
name,
0,
RegistryValueKind.MultiString,
dataChars,
sizeInBytes);
break;
}
case RegistryValueKind.None:
case RegistryValueKind.Binary:
byte[] dataBytes = (byte[])value;
ret = Interop.Advapi32.RegSetValueEx(_hkey,
name,
0,
(valueKind == RegistryValueKind.None ? Interop.Advapi32.RegistryValues.REG_NONE : RegistryValueKind.Binary),
dataBytes,
dataBytes.Length);
break;
case RegistryValueKind.DWord:
{
// We need to use Convert here because we could have a boxed type cannot be
// unboxed and cast at the same time. I.e. ((int)(object)(short) 5) will fail.
int data = Convert.ToInt32(value, System.Globalization.CultureInfo.InvariantCulture);
ret = Interop.Advapi32.RegSetValueEx(_hkey,
name,
0,
RegistryValueKind.DWord,
ref data,
4);
break;
}
case RegistryValueKind.QWord:
{
long data = Convert.ToInt64(value, System.Globalization.CultureInfo.InvariantCulture);
ret = Interop.Advapi32.RegSetValueEx(_hkey,
name,
0,
RegistryValueKind.QWord,
ref data,
8);
break;
}
}
}
catch (Exception exc) when(exc is OverflowException || exc is InvalidOperationException || exc is FormatException || exc is InvalidCastException)
{
ThrowHelper.ThrowArgumentException(SR.Arg_RegSetMismatchedKind);
}
if (ret == 0)
{
SetDirty();
}
else
{
Win32Error(ret, null);
}
}
/// <summary>
/// 设置注册表值(HKEY_CURRENT_USER)
/// </summary>
/// <param name="regeditKey">注册表项</param>
/// <param name="regeditName">注册表键</param>
/// <param name="regeditValue">数据</param>
/// <param name="valueKind">RegistryValueKind 枚举</param>
/// <returns></returns>
public static bool SetValueCurrentUser(string regeditKey, string regeditName, object regeditValue, RegistryValueKind valueKind = RegistryValueKind.None)
{
return(SetValue(RegeditTypeEnum.HKEY_CURRENT_USER, regeditKey, regeditName, regeditValue, valueKind));
}
private bool CompareValueKinds(AddinKey item, RegistryValueKind kindToCompare)
{
return(true);
}
public static RegistryKeyClass Create(string hkeyPath, EActivationParameter enableFunction, string allowText, RegistryValueKind valueKind, ERegistryHkey hkey = ERegistryHkey.LOCALMACHINE)
{
return(new RegistryKeyClass(hkeyPath, enableFunction, allowText, valueKind, hkey));
}
internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
int Reserved, RegistryValueKind dwType, String lpData, int cbData);
/// <summary>
/// Retrieves the part of the sqlUserInstance.dll from the registry
/// </summary>
/// <param name="errorState">In case the dll path is not found, the error is set here.</param>
/// <returns></returns>
private string GetUserInstanceDllPath(out LocalDBErrorState errorState)
{
long scopeID = SqlClientEventSource.Log.TrySNIScopeEnterEvent(s_className);
try
{
string dllPath = null;
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(LocalDBInstalledVersionRegistryKey))
{
if (key == null)
{
errorState = LocalDBErrorState.NO_INSTALLATION;
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.ERR, "No installation found.");
return(null);
}
Version zeroVersion = new Version();
Version latestVersion = zeroVersion;
foreach (string subKey in key.GetSubKeyNames())
{
Version currentKeyVersion;
if (!Version.TryParse(subKey, out currentKeyVersion))
{
errorState = LocalDBErrorState.INVALID_CONFIG;
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.ERR, "Invalid Configuration.");
return(null);
}
if (latestVersion.CompareTo(currentKeyVersion) < 0)
{
latestVersion = currentKeyVersion;
}
}
// If no valid versions are found, then error out
if (latestVersion.Equals(zeroVersion))
{
errorState = LocalDBErrorState.INVALID_CONFIG;
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.ERR, "Invalid Configuration.");
return(null);
}
// Use the latest version to get the DLL path
using (RegistryKey latestVersionKey = key.OpenSubKey(latestVersion.ToString()))
{
object instanceAPIPathRegistryObject = latestVersionKey.GetValue(InstanceAPIPathValueName);
if (instanceAPIPathRegistryObject == null)
{
errorState = LocalDBErrorState.NO_SQLUSERINSTANCEDLL_PATH;
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.ERR, "No SQL user instance DLL. Instance API Path Registry Object Error.");
return(null);
}
RegistryValueKind valueKind = latestVersionKey.GetValueKind(InstanceAPIPathValueName);
if (valueKind != RegistryValueKind.String)
{
errorState = LocalDBErrorState.INVALID_SQLUSERINSTANCEDLL_PATH;
SqlClientEventSource.Log.TrySNITraceEvent(s_className, EventType.ERR, "Invalid SQL user instance DLL path. Registry value kind mismatch.");
return(null);
}
dllPath = (string)instanceAPIPathRegistryObject;
errorState = LocalDBErrorState.NONE;
return(dllPath);
}
}
}
finally
{
SqlClientEventSource.Log.TrySNIScopeLeaveEvent(scopeID);
}
}
/// <summary>
/// 设置注册表启动项
/// </summary>
/// <param name="regeditName">注册表键</param>
/// <param name="regeditValue">数据</param>
/// <param name="valueKind">RegistryValueKind 枚举</param>
/// <returns></returns>
public static bool SetValueRun(string regeditName, object regeditValue, RegistryValueKind valueKind = RegistryValueKind.None)
{
return(SetValueLocalMachine(REGEDIT_KEY_RUN, regeditName, regeditValue, valueKind));
}
