DanielR78/Yaulw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial checkin of yaulw (locally)

Browse Source
This commit is contained in:
Donald Duck
2016-02-15 12:32:26 -05:00
commit 857eda29e3
115 changed files with 27392 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

487
Registry/RegKey.cs Normal file
View File

@@ -0,0 +1,487 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Win32;
using Yaulw.Tools;
namespace Yaulw.Registry
{
#region RegKey Enums
/// <summary>
/// Registry Root Key
/// </summary>
public enum HKEYRoot
{
ClassesRoot,
CurrentUser,
LocalMachine,
}
/// <summary>
/// Registry Sub Key
/// </summary>
public enum KeySub
{
Software,
Custom
}
#endregion
/// <remarks>
/// Wrapper Class around Registry Functionallity,
/// allows for easy reading/writing to the registry, especially HKEY_CURRENT_USER\Software
/// ~If you use this class directly make sure to call dispose(),
/// otherwise, use the Public Static Helper Functions to do the work for you
/// </remarks>
public class RegKey : IDisposable
{
#region Private Members
private RegistryKey _RegKey;
private bool _disposed = false;
#endregion
#region Constructors
/// <summary>
/// Use this to Open or Automatically Create the specified Key in CURRENT_USER\Software\Key.
/// </summary>
/// <param name="Key">Specify Key to Open</param>
/// <param name="bReadOnly">Set to true to Open, false to Create if not Exists</param>
public RegKey(string Key, bool bReadOnly = true) : this(HKEYRoot.CurrentUser, KeySub.Software, Key, bReadOnly) {}
/// <summary>
/// Use this to Open or Automatically Create a Registry Key
/// </summary>
/// <param name="root">specify registry root</param>
/// <param name="sub">specify a sub or custom</param>
/// <param name="Key">key you want to open / create </param>
/// <param name="bReadOnly">true if you want to force only reading it</param>
private RegKey(HKEYRoot root, KeySub sub, string Key, bool bReadOnly)
{
string KeyToOpen = String.Empty;
if (sub == KeySub.Custom)
KeyToOpen = Key;
else
KeyToOpen = sub.ToString() + "\\" + Key;
// Read Only Permission
RegistryKeyPermissionCheck permission = RegistryKeyPermissionCheck.ReadSubTree;
if (!bReadOnly)
permission = RegistryKeyPermissionCheck.ReadWriteSubTree;
// Open or Create, if it doesn't exist and we have writable set
switch (root)
{
case HKEYRoot.ClassesRoot:
if (bReadOnly)
_RegKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(KeyToOpen);
else
_RegKey = Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(KeyToOpen, permission);
break;
case HKEYRoot.CurrentUser:
if (bReadOnly)
_RegKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(KeyToOpen, permission);
else
_RegKey = Microsoft.Win32.Registry.CurrentUser.CreateSubKey(KeyToOpen, permission);
break;
case HKEYRoot.LocalMachine:
if (bReadOnly)
_RegKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(KeyToOpen, permission);
else
_RegKey = Microsoft.Win32.Registry.LocalMachine.CreateSubKey(KeyToOpen, permission);
break;
}
}
/// <summary>
/// Finalizer
/// </summary>
~RegKey()
{
Dispose(true);
}
#endregion
#region GetValue Registry Functions
/// <summary>
/// Generic Registry KeyValue Getter Function
/// </summary>
/// <typeparam name="T">Should be a System Type like string, bool, int32, double, decimal, etc...</typeparam>
/// <param name="strKeyValue">The Value to get from the Registry</param>
/// <param name="DefaultValue">Default value to use if nothing was retrieved * Error occured *</param>
/// <returns>Value found or Default Value</returns>
public T GetVal<T>(string strKeyValue, T DefaultValue)
{
T retVal = DefaultValue;
try
{
if (_RegKey != null)
{
object keyvalue = _RegKey.GetValue(strKeyValue);
string strvalue = string.Empty;
if (ObjTool.IsNotNullAndNotEmpty(keyvalue))
{
#region First Handle the Value as a string
// Handle Multi-Strings
if (keyvalue is object[])
{
string keyVal2 = string.Empty;
string[] strVal2 = (string[])keyvalue;
foreach (string str in strVal2)
{
keyVal2 += str;
}
strvalue = keyVal2;
}
else
{
// Handle Single-Strings
strvalue = keyvalue.ToString();
}
#endregion
// Now cast the Object Return type * Handle each object differently *
retVal = ObjTool.ConvertStringToObj<T>(strvalue);
}
}
}
catch (Exception) { /* ignore */ }
return retVal;
}
/// <summary>
/// Binary Registry KeyValue Getter Function
/// </summary>
/// <param name="strKeyValue">The Value to get from the Registry</param>
/// <returns>an array of Bytes found in the Registry, or null if none found, or error occured</returns>
public byte[] GetVal(string strKeyValue)
{
byte[] retVal = null;
try
{
string StringValue = GetVal<System.String>(strKeyValue, String.Empty);
if (!String.IsNullOrEmpty(StringValue))
{
Byte[] ByteValue = new Byte[StringValue.Length];
for (int i = 0; i < ByteValue.Length; ++i)
{
string strByte = System.Convert.ToString(StringValue[i]);
ByteValue[i] = byte.Parse(strByte);
}
retVal = ByteValue;
}
}
catch (Exception) { /* ignore */ }
return retVal;
}
#endregion
#region SetValue Registry Functions
/// <summary>
/// Generic Registry KeyValue Setter Function
/// </summary>
/// <typeparam name="T">Should be a System Type like string, bool, int32, double, decimal, etc...</typeparam>
/// <param name="strKeyValue">The Value to write to in the Registry</param>
/// <param name="Value">The Value to set to the Registry</param>
/// <returns>true if successful, false otherwise</returns>
public bool SetVal<T>(string strKeyValue, T Value)
{
bool bRetVal = false;
try
{
if (_RegKey != null)
{
if (Value is System.Int32)
{
_RegKey.SetValue(strKeyValue, Value, RegistryValueKind.DWord);
}
else if (Value is System.Int64)
{
_RegKey.SetValue(strKeyValue, Value, RegistryValueKind.QWord);
}
else
{
_RegKey.SetValue(strKeyValue, Value, RegistryValueKind.String);
}
bRetVal = true;
}
}
catch (Exception) { /* ignore */ }
return bRetVal;
}
/// <summary>
/// Generic Registry KeyValue Setter Function
/// </summary>
/// <param name="strKeyValue">The Value to write to in the Registry</param>
/// <param name="ByteValue">A binary array of bytes to write to the Registry</param>
/// <returns>true if successful, false otherwise</returns>
public bool SetVal(string strKeyValue, byte[] ByteValue)
{
try
{
_RegKey.SetValue(strKeyValue, ByteValue, RegistryValueKind.Binary);
return true;
}
catch (Exception) { /* ignore */ }
return false;
}
#endregion
#region Delete Registry Function
/// <summary>
/// Registry KeyValue Delete Function
/// </summary>
/// <param name="strKeyValue">The Value to delete in the Registry</param>
/// <returns>true if successful, false otherwise</returns>
public bool DeleteKey(string strKeyValue)
{
try
{
if (_RegKey != null)
{
_RegKey.DeleteValue(strKeyValue, false);
return true;
}
}
catch (Exception) { /* ignore */ }
return false;
}
#endregion
#region Public Static Helper Functions
/// <summary>
/// Generic Static Registry Writer Function * Allows writing to HKEY\CURRENT_USER\SOFTWARE *
/// </summary>
/// <typeparam name="T">Should be a System Type like string, bool, int32, double, decimal, etc...</typeparam>
/// <param name="SubKey">SubKey i.e. Microsoft, Microsoft\Windows</param>
/// <param name="KeyValue">Value to write to</param>
/// <param name="Value">Value to write</param>
/// <returns>true if successful, false otherwise</returns>
public static bool SetKey<T>(String SubKey, String KeyValue, T Value)
{
bool bRetVal = false;
using (RegKey reg = new RegKey(HKEYRoot.CurrentUser, KeySub.Software, SubKey, false))
{
bRetVal = reg.SetVal<T>(KeyValue, Value);
}
return bRetVal;
}
/// <summary>
/// Generic Static Registry Writer For Binary Function * Allows writing to HKEY\CURRENT_USER\SOFTWARE *
/// </summary>
/// <param name="SubKey">SubKey i.e. Microsoft, Microsoft\Windows</param>
/// <param name="KeyValue">Value to write to</param>
/// <param name="ByteValue">Binary Value to write</param>
/// <returns>true if successful, false otherwise</returns>
public static bool SetKey(String SubKey, String KeyValue, byte[] ByteValue)
{
bool bRetVal = false;
using (RegKey reg = new RegKey(HKEYRoot.CurrentUser, KeySub.Software, SubKey, false))
{
bRetVal = reg.SetVal(KeyValue, ByteValue);
}
return bRetVal;
}
/// <summary>
/// Generic Static Registry Writer Function * Allows writing to any key *
/// </summary>
/// <typeparam name="T">Should be a System Type like string, bool, int32, double, decimal, etc...</typeparam>
/// <param name="rootKey">RootKey as defined in this Class</param>
/// <param name="SubKey">SubKey i.e. Software, Software\Microsoft</param>
/// <param name="KeyValue">Value to write to</param>
/// <param name="Value">Value to write</param>
/// <returns>true if successful, false otherwise</returns>
public static bool SetKey<T>(HKEYRoot rootKey, String SubKey, String KeyValue, T Value)
{
bool bRetVal = false;
using (RegKey reg = new RegKey(rootKey, KeySub.Custom, SubKey, false))
{
bRetVal = reg.SetVal<T>(KeyValue, Value);
}
return bRetVal;
}
/// <summary>
/// Generic Static Registry Writer For Binary Function * Allows writing to any key *
/// </summary>
/// <param name="rootKey">RootKey as defined in this Class</param>
/// <param name="SubKey">SubKey i.e. Software, Software\Microsoft</param>
/// <param name="KeyValue">Value to write to</param>
/// <param name="ByteValue">Binary Value to write</param>
/// <returns>true if successful, false otherwise</returns>
public static bool SetKey(HKEYRoot rootKey, String SubKey, String KeyValue, byte[] ByteValue)
{
bool bRetVal = false;
using (RegKey reg = new RegKey(rootKey, KeySub.Custom, SubKey, false))
{
bRetVal = reg.SetVal(KeyValue, ByteValue);
}
return bRetVal;
}
/// <summary>
/// Static Registry Delete Function * Allows Deleting from HKEY\CURRENT_USER\SOFTWARE *
/// </summary>
/// <param name="SubKey">SubKey i.e. Microsoft, Microsoft\Windows</param>
/// <param name="KeyValue">Value to delete</param>
/// <returns>true if successful, false otherwise</returns>
public static bool DeleteKey(String SubKey, String KeyValue)
{
bool bRetVal = false;
using (RegKey reg = new RegKey(HKEYRoot.CurrentUser, KeySub.Software, SubKey, false))
{
bRetVal = reg.DeleteKey(KeyValue);
}
return bRetVal;
}
/// <summary>
/// Static Registry Delete Function * Allows Deleting any key *
/// </summary>
/// <param name="rootKey">RootKey as defined in this Class</param>
/// <param name="SubKey">SubKey i.e. Software, Software\Microsoft</param>
/// <param name="KeyValue">Value to delete</param>
/// <returns>true if successful, false otherwise</returns>
public static bool DeleteKey(HKEYRoot rootKey, String SubKey, String KeyValue)
{
bool bRetVal = false;
using (RegKey reg = new RegKey(rootKey, KeySub.Custom, SubKey, false))
{
bRetVal = reg.DeleteKey(KeyValue);
}
return bRetVal;
}
/// <summary>
/// Generic Static Registry Reader Function * Allows reading from HKEY\CURRENT_USER\SOFTWARE *
/// </summary>
/// <typeparam name="T">Should be a System Type like string, bool, int32, double, decimal, etc...</typeparam>
/// <param name="SubKey">SubKey i.e. Microsoft, Microsoft\Windows</param>
/// <param name="KeyValue">Value to write to</param>
/// <param name="DefaultValue">Default Value to return if none found or error occured</param>
/// <returns>true if successful, false otherwise</returns>
public static T GetKey<T>(String SubKey, String KeyValue, T DefaultValue)
{
T tRetVal = default(T);
using (RegKey reg = new RegKey(HKEYRoot.CurrentUser, KeySub.Software, SubKey, true))
{
tRetVal = reg.GetVal<T>(KeyValue, DefaultValue);
}
return tRetVal;
}
/// <summary>
/// Generic Static Registry Reader For Binary Function * Allows reading from HKEY\CURRENT_USER\SOFTWARE *
/// </summary>
/// <param name="SubKey">SubKey i.e. Microsoft, Microsoft\Windows</param>
/// <param name="KeyValue">Value to write to</param>
/// <returns>true if successful, false otherwise</returns>
public static Byte[] GetKey(String SubKey, String KeyValue)
{
Byte[] retByte = null;
using (RegKey reg = new RegKey(HKEYRoot.CurrentUser, KeySub.Software, SubKey, true))
{
retByte = reg.GetVal(KeyValue);
}
return retByte;
}
/// <summary>
/// Generic Static Registry Reader Function * Allows reading from any key *
/// </summary>
/// <typeparam name="T">Should be a System Type like string, bool, int32, double, decimal, etc...</typeparam>
/// <param name="rootKey">RootKey as defined in this Class</param>
/// <param name="SubKey">SubKey i.e. Software, Software\Microsoft</param>
/// <param name="KeyValue">Value to write to</param>
/// <param name="DefaultValue">Default Value to return if none found or error occured</param>
/// <returns>true if successful, false otherwise</returns>
public static T GetKey<T>(HKEYRoot rootKey, String SubKey, String KeyValue, T DefaultValue)
{
T tRetVal = default(T);
using (RegKey reg = new RegKey(rootKey, KeySub.Custom, SubKey, true))
{
tRetVal = reg.GetVal<T>(KeyValue, DefaultValue);
}
return tRetVal;
}
/// <summary>
/// Generic Static Registry Reader For Binary Function * Allows reading from any key *
/// </summary>
/// <typeparam name="T">Should be a System Type like string, bool, int32, double, decimal, etc...</typeparam>
/// <param name="rootKey">RootKey as defined in this Class</param>
/// <param name="SubKey">SubKey i.e. Software, Software\Microsoft</param>
/// <param name="KeyValue">Value to write to</param>
/// <returns>true if successful, false otherwise</returns>
public static Byte[] GetKey(HKEYRoot rootKey, String SubKey, String KeyValue)
{
Byte[] retByte = null;
using (RegKey reg = new RegKey(rootKey, KeySub.Custom, SubKey, true))
{
retByte = reg.GetVal(KeyValue);
}
return retByte;
}
#endregion
#region IDisposable Members
/// <summary>
/// Dispose the Registry Handle
/// </summary>
public void Dispose()
{
Dispose(true);
// Use SupressFinalize in case a subclass
// of this type implements a finalizer
GC.SuppressFinalize(this);
}
/// <summary>
/// Dispose the Registry Handle
/// </summary>
/// <param name="disposing">true, if called from within</param>
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
#if NET4
if (disposing)
{
if (_RegKey != null)
_RegKey.Dispose(); // Works in .Net 4.0 Only
}
#endif
// Indicate that the instance has been disposed.
_RegKey = null;
_disposed = true;
}
}
#endregion
}
}