Click here to Skip to main content
11,924,995 members (50,159 online)
Click here to Skip to main content
Add your own
alternative version


24 bookmarked

Using NetZ with Dynamically Loaded Assemblies

, 21 Jul 2006 CPOL
Rate this:
Please Sign up or sign in to vote.
How to use dynamically loaded assemblies with your NetZ-built application.


NetZ is a fantastic tool for merging your executable and dependent assemblies into a single, zipped, executable. Using NetZ makes distribution of an application very easy, and it provides a layer of protection from programs like Reflector without having to buy into an obfuscation approach. However, a NetZ application will not be able to resolve dynamically loaded assemblies, such as business rule plug-ins, extenders, or assemblies referenced in MyXaml-based applications.

The Assembly Resolver

I wrote this small static class to sneak into NetZ's assembly loading mechanism so that a dynamically loaded assembly can be acquired from the NetZ assembly collection. This library can be added to your application, and used during development when you don't need the resolver. When you are ready to build your NetZ executable, the resolver will automatically figure out that the application is being run from the NetZ loader and will take the appropriate action.

The first step is to detect NetZ, which uses a bit of Reflection to see if the NetzStarter class is in the executable:

/// <summary>
/// Checks whether the application has been started from a NetZ loader.
/// If so, then the current domain's AssemblyResolve event is hooked so 
/// that we can get dynamically loaded assemblies from the NetZ assembly
/// collection.
/// </summary>
protected static void CheckForNetZ()
  string appName = AppDomain.CurrentDomain.FriendlyName;
  appName = StringHelpers.LeftOfRightmostOf(appName, '.');
  Type t = Type.GetType("netz.NetzStarter, " + appName);

  // t will be valid if the app is started from a NetZ loader.
  if (t != null)
    Trace.WriteLine("Found NetZ. Hooking assembly resolver.");
    netzAssemblyLoader = t.GetMethod("GetAssemblyByName", 
             BindingFlags.Static | BindingFlags.NonPublic);
    AppDomain.CurrentDomain.AssemblyResolve += 
             new ResolveEventHandler(OnAssemblyResolve);

I put in some trace messages so you can see what the application is doing in Debug mode.

The next step is to resolve the assembly:

/// <summary>
/// Resolve dynamically loaded assemblies.
/// </summary>
private static Assembly OnAssemblyResolve(object sender, 
          ResolveEventArgs args)
  Assembly assy = null;
  string assyName = args.Name;

  // If this is a short name format...
  if (assyName.Split(',').Length == 1)
    // Look up the fully qualified name.
    assyName = qualifiedNameMap[assyName.ToLower()];

  Trace.WriteLine("(NetZResolver) Attempting to resolve: " + assyName);
  assy = (Assembly)netzAssemblyLoader.Invoke(null, new object[] { assyName });

  return assy;


Using the class is very simple. For example, here are the calls to resolve the MyXaml.WinForms extension, which is dynamically loaded:

NetZResolver.RegisterShortName("MyXaml.WinForms", "MyXaml.WinForms, 
       Version=, Culture=neutral, PublicKeyToken=null");

Note that the fully qualified assembly name is required, including the version. This means that if you update an assembly version number, you will need to also update the fully qualified name. This is only necessary if the resolver is given a short name. If you have dynamic assemblies that are being loaded by only the short name, then you will have to register the short name and the fully qualified assembly name with the resolver, as the above example illustrates.


Using this class, you shouldn't have any problems resolving dynamically loaded assemblies. Please note that I will not answer any NetZ support questions--NetZ is well documented, and if you have any problems, please contact the author of NetZ. Feel free to change the namespaces for the two source files to more suit your needs, but please keep the copyright in the source code.


  • 21 July, 2006: Initial post.


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


About the Author

Marc Clifton
United States United States
Marc is the creator of two open source projects, MyXaml, a declarative (XML) instantiation engine and the Advanced Unit Testing framework, and Interacx, a commercial n-tier RAD application suite.  Visit his website,, where you will find many of his articles and his blog.

Marc lives in Philmont, NY.

You may also be interested in...

Comments and Discussions

Questionexe @ network location [modified] Pin
mdcobra12-Oct-07 5:59
membermdcobra12-Oct-07 5:59 
QuestionReflector Protection? Pin
Philip Laureano22-Jul-06 11:34
memberPhilip Laureano22-Jul-06 11:34 
AnswerRe: Reflector Protection? Pin
Marc Clifton22-Jul-06 13:26
protectorMarc Clifton22-Jul-06 13:26 
GeneralNetZ Rocks! Pin
PaulC197221-Jul-06 14:02
memberPaulC197221-Jul-06 14:02 
GeneralRe: NetZ Rocks! Pin
Marc Clifton21-Jul-06 14:08
protectorMarc Clifton21-Jul-06 14:08 
GeneralRe: NetZ Rocks! Pin
PaulC197221-Jul-06 14:20
memberPaulC197221-Jul-06 14:20 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.151125.3 | Last Updated 21 Jul 2006
Article Copyright 2006 by Marc Clifton
Everything else Copyright © CodeProject, 1999-2015
Layout: fixed | fluid