Depends4Net - Part 1

• Download source - 465.84 KB

Introduction

I’ve been looking for something like “Dependency Walker” for a while – something that simple to deploy. Currently Depends4Net allows me to view a tree of all dependent assemblies – even those not present on the system, or otherwise inaccessible to the rather simple assembly resolver currently implemented, in a manner similar to “Dependency Walker”.

A .NET 2.0 Windows Forms based version of the utility is available in the second part of this series. Also includes a preview of an Expression Dark like style for the WPF DataGrid.

While far from production quality, it’s still a useful little tool that allows me to figure out which assemblies are missing from a given installation. The code depends on the WPF Toolkit, included with Visual Studio 2010, and does not require any other framework to build. You can easily use this code to create a command line utility requiring nothing but a working .NET 4 installation.

To keep things interesting, I load the assemblies into a separate application domain, and this presents us with a few challenges. As the .NET Assembly class is [Serializable], accessing the assembly directly would actually load the assembly into the current domain, and hence defeat the whole purpose of creating a separate domain, so another type must be used to transfer information about the loaded assemblies back to the primary AppDomain. A bit of testing also seems to indicate that this gives us the correct version the .NET Framework libraries.

The class responsible for loading the assemblies is part of the primary assembly for the application, and as I really want to be able to load assemblies from any location, this requires a little trick.

AppDomainSetup domainSetup = new AppDomainSetup();

domainSetup.ApplicationName = fileInfo.Name;
domainSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;

appDomain = AppDomain.CreateDomain("ReflectionLoader", null, domainSetup);

Loader loader = (Loader)appDomain.CreateInstanceAndUnwrap
			(Assembly.GetExecutingAssembly().FullName, 
    "Harlinn.Depends4Net.Utils.Assemblies.Loader");
loader.AddPath(fileInfo.DirectoryName);

loader.LoadAssembly(filename);
assemblies = loader.Assemblies;
rootAssembly = loader.RootAssembly;

Notice that the domainSetup.ApplicationBase is set to the BaseDirectory of the current domain – this allows appDomain.CreateInstanceAndUnwrap to locate the currently executing assembly and create an instance of the Loader class. At this point, the new AppDomain does not know where to find the assembly we want to inspect – so we pass the “real” ApplicationBase to loader.AddPath before calling loader.LoadAssembly.

The Loader

The Loader class is derived from MarshalByRefObject, so when we call loader.AddPath and loader.LoadAssembly the code is executed in our new AppDomain and not in the primary AppDomain. So when we implement loader.LoadAssembly

public void LoadAssembly(string filename)
{
    if (File.Exists(filename))
    {
        AppDomain.CurrentDomain.AssemblyLoad += OnAssemblyLoaded;
        try
        {
            InternalLoadAssemblyFrom(filename);
                    
        }
        finally
        {
            AppDomain.CurrentDomain.AssemblyLoad -= OnAssemblyLoaded;
        }
    }
}

AppDomain.CurrentDomain refers to the new AppDomain. By adding our OnAssemblyLoaded event handler to the AssemblyLoad event, we get notified whenever an assembly gets loaded into the domain. Since we are using Assembly.ReflectionOnlyLoadFrom and Assembly.ReflectionOnlyLoad to load assemblies, the event handler loads referenced assemblies into the AppDomain until all the resolvable assemblies are found, and we also add an AssemblyInfo element for each assembly we are unable to locate – as my primary reason for writing Depends4Net is to collect information about missing assemblies.

void OnAssemblyLoaded(object sender, AssemblyLoadEventArgs args)
{
 Assembly loadedAssembly = args.LoadedAssembly;
 AssemblyName assemblyName = loadedAssembly.GetName();
 
 AssemblyInfo assemblyInfo = new AssemblyInfo();
 assemblyInfo.AssemblyName = assemblyName;
 assemblyInfo.ManifestModuleName = loadedAssembly.ManifestModule.Name;
 assemblyInfo.LoadedFromGlobalAssemblyCache = loadedAssembly.GlobalAssemblyCache;
 assemblyInfo.Location = loadedAssembly.Location;
 assemblyInfo.Found = true;

 assemblies.Add(loadedAssembly.FullName, assemblyInfo);
 if (currentReferencingAssembly != null)
 {
  currentReferencingAssembly.
           ReferencedAssemblies.Add(loadedAssembly.FullName, assemblyInfo);
  assemblyInfo.FirstLoadedBy = currentReferencingAssembly;
 }
 else
 {
  rootAssembly = assemblyInfo;
 }

 AssemblyName[] referencedAssemblies = args.LoadedAssembly.GetReferencedAssemblies();
 
 if (referencedAssemblies.Length > 0)
 {
  AssemblyInfo previouslyReferencingAssembly = currentReferencingAssembly;
  currentReferencingAssembly = assemblyInfo;
  try
  {
   foreach (AssemblyName referencedAssemblyName in referencedAssemblies)
   {
    if (assemblies.ContainsKey(referencedAssemblyName.FullName) == false)
    {
     string fileName = resolver.Resolve(referencedAssemblyName);

     if (InternalLoadAssemblyFrom(fileName) == false)
     {
      if (InternalLoadAssembly(referencedAssemblyName) == false)
      {
       AssemblyInfo referencedAssemblyInfo = new AssemblyInfo();
       referencedAssemblyInfo.AssemblyName = referencedAssemblyName;
       assemblies.Add(referencedAssemblyName.FullName, referencedAssemblyInfo);
       currentReferencingAssembly.
             ReferencedAssemblies.Add(referencedAssemblyName.FullName,
			referencedAssemblyInfo);
      }
     }
    }
    else
    {
     AssemblyInfo referencedAssemblyInfo = 
          assemblies[referencedAssemblyName.FullName];
     currentReferencingAssembly.
          ReferencedAssemblies.Add(referencedAssemblyName.FullName, 
			referencedAssemblyInfo);
    }
   }
  }
  finally
  {
   currentReferencingAssembly = previouslyReferencingAssembly;
  }
 }
}

The XAML

In “App.xaml”, we pull in the “ExpressionDark.xaml” resource dictionary giving us a nice “expression” like user interface – without exactly exerting ourselves. This theme and a few others are available from as part of the WPF Toolkit on CodePlex.

<Application x:Class="Harlinn.Depends4Net.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:types="clr-namespace:Harlinn.Depends4Net.Types"
             StartupUri="MainWindow.xaml">
    <Application.Resources>
        <ResourceDictionary >
            <ObjectDataProvider x:Key="DependsDataSource" 
		ObjectType="{x:Type types:Depends}">
                <ObjectDataProvider.ConstructorParameters />
            </ObjectDataProvider>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="ExpressionDark.xaml" />
            </ResourceDictionary.MergedDictionaries>
            
        </ResourceDictionary>
    </Application.Resources>
</Application>

Building the Hierarchy

A careful look at how I build the hierarchy will reveal that each assembly is only represented by one AssemblyNode instance – even if present at several locations in the hierarchy. AddAssemblyNode is called recursively and takes a dictionary containing all the nodes created so far, this allows me to reuse existing nodes for assemblies that are referenced by multiple assemblies.

private AssemblyNode AddAssemblyNode(AssemblyNode parent, 
    Dictionary<string, AssemblyNode> assemblyNodes, AssemblyInfo assemblyInfo)
{
    AssemblyNode result = null;
    if (assemblyNodes.ContainsKey(assemblyInfo.AssemblyName.FullName))
    {
        result = assemblyNodes[assemblyInfo.AssemblyName.FullName];
        if (parent != null)
        {
            parent.ReferencedAssemblies.Add(result);
        }
    }
    else
    {
        result = new AssemblyNode();
        result.AssignFromAssemblyInfo(assemblyInfo);

        assemblyNodes.Add(assemblyInfo.AssemblyName.FullName, result);
        if (parent != null)
        {
            parent.ReferencedAssemblies.Add(result);
        }

        Dictionary<string, AssemblyInfo>.ValueCollection referencedAssemblyCollection = 
            assemblyInfo.ReferencedAssemblies.Values;

        List<AssemblyInfo> referencedAssemblies = new List<AssemblyInfo>();
        referencedAssemblies.AddRange(referencedAssemblyCollection);
        referencedAssemblies.Sort(new AssemblyInfoComparer());

        foreach (AssemblyInfo referencedAssemblyInfo in referencedAssemblies)
        {
            AddAssemblyNode(result, assemblyNodes, referencedAssemblyInfo);
        }
    }
    return result;
}

Concluding Remarks

The most interesting thing here is how I set up the paths for the new AppDomain and that I avoid instantiating the assemblies in the primary domain by inadvertently serializing them from the new AppDomain to the primary AppDomain.

History

• 29^th of August, 2011 – Initial posting