void LoadDebugging(object sender, AssemblyLoadEventArgs args, string name)
        {
            // we'll output the full assemblyName
            Console.WriteLine("{0} was loaded:", args.LoadedAssembly.FullName);

            // can skip the first 2 frames,
            // they just have the event handlers for assem load
            StackTrace stackTrace = new StackTrace(2);
            StackFrame[] frames = stackTrace.GetFrames();

            // dump the stack
            foreach (StackFrame frame in frames)
            {
                MethodBase method = frame.GetMethod();
                ParameterInfo[] parameters = method.GetParameters();
                StringBuilder parString = new StringBuilder();
                for (int i = 0; i < parameters.Length; i++)
                {
                    ParameterInfo par = parameters[i];
                    if (i > 0)
                        parString.Append(", ");

                    parString.Append(par.ParameterType.ToString());
                }

                Console.WriteLine(" at {0}.{1}({2})",
                method.DeclaringType.Name,
                method.Name,
                parString.ToString());
            }
        }

 static void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     Assembly assembly = args.LoadedAssembly;
     lock (assemblies) {
         assemblies[assembly.FullName] = assembly;
     }
 }

        private void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
        {
            if (args.LoadedAssembly.GlobalAssemblyCache)
                return;

            Trace.TraceInformation("Assembly Loaded... {0}", args.LoadedAssembly.Location);

            if (args.LoadedAssembly.Location.StartsWith(_pluginFolder.FullName, StringComparison.InvariantCultureIgnoreCase))
            {
                try
                {
                    RegisterWithCheck(args.LoadedAssembly);

                    var types = args.LoadedAssembly.GetExportedTypes();

                    if (types.Any())
                    {
                        foreach (var type in types)
                        {
                            Trace.TraceInformation("Type exported: {0}", type.FullName);
                        }
                    }
                    else
                    {
                        Trace.TraceInformation("No types exported by Assembly: '{0}'",
                            args.LoadedAssembly.GetName().Name);
                    }
                }
                catch (Exception ex)
                {
                    Trace.TraceInformation(ex.Message);
                }
            }
        }

        void LoadDebugging(object sender, AssemblyLoadEventArgs args, string name)
        {
            // can skip the first 2 frames,
            // they just have the event handlers for assem load
            StackTrace stackTrace = new StackTrace(2);
            StackFrame[] frames = stackTrace.GetFrames();

            // dump the stack
            foreach (StackFrame frame in frames)
            {
                MethodBase method = frame.GetMethod();
                ParameterInfo[] parameters = method.GetParameters();
                StringBuilder parString = new StringBuilder();
                for (int i = 0; i < parameters.Length; i++)
                {
                    ParameterInfo par = parameters[i];
                    if (i > 0)
                        parString.Append(", ");

                    parString.Append(par.ParameterType.ToString());
                }

                //LoggerFactory.Default.Log(AssemblyLoadMonitorLogID, " at " + method.DeclaringType.Name + "." + method.Name + "(" + parString.ToString() + ")");
            }
        }

 /// <summary>
 /// Handles the AssemblyLoad event of the AppDomain.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="args">The <see cref="AssemblyLoadEventArgs"/> instance containing the event data.</param>
 private void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     lock (this)
     {
         UpdateMap();
     }
 }

        private static void OnAssemblyLoaded(object sender, AssemblyLoadEventArgs args)
        {
            _assembliesByName[args.LoadedAssembly.FullName] = args.LoadedAssembly;
            _assembliesByIndex.Add(args.LoadedAssembly);

            _cachedTypes = new Dictionary<string, Type>();
        }

    private void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args) {
        Assembly a = args.LoadedAssembly;

        // Ignore GAC assemblies
        if (a.GlobalAssemblyCache)
            return;

        // Ignore assemblies that don't start with our prefix
        string name = a.GetName().Name;
        if (!StringUtil.StringStartsWith(name, BuildManager.AssemblyNamePrefix))
            return;

        // Go through all the assemblies it references
        foreach (AssemblyName assemblyName in a.GetReferencedAssemblies()) {

            // Ignore references that don't start with our prefix
            if (!StringUtil.StringStartsWith(assemblyName.Name, BuildManager.AssemblyNamePrefix))
                continue;

            lock (_dependentAssemblies) {
                // Check whether we already have an ArrayList for this reference
                ArrayList dependentList = _dependentAssemblies[assemblyName.Name] as ArrayList;
                if (dependentList == null) {
                    // If not, create one and add it to the hashtable
                    dependentList = new ArrayList();
                    _dependentAssemblies[assemblyName.Name] = dependentList;
                }

                // Add the assembly that just got loaded as a dependent
                Debug.Assert(!dependentList.Contains(name));
                dependentList.Add(name);
            }
        }
    }

            private void AssemblyLoaded(object sender, AssemblyLoadEventArgs args) {
                // !!! BUG on .Net 2 SP1: going further breaks DefineDynamicAssembly in very strange manner, so don't process dynamic assemblies
                // simple test:
                // AppDomain.CurrentDomain.DefineDynamicAssembly(new System.Reflection.AssemblyName("dynBoxed" + Guid.NewGuid().ToString()), System.Reflection.Emit.AssemblyBuilderAccess.Run);
                // previous workaround using RegisterAssemblyForNonAutoRegistration/ShouldSkipAssemblyTypeAutoRegistration
                // is deficient, there may be dynamic assemblies irrelevant to IIOPNet.
                // So this patch is simple and universal:
                if (args.LoadedAssembly is System.Reflection.Emit.AssemblyBuilder)
                    return;

                RegisterTypes(args.LoadedAssembly);
                AssemblyName[] refAssemblies =
                    args.LoadedAssembly.GetReferencedAssemblies();
                if (refAssemblies != null) {
                    for (int i = 0; i <refAssemblies.Length; i++) {
                        try {
                            if (refAssemblies[i] != null) {
                                Assembly.Load(refAssemblies[i]); // this will call AssemblyLoaded for this assembly
                            }
                        } catch (BadImageFormatException) {
                            Trace.WriteLine("bad format -> ignoring assembly " + refAssemblies[i].FullName);
                            // ignore assembly
                        } catch (FileNotFoundException) {
                            Trace.WriteLine("missing -> ignoring assembly " + refAssemblies[i].FullName);
                            // ignore assembly
                        } catch (System.Security.SecurityException) {
                            Trace.WriteLine("security problem -> ignoring assembly " + refAssemblies[i].FullName);
                            // ignore assembly
                        }
                    }
                }
            }

 void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     foreach (var type in args.LoadedAssembly.GetTypes().Where(
             type => type.GetCustomAttributes(typeof(GuidAttribute), true).Any()))
     {
         this.types.TryAdd(type.GUID, type);
     }
 }

		private void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
		{
			if (IsPluginAssembly(args.LoadedAssembly))
			{
				var plugin = CreatePluginFromAssembly(args.LoadedAssembly);
				PublishPlugin(plugin);
			}
		}

#pragma warning restore 1591 // Xml Comments

        void AssemblyLoaded(object sender, AssemblyLoadEventArgs args)
        {
            var assembly = args.LoadedAssembly;
            if (!assembly.IsDynamic)
            {
                AvailableAssemblies.Add(AssemblyInfoFromAssembly(assembly));
            }
        }

 private static void OnAssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     var asm = args.LoadedAssembly;
     if (!asm.IsDynamic)
     {
         Log.LogVerbose(nameof(PackageAssemblyHandler), $"Assembly loaded: {asm.Location}");
     }
 }

        public void AssemblyLoadedInCurrentDomain()
        {
            AssemblyLoadEventArgs assemblyEvent = new AssemblyLoadEventArgs(Assembly.GetAssembly(GetType()));
            BinaryDataFactory binaryDataFactory = new BinaryDataFactory();
            binaryDataFactory.OnAssemblyLoadInCurrentDomain(null, assemblyEvent);

            Assert.That(binaryDataFactory.shortNames.Count, Is.GreaterThanOrEqualTo(4));
            Assert.That(binaryDataFactory.typeMap.Count, Is.GreaterThanOrEqualTo(4));
        }

 static void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     if (!args.LoadedAssembly.GetName().Name.Contains("Proxies_"))
     {
         ConsoleColor CurrentColor = Console.ForegroundColor;
         Console.ForegroundColor = ConsoleColor.Yellow;
         Console.WriteLine(string.Format("Loading {0}.dll", args.LoadedAssembly.GetName().Name));
         Console.ForegroundColor = CurrentColor;
     }
 }

 private static void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     try
     {
         Logger.Log.DebugFormat("Assembly loaded: {0}", args.LoadedAssembly);
     }
     catch
     {
     }
 }

        public static void Loaded(object sender, AssemblyLoadEventArgs args)
        {
            loadedAssemblies.Add(args.LoadedAssembly);

            var dir = new FileInfo(args.LoadedAssembly.Location).Directory;
            if (!directories.Contains(dir.FullName))
            {
                directories.Add(dir.FullName);
            }
        }

 void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     try
     {
         var assm = args.LoadedAssembly;
         var aName = assm.GetName();
         this.TrackAssembly(aName);
     }
     catch { }
 }

 static void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
 {
     //AppDomain domain = sender as AppDomain;
     //string senderTxt = "-NA-";
     //if (domain != null)
     //    senderTxt = "domain " + domain.FriendlyName;
     //_tr.WriteLine("CurrentDomain_AssemblyLoad");
     //_tr.WriteLine("  sender                    {0}", senderTxt);
     //_tr.WriteLine("  args.LoadedAssembly       {0}", args.LoadedAssembly.FullName);
     _tr.WriteLine("Assembly loaded \"{0}\"", args.LoadedAssembly.FullName);
 }

        /// <summary>
        /// Ocorre toda vez que um assembly é carregado tardiamente.
        /// </summary>
        private void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
        {
            foreach (ExporBotãoAttribute exportação in 
                args.LoadedAssembly.GetCustomAttributes(typeof(ExporBotãoAttribute), true))
            {
                Botão botão = ExportarBotão(args.LoadedAssembly, exportação);

                if (botão != null)
                    botão.Controlador.AoCarregarCompletamente(null);
            }
        }

        static void CurrentDomain_AssemblyLoad(object sender, AssemblyLoadEventArgs args)
        {
            var assembly = args.LoadedAssembly;
            var assemblyName = assembly.GetName();

            // Note that we load assembly by name, not full name
            // This means that we forgot the version number
            // we should handle the version number too,
            // but take into account that we want to deliver the assembly if we don't find the exact same version number
            assemblies.TryAdd(assemblyName.Name, assembly);
        }