private void AssertNotMarkedForDeletion() { if (IsMarkedForDeletion) { throw RegistryKey.CreateMarkedForDeletionException(); } }
public int SubKeyCount(RegistryKey rkey) { StringBuilder stringBuilder = new StringBuilder(1024); IntPtr handle = Win32RegistryApi.GetHandle(rkey); int num = 0; for (;;) { int num2 = Win32RegistryApi.RegEnumKey(handle, num, stringBuilder, stringBuilder.Capacity); if (num2 == 1018) { break; } if (num2 != 0) { if (num2 == 259) { return(num); } this.GenerateException(num2); } num++; } throw RegistryKey.CreateMarkedForDeletionException(); }
public string[] GetValueNames(RegistryKey rkey) { IntPtr handle = Win32RegistryApi.GetHandle(rkey); ArrayList arrayList = new ArrayList(); int num = 0; for (;;) { StringBuilder stringBuilder = new StringBuilder(1024); int capacity = stringBuilder.Capacity; RegistryValueKind registryValueKind = RegistryValueKind.Unknown; int num2 = Win32RegistryApi.RegEnumValue(handle, num, stringBuilder, ref capacity, IntPtr.Zero, ref registryValueKind, IntPtr.Zero, IntPtr.Zero); if (num2 == 0 || num2 == 234) { arrayList.Add(stringBuilder.ToString()); } else { if (num2 == 259) { break; } if (num2 == 1018) { goto Block_3; } this.GenerateException(num2); } num++; } return((string[])arrayList.ToArray(typeof(string))); Block_3: throw RegistryKey.CreateMarkedForDeletionException(); }
/// <summary> /// convert a win32 error code into an appropriate exception. /// </summary> private void GenerateException(int errorCode) { switch (errorCode) { case Win32ResultCode.FileNotFound: case Win32ResultCode.InvalidParameter: throw new ArgumentException(); case Win32ResultCode.AccessDenied: throw new SecurityException(); case Win32ResultCode.NetworkPathNotFound: throw new IOException("The network path was not found."); case Win32ResultCode.InvalidHandle: throw new IOException("Invalid handle."); case Win32ResultCode.MarkedForDeletion: throw RegistryKey.CreateMarkedForDeletionException(); case Win32ResultCode.ChildMustBeVolatile: throw new IOException("Cannot create a stable subkey under a volatile parent key."); default: // unidentified system exception throw new SystemException(); } }
public int ValueCount(RegistryKey rkey) { StringBuilder stringBuilder = new StringBuilder(1024); IntPtr handle = Win32RegistryApi.GetHandle(rkey); int num = 0; for (;;) { RegistryValueKind registryValueKind = RegistryValueKind.Unknown; int capacity = stringBuilder.Capacity; int num2 = Win32RegistryApi.RegEnumValue(handle, num, stringBuilder, ref capacity, IntPtr.Zero, ref registryValueKind, IntPtr.Zero, IntPtr.Zero); if (num2 == 1018) { break; } if (num2 != 0 && num2 != 234) { if (num2 == 259) { return(num); } this.GenerateException(num2); } num++; } throw RegistryKey.CreateMarkedForDeletionException(); }
public int SubKeyCount(RegistryKey rkey) { int index; StringBuilder stringBuffer = new StringBuilder(BufferMaxLength); IntPtr handle = GetHandle(rkey); for (index = 0; true; index++) { int result = RegEnumKey(handle, index, stringBuffer, stringBuffer.Capacity); if (result == Win32ResultCode.MarkedForDeletion) { throw RegistryKey.CreateMarkedForDeletionException(); } if (result == Win32ResultCode.Success) { continue; } if (result == Win32ResultCode.NoMoreEntries) { break; } // something is wrong!! GenerateException(result); } return(index); }
public string [] GetValueNames(RegistryKey rkey) { IntPtr handle = GetHandle(rkey); var values = new List <string> (); for (int index = 0; true; index++) { StringBuilder buffer = new StringBuilder(BufferMaxLength); int bufferCapacity = buffer.Capacity; RegistryValueKind type = 0; int result = RegEnumValue(handle, index, buffer, ref bufferCapacity, IntPtr.Zero, ref type, IntPtr.Zero, IntPtr.Zero); if (result == Win32ResultCode.Success || result == Win32ResultCode.MoreData) { values.Add(buffer.ToString()); continue; } if (result == Win32ResultCode.NoMoreEntries) { break; } if (result == Win32ResultCode.MarkedForDeletion) { throw RegistryKey.CreateMarkedForDeletionException(); } GenerateException(result); } return(values.ToArray()); }
public void SetValue(RegistryKey rkey, string name, object value, RegistryValueKind valueKind) { KeyHandler keyHandler = KeyHandler.Lookup(rkey, true); if (keyHandler == null) { throw RegistryKey.CreateMarkedForDeletionException(); } keyHandler.SetValue(name, value, valueKind); }
private RegistryKey CreateSubKey(RegistryKey rkey, string keyname, bool writable) { KeyHandler keyHandler = KeyHandler.Lookup(rkey, true); if (keyHandler == null) { throw RegistryKey.CreateMarkedForDeletionException(); } return(keyHandler.Ensure(rkey, UnixRegistryApi.ToUnix(keyname), writable)); }
public int ValueCount(RegistryKey rkey) { KeyHandler keyHandler = KeyHandler.Lookup(rkey, true); if (keyHandler == null) { throw RegistryKey.CreateMarkedForDeletionException(); } return(keyHandler.ValueCount); }
public string[] GetValueNames(RegistryKey rkey) { KeyHandler keyHandler = KeyHandler.Lookup(rkey, true); if (keyHandler == null) { throw RegistryKey.CreateMarkedForDeletionException(); } return(keyHandler.GetValueNames()); }
public int SubKeyCount(RegistryKey rkey) { KeyHandler self = KeyHandler.Lookup(rkey, true); if (self == null) { throw RegistryKey.CreateMarkedForDeletionException(); } return(self.GetSubKeyCount()); }
public int SubKeyCount(RegistryKey rkey) { KeyHandler keyHandler = KeyHandler.Lookup(rkey, true); if (keyHandler == null) { throw RegistryKey.CreateMarkedForDeletionException(); } return(Directory.GetDirectories(keyHandler.Dir).Length); }
public void SetValue(RegistryKey rkey, string name, object value) { KeyHandler self = KeyHandler.Lookup(rkey, true); if (self == null) { throw RegistryKey.CreateMarkedForDeletionException(); } self.SetValue(name, value); }
public void SetValue(RegistryKey rkey, string name, object value) { Type type = value.GetType(); int result; IntPtr handle = GetHandle(rkey); if (type == typeof(int)) { int rawValue = (int)value; result = RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.DWord, ref rawValue, Int32ByteSize); } else if (type == typeof(byte[])) { byte[] rawValue = (byte[])value; result = RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.Binary, rawValue, rawValue.Length); } else if (type == typeof(string[])) { string[] vals = (string[])value; StringBuilder fullStringValue = new StringBuilder(); foreach (string v in vals) { fullStringValue.Append(v); fullStringValue.Append('\0'); } fullStringValue.Append('\0'); byte[] rawValue = Encoding.Unicode.GetBytes(fullStringValue.ToString()); result = RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.MultiString, rawValue, rawValue.Length); } else if (type.IsArray) { throw new ArgumentException("Only string and byte arrays can written as registry values"); } else { string rawValue = String.Format("{0}{1}", value, '\0'); result = RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.String, rawValue, rawValue.Length * NativeBytesPerCharacter); } if (result == Win32ResultCode.MarkedForDeletion) { throw RegistryKey.CreateMarkedForDeletionException(); } // handle the result codes if (result != Win32ResultCode.Success) { GenerateException(result); } }
private RegistryKey CreateSubKey(RegistryKey rkey, string keyname, bool writable, bool is_volatile) { KeyHandler self = KeyHandler.Lookup(rkey, true); if (self == null) { throw RegistryKey.CreateMarkedForDeletionException(); } if (KeyHandler.VolatileKeyExists(self.Dir) && !is_volatile) { throw new IOException("Cannot create a non volatile subkey under a volatile key."); } return(self.Ensure(rkey, ToUnix(keyname), writable, is_volatile)); }
public RegistryKey CreateSubKey(RegistryKey rkey, string keyName) { IntPtr handle = Win32RegistryApi.GetHandle(rkey); IntPtr intPtr; int num = Win32RegistryApi.RegCreateKey(handle, keyName, out intPtr); if (num == 1018) { throw RegistryKey.CreateMarkedForDeletionException(); } if (num != 0) { this.GenerateException(num); } return(new RegistryKey(intPtr, Win32RegistryApi.CombineName(rkey, keyName), true)); }
public void SetValue(RegistryKey rkey, string name, object value) { Type type = value.GetType(); IntPtr handle = Win32RegistryApi.GetHandle(rkey); int num2; if (type == typeof(int)) { int num = (int)value; num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.DWord, ref num, 4); } else if (type == typeof(byte[])) { byte[] array = (byte[])value; num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.Binary, array, array.Length); } else if (type == typeof(string[])) { string[] array2 = (string[])value; StringBuilder stringBuilder = new StringBuilder(); foreach (string value2 in array2) { stringBuilder.Append(value2); stringBuilder.Append('\0'); } stringBuilder.Append('\0'); byte[] bytes = Encoding.Unicode.GetBytes(stringBuilder.ToString()); num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.MultiString, bytes, bytes.Length); } else { if (type.IsArray) { throw new ArgumentException("Only string and byte arrays can written as registry values"); } string text = string.Format("{0}{1}", value, '\0'); num2 = Win32RegistryApi.RegSetValueEx(handle, name, IntPtr.Zero, RegistryValueKind.String, text, text.Length * this.NativeBytesPerCharacter); } if (num2 == 1018) { throw RegistryKey.CreateMarkedForDeletionException(); } if (num2 != 0) { this.GenerateException(num2); } }
public RegistryKey CreateSubKey(RegistryKey rkey, string keyName) { IntPtr handle = GetHandle(rkey); IntPtr subKeyHandle; int result = RegCreateKey(handle, keyName, out subKeyHandle); if (result == Win32ResultCode.MarkedForDeletion) { throw RegistryKey.CreateMarkedForDeletionException(); } if (result != Win32ResultCode.Success) { GenerateException(result); } return(new RegistryKey(subKeyHandle, CombineName(rkey, keyName), true)); }
public RegistryKey CreateSubKey(RegistryKey rkey, string keyName, RegistryOptions options) { IntPtr handle = GetHandle(rkey); IntPtr subKeyHandle; int disposition; int result = RegCreateKeyEx(handle, keyName, 0, IntPtr.Zero, options == RegistryOptions.Volatile ? RegOptionsVolatile : RegOptionsNonVolatile, OpenRegKeyRead | OpenRegKeyWrite, IntPtr.Zero, out subKeyHandle, out disposition); if (result == Win32ResultCode.MarkedForDeletion) { throw RegistryKey.CreateMarkedForDeletionException(); } if (result != Win32ResultCode.Success) { GenerateException(result); } return(new RegistryKey(subKeyHandle, CombineName(rkey, keyName), true)); }
public int ValueCount(RegistryKey rkey) { int index, result, bufferCapacity; RegistryValueKind type; StringBuilder buffer = new StringBuilder(BufferMaxLength); IntPtr handle = GetHandle(rkey); for (index = 0; true; index++) { type = 0; bufferCapacity = buffer.Capacity; result = RegEnumValue(handle, index, buffer, ref bufferCapacity, IntPtr.Zero, ref type, IntPtr.Zero, IntPtr.Zero); if (result == Win32ResultCode.MarkedForDeletion) { throw RegistryKey.CreateMarkedForDeletionException(); } if (result == Win32ResultCode.Success || result == Win32ResultCode.MoreData) { continue; } if (result == Win32ResultCode.NoMoreEntries) { break; } // something is wrong GenerateException(result); } return(index); }