This post gets you Linq access to the GAC with no fuss.

Fusion is wrapped for you so no need to understand the unmanaged stuff unless you want to. Your up and running with GAC as a new Linq to Objects source in minutes.

The Big Picture of the Project (You can skip to the next section if you just want the GAC code)

Note: The reason both the Gac and MyEnvironment IEnumerable<T> references below are different? See the reference on the bottom right of the picture into the entry point to all of it (ThisBox)?

Introduction to the Fusion  IEnumerable Wrapper

A simple case. I want to know how my GAC is broken into ‘Major Vendors’. We assume this is roughly the first part of the name. (i.e. Microsoft.System = Microsoft).

Oh yeah. Exclude the assemblies that only occur once. We are looking for the larger view here.

Here is an easy solution:

        [Fact]
        public void should_show_gac_by_vendor()
        {
            var result = from matchedAssembly in ThisBox.By<AssemblyDetail>()
                         group matchedAssembly by
                             matchedAssembly.MajorName
                             into grouping
                             where grouping.Count() > 1
                             orderby grouping.Count() descending
                             select grouping;

            var TotalSum = result.Sum(ad => ad.Count());

            Console.WriteLine("** ASSEMBLIES BY NAME WITH > 1 REGISTERED  = {0} ***", TotalSum);

            foreach (var firstGroup in result)
            {
                var groupCount = firstGroup.Count();
                Console.WriteLine("Group '{0}' Assemblies={1} Percent={2} Public Keys Used={3}",
                                    firstGroup.Key,
                                    groupCount,
                                    groupCount.ToPctString(TotalSum),
                                    firstGroup.Select(ad => ad.PublicKey).Distinct().Count()
                                    );
            }
        }

** ASSEMBLIES BY NAME WITH > 1 REGISTERED  = 664 ***

Group ‘Microsoft’ Assemblies=466 Percent=70.18% Public Keys Used=5
Group ‘DevExpress’ Assemblies=73 Percent=10.99% Public Keys Used=2
Group ‘System’ Assemblies=71 Percent=10.69% Public Keys Used=4
Group ‘Policy’ Assemblies=14 Percent=2.11% Public Keys Used=2
Group ‘FSharp’ Assemblies=11 Percent=1.66% Public Keys Used=1
Group ‘VLinq’ Assemblies=10 Percent=1.51% Public Keys Used=1
Group ‘policy’ Assemblies=6 Percent=0.9% Public Keys Used=2
Group ‘PresentationFramework’ Assemblies=5 Percent=0.75% Public Keys Used=1
Group ‘mscorcfg’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘WebDev’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘VSTADTEProvider’ Assemblies=2 Percent=0.3% Public Keys Used=1
Group ‘VsWebSite’ Assemblies=2 Percent=0.3% Public Keys Used=1

Try that with GacUtil (grin)..

C# GAC IEnumerable<Assembly> implementation

Ah yes the GAC Fusion wrapper code.  Thanks to Debasish Bose for his help here.

C# Fusion Gac Enumerable : Domain.Dot.Net Team

    /// <summary>
    /// Just to have some room to breath
    /// </summary>
    public class AssemblyDetail : AssemblyDetailBase
    {
        public AssemblyDetail(IAssemblyName currentAssembly) : base(currentAssembly) {}

        public override String FullName
        {
            get
            {
                return _fullName;
            }
        }
        public override string Version
        {
            get
            {
                return _versionString;
            }
        }
        public override int Major
        {
            get
            {
                return VersionComponent(0);
            }
        }
        public override int Minor
        {
            get
            {
                return VersionComponent(1);
            }
        }
        public override int Revision
        {
            get
            {
                return VersionComponent(2);
            }
        }
        public override int Build
        {
            get
            {
                return VersionComponent(3);
            }
        }

        public override string PublicKey
        {
            get
            {
                return _pkey;
            }
        }
        public override string MajorName
        {
            get
            {
                return _majorName;
            }
        }
        public String Name
        {
            get
            {
                return _fullName;
            }
        }

        int VersionComponent(int position)
        {
            return _version.Length <= position + 1
                           ? Convert.ToInt32(_version[position]) : 0;
        }
    }

    #region

    using System;
    using System.Runtime.InteropServices;

    #endregion

    /// <summary>
    /// Alpha - Comment and Add Regressions
    /// </summary>
    public abstract class AssemblyDetailBase
    {
        protected string _fullName;
        protected string _majorName;
        string[] _nameSplit;
        protected string _pkey;
        string _rawname;
        protected string[] _version;
        protected string _versionString;

        /// <summary>
        /// Initializes a new instance of the <see cref="AssemblyDetailBase"/> class.
        /// </summary>
        /// <param name="Current">The current.</param>
        protected AssemblyDetailBase(IAssemblyName Current)
        {
            ExtractParsedDetail(Current);
        }

        public abstract string FullName
        {
            get;
        }
        public abstract string Version
        {
            get;
        }
        public abstract int Major
        {
            get;
        }
        public abstract int Minor
        {
            get;
        }
        public abstract int Revision
        {
            get;
        }
        public abstract int Build
        {
            get;
        }
        public abstract string PublicKey
        {
            get;
        }
        public abstract string MajorName
        {
            get;
        }

        /// <summary>
        /// I do not want to persist the IAssemblyName
        /// as it might introduce a COM reference when
        /// we just can extract what we need and let it
        /// pass away into whatever...
        ///
        /// Extracts the parsed detail.
        /// </summary>
        /// <param name="Current">The current.</param>
        void ExtractParsedDetail(IAssemblyName Current)
        {
            const int stongKeyPosition = 3;
            const int versionPosition = 1;

            // Main Work Happens Here
            _fullName = GetDisplayName(Current);

            // Simply parse the ", " that seperates the full
            // name
            var _parsedDetails = _fullName.Split(new[]
                                                 {
                                                         ", "
                                                 }, StringSplitOptions.RemoveEmptyEntries);

            ExtractVersionInfo(versionPosition, _parsedDetails);
            ExtractAddition(stongKeyPosition, _parsedDetails);
        }

        void ExtractAddition(int stongKeyPosition, string[] parsedDetails)
        {
            _pkey = parsedDetails[stongKeyPosition];
            _rawname = parsedDetails[0].Trim();
            _nameSplit = _rawname.Split('.');
            _majorName = _nameSplit[0].Trim();
        }

        /// <summary>
        /// Gets the display name from the unmanaged pointer
        /// </summary>
        /// <param name="aName">A name.</param>
        /// <returns></returns>
        static string GetDisplayName(IAssemblyName aName)
        {
            var displayFlags = AssemblyNameDisplayFlags.ALL;

            uint uiLen = 0;

            string _displayAssemblyName = null;

            // Get the length
            aName.GetDisplayName(IntPtr.Zero, ref uiLen, (uint) displayFlags);

            if (uiLen > 0)
            {
                var byteBuffer = new byte[(uiLen + 1)*2];
                unsafe //turn on sunsafe in project properties
                {
                    fixed (byte* numRef1 = byteBuffer)
                    {
                        var ptr1 = new IntPtr(numRef1);
                        aName.GetDisplayName(ptr1, ref uiLen, (uint) displayFlags);
                        _displayAssemblyName = Marshal.PtrToStringUni(ptr1);
                    }
                }
            }

            return _displayAssemblyName;
        }

        /// <summary>
        /// Extracts the version info.
        /// </summary>
        /// <param name="versionPosition">The version position.</param>
        /// <param name="parsedDetails">The parsed details.</param>
        void ExtractVersionInfo(int versionPosition, string[] parsedDetails)
        {
            var versionLiteral = parsedDetails[versionPosition];
            _versionString = ToCoreVersion(versionPosition, versionLiteral);
            if (_versionString != String.Empty)
                _version = _versionString.Split('.');
        }

        /// <summary>
        /// Gets the nice clean x.x.x.x string
        /// </summary>
        /// <param name="versionPosition">The version position.</param>
        /// <param name="versionLiteral">The version literal.</param>
        /// <returns></returns>
        static string ToCoreVersion(int versionPosition, string versionLiteral)
        {
            var returnVal = String.Empty;

            if (!String.IsNullOrEmpty(versionLiteral))
            {
                var _indexOf = versionLiteral.IndexOf("=");

                if (_indexOf != -1)
                    returnVal = versionLiteral.Substring(_indexOf + versionPosition);
            }

            return returnVal;
        }
    }

#region

using System.Runtime.InteropServices;

#endregion

class GAC
{
    GAC() {}

    [DllImport("Fusion.dll", CharSet = CharSet.Auto)]
    public static extern int CreateAssemblyEnum(out IAssemblyEnum ppEnum,
                                                IApplicationContext pAppCtx,
                                                IAssemblyName pName, uint dwFlags,
                                                int pvReserved);
}

#region

using System.Runtime.InteropServices;
using System.Security;

#endregion

[SuppressUnmanagedCodeSecurity, ComImport, Guid("7C23FF90-33AF-11D3-95DA-00A024A85B51"),
 InterfaceType(1)]
public interface IApplicationContext
{
    void SetContextNameObject(IAssemblyName pName);

    void GetContextNameObject([Out] out IAssemblyName ppName);

    void Set([MarshalAs(UnmanagedType.LPWStr)] string szName, int pvValue, uint cbValue,
             uint dwFlags);

    void Get([MarshalAs(UnmanagedType.LPWStr)] string szName, [Out] out int pvValue,
             ref uint pcbValue, uint dwFlags);

    void GetDynamicDirectory([Out] out int wzDynamicDir, ref uint pdwSize);
}

#region

using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;

#endregion

/// <summary>
/// IAssemblyName from Fusion
/// </summary>
[SuppressUnmanagedCodeSecurity, ComImport, Guid("CD193BC0-B4BC-11D2-9833-00C04FC31D2E"),
 InterfaceType(1)]
public interface IAssemblyName
{
    [PreserveSig]
    int SetProperty(uint PropertyId, IntPtr pvProperty, uint cbProperty);

    [PreserveSig]
    int GetProperty(uint PropertyId, IntPtr pvProperty, ref uint pcbProperty);

    [PreserveSig]
    int Finalize();

    [PreserveSig]
    int GetDisplayName(IntPtr szDisplayName, ref uint pccDisplayName, uint dwDisplayFlags);

    [PreserveSig]
    int BindToObject(object refIID, object pAsmBindSink,
                     IApplicationContext pApplicationContext,
                     [MarshalAs(UnmanagedType.LPWStr)] string szCodeBase, long llFlags,
                     int pvReserved, uint cbReserved, [Out] out int ppv);

    [PreserveSig]
    int GetName(ref uint lpcwBuffer,
                [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwzName);

    [PreserveSig]
    int GetVersion([Out] out uint pdwVersionHi, [Out] out uint pdwVersionLow);

    [PreserveSig]
    int IsEqual(IAssemblyName pName, uint dwCmpFlags);

    [PreserveSig]
    int Clone([Out] out IAssemblyName pName);
}

#region

using System.Runtime.InteropServices;
using System.Security;

#endregion

[SuppressUnmanagedCodeSecurity, ComImport, Guid("21B8916C-F28E-11D2-A473-00C04F8EF448"),
 InterfaceType(1)]
interface IAssemblyEnum
{
    [PreserveSig]
    int GetNextAssembly([Out] out IApplicationContext ppAppCtx,
                        [Out] out IAssemblyName ppName, uint dwFlags);

    [PreserveSig]
    int Reset();

    [PreserveSig]
    int Clone([Out] out IAssemblyEnum ppEnum);
}

#region

using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;

#endregion

/// <summary>
/// Fairly basic stuff once the
/// unmanaged stuff is all mapped
/// </summary>
public class GacEnumerable : IEnumerator<IAssemblyName>, IEnumerable<IAssemblyName>
{
    readonly IAssemblyEnum _enumeration;
    IAssemblyName _enumCurrentAssembly;

    GacEnumerable()
    {
        HandleCom(GAC.CreateAssemblyEnum(out _enumeration, null, null,
                                         (uint) AssemblyCacheFlags.GAC, 0));
    }

    public static GacEnumerable New
    {
        get
        {
            return new GacEnumerable();
        }
    }

    #region IEnumerable<IAssemblyName> Members

    /// <summary>
    /// Returns an enumerator that iterates through the collection.
    /// </summary>
    /// <returns>
    /// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
    /// </returns>
    public IEnumerator<IAssemblyName> GetEnumerator()
    {
        return this;
    }

    /// <summary>
    /// Returns an enumerator that iterates through a collection.
    /// </summary>
    /// <returns>
    /// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
    /// </returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion

    #region IEnumerator<IAssemblyName> Members

    /// <summary>
    /// Advances the enumerator to the next element of the collection.
    /// </summary>
    /// <returns>
    /// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
    /// </returns>
    /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
    bool IEnumerator.MoveNext()
    {
        IApplicationContext context1;
        return (0 ==
                _enumeration.GetNextAssembly(out context1, out _enumCurrentAssembly, 0));
    }

    /// <summary>
    /// Sets the enumerator to its initial position, which is before the first element in the collection.
    /// </summary>
    /// <exception cref="T:System.InvalidOperationException">The collection was modified after the enumerator was created. </exception>
    void IEnumerator.Reset()
    {
        _enumeration.Reset();
    }

    /// <summary>
    /// IAssemblyName is a Fusion interface
    /// Gets the element in the collection at the current position of the enumerator.
    /// </summary>
    /// <value></value>
    /// <returns>The element in the collection at the current position of the enumerator.</returns>
    public IAssemblyName Current
    {
        get
        {
            return _enumCurrentAssembly;
        }
    }
    // Properties
    object IEnumerator.Current
    {
        // Go to the other darn Current not this one
        get
        {
            return Current;
        }
    }
    // Fields
    public void Dispose()
    {
        _enumCurrentAssembly = null;
    }

    #endregion

    internal static void HandleCom(int hResult)
    {
        if (hResult < 0)
            Marshal.ThrowExceptionForHR(hResult);
    }
}

[Flags]
enum AssemblyCacheFlags
{
    NGenCache = 0x1,
    GAC = 0x2,
    DownloadCache = 0x4
}

[Flags]
public enum AssemblyNameDisplayFlags
{
    VERSION = 0x01,
    CULTURE = 0x02,
    PUBLIC_KEY_TOKEN = 0x04,
    PROCESSORARCHITECTURE = 0x20,
    RETARGETABLE = 0x80,
    ALL = VERSION |
        CULTURE | PROCESSORARCHITECTURE |
        PUBLIC_KEY_TOKEN | RETARGETABLE
}

More to Come

This is the tip of the iceberg so to speak. Here is a test case to show you what this now is doing and perhaps you can give us ideas where to take it. There is a lot of code. Should it be up on CodePlex? Google Code? Your Environment Variables:

       [Fact]
        public void should_show_my_env()
        {
            var sw = Stopwatch.StartNew();
            var dirs = from env in ThisBox.By<EnvironmentVariable>()
                       select env;
            foreach (var s in dirs)
            {
                Console.WriteLine(s.TypeOfEnv + " " + s.KeyName);
                Console.WriteLine("  ==>" + s.Value);
            }
            Console.WriteLine("Count : " + dirs.Count());
            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");
            sw.Stop();
        }

Let’s join our GAC with our registry!

NOTE: we get 592 hits in 20 or so seconds…

        [Fact]
        public void should_join_policy_registry_section()
        {
            var sw = Stopwatch.StartNew();

            var result = from
                             gac in ThisBox.By<AssemblyDetail>()
                         join
                             registryKey in ThisBox.By<RegistryKey>() 

                         on gac.MajorName equals registryKey.FirstRegValue()

                         select new
                                {
                                        gac, RegVal=registryKey.FirstRegValue()
                                };

            Console.WriteLine("Count : " + result.Count());
            sw.Stop();
            foreach (var a in result)
            {
                Console.WriteLine(a.gac.MajorName + " == " + a.RegVal);
                Console.WriteLine(" ==>" + a.gac.FullName);
            }

            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");
        }

Appendix : A Few Extension Methods we Use

  static class LinqProviderTestExtensions
    {
        /// <summary>
        /// Will perform each action for each
        /// 'row' in the included collection
        /// Each 'row' is of Type TTreeNode
        /// Will typically only be one action
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="items"></param>
        /// <param name="actions"></param>
        static internal void ForEach<T>(this IEnumerable<T> items, params Action<T>[] actions)
        {
            foreach (var t in items)
                foreach (var act in actions)
                    act.Invoke(t);
        }

        public static string FirstRegValue(this RegistryKey registryKey)
        {
            return registryKey.ValueCount > 0
                           ? (string) registryKey.GetValueNames().GetValue(0) : String.Empty;
        }

        public static double ToPercent(this int target, int total)
        {
            return target.ToPercent((double) total);
        }

        public static String ToPctString(this int target, int total)
        {
            return target.ToPercent((double) total) + "%";
        }

        public static double ToPercent(this int target, double total)
        {
            return Math.Round((target/total)*100, 2);
        }
    }

A huge Thanks:

Debasish Bose

del.icio.us Tags: Advanced C#,C# Unmanaged Wrapper,Fusion,GAC,Global Assembly Cache,IEnumerable,IEnumerator,Internals,Lambada,Linq to Gac,Linq to Objects,Machine,Registry
Technorati Tags: Advanced C#,C# Unmanaged Wrapper,Fusion,GAC,Global Assembly Cache,IEnumerable,IEnumerator,Internals,Lambada,Linq to Gac,Linq to Objects,Machine,Registry

Related Posts

Linq is not just about databases. It’s about reading the registry, your hard-disk, or even a list of function pointers to be invoked. Linq is about more even then sets (collections). It’s about making tasks easier in many cases and vastly more powerful (and most importantly your code more readable and maintainable at the same time).

It’s astounding just how fast the HashSet<T> collection is.

This post will show how to gain additional power that is fully supported from Microsoft which is often overlooked, yet it can solve some of the hardest problems (especially around performance however don’t prematurely optimize!).

 
There are tons of cases where we need a real powerhouse to manage super-large sets (in this example we will use the registry). An entire part of the registry actually.

Here is the API we want to use to query the HKLM part of our registry:

            var FindFontsColors = from rk in RegistryServer.Hklm
                                  where
                                          rk.Name.Contains("VisualStudio") &&
                                          rk.Name.EndsWith("FontsAndColors") &&
                                          rk.ValueCount > 0

                                  select rk.Name;

• The core win here is ‘ease of development and maintenance’ without the typical trade-off
  
  in performance. The entire equation is shifted actually so the tradeoff becomes irrelevant.
• Sure you could do this with a lot more code perhaps even a few ms faster. But at what real cost over the life of your code?
• The entire point of this post is the far greater win in maintenance and ease of understanding, without the assumed loss of things like performance.

When there is no intelligence available on a ‘back-end’ to parse your requests, yet you need the power of finding complex conditional results and much more, there is one recently introduced superstar that is often not described in terms of Linq:

HashSet<T>

Let’s start with some code. You know you can call ToList, ToArray, ToDictionary & ToLookup on your collections (we’ll call them Sequences to stay in line with Linq terms).

• You will see ‘sets’, ‘collections’ & sequences used together in documentation today. The differences are mostly academic, however the HashSet does illustrate some of those semantic differences which we point out.

We are going to add an extension method to provide us a ToHashSet capability off any IEnumerable<T> (in exactly the same implementation style Microsoft used internally).

Here is how we gain access to this type in the easiest way:

    using System;
    using System.Collections.Generic;

    /// <summary>
    /// This extension method class will add a ToHashSet<typeparamref name=">"/>
    /// in exactly the same way it is provided by the others:
    ///
    /// ToList(), ToArray(), ToDictionary().. Now ToHashSet() is available
    /// </summary>
    public static class HashSetLinqAccess
    {
        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> fromEnumerable,
            IEqualityComparer<T> comparer)
        {
            if (fromEnumerable == null)
                throw new ArgumentNullException("fromEnumerable");

            if (comparer == null)
                comparer = EqualityComparer<T>.Default;

            return !typeof(HashSet<T>).IsAssignableFrom(fromEnumerable.GetType())
                           ? new HashSet<T>(fromEnumerable, comparer)
                           : (HashSet<T>)fromEnumerable;
        }

        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> fromEnumerable) {

            return ToHashSet(fromEnumerable, EqualityComparer<T>.Default);
        }
    }

Ok so what are we going to do with the HashSet<T> and why?

The benefit comes when we have in-memory large sequences to deal with. I will be using the following code as the ‘server’ here. This is code that provides a ‘Registry Server’ to our application. We will populate up a HashSet<T> with RegistryKey instances and then see just how fast it is.

In the next post we will cover all of the additional methods the HashSet<T> exposes.

Here is the code for our Registry Server. NOTE: Please do not try to modify this to change your registry unless you know what you are doing. This is an immutable (read-only) projection from the registry for a very good reason: You can thrash your machine otherwise.

————————————————————

namespace domaindotnet.LinqToRegistry {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.CompilerServices;
    using System.Threading;
    using Castle.Core;
    using LinqToCore;
    using Microsoft.Win32;

    /// <summary>
    /// Provider immutable projections from the registry
    /// of the machine, as well as events for status and errors
    /// via a singeton wrapper on the .NET Registry
    /// singleton.
    /// Here we are only exposing the HKLM area
    /// subkey but you can see it is easily extensible
    /// </summary>
    public class RegistryServer : IEqualityComparer<RegistryKey>, IInitializable,
                                  IEnumerable<RegistryKey> {
        // IInitializable is from Castle.Core Contractually
        // saying we need a call on our Initialize() method
        // before we can be given out as a service to
        // others

        private static readonly RegistryServer _instance;
        private static int iCounter;
        private HashSet<RegistryKey> allKeys;
        private PopulateProgressEventArgs eventArgStatus;
        private bool isInitialized;

        private PopulateProgressDelegateError populateError = delegate { };
        private PopulateProgressDelegate populateEventOk = delegate { };

        static RegistryServer() {
          

            _instance = new RegistryServer
            {eventArgStatus = new PopulateProgressEventArgs()};

        }

        private RegistryServer() {}

        public static long Count {
            get {
                if (!_instance.isInitialized)
                    throw new InvalidOperationException(
                            "Please initialize the backing store first");

                return _instance.allKeys.Count;
            }
        }

        public static RegistryServer Hklm {
            get {
                if (!_instance.isInitialized)
                    throw new InvalidOperationException(
                            "Please initialize the backing store first");

                return _instance;
            }
        }

        #region IEnumerable<RegistryKey> Members

        public IEnumerator<RegistryKey> GetEnumerator() {
            if (!isInitialized)
                throw new InvalidOperationException(
                        "Please initialize the backing store first");

            return allKeys.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            return GetEnumerator();
        }

        #endregion

        #region IEqualityComparer<RegistryKey> Members

        /// <summary>
        /// If either contains a null, the result is false (actually it is
        /// null be we do not have that option. It is 'unknown and indeterminant'.
        /// An emptry string however is treated as 'known to be empty'
        /// where null is 'could be anything we have no idea'.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public bool Equals(RegistryKey x, RegistryKey y) {
            return x.Name != null && y.Name != null && x.Name == y.Name;
        }

        /// <summary>
        /// For null names here we will calculate a funky random number
        /// as null != null
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int GetHashCode(RegistryKey obj) {
            return obj.Name != null
                           ? obj.Name.GetHashCode()
                           : RuntimeHelpers.GetHashCode(new object());
        }

        #endregion

        #region IInitializable Members

        void IInitializable.Initialize() {
            Initialize();
        }

        #endregion

        public static event PopulateProgressDelegate PopulateProgress {
            add { _instance.populateEventOk += value; }
            remove { _instance.populateEventOk -= value; }
        }

        private void InvokePopulateProgress() {
            var PopulateProgressDelegate = _instance.populateEventOk;
                eventArgStatus.ItemCount = Interlocked.Increment(ref iCounter);
                PopulateProgressDelegate(this, eventArgStatus);

        }

        public static event PopulateProgressDelegateError PopulateProgressItemError {
            add { _instance.populateError += value; }
            remove { _instance.populateError -= value; }
        }

        private static void InvokePopulateProgressItemError(PopulateProgressEventArgs args) {
           _instance.populateError(_instance, args);
        }

        public static void Initialize() {
            Initialize(Registry.LocalMachine);
        }

        private static void Initialize(RegistryKey RegistryStartKey) {
            if (_instance.isInitialized)
                throw new InvalidOperationException(
                        "Already Initialized. Cannot perform twice");

          
            _instance.allKeys = GetAllSubkeys(RegistryStartKey, "").ToHashSet(_instance);

            _instance.isInitialized = true;
        }

        private static IEnumerable<RegistryKey> GetAllSubkeys(RegistryKey StartkeyIn,
                                                              String NodeKey) {
            _instance.InvokePopulateProgress();

            if (StartkeyIn != null) {
                RegistryKey SubItemRoot;

                if (TryOpenSubKey(StartkeyIn, NodeKey, out SubItemRoot)) {
                    yield return SubItemRoot;

                    foreach (var sub in

                            SubItemRoot.GetSubKeyNames().SelectMany( // Recursion back into this method
                                    s => GetAllSubkeys(SubItemRoot, s)))

                        yield return sub;
                }
            }
        }

        private static bool TryOpenSubKey(RegistryKey StartFrom, String Name,
                                          out RegistryKey itemOut) {
            var bIsOK = false;
            itemOut = null;

            try {
                itemOut = StartFrom.OpenSubKey(Name,
                        RegistryKeyPermissionCheck.ReadSubTree);
                if (itemOut != null)
                    bIsOK = true;
            }
            catch (Exception ex) {
                InvokePopulateProgressItemError(new PopulateProgressEventArgs(-1,
                        ex.Message + Environment.NewLine + "Key=" + StartFrom.Name + " failed trying " + Name));
            }

            return bIsOK;
        }
                                  }

    public delegate void PopulateProgressDelegateError(
            object sender, PopulateProgressEventArgs args);

    public delegate void PopulateProgressDelegate(
            object sender, PopulateProgressEventArgs args);
}

namespace domaindotnet.LinqToRegistry {
    using System;

    /// <summary>
    /// Simple EventArg for the two progress events
    ///
    /// NOTE: There will typically be some errors
    /// which is fine as some parts of the Registry are
    /// not accessible with standard security
    /// </summary>
    public class PopulateProgressEventArgs : EventArgs {

        private readonly string _keyName;

        public PopulateProgressEventArgs(int itemCount) : this(itemCount, null) {}

        public PopulateProgressEventArgs(int itemCount, String KeyName) {

            ItemCount = itemCount;
            _keyName = KeyName;

        }

        public PopulateProgressEventArgs() : this(-1, null) {}

        public string KeyName {
            get { return _keyName; }
        }

        public int ItemCount { get; internal set; }
    }
}

Although not required, if you want to use this Registry Server (it makes a fantastic ‘mock’ server – although not really a Mock at all) put all the code above in a separate assembly for ease of use.

It’s great for trying our many variants of Linq queries over objects (as we do here) as the Registry – although a bit dangerous to muck about with – is a nice hierarchical source with enough interesting turns to make it fun.

In practice we rarely need to change the registry but if we did, it would be though this (we would carefully evolve it so it could perform controlled updates).

The Regression Tests

So we are using xUnit because we like it. Use whatever you want. The code shown next is the abstract base class our real test cases will use:

namespace LinqToORMValidation {
    using System;
    using domaindotnet.LinqToRegistry;

    public abstract class BaseTestContext {

        private static void RegistryServer_OnPopulateProgress(object sender, PopulateProgressEventArgs args)
        {
            //Console.WriteLine("Processed " + args.ItemCount + " items");

        }

        private static void RegistryServer_OnPopulateProgressError(object sender, PopulateProgressEventArgs args)
        {
            Console.WriteLine("Error : " + args.KeyName);
        }
        protected BaseTestContext() {

            RegistryServer.PopulateProgress += RegistryServer_OnPopulateProgress;
            RegistryServer.PopulateProgressItemError += RegistryServer_OnPopulateProgressError;
            RegistryServer.Initialize();

            Console.WriteLine("Initialization Complete. Total Records = " + RegistryServer.Count);
        }

    }
}

NOTE: Un-Comment the Console.WriteLine in the OnPopulateProgress to view the status as it runs.

The main area to see is the protected constructor. It’s clear that the Singleton is exposing a separate Initialize() method (we did this on purpose as it can take a little while for all those keys to get inside the HashSet<T> and debugging things if they go wrong in say a static constructor is harder then making a long-running initialization explicit. In general a good design decision we believe.

So the final part of code for this post at least is the first test which indeed shows the exact query from the beginning working:"

namespace LinqToORMValidation {
    using System;
    using System.Diagnostics;
    using System.Linq;
    using domaindotnet.LinqToRegistry;
    using Xunit;

    public class RegistryServerValidation : BaseTestContext {

        /// <summary>
        /// As a Linq IEnumerable<T> result
        /// if anything changed, the
        /// underlying HashSet<T> would not change. However if this
        /// were a direct reference to the HashSet the values ARE
        /// changeable. The idea is to project out immutable results
        /// from the Registry server and indeed treat all the data
        /// as read only
        /// </summary>
        [Fact]
        public void should_prove_basic() {

            // Find the registry key(s) that have
            // VisualStudo in the name and end in
            // 'FontsAndColors' that also have at least
            // one value defined inside they key

            var sw =Stopwatch.StartNew();

            var FindFontsColors = from rk in RegistryServer.Hklm
                                  where
                                          rk.Name.Contains("VisualStudio") &&
                                          rk.Name.EndsWith("FontsAndColors") &&
                                          rk.ValueCount > 0

                                  select rk.Name;

            var countMatched = FindFontsColors.Count();

            sw.Stop();

            Console.WriteLine("Total Records Matched = " + countMatched);
            Console.WriteLine("Search Took : " + sw.ElapsedMilliseconds + " ms");

            // Assert it took less then one second
            Assert.True(sw.ElapsedMilliseconds < 1000);
            ObjectDumper.Write(FindFontsColors);
        }

    }
}

For this test cases we are very specifically finding any keys across any in HKLM matching the conditions:

• The key name ‘VisualStudio’ somewhere.
• The key ends with ‘FontsAndColors’
• The key has at least one value inside (you’ll see why in the next post when things get harder)

We also introduce a time to show off the speed of the HashSet<T>.

Here I am making the assumption that the name of the key holds identity, and if null, we use standard null semantics (as defined in relational algebra).

The only few interesting points are the use of the static RuntimeHelpers class from .NET as the fact we are using the singleton static instance as the Equality instance.

Running the Code

As expected we received a few errors, but they make sense as they are protected areas of the registry.

So we matched across 233142 instances of RegistryKey with three conditions in 746ms. Try that in RegEdt32!!

So far this has only set a baseline for the next exploration into these new methods provided in the HashSet<T> you might not have been aware of which we can now easily use:

More accurately called ..‘Variance and Generalized Constraints for C# Generics’) (1)

An item we often see teams ‘leaving money on the table’ with is a failure to leverage (or leverage fully) generic type constraints. Now with Linq you cannot get away with it anymore as for now, although far more powerful, there are still long lines of complex generic delegate types to navigate.

This post based on the docs from MSDN, however we’ve added some significant teeth we believe (with more to come) We at least made this potentially more ‘real world’ in complexity.

By constraining the type parameter, you increase the number of allowable operations and

method calls to those supported by the constraining type and all types in its inheritance hierarchy. Therefore, when you design generic classes or methods, if you will be performing any operation on the generic members beyond simple assignment or calling any methods not supported by System.Object, you will have to apply constraints to the type parameter.

When applying the where T : class constraint, avoid the == and != operators on the type parameter because these operators will test for reference identity only, not for value equality. This is the case even if these operators are overloaded in a type that is used as an argument. The following code illustrates this point; the output is false even though the String class overloads the == operator.

public static void OpTest<T>(T s, T t) where T : class {

       System.Console.WriteLine(s == t);

}

 static void Main() {

           string s1 = “foo”;

            var sb = new System.Text.StringBuilder(“foo”);

            string s2 = sb.ToString();

            OpTest<string>(s1, s2);

}

The reason for this behavior is that, at compile time, the compiler only knows that T is a reference type, and therefore must use the default operators that are valid for all reference types. If you must test for value equality, the recommended way is to also apply the where T : IComparable<T> constraint and implement that interface in any class that will be used to construct the generic class.

In the previous example, T is a naked type constraint in the context of the Add method, and an unbounded type parameter in the context of the List class.

Naked type constraints can also be used in generic class definitions. Note that the naked type constraint must also have been declared within the angle brackets together with any other type parameters:

//naked type constraint

public class SampleClass<T, U, V> where T : V { }

The usefulness of naked type constraints with generic classes is very limited because the

compiler can assume nothing about a naked type constraint except that it derives from System.Object. Use naked type constraints on generic classes in scenarios in which you want to enforce an inheritance relationship between two type parameters.

Burak Emir1, Andrew Kennedy2, Claudio Russo2, and Dachuan Yu3

1 EPFL, Lausanne, Switzerland

2 Microsoft Research, Cambridge, U.K.

3 DoCoMo Communications Laboratories USA, San Jose, California