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);
}
