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 Task <bool> InnerCompare(RegistryKey A, RegistryKey B, string root) { 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; } }