public static bool DeleteValue(RegRoot root, string keyname, string valuename)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname, true);
if (key == null)
{
return(false);
}
try
{
key.DeleteValue(valuename);
return(true);
}
finally
{
key.Close();
}
}
catch
{
return(false);
}
}
public static bool IsValue(RegRoot root, string keyname, string valuename)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname);
try
{
object o = key.GetValue(valuename);
if (o == null)
{
return(false);
}
}
finally
{
key.Close();
}
return(true);
}
catch
{
return(false);
}
}
public static void PrintRegKeys(RegRoot root, string key, int depth = 0)
{
const int padUnit = 2;
key._TryTrimStartWith(out key, StrCmpi, @"\");
string pad1 = ' '._MakeCharArray(depth * padUnit);
string pad2 = ' '._MakeCharArray((depth + 1) * padUnit);
Con.WriteLine($"{pad1}[{root}\\{key}]");
var x = MsReg.EnumKey(root, key);
var subkeys = MsReg.EnumKey(root, key)._EmptyArrayIfNull().OrderBy(x => x, StrCmpi);
var values = MsReg.EnumValue(root, key)._EmptyArrayIfNull().OrderBy(x => x, StrCmpi);
foreach (var value in values)
{
object?data = MsReg.ReadValue(root, key, value);
Con.WriteLine($"{pad2}{value}='{data._ObjectToJson(compact: true)}'");
}
Con.WriteLine();
foreach (var subkey in subkeys)
{
PrintRegKeys(root, key + @"\" + subkey, depth + 1);
}
}
public static RegUtil Create(RegRoot root, string subKey, bool stayOpen)
{
RegistryKey regKey;
RegUtil regUtil;
try
{
regKey = GetKey(root).CreateSubKey(subKey, RegistryKeyPermissionCheck.ReadWriteSubTree);
}
catch
{
return null;
}
if (regKey != null)
{
regUtil = new RegUtil();
regUtil.key = regKey;
if (!stayOpen)
regUtil.Close();
return regUtil;
}
return null;
}
public static bool NewKey(RegRoot root, string keyname)
{
if (IsKey(root, keyname))
{
return(true);
}
try
{
RegistryKey key = rootKey(root).CreateSubKey(keyname);
if (key == null)
{
return(false);
}
key.Close();
return(true);
}
catch
{
return(false);
}
}
public static string[] EnumKey(RegRoot root, string keyname)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname);
if (key == null)
{
return(new string[0]);
}
try
{
return(key.GetSubKeyNames());
}
finally
{
key.Close();
}
}
catch
{
return(new string[0]);
}
}
public static object ReadValue(RegRoot root, string keyname, string valuename)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname);
if (key == null)
{
return(null);
}
try
{
return(key.GetValue(valuename));
}
finally
{
key.Close();
}
}
catch
{
return(null);
}
}
public static bool CreateKey(RegRoot root, string keyName)
{
try
{
using (var key = root.GetKey().OpenSubKey(keyName, true))
{
if (key != null)
{
return(true);
}
}
using (var key = root.GetKey().CreateSubKey(keyName, true))
{
if (key == null)
{
return(false);
}
return(true);
}
}
catch
{
return(false);
}
}
public static object?ReadValue(RegRoot root, string keyName, string valueName, object?defaultValue = null)
{
try
{
using (var key = root.GetKey().OpenSubKey(keyName, false))
{
if (key == null)
{
return(defaultValue);
}
object?value = key.GetValue(valueName);
if (value == null)
{
return(defaultValue);
}
return(value);
}
}
catch
{
return(defaultValue);
}
}
public RegistryHandler(RegRoot look_here, string register_me, bool writable)
{
key_found = false;
switch (look_here)
{
case RegRoot.classes_root:
root_key = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry64);
break;
case RegRoot.current_config:
root_key = RegistryKey.OpenBaseKey(RegistryHive.CurrentConfig, RegistryView.Registry64);
break;
case RegRoot.current_user:
root_key = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Registry64);
break;
case RegRoot.dyn_data:
root_key = RegistryKey.OpenBaseKey(RegistryHive.DynData, RegistryView.Registry64);
break;
case RegRoot.local_machine:
root_key = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
break;
case RegRoot.performace_data:
root_key = RegistryKey.OpenBaseKey(RegistryHive.PerformanceData, RegistryView.Registry64);
break;
case RegRoot.users:
root_key = RegistryKey.OpenBaseKey(RegistryHive.Users, RegistryView.Registry64);
break;
default:
root_key = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
break;
}
//root_key = RegistryKey.OpenRemoteBaseKey(look_here, RegistryView.Registry64);
if (register_me != null)
{
the_key = root_key.OpenSubKey(register_me, writable);
if (the_key == null)
{
the_key = root_key.OpenSubKey(register_me.Replace("SOFTWARE", "Software\\Wow6432Node"), writable);
}
if (the_key != null)
{
key_found = true;
}
}
else
{
key_found = false;
}
}
/// <summary>
/// 读取指定名称的注册表的值
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static string GetValue(RegRoot root, string subkey, string name)
{
string registData = "";
RegistryKey myKey = getRegistryRoot(root).OpenSubKey(subkey, true);
if (myKey != null)
{
registData = myKey.GetValue(name).ToString();
}
return(registData);
}
/// <summary>
/// Convert a root key into WiX.
/// </summary>
/// <param name="sr">Reader for the reg file.</param>
/// <param name="writer">XmlWriter to write registry information to.</param>
/// <param name="root">Root registry key.</param>
/// <param name="line">Current line to parse.</param>
private void ConvertRoot(StreamReader sr, XmlWriter writer, RegRoot root, string line)
{
writer.WriteStartElement("Registry");
writer.WriteAttributeString("Root", root.ToString());
writer.WriteAttributeString("Key", line);
this.regId++; // increment the registry key counter
this.ConvertValues(sr, writer);
writer.WriteEndElement();
}
public static int ReadInt32(RegRoot root, string keyName, string valueName, int defaultValue = 0)
{
object?o = ReadValue(root, keyName, valueName);
if (o is int)
{
return((int)o);
}
else
{
return(defaultValue);
}
}
public static long ReadInt64(RegRoot root, string keyName, string valueName, long defaultValue = 0)
{
object?o = ReadValue(root, keyName, valueName);
if (o is long)
{
return((long)o);
}
else
{
return(defaultValue);
}
}
public static Memory <byte> ReadBin(RegRoot root, string keyName, string valueName, ReadOnlyMemory <byte> defaultValue = default)
{
object?o = ReadValue(root, keyName, valueName);
if (o is byte[])
{
return((byte[])o);
}
else
{
return(defaultValue._CloneMemory());
}
}
public static bool DeleteKey(RegRoot root, string keyName)
{
try
{
root.GetKey().DeleteSubKey(keyName, true);
return(true);
}
catch
{
return(false);
}
}
public VdRegKey(ref List <BaseRegKey> allRegistryKeys, RegRoot root, string parentPath, XmlNode keyNode)
{
mRegistryKeys = allRegistryKeys;
Id = keyNode.Name;
Root = root;
if (String.IsNullOrEmpty(parentPath))
{
Path = ElementValue(ref keyNode, "Name");
}
else
{
Path += parentPath + "\\" + ElementValue(ref keyNode, "Name");
}
XmlNode regValues = keyNode.SelectSingleNode("Values");
// If there are no <Values then this is only parent of sub-key (so do not add it)
if (regValues != null && regValues.HasChildNodes)
{
Values = new List <RegValue>(regValues.ChildNodes.Count);
for (int k = 0; k < regValues.ChildNodes.Count; k++)
{
XmlNode valNode = regValues.ChildNodes[k];
string name = ElementValue(ref valNode, "Name");
RegValueType type = (RegValueType)int.Parse(ElementValue(ref valNode, "ValueTypes"));
string value = ElementValue(ref valNode, "Value");
Values.Add(new RegValue(name, type, value));
}
// Add registry key
mRegistryKeys.Add(this);
}
else
{
// Process sub-keys (without adding parent)
XmlNode subKeys = keyNode.SelectSingleNode("Keys");
if (subKeys != null && subKeys.HasChildNodes)
{
for (int i = 0; i < subKeys.ChildNodes.Count; i++)
{
XmlNode childNode = subKeys.ChildNodes[i];
VdRegKey regKey = new VdRegKey(ref mRegistryKeys, Root, Path, childNode);
}
}
else
{
// Add registry key (without Values)
mRegistryKeys.Add(this);
}
}
}
/// <summary>
/// 删除注册表中指定的注册表项
/// </summary>
/// <param name="name"></param>
public void Delete(RegRoot root, string subkey, string name)
{
string[] subkeyNames;
RegistryKey myKey = getRegistryRoot(root).OpenSubKey(subkey, true);
subkeyNames = myKey.GetSubKeyNames();
foreach (string aimKey in subkeyNames)
{
if (aimKey == name)
{
myKey.DeleteSubKeyTree(name);
}
}
}
public static string[]? EnumKey(RegRoot root, string keyName)
{
try
{
using (var key = root.GetKey().OpenSubKey(keyName, false))
{
return(key !.GetSubKeyNames());
}
}
catch
{
return(null);
}
}
static RegistryKey rootKey(RegRoot r)
{
switch (r)
{
case RegRoot.LocalMachine:
return(Registry.LocalMachine);
case RegRoot.CurrentUser:
return(Registry.CurrentUser);
case RegRoot.Users:
return(Registry.Users);
}
throw new ArgumentException();
}
public RegistryHandler(RegRoot look_here, string register_me, bool writable)
{
key_found = false;
switch(look_here) {
case RegRoot.classes_root:
root_key = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry64);
break;
case RegRoot.current_config:
root_key = RegistryKey.OpenBaseKey(RegistryHive.CurrentConfig, RegistryView.Registry64);
break;
case RegRoot.current_user:
root_key = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Registry64);
break;
case RegRoot.dyn_data:
root_key = RegistryKey.OpenBaseKey(RegistryHive.DynData, RegistryView.Registry64);
break;
case RegRoot.local_machine:
root_key = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
break;
case RegRoot.performace_data:
root_key = RegistryKey.OpenBaseKey(RegistryHive.PerformanceData, RegistryView.Registry64);
break;
case RegRoot.users:
root_key = RegistryKey.OpenBaseKey(RegistryHive.Users, RegistryView.Registry64);
break;
default:
root_key = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
break;
}
//root_key = RegistryKey.OpenRemoteBaseKey(look_here, RegistryView.Registry64);
if(register_me!=null) {
the_key = root_key.OpenSubKey(register_me,writable);
if (the_key==null) {
the_key = root_key.OpenSubKey(register_me.Replace("SOFTWARE","Software\\Wow6432Node"),writable);
}
if (the_key!=null) {
key_found=true;
}
} else {
key_found = false;
}
}
public static string ReadStr(RegRoot root, string keyName, string valueName, string defaultValue = "")
{
object?o = ReadValue(root, keyName, valueName);
if (o is string)
{
return((string)o);
}
else if (o is string[])
{
string?s = ((string[])o).FirstOrDefault();
return(s ?? defaultValue);
}
else
{
return(defaultValue);
}
}
public static string[] ReadStrList(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return(new string[0]);
}
try
{
return((string[])o);
}
catch
{
return(new string[0]);
}
}
public static string ReadStr(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return("");
}
try
{
return((string)o);
}
catch
{
return("");
}
}
public static int ReadInt(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return(0);
}
try
{
return((int)o);
}
catch
{
return(0);
}
}
public static byte[] ReadByte(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return(new byte[0]);
}
try
{
return((byte[])o);
}
catch
{
return(new byte[0]);
}
}
/// <summary>
/// 判断指定注册表项是否存在
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public bool IsExist(RegRoot root, string subkey, string name)
{
bool _exit = false;
string[] subkeyNames;
RegistryKey myKey = getRegistryRoot(root).OpenSubKey(subkey, true);
subkeyNames = myKey.GetSubKeyNames();
foreach (string keyName in subkeyNames)
{
if (keyName == name)
{
_exit = true;
return(_exit);
}
}
return(_exit);
}
public static RegistryValueKind GetValueType(RegRoot root, string keyName, string valueName)
{
try
{
using (var key = root.GetKey().OpenSubKey(keyName, false))
{
if (key == null)
{
return(RegistryValueKind.Unknown);
}
return(key.GetValueKind(valueName));
}
}
catch
{
return(RegistryValueKind.Unknown);
}
}
public static bool DeleteKey(RegRoot root, string keyname, bool deleteAll)
{
try
{
if (deleteAll == false)
{
rootKey(root).DeleteSubKey(keyname);
}
else
{
rootKey(root).DeleteSubKeyTree(keyname);
}
return(true);
}
catch
{
return(false);
}
}
public static RegistryKey GetKey(this RegRoot root)
{
switch (root)
{
case RegRoot.ClassesRoot:
return(Registry.ClassesRoot);
case RegRoot.LocalMachine:
return(Registry.LocalMachine);
case RegRoot.CurrentUser:
return(Registry.CurrentUser);
case RegRoot.Users:
return(Registry.Users);
default:
throw new ArgumentException(nameof(root));
}
}
public static bool IsKey(RegRoot root, string name)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(name);
if (key == null)
{
return(false);
}
key.Close();
return(true);
}
catch
{
return(false);
}
}
private static RegistryKey getRegistryRoot(RegRoot root)
{
if (root == RegRoot.CurrentUser)
{
return(Registry.CurrentUser);
}
if (root == RegRoot.LocalMachine)
{
return(Registry.LocalMachine);
}
if (root == RegRoot.ClassRoot)
{
return(Registry.ClassesRoot);
}
if (root == RegRoot.Users)
{
return(Registry.Users);
}
return(Registry.CurrentUser);
}
public static string ReadStr(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return "";
}
try
{
return (string)o;
}
catch
{
return "";
}
}
public static bool WriteValue(RegRoot root, string keyname, string valuename, object o)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname, true);
if (key == null)
{
key = rootKey(root).CreateSubKey(keyname);
if (key == null)
{
return false;
}
}
try
{
key.SetValue(valuename, o);
return true;
}
catch
{
return false;
}
finally
{
key.Close();
}
}
catch
{
return false;
}
}
public static string[] ReadStrList(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return new string[0];
}
try
{
return (string[])o;
}
catch
{
return new string[0];
}
}
public static bool WriteStr(RegRoot root, string keyname, string valuename, string value)
{
return WriteValue(root, keyname, valuename, value);
}
public static RegUtil Open(RegRoot root, string subKey, bool writable=true, bool createIfNotExists=false)
{
RegUtil util;
if (!Exists(root, subKey))
{
if (!createIfNotExists)
return null;
return Create(root, subKey,true);
}
util = new RegUtil();
util.key = GetKey(root).OpenSubKey(subKey, writable);
return util;
}
public static int ReadInt(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return 0;
}
try
{
return (int)o;
}
catch
{
return 0;
}
}
public RegistryEntry addRegEntry(RegRoot root, string key, string value, string type) {
if (!RegistryTypes.ContainsKey(type)) {
RegistryType reg = new RegistryType(this, type);
this.XML.AppendChild(reg.XML);
RegistryTypes.Add(type, reg);
}
RegistryType registry = RegistryTypes[type];
RegistryEntry entry = registry.addEntry(root, key, type);
return entry;
}
public static void Delete(RegRoot root, string subKey)
{
GetKey(root).DeleteSubKeyTree(subKey);
}
public static bool DeleteKey(RegRoot root, string keyname, bool deleteAll)
{
try
{
if (deleteAll == false)
{
rootKey(root).DeleteSubKey(keyname);
}
else
{
rootKey(root).DeleteSubKeyTree(keyname);
}
return true;
}
catch
{
return false;
}
}
public static bool IsKey(RegRoot root, string name)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(name);
if (key == null)
{
return false;
}
key.Close();
return true;
}
catch
{
return false;
}
}
public static bool DeleteValue(RegRoot root, string keyname, string valuename)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname, true);
if (key == null)
{
return false;
}
try
{
key.DeleteValue(valuename);
return true;
}
finally
{
key.Close();
}
}
catch
{
return false;
}
}
public static string[] EnumerateSubKeys(RegRoot root, string subKey)
{
try
{
return Open(root, subKey, false).key.GetSubKeyNames();
}
catch { }
return new string[0];
}
public RegistryEntry(RegistryType reg, RegRoot root, string key, string value)
: base(reg) {
this.Root = root;
this.Key = key;
this.Value = value;
}
public static object ReadValue(RegRoot root, string keyname, string valuename)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname);
if (key == null)
{
return null;
}
try
{
return key.GetValue(valuename);
}
finally
{
key.Close();
}
}
catch
{
return null;
}
}
public static bool Exists(RegRoot root, string subKey)
{
RegistryKey regKey = GetKey(root).OpenSubKey(subKey);
if (regKey != null)
{
regKey.Close();
return true;
}
return false;
}
public static bool IsValue(RegRoot root, string keyname, string valuename)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname);
try
{
object o = key.GetValue(valuename);
if (o == null)
{
return false;
}
}
finally
{
key.Close();
}
return true;
}
catch
{
return false;
}
}
/// <summary>
/// Convert a root key into WiX.
/// </summary>
/// <param name="sr">Reader for the reg file.</param>
/// <param name="writer">XmlWriter to write registry information to.</param>
/// <param name="root">Root registry key.</param>
/// <param name="line">Current line to parse.</param>
private void ConvertRoot(StreamReader sr, XmlWriter writer, RegRoot root, string line)
{
writer.WriteStartElement("Registry");
writer.WriteAttributeString("Root", root.ToString());
writer.WriteAttributeString("Key", line);
this.regId++; // increment the registry key counter
this.ConvertValues(sr, writer);
writer.WriteEndElement();
}
public static bool DeleteKey(RegRoot root, string keyname)
{
return DeleteKey(root, keyname, false);
}
public AppReg(RegRoot root, string subkey)
{
subkey = subkey.TrimEnd('\\');
this.rootKey = root;
this.appSubKey = subkey;
}
public static bool NewKey(RegRoot root, string keyname)
{
if (IsKey(root, keyname))
{
return true;
}
try
{
RegistryKey key = rootKey(root).CreateSubKey(keyname);
if (key == null)
{
return false;
}
key.Close();
return true;
}
catch
{
return false;
}
}
static RegistryKey rootKey(RegRoot r)
{
switch (r)
{
case RegRoot.LocalMachine:
return Registry.LocalMachine;
case RegRoot.CurrentUser:
return Registry.CurrentUser;
case RegRoot.Users:
return Registry.Users;
}
throw new ArgumentException();
}
public static string[] EnumKey(RegRoot root, string keyname)
{
try
{
RegistryKey key = rootKey(root).OpenSubKey(keyname);
if (key == null)
{
return new string[0];
}
try
{
return key.GetSubKeyNames();
}
finally
{
key.Close();
}
}
catch
{
return new string[0];
}
}
public static bool WriteByte(RegRoot root, string keyname, string valuename, byte[] data)
{
return WriteValue(root, keyname, valuename, data);
}
public RegistryEntry addEntry(RegRoot root, string key, string value) {
RegistryEntry entry = new RegistryEntry(this, root, key, value);
Entries.Add(entry);
this.XML.AppendChild(entry.XML);
return entry;
}
public static byte[] ReadByte(RegRoot root, string keyname, string valuename)
{
object o = ReadValue(root, keyname, valuename);
if (o == null)
{
return new byte[0];
}
try
{
return (byte[])o;
}
catch
{
return new byte[0];
}
}
private void loadUsersData(RegRoot reg_root, string path)
{
RegistryHandler user_key;
if(path==null)
user_key = new RegistryHandler(reg_root,@"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders",false);
else
user_key = new RegistryHandler(reg_root,path + @"\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders",false);
UserData add_me;
string[] split ;
try {
split = user_key.getValue("AppData").Split(Path.DirectorySeparatorChar);
if(xp)
add_me = new UserData(split[split.Length-2]);
else
add_me = new UserData(split[split.Length-3]);
add_me.setEvFolder(EnvironmentVariable.AppData,user_key.getValue("AppData"));
DirectoryInfo flash_share = new DirectoryInfo(Path.Combine(add_me.getFolder(EnvironmentVariable.AppData),@"Macromedia\Flash Player\#SharedObjects"));
if(flash_share.Exists) {
DirectoryInfo[] flash_users = flash_share.GetDirectories();
switch(flash_users.Length) {
case 0:
break;
case 1:
add_me.setEvFolder(EnvironmentVariable.FlashShared,flash_users[0].FullName);
break;
default:
add_me.setEvFolder(EnvironmentVariable.FlashShared,flash_users[0].FullName);
break;
}
}
add_me.setEvFolder(EnvironmentVariable.LocalAppData,user_key.getValue("Local AppData"));
//add_me.local_settings = user_key.GetValue("Local Settings").ToString();
//add_me.start_menu = user_key.getValue("Start Menu");
StringBuilder user_dir = new StringBuilder(split[0]);
if(xp) {
for(int i = 1;i<split.Length-1;i++) {
user_dir.Append(Path.DirectorySeparatorChar + split[i]);
}
} else {
for(int i = 1;i<split.Length-2;i++) {
user_dir.Append(Path.DirectorySeparatorChar + split[i]);
}
}
add_me.setEvFolder(EnvironmentVariable.UserProfile,user_dir.ToString());
add_me.setEvFolder(EnvironmentVariable.UserDocuments,user_key.getValue("Personal"));
if(platform_version== PlatformVersion.Vista)
add_me.setEvFolder(EnvironmentVariable.VirtualStore,Path.Combine(user_key.getValue("Local AppData"),"VirtualStore"));
user_key.close();
if(path==null)
user_key = new RegistryHandler(reg_root,@"Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders",false);
else
user_key = new RegistryHandler(reg_root,path + @"\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders",false);
string saved_games = user_key.getValue("{4C5C32FF-BB9D-43B0-B5B4-2D72E54EAAA4}");
if(saved_games!=null) {
if(saved_games.StartsWith("%USERPROFILE%")) {
saved_games = Path.Combine(user_dir.ToString(),saved_games.Substring(14));
}
add_me.setEvFolder(EnvironmentVariable.SavedGames,saved_games);
} else {
if(Directory.Exists(Path.Combine(user_dir.ToString(), "Saved Games"))) {
add_me.setEvFolder(EnvironmentVariable.SavedGames,Path.Combine(user_dir.ToString(), "Saved Games"));
}
}
this.Add(add_me);
user_key.close();
} catch {
return;
}
}
private static RegistryKey GetKey(RegRoot root)
{
switch (root)
{
case RegRoot.ClassesRoot:
return Registry.ClassesRoot;
case RegRoot.CurrentUser:
return Registry.CurrentUser;
case RegRoot.LocalMachine:
return Registry.LocalMachine;
}
throw new Exception("Invalid root identifier");
}
