public void TestInitialize()
{
Service.ConnectorService = ConnectorService;
Service.SettingsService = SettingsService;
Service.CurrentExePath = CurrentExePath;
Service.CurrentUserRun64Connector = CurrentUserRun64Connector;
Guid = new Guid();
AutoStartEntry = new RegistryAutoStartEntry()
{
Id = Guid,
Category = Category.CurrentUserRun64,
Path = "",
Value = ""
};
}
protected void AddAutoStart(AutoStartEntry autoStart, bool dryRun)
{
Logger.Trace("AddAutoStart called for {Value} in {Path} (dryRun: {DryRun})", autoStart.Value, autoStart.Path, dryRun);
if (!(autoStart is RegistryAutoStartEntry))
{
throw new ArgumentException("Parameter must be of type RegistryAutoStartEntry");
}
RegistryAutoStartEntry regAutoStart = (RegistryAutoStartEntry)autoStart;
var firstDelimiterPos = regAutoStart.Path.IndexOf('\\');
var lastDelimiterPos = regAutoStart.Path.LastIndexOf('\\');
var keyPath = regAutoStart.Path.Substring(0, lastDelimiterPos);
var subKeyPath = keyPath.Substring(firstDelimiterPos + 1);
var valueName = regAutoStart.Path.Substring(lastDelimiterPos + 1);
using (var registry = GetBaseRegistry())
using (var key = registry.OpenSubKey(subKeyPath, !dryRun)) {
if (key == null && dryRun)
{
return;
}
object value = key.GetValue(valueName, null);
if (value != null)
{
var currentValueKind = key.GetValueKind(valueName);
if (currentValueKind != regAutoStart.RegistryValueKind)
{
throw new ArgumentException($"Value \"{valueName}\" of key \"{keyPath}\" already exists with different type \"{currentValueKind}\"");
}
}
switch (regAutoStart.RegistryValueKind)
{
case RegistryValueKind.String:
case RegistryValueKind.ExpandString: {
if (value != null)
{
if (!string.Equals((string)value, regAutoStart.Value, StringComparison.OrdinalIgnoreCase))
{
throw new AlreadySetByOtherException($"Value \"{valueName}\" of key \"{keyPath}\" already set to value \"{(string)value}\"");
}
else
{
throw new AlreadySetException($"Value \"{valueName}\" of key \"{keyPath}\" already set");
}
}
if (dryRun)
{
return;
}
Microsoft.Win32.Registry.SetValue(keyPath, valueName, regAutoStart.Value, regAutoStart.RegistryValueKind);
Logger.Info("Added {Value} to {Path}", regAutoStart.Value, regAutoStart.Path);
break;
}
case RegistryValueKind.MultiString: {
var newValues = new List <string> {
regAutoStart.Value
};
bool exists = false;
if (value != null)
{
foreach (var subValue in value as IEnumerable <string> )
{
newValues.Add(subValue);
if (string.Equals(subValue, regAutoStart.Value, StringComparison.OrdinalIgnoreCase))
{
exists = true;
break;
}
}
}
if (!exists)
{
if (dryRun)
{
return;
}
Microsoft.Win32.Registry.SetValue(keyPath, valueName, newValues.ToArray(), regAutoStart.RegistryValueKind);
Logger.Info("Added {Value} to {Path}", regAutoStart.Value, regAutoStart.Path);
}
else
{
throw new AlreadySetException($"\"{regAutoStart.Value}\" already exists at \"{regAutoStart.Path}\"");
}
break;
}
case RegistryValueKind.Binary:
case RegistryValueKind.DWord:
case RegistryValueKind.QWord:
case RegistryValueKind.Unknown:
case RegistryValueKind.None:
default:
throw new ArgumentException($"Don't know how to handle data type \"{regAutoStart.RegistryValueKind}\" of key \"{regAutoStart.Path}\"");
}
}
}
/// <summary>
/// Gets all values inside the key as RegistryAutoStartEntry
/// </summary>
/// <param name="currentKey"></param>
/// <param name="recursive"></param>
/// <returns></returns>
public IList <RegistryAutoStartEntry> GetCurrentAutoStarts(RegistryKey currentKey, bool recursive = false, int level = 0)
{
var ret = new List <RegistryAutoStartEntry>();
var valueNames = currentKey.GetValueNames();
foreach (var valueName in valueNames)
{
try {
var valueKind = currentKey.GetValueKind(valueName);
switch (valueKind)
{
case RegistryValueKind.String:
case RegistryValueKind.ExpandString: {
string value = (string)currentKey.GetValue(valueName, null);
if (value == null)
{
continue;
}
if (value.Length > 0 && GetIsAutoStartEntry(currentKey, valueName, level))
{
var newAutoStart = new RegistryAutoStartEntry {
Category = Category,
Value = value.ToString(),
Path = $"{currentKey}\\{valueName}",
RegistryValueKind = valueKind,
Date = DateTime.Now,
};
ret.Add(newAutoStart);
}
break;
}
case RegistryValueKind.MultiString: {
IEnumerable <string> value = (IEnumerable <string>)currentKey.GetValue(valueName, null);
if (value == null)
{
continue;
}
foreach (var subValue in value)
{
if (subValue.Length > 0 && GetIsAutoStartEntry(currentKey, valueName, level))
{
var newAutoStart = new RegistryAutoStartEntry {
Category = Category,
Value = subValue.ToString(),
Path = $"{currentKey}\\{valueName}",
RegistryValueKind = valueKind,
Date = DateTime.Now,
};
ret.Add(newAutoStart);
}
}
break;
}
case RegistryValueKind.Binary:
case RegistryValueKind.DWord:
case RegistryValueKind.QWord:
case RegistryValueKind.Unknown:
case RegistryValueKind.None:
default:
Logger.Trace("Skipping {valueName} from {currentKey} because of not implemented type {type}", valueName, currentKey, valueKind);
break;
}
} catch (Exception ex) {
var err = new Exception($"Failed to get \"{valueName}\" from \"{currentKey}\"", ex);
throw err;
}
}
if (recursive)
{
var subKeyNames = currentKey.GetSubKeyNames();
foreach (var subKeyName in subKeyNames)
{
using (var subKey = currentKey.OpenSubKey(subKeyName)) {
if (subKey != null)
{
var subAutoStartEntries = GetCurrentAutoStarts(subKey, recursive, level + 1);
ret.AddRange(subAutoStartEntries);
}
}
}
}
return(ret);
}
