How do you loop through currently loaded assemblies?

I've got a "diagnostics" page in my ASP.NET application which does things like verify the database connection(s), display the current appSettings and ConnectionStrings, etc. A section of this page displays the Assembly versions of important types used throughout, but I could not figure out how to effectively show the versions of ALL of the loaded assemblies.

What is the most effective way to figure out all currently referenced and/or loaded Assemblies in a .NET application?

Note: I'm not interested in file-based methods, like iterating through *.dll in a particular directory. I am interested in what the application is actually using right now.

Getting loaded assemblies for the current AppDomain:

var loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();

Getting the assemblies referenced by another assembly:

var referencedAssemblies = someAssembly.GetReferencedAssemblies();

Note that if assembly A references assembly B and assembly A is loaded, that does not imply that assembly B is also loaded. Assembly B will only be loaded if and when it is needed. For that reason, GetReferencedAssemblies() returns AssemblyName instances rather than Assembly instances.

This extension method gets all referenced assemblies, recursively, including nested assemblies.

As it uses ReflectionOnlyLoad, it loads the assemblies in a separate AppDomain, which has the advantage of not interfering with the JIT process.

You'll notice that there is also a MyGetMissingAssembliesRecursive. You can use this to detect any missing assemblies that are referenced, but not present in the current directory for some reason. This is incredibly useful when using MEF. The return list will give you both the missing assembly, and who owns it (its parent).

/// <summary>
///		Intent: Get referenced assemblies, either recursively or flat. Not thread safe, if running in a multi
///		threaded environment must use locks.
/// </summary>
public static class GetReferencedAssemblies
{
	static void Demo()
	{
		var referencedAssemblies = Assembly.GetEntryAssembly().MyGetReferencedAssembliesRecursive();
		var missingAssemblies = Assembly.GetEntryAssembly().MyGetMissingAssembliesRecursive();
		// Can use this within a class.
		//var referencedAssemblies = this.MyGetReferencedAssembliesRecursive();
	}

	public class MissingAssembly
	{
		public MissingAssembly(string missingAssemblyName, string missingAssemblyNameParent)
		{
			MissingAssemblyName = missingAssemblyName;
			MissingAssemblyNameParent = missingAssemblyNameParent;
		}

		public string MissingAssemblyName { get; set; }
		public string MissingAssemblyNameParent { get; set; }
	}

	private static Dictionary<string, Assembly> _dependentAssemblyList;
	private static List<MissingAssembly> _missingAssemblyList;

	/// <summary>
	///     Intent: Get assemblies referenced by entry assembly. Not recursive.
	/// </summary>
	public static List<string> MyGetReferencedAssembliesFlat(this Type type)
	{
		var results = type.Assembly.GetReferencedAssemblies();
		return results.Select(o => o.FullName).OrderBy(o => o).ToList();
	}

	/// <summary>
	///     Intent: Get assemblies currently dependent on entry assembly. Recursive.
	/// </summary>
	public static Dictionary<string, Assembly> MyGetReferencedAssembliesRecursive(this Assembly assembly)
	{
		_dependentAssemblyList = new Dictionary<string, Assembly>();
		_missingAssemblyList = new List<MissingAssembly>();

		InternalGetDependentAssembliesRecursive(assembly);

		// Only include assemblies that we wrote ourselves (ignore ones from GAC).
		var keysToRemove = _dependentAssemblyList.Values.Where(
			o => o.GlobalAssemblyCache == true).ToList();

		foreach (var k in keysToRemove)
		{
			_dependentAssemblyList.Remove(k.FullName.MyToName());
		}

		return _dependentAssemblyList;
	}

	/// <summary>
	///     Intent: Get missing assemblies.
	/// </summary>
	public static List<MissingAssembly> MyGetMissingAssembliesRecursive(this Assembly assembly)
	{
		_dependentAssemblyList = new Dictionary<string, Assembly>();
		_missingAssemblyList = new List<MissingAssembly>();
		InternalGetDependentAssembliesRecursive(assembly);

		return _missingAssemblyList;
	}

	/// <summary>
	///     Intent: Internal recursive class to get all dependent assemblies, and all dependent assemblies of
	///     dependent assemblies, etc.
	/// </summary>
	private static void InternalGetDependentAssembliesRecursive(Assembly assembly)
	{
		// Load assemblies with newest versions first. Omitting the ordering results in false positives on
		// _missingAssemblyList.
		var referencedAssemblies = assembly.GetReferencedAssemblies()
			.OrderByDescending(o => o.Version);

		foreach (var r in referencedAssemblies)
		{
			if (String.IsNullOrEmpty(assembly.FullName))
			{
				continue;
			}

			if (_dependentAssemblyList.ContainsKey(r.FullName.MyToName()) == false)
			{
				try
				{
					var a = Assembly.ReflectionOnlyLoad(r.FullName);
					_dependentAssemblyList[a.FullName.MyToName()] = a;
					InternalGetDependentAssembliesRecursive(a);
				}
				catch (Exception ex)
				{
					_missingAssemblyList.Add(new MissingAssembly(r.FullName.Split(',')[0], assembly.FullName.MyToName()));
				}
			}
		}
	}

	private static string MyToName(this string fullName)
	{
		return fullName.Split(',')[0];
	}
}

Update

To make this code thread safe, put a lock around it. It's not currently thread safe by default, as it references a shared static global variable to do its magic.