Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

ScanX - A Registry Cleaner

, 29 Jan 2012
C#/WPF - ScanX: Creating a commercial quality Registry cleaner.
Prize winner in Competition "Best C# article of December 2011"
scanx_source_19.zip
RegScanHarness
CircularProgressBar
bin
Debug
CircularProgressBar.dll
CircularProgressBar.pdb
Helpers
obj
Debug
CircularProgressBar.csproj.GenerateResource.Cache
CircularProgressBar.dll
CircularProgressBar.g.resources
CircularProgressBar.pdb
CircularProgressBar.Properties.Resources.resources
CircularProgressBar_MarkupCompile.cache
CircularProgressBar_MarkupCompile.lref
Refactor
CircularProgressBar.dll
TempPE
Themes
CircularProgressBar.Theme.baml
Generic.baml
GlassyProgressBar.Theme.baml
PieProgressBar.Theme.baml
Properties
Settings.settings
Themes
RegScanHarness.suo
RegScanHarness
bin
Debug
app.publish
Application Files
ScanX_1_1_0_3
CircularProgressBar.dll.deploy
ScanX.exe.config.deploy
ScanX.exe.deploy
ScanX.exe.manifest
VTRegScan.dll.deploy
ScanX.application
setup.exe
CircularProgressBar.dll
CircularProgressBar.pdb
RegScanHarness.vshost.application
ScanX.exe
ScanX.pdb
ScanX.vshost.exe
ScanX.vshost.exe.manifest
VTRegScan.dll
VTRegScan.pdb
Release
Helpers
Images
about.png
aboutsm.png
monitor.png
options.png
regctrl.png
regdeep.png
regfont.png
reghelp.png
reghist.png
reginst.png
reglib.png
regmru.png
regstart.png
regsystem.png
reguser.png
regvdf.png
stars.jpg
stars.png
starsbg.png
Implementation
obj
Debug
Panels
HelpPanel.baml
OptionsPanel.baml
RegScanActivePanel.baml
RegScanPanel.baml
ScanResultsPanel.baml
Refactor
ResolveAssemblyReference.cache
Resources
Brushes.baml
ControlStyles.baml
ScanX.csproj.GenerateResource.Cache
ScanX.exe
ScanX.g.resources
ScanX.pdb
ScanX.Properties.Resources.resources
ScanX_MarkupCompile.cache
ScanX_MarkupCompile.lref
TempPE
Properties.Resources.Designer.cs.dll
wndAbout.baml
wndDetails.baml
wndMain.baml
Release
Panels
Properties
app.manifest
Settings.settings
publish
Resources
ScanX.csproj.user
Service References
VTRegScan
bin
Debug
VTRegScan.dll
VTRegScan.pdb
obj
Debug
Refactor
VTRegScan.dll
TempPE
VTRegScan.dll
VTRegScan.pdb
Properties
scanx_source_20.zip
CircularProgressBar.dll
Settings.settings
CircularProgressBar.dll.deploy
ScanX.exe.config.deploy
ScanX.exe.deploy
ScanX.exe.manifest
VTRegScan.dll.deploy
ScanX.application
setup.exe
CircularProgressBar.dll
RegScanHarness.vshost.application
ScanX.exe
ScanX.vshost.exe
VTRegScan.dll
about.png
aboutsm.png
monitor.png
options.png
regctrl.png
regdeep.png
regfont.png
reghelp.png
reghist.png
reginst.png
reglib.png
regmru.png
regstart.png
regsystem.png
reguser.png
regvdf.png
stars.jpg
stars.png
starsbg.png
app.manifest
Settings.settings
ScanX.csproj.user
VTRegScan.dll
using System;
using System.Linq;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Media;
using LinqToVisualTree;
using CircularProgressBar.Helpers;

namespace CircularProgressBar.Helpers
{
  /// <summary>
  /// Adapts a DependencyObject to provide methods required for generate
  /// a Linq To Tree API
  /// </summary>
  public class VisualTreeAdapter : ILinqTree<DependencyObject>
  {
    private DependencyObject _item;

    public VisualTreeAdapter(DependencyObject item)
    {
      _item = item;
    }

    public IEnumerable<DependencyObject> Children()
    {
      int childrenCount = VisualTreeHelper.GetChildrenCount(_item);
      for (int i = 0; i < childrenCount; i++)
      {
        yield return VisualTreeHelper.GetChild(_item, i);
      }
    }

    public DependencyObject Parent
    {
      get
      {
        return VisualTreeHelper.GetParent(_item);
      }
    }
  }
}

namespace LinqToVisualTree
{
  /// <summary>
  /// Defines an interface that must be implemented to generate the LinqToTree methods
  /// </summary>
  /// <typeparam name="T"></typeparam>
  public interface ILinqTree<T>
  {
    IEnumerable<T> Children();

    T Parent { get; }
  }

  public static class TreeExtensions
  {
    /// <summary>
    /// Returns a collection of descendant elements.
    /// </summary>
    public static IEnumerable<DependencyObject> Descendants(this DependencyObject item)
    {
      ILinqTree<DependencyObject> adapter = new VisualTreeAdapter(item);
      foreach (var child in adapter.Children())
      {
        yield return child;

        foreach (var grandChild in child.Descendants())
        {
          yield return grandChild;
        }
      }
    }

    /// <summary>
    /// Returns a collection containing this element and all descendant elements.
    /// </summary>
    public static IEnumerable<DependencyObject> DescendantsAndSelf(this DependencyObject item)
    {
      yield return item;

      foreach (var child in item.Descendants())
      {
        yield return child;
      }
    }

    /// <summary>
    /// Returns a collection of ancestor elements.
    /// </summary>
    public static IEnumerable<DependencyObject> Ancestors(this DependencyObject item)
    {
      ILinqTree<DependencyObject> adapter = new VisualTreeAdapter(item);

      var parent = adapter.Parent;
      while (parent != null)
      {
        yield return parent;
        adapter = new VisualTreeAdapter(parent);
        parent = adapter.Parent;
      }
    }

    /// <summary>
    /// Returns a collection containing this element and all ancestor elements.
    /// </summary>
    public static IEnumerable<DependencyObject> AncestorsAndSelf(this DependencyObject item)
    {
      yield return item;

      foreach (var ancestor in item.Ancestors())
      {
        yield return ancestor;
      }
    }

    /// <summary>
    /// Returns a collection of child elements.
    /// </summary>
    public static IEnumerable<DependencyObject> Elements(this DependencyObject item)
    {
      ILinqTree<DependencyObject> adapter = new VisualTreeAdapter(item);
      foreach (var child in adapter.Children())
      {
        yield return child;
      }
    }

    /// <summary>
    /// Returns a collection of the sibling elements before this node, in document order.
    /// </summary>
    public static IEnumerable<DependencyObject> ElementsBeforeSelf(this DependencyObject item)
    {
      if (item.Ancestors().FirstOrDefault() == null)
        yield break;
      foreach (var child in item.Ancestors().First().Elements())
      {
        if (child.Equals(item))
          break;
        yield return child;
      }
    }

    /// <summary>
    /// Returns a collection of the after elements after this node, in document order.
    /// </summary>
    public static IEnumerable<DependencyObject> ElementsAfterSelf(this DependencyObject item)
    {
      if (item.Ancestors().FirstOrDefault() == null)
        yield break;
      bool afterSelf = false;
      foreach (var child in item.Ancestors().First().Elements())
      {
        if (afterSelf)
          yield return child;

        if (child.Equals(item))
          afterSelf = true;
      }
    }

    /// <summary>
    /// Returns a collection containing this element and all child elements.
    /// </summary>
    public static IEnumerable<DependencyObject> ElementsAndSelf(this DependencyObject item)
    {
      yield return item;

      foreach (var child in item.Elements())
      {
        yield return child;
      }
    }

    /// <summary>
    /// Returns a collection of descendant elements which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> Descendants<T>(this DependencyObject item)
    {
      return item.Descendants().Where(i => i is T).Cast<DependencyObject>();
    }

    /// <summary>
    /// Returns a collection of the sibling elements before this node, in document order
    /// which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> ElementsBeforeSelf<T>(this DependencyObject item)
    {
      return item.ElementsBeforeSelf().Where(i => i is T).Cast<DependencyObject>();
    }

    /// <summary>
    /// Returns a collection of the after elements after this node, in document order
    /// which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> ElementsAfterSelf<T>(this DependencyObject item)
    {
      return item.ElementsAfterSelf().Where(i => i is T).Cast<DependencyObject>();
    }

    /// <summary>
    /// Returns a collection containing this element and all descendant elements
    /// which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> DescendantsAndSelf<T>(this DependencyObject item)
    {
      return item.DescendantsAndSelf().Where(i => i is T).Cast<DependencyObject>();
    }

    /// <summary>
    /// Returns a collection of ancestor elements which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> Ancestors<T>(this DependencyObject item)
    {
      return item.Ancestors().Where(i => i is T).Cast<DependencyObject>();
    }

    /// <summary>
    /// Returns a collection containing this element and all ancestor elements
    /// which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> AncestorsAndSelf<T>(this DependencyObject item)
    {
      return item.AncestorsAndSelf().Where(i => i is T).Cast<DependencyObject>();
    }

    /// <summary>
    /// Returns a collection of child elements which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> Elements<T>(this DependencyObject item)
    {
      return item.Elements().Where(i => i is T).Cast<DependencyObject>();
    }

    /// <summary>
    /// Returns a collection containing this element and all child elements.
    /// which match the given type.
    /// </summary>
    public static IEnumerable<DependencyObject> ElementsAndSelf<T>(this DependencyObject item)
    {
      return item.ElementsAndSelf().Where(i => i is T).Cast<DependencyObject>();
    }

  }

  public static class EnumerableTreeExtensions
  {
      /// <summary>
      /// Applies the given function to each of the items in the supplied
      /// IEnumerable.
      /// </summary>
      private static IEnumerable<DependencyObject> DrillDown(this IEnumerable<DependencyObject> items,
          Func<DependencyObject, IEnumerable<DependencyObject>> function)
      {
          foreach (var item in items)
          {
              foreach (var itemChild in function(item))
              {
                  yield return itemChild;
              }
          }
      }

      /// <summary>
      /// Applies the given function to each of the items in the supplied
      /// IEnumerable, which match the given type.
      /// </summary>
      public static IEnumerable<DependencyObject> DrillDown<T>(this IEnumerable<DependencyObject> items,
          Func<DependencyObject, IEnumerable<DependencyObject>> function)
          where T : DependencyObject
      {
          foreach (var item in items)
          {
              foreach (var itemChild in function(item))
              {
                  if (itemChild is T)
                  {
                      yield return (T)itemChild;
                  }
              }
          }
      }

      /// <summary>
      /// Returns a collection of descendant elements.
      /// </summary>
      public static IEnumerable<DependencyObject> Descendants(this IEnumerable<DependencyObject> items)
      {
          return items.DrillDown(i => i.Descendants());
      }

      /// <summary>
      /// Returns a collection containing this element and all descendant elements.
      /// </summary>
      public static IEnumerable<DependencyObject> DescendantsAndSelf(this IEnumerable<DependencyObject> items)
      {
          return items.DrillDown(i => i.DescendantsAndSelf());
      }

      /// <summary>
      /// Returns a collection of ancestor elements.
      /// </summary>
      public static IEnumerable<DependencyObject> Ancestors(this IEnumerable<DependencyObject> items)
      {
          return items.DrillDown(i => i.Ancestors());
      }

      /// <summary>
      /// Returns a collection containing this element and all ancestor elements.
      /// </summary>
      public static IEnumerable<DependencyObject> AncestorsAndSelf(this IEnumerable<DependencyObject> items)
      {
          return items.DrillDown(i => i.AncestorsAndSelf());
      }

      /// <summary>
      /// Returns a collection of child elements.
      /// </summary>
      public static IEnumerable<DependencyObject> Elements(this IEnumerable<DependencyObject> items)
      {
          return items.DrillDown(i => i.Elements());
      }

      /// <summary>
      /// Returns a collection containing this element and all child elements.
      /// </summary>
      public static IEnumerable<DependencyObject> ElementsAndSelf(this IEnumerable<DependencyObject> items)
      {
          return items.DrillDown(i => i.ElementsAndSelf());
      }

      /// <summary>
      /// Returns a collection of descendant elements which match the given type.
      /// </summary>
      public static IEnumerable<DependencyObject> Descendants<T>(this IEnumerable<DependencyObject> items)
          where T : DependencyObject
      {
          return items.DrillDown<T>(i => i.Descendants());
      }

      /// <summary>
      /// Returns a collection containing this element and all descendant elements.
      /// which match the given type.
      /// </summary>
      public static IEnumerable<DependencyObject> DescendantsAndSelf<T>(this IEnumerable<DependencyObject> items)
          where T : DependencyObject
      {
          return items.DrillDown<T>(i => i.DescendantsAndSelf());
      }

      /// <summary>
      /// Returns a collection of ancestor elements which match the given type.
      /// </summary>
      public static IEnumerable<DependencyObject> Ancestors<T>(this IEnumerable<DependencyObject> items)
          where T : DependencyObject
      {
          return items.DrillDown<T>(i => i.Ancestors());
      }

      /// <summary>
      /// Returns a collection containing this element and all ancestor elements.
      /// which match the given type.
      /// </summary>
      public static IEnumerable<DependencyObject> AncestorsAndSelf<T>(this IEnumerable<DependencyObject> items)
          where T : DependencyObject
      {
          return items.DrillDown<T>(i => i.AncestorsAndSelf());
      }

      /// <summary>
      /// Returns a collection of child elements which match the given type.
      /// </summary>
      public static IEnumerable<DependencyObject> Elements<T>(this IEnumerable<DependencyObject> items)
          where T : DependencyObject
      {
          return items.DrillDown<T>(i => i.Elements());
      }

      /// <summary>
      /// Returns a collection containing this element and all child elements.
      /// which match the given type.
      /// </summary>
      public static IEnumerable<DependencyObject> ElementsAndSelf<T>(this IEnumerable<DependencyObject> items)
          where T : DependencyObject
      {
          return items.DrillDown<T>(i => i.ElementsAndSelf());
      }
  }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

John Underhill (Steppenwolfe)
Network Administrator vtdev.com
Canada Canada
Network and programming specialist. Started in C, and have learned about 14 languages since then. Cisco programmer, and lately writing a lot of C# and WPF code, (learning Java too). If I can dream it up, I can probably put it to code. My software company, (VTDev), is on the verge of releasing a couple of very cool things.. keep you posted.

| Advertise | Privacy | Mobile
Web04 | 2.8.140721.1 | Last Updated 29 Jan 2012
Article Copyright 2011 by John Underhill (Steppenwolfe)
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid