Dynamically loading and Unloading Assemblies in C#

While working on a plugin manager for a program written in C#, I found myself with a need to be able to load and unload assemblies dynamically be an application. In C#, loading assemblies is a fairly easy prospect — one just needs to make use of the System.Reflection class. Something like the following:

System.Reflection.Assembly assembly = System.Reflection.Assembly.LoadFile(@"c:\yourassembly.dll");

However, if you need to unload the assembly — good luck. The .NET assembly class doesn’t include an unload method. If you have a need to be able to dynamically load an unload assemblies, you need to work with the AppDomain class. The .NET framework works on an Application Domain model, so for items like plugins (where you may need to load, unload or modify an assembly), you need to create an Application Domain manager to load assemblies onto. This way, when you need to unload an assembly, you use the Unload method found within the AppDomain class.

Of course, when dealing with plugins, you likely will need to create a new application domain for each plugin to be loaded. This is because the you unload the appdomain, not the assemblies attached to the domains. So for my project, I decided to create something much like the TempFileCollection. In a global class, I decided to create a hash that stories a domain name and the domain object. Using this method, I can do something like the following:

   1:  string path = cglobal.mglobal.AppPath() + "plugins" + System.IO.Path.DirectorySeparatorChar;

   2:              string[] files = System.IO.Directory.GetFiles(path);

3:

   4:              lstInstalled.Items.Clear();

   5:              foreach (string f in files)

   6:              {

   7:                  try

   8:                  {

   9:                      System.AppDomain domain = System.AppDomain.CreateDomain(System.IO.Path.GetFileName(f));

  10:                      System.IO.StreamReader reader = new System.IO.StreamReader(f, System.Text.Encoding.GetEncoding(1252), false);

11:

  12:                      byte[] b = new byte[reader.BaseStream.Length];

  13:                      reader.BaseStream.Read(b, 0, System.Convert.ToInt32(reader.BaseStream.Length));

14:

  15:                      domain.Load(b);

  16:                      System.Reflection.Assembly[] a = domain.GetAssemblies();

  17:                      int index = 0;

18:

19:

20:

21:

  22:                      for (int x = 0; x < a.Length; x++)

  23:                      {

  24:                          if (a[x].GetName().Name + ".dll" == System.IO.Path.GetFileName(f))

  25:                          {

  26:                              index = x;

  27:                              break;

  28:                          }

  29:                      }

30:

  31:                      System.Windows.Forms.ListViewItem item = new ListViewItem();

32:

  33:                      item.Text = a[index].GetName().Name + ".dll";

  34:                      item.SubItems.Add(a[index].GetName().Version.ToString());

  35:                      item.SubItems.Add(reader.BaseStream.Length.ToString());

  36:                      lstInstalled.Items.Add(item);

  37:                      reader.Close();

  38:                      cglobal.mglobal.domains.Add(System.IO.Path.GetFileName(f), domain);

39:

  40:                  }

  41:                  catch { }

  42:              }

Then, if we need to unload the assembly, we can unload the domain that its attached to. Something like:

   1:  for (int x = 0; x < lstInstalled.Items.Count; x++)

   2:              {

   3:                  if (lstInstalled.Items[x].Selected == true) {

   4:                      try {

   5:                          if (System.IO.File.Exists(cglobal.mglobal.AppPath() + "plugins" + System.IO.Path.DirectorySeparatorChar + lstInstalled.Items[x].Text)) {

   6:                              System.AppDomain.Unload((System.AppDomain)cglobal.mglobal.domains[lstInstalled.Items[x].Text]);

   7:                              cglobal.mglobal.domains.Remove(lstInstalled.Items[x].Text);

   8:                              System.IO.File.Delete(cglobal.mglobal.AppPath() + "plugins" + System.IO.Path.DirectorySeparatorChar + lstInstalled.Items[x].Text);

   9:                          }

  10:                      }

  11:                      catch {}

  12:                  }

  13:              }

Seems a little more involved that it has to be, but once you know how it works, its not that big of a deal.

–TR

Monday, November 19th, 2007 C#

3 Comments to Dynamically loading and Unloading Assemblies in C#

[...] the Plugin manager. Was a little more involved than I thought it would be (see: Dynamically loading/unloading Assemblies in C#), but it looks like the loading and unloading of assemblies is working like I want it to. No [...]