string ReadLicenseFromRegistry(RegistryView view)
        {
            try
            {
                using (var rootKey = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, view))
                using (var registryKey = rootKey.OpenSubKey(keyPath))
                {
                    if (registryKey == null)
                    {
                        return null;
                    }

                    var licenseValue = registryKey.GetValue("License", null);

                    if (licenseValue is string[])
                    {
                        return string.Join(" ", (string[])licenseValue);
                    }
                    return (string)licenseValue;
                }
            }
            catch
            {
                return null;
            }
        }

        static bool RegistryKeyExists(string keyName, RegistryView registryView)
        {
            var localKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, registryView);
            localKey = localKey.OpenSubKey(keyName);

            return localKey != null;
        }

        public static object ReadKey(RegistryHive hive, RegistryView view, string subkey, string name)
        {
            // open root
            RegistryKey rootKey = Microsoft.Win32.RegistryKey.OpenBaseKey(hive, view);
            if (rootKey == null)
            {
                return null;
            }

            // look for key
            RegistryKey key = rootKey.OpenSubKey(subkey);
            if (key == null)
            {
                return null;
            }

            // look for value
            object value = key.GetValue(name);
            if (value == null)
            {
                return null;
            }

            return value;
        }

 public IRegistryKey FromHandle(
     SafeRegistryHandle handle,
     RegistryView view
 )
 {
     return new RegistryKeyWrap(RegistryKey.FromHandle(handle, view));
 }

 public IRegistryKey OpenBaseKey(
     RegistryHive hKey,
     RegistryView view
 )
 {
     return new RegistryKeyWrap(RegistryKey.OpenBaseKey(hKey, view));
 }

 private void add_key(IList<RegistryKey> keys, RegistryHive hive, RegistryView view)
 {
     FaultTolerance.try_catch_with_logging_exception(
         () => keys.Add(RegistryKey.OpenBaseKey(hive, view)),
         "Could not open registry hive '{0}' for view '{1}'".format_with(hive.to_string(), view.to_string()),
         logWarningInsteadOfError: true);
 }

        public static void Init(RegistryView settingsRoot, IDictionary<string, IEnumerable<string>> options)
        {
            if (BitlySettings == null) {
                BitlySettings = settingsRoot["bitly"];

                bitlyUsername = BitlySettings["#username"].StringValue;
                bitlySecret = BitlySettings["#password"].EncryptedStringValue;

                foreach (var arg in options.Keys) {
                    var argumentParameters = options[arg];
                    var last = argumentParameters.LastOrDefault();

                    switch (arg) {
                        case "bitly-username":
                            bitlyUsername = last;
                            BitlySettings["#username"].StringValue = bitlyUsername;
                            break;

                        case "bitly-secret":
                            bitlySecret = last;
                            BitlySettings["#password"].EncryptedStringValue = bitlySecret;
                            break;
                    }
                }
            }
        }

 public RegistrySettingsProvider
     (RegistryHive hKey, RegistryView view = RegistryView.Default, string baseKey = null)
 {
     this.hKey = hKey;
     this.view = view;
     this.baseKey = baseKey ?? ProductInfo.Company + "\\" + ProductInfo.Product;
 }

 /// <summary>
 /// Given a registry path, locate the correct root key and return the relative path. For example, when the user gives the absolute registry path
 /// 
 /// HKEY_LOCAL_MACHINE\Software\Microsoft
 /// 
 /// you really have two parts: HKEY_LOCAL_MACHINE is a "registry hive" root, and "Software\Microsoft" the relative path. 
 /// </summary>
 /// <param name="rootPath">absolute registry path</param>
 /// <param name="rootPathWithoutHive">Returns the relative path</param>
 /// <param name="registryView">Type of registry you want to see (32-bit, 64-bit, default).</param>
 /// <param name="remoteMachineName">Name of a remote machine. User must ensure that caller has sufficient privileges to access the key</param>
 /// <returns>"registry hive" root</returns>
 public static RegistryKey OpenRegistryHive(string rootPath, out string rootPathWithoutHive, RegistryView registryView, string remoteMachineName = null)
 {
     rootPathWithoutHive = "";
     bool found = false;
     foreach (string key in KnownHives.Keys)
     {
         if (rootPath.StartsWith(key+"\\", StringComparison.OrdinalIgnoreCase))
         {
             rootPathWithoutHive = rootPath.Substring(key.Length+1);
             found = true;
         }
         if (rootPath.Equals(key, StringComparison.OrdinalIgnoreCase))
         {
             rootPathWithoutHive = rootPath.Substring(key.Length);
             found = true;
         }
         if (found)
         {
             if (string.IsNullOrEmpty(remoteMachineName))
             {
                 return RegistryKey.OpenBaseKey(KnownHives[key], registryView);
             }
             else
             {
                 return RegistryKey.OpenRemoteBaseKey(KnownHives[key], remoteMachineName, registryView);
             }
         }
     }
     Trace.TraceWarning("'{0}' is not a well-formed registry path", rootPath);
     return null;
 }

        LicenseSourceResult ReadFromRegistry(RegistryView view, string applicationName)
        {
            try
            {
                using (var rootKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, view))
                using (var registryKey = rootKey.OpenSubKey(keyPath))
                {
                    if (registryKey == null)
                    {
                        return ValidateLicense(null, applicationName);
                    }

                    var regValue = registryKey.GetValue("License", null);

                    var licenseText = (regValue is string[])
                        ? string.Join(" ", (string[])regValue)
                        : (string)regValue;

                    return ValidateLicense(licenseText, applicationName);
                }
            }
            catch (SecurityException)
            {
                return new LicenseSourceResult
                {
                    Location = location,
                    Result = $"Insufficent rights to read license from {location}"
                };
            }
        }

        public IRegistryKey OpenRemoteBaseKey(
	RegistryHive hKey,
	string machineName,
	RegistryView view
)
        {
            return new RegistryKeyWrap(RegistryKey.OpenRemoteBaseKey(hKey, machineName, view));
        }

		static void DeleteKey(RegistryHive hive, RegistryView view, string guid)
		{
			using (RegistryKey key = RegistryKey.OpenBaseKey(hive, view)) {
				key.DeleteSubKey("Software\\Classes\\CLSID\\" + guid + "\\ProgId", false);
				key.DeleteSubKey("Software\\Classes\\CLSID\\" + guid + "\\InProcServer32", false);
				key.DeleteSubKey("Software\\Classes\\CLSID\\" + guid, false);
			}
		}

 private static string FindRegistryValueUnderKey(string registryBaseKeyName, string registryKeyName, RegistryView registryView)
 {
     using (RegistryKey registryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, registryView))
     {
         using (RegistryKey registryKey2 = registryKey.OpenSubKey(registryBaseKeyName))
         {
             return registryKey2?.GetValue(registryKeyName)?.ToString() ?? string.Empty;
         }
     }
 }

		static void CreateKeys(RegistryHive hive, RegistryView view, string guid, string libraryId, string classId, string path)
		{
			using (RegistryKey key = RegistryKey.OpenBaseKey(hive, view)) {
				using (RegistryKey subKey = key.CreateSubKey("Software\\Classes\\CLSID\\" + guid))
					subKey.SetValue(null, classId + " Class");
				using (RegistryKey subKey = key.CreateSubKey("Software\\Classes\\CLSID\\" + guid + "\\InProcServer32"))
					subKey.SetValue(null, path);
				using (RegistryKey subKey = key.CreateSubKey("Software\\Classes\\CLSID\\" + guid + "\\ProgId"))
					subKey.SetValue(null, libraryId + "." + classId);
			}
		}

 static string ReadRegistry(RegistryView view, string keyName, string defaultValue)
 {
     using (var key = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, view).OpenSubKey(@"SOFTWARE\ParticularSoftware\ServiceBus"))
     {
         if (key == null)
         {
             return defaultValue;
         }
         return (string) key.GetValue(keyName, defaultValue);
     }
 }

 public void RegisterTypeLib(System.Reflection.Assembly typeLib, RegistryView registryView )
 {
     var reg = ComClrInfoFactory.CreateTypeLib(typeLib);
     #if NET35
     throw new NotImplementedException("Need to backport 4.0 methods");
     #else
     var root = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, registryView);
     var classes = root.CreateSubKey(CLASSES);
     registerTypeLib(classes, reg);
     #endif
 }

        /// <summary>
        /// The default constructor takes a registry root path encoded as a string (for example, HKEY_LOCAL_MACHINE\Software\Microsoft) 
        /// and reads everything under it.
        /// </summary>
        /// <param name="rootPath">Root path</param>
        /// <param name="registryView">Type of registry you want to see (32-bit, 64-bit, default).</param>
        public RegistryImporter(string rootPath, RegistryView registryView)
        {
            Result = new RegKeyEntry(null, rootPath);

            string rootPathWithoutHive;
            RegistryKey rootKey = Regis3.OpenRegistryHive(rootPath, out rootPathWithoutHive, registryView);
            using (RegistryKey key = rootKey.OpenSubKey(rootPathWithoutHive))
            {
                ImportRecursive(Result, key);
            }
        }

 public void UnregisterInProcServer(Type t, RegistryView registryView = RegistryView.Default)
 {
     var reg = ComClrInfoFactory.CreateClass(t);
      #if NET35
     throw new NotImplementedException("Need to backport 4.0 methods");
     #else
     var root = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, registryView);
     var classes = root.CreateSubKey(CLASSES);
     unregisterInProcServer(classes, reg);
     #endif
 }

 public void UnregisterInterface(Type type, RegistryView registryView = RegistryView.Default)
 {
     var reg = ComClrInfoFactory.CreateInterface(type);
     #if NET35
     throw new NotImplementedException("Need to backport 4.0 methods");
     #else
     var root = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, registryView);
     var classes = root.CreateSubKey(CLASSES);
     unregisterInterface(classes, reg);
     #endif
 }

 private ODBC GetDataAndConstructOdbcObject(RegistryHive hiveToUse, RegistryView viewToUse, string stringToReplace, string path, string odbcKey)
 {
     RegistryKey odbcReg = RegistryKey.OpenBaseKey(hiveToUse, viewToUse);
     odbcReg = odbcReg.OpenSubKey(path);
     odbcReg = odbcReg.OpenSubKey(odbcKey);
     string server = (string)odbcReg.GetValue("server");
     string driver = (string)odbcReg.GetValue("driver");
     string name = odbcReg.Name.Replace(stringToReplace + "\\" + path + "\\", "");
     string dsn = name;
     ODBC odbcObject = new ODBC(dsn, driver, server);
     return odbcObject;
 }