private async Task<bool> BOnlyInnerCompare(RegistryKey A, RegistryKey B, string root)
{
List<Task<bool>> tasks = new List<Task<bool>>();
List<bool> bools = new List<bool>();
try
{
if (B != null)
{
// Process A
string[] bVals;
lock (HiveB)
bVals = B.GetValueNames();
string[] aVals = new string[0];
if (A != null)
lock (HiveA)
aVals = A.GetValueNames();
foreach (var Name in bVals)
{
string EntryName;
lock (HiveB)
EntryName = root + B.Name + "::" + Name;
var dat = new Data();
lock (HiveB)
dat.SetB(B.GetValue(Name), B.GetValueType(Name));
if (aVals.Contains(Name, StringComparer.CurrentCultureIgnoreCase))
lock (HiveA)
dat.SetA(A.GetValue(Name), A.GetValueType(Name));
lock(Output)
Output.Add(EntryName, dat);
}
string[] BSubKeys;
lock (HiveB)
BSubKeys = B.GetSubKeyNames();
string[] ASubKeys = new string[0];
if (A != null)
lock (HiveA)
ASubKeys = A.GetSubKeyNames();
tasks.AddRange(BSubKeys.Select(async keyName =>
{
RegistryKey aSub, bSub;
lock (HiveB)
bSub = B.OpenSubKey(keyName);
lock (HiveA)
aSub = A == null
? null
: ASubKeys.Contains(keyName, StringComparer.CurrentCultureIgnoreCase)
? A.OpenSubKey(keyName)
: null;
return await BOnlyInnerCompare(aSub, bSub, root + keyName + @"\");
}));
}
/*
return Task.Factory.StartNew(() =>
tasks.AsParallel().Aggregate(true, (ret, task) =>
{
task.Wait();
return ret && task.Result;
}), TaskCreationOptions.AttachedToParent);
*/
return tasks.AsParallel().Aggregate(true, (ret, task) =>
{
task.Wait();
return ret && task.Result;
});
}
catch (Exception e)
{
throw;
}
}
private static void InnerRead(RegistryKey key, XDictionary<string, XDictionary<string, ValueObject>> data)
{
foreach (var name in key.GetValueNames())
{
data[key.Name][name] = new ValueObject(key.GetValueType(name), key.GetValue(name));
}
foreach (var sub in key.GetSubKeyNames())
{
InnerRead(key.OpenSubKey(sub), data);
}
}
private Task<bool> InnerCompare(RegistryKey A, RegistryKey B, string root) // TODO: Adjust to match the BOnly comparison (below)
{
List<Task<bool>> tasks = new List<Task<bool>>();
try
{
if (A != null)
{
// Process A
string[] aVals;
lock (HiveA)
aVals = A.GetValueNames();
foreach (var Name in aVals)
{
string EntryName;
lock (HiveA)
EntryName = root + A.Name + "::" + Name;
var dat = new Data();
lock (HiveA)
dat.SetA(A.GetValue(Name), A.GetValueType(Name));
Output.Add(EntryName, dat);
}
string[] ASubKeys;
lock (HiveA)
ASubKeys = A.GetSubKeyNames();
string[] BSubKeys = new string[0];
if (B != null)
lock (HiveB)
BSubKeys = B.GetSubKeyNames();
tasks.AddRange(ASubKeys.AsParallel().Select(keyName =>
{
RegistryKey aSub, bSub;
lock (HiveA)
aSub = A.OpenSubKey(keyName);
lock (HiveB)
bSub = B == null
? null
: BSubKeys.Contains(keyName, StringComparer.CurrentCultureIgnoreCase)
? B.OpenSubKey(keyName)
: null;
return InnerCompare(aSub, bSub, root + keyName + @"\");
}));
}
if (B != null)
{
// Process B
string[] bVals;
lock (HiveB)
bVals = B.GetValueNames();
foreach (var Name in bVals)
{
string EntryName;
lock (HiveB)
EntryName = root + B.Name + "::" + Name;
Data dat = Output.ContainsKey(EntryName) ? Output[EntryName] : new Data();
lock (HiveB)
dat.SetB(B.GetValue(Name), B.GetValueType(Name));
Output[EntryName] = dat;
}
string[] BSubKeys;
lock (HiveB)
BSubKeys = B.GetSubKeyNames();
tasks.AddRange(BSubKeys.AsParallel().Select(keyName =>
{
RegistryKey bSub;
lock (HiveB)
bSub = B.OpenSubKey(keyName);
return InnerCompare(null, bSub, root + keyName + @"\");
}));
}
return Task.Factory.StartNew(() =>
tasks.Aggregate(true, (ret, task) =>
{
task.Wait();
return ret && task.Result;
}), TaskCreationOptions.AttachedToParent);
}
catch (Exception e)
{
throw;
}
}