C# AppDomain.GetAssemblies方法代码示例

        public static void RegisterWithBuilderFromPath(ContainerBuilder builder, AppDomain currentDomain, EnumRegistrationType enumRegistrationType)
        {
            List<Assembly> vuelingAssembliesList = new List<Assembly>();
            Assembly[] vuelingAssembliesArray;

            customRegistration(builder);

            List<Assembly> assemblies = currentDomain.GetAssemblies().ToList<Assembly>();

            var loadedAssemblies = currentDomain.GetAssemblies().ToList();
            var loadedPaths = loadedAssemblies.Select(a => a.Location).ToArray();

            var referencedPaths = Directory.GetFiles(currentDomain.BaseDirectory, "*.dll");
            var toLoad = referencedPaths.Where(r => !loadedPaths.Contains(r, StringComparer.InvariantCultureIgnoreCase)).ToList();
            toLoad.ForEach(path => loadedAssemblies.Add(currentDomain.Load(AssemblyName.GetAssemblyName(path))));

            foreach (var referencedAssembly in toLoad)
            {

                assemblies.Add(Assembly.LoadFrom(referencedAssembly));

            }

            foreach (var assembly in assemblies.Distinct())
            {

                if (assembly.GetName().Name.ToLower().Contains("vueling")) vuelingAssembliesList.Add(Assembly.Load(assembly.GetName().Name));

            }
            vuelingAssembliesArray = vuelingAssembliesList.ToArray<Assembly>();

            if (enumRegistrationType == EnumRegistrationType.justWithDecoratedClasses) RegisterAssemblyTypesWithDecoratedClasses(builder, vuelingAssembliesArray);
            else RegisterAssemblyTypes(builder, vuelingAssembliesArray);
        }

 /// <summary>
 /// Discovers the services.
 /// </summary>
 public static void DiscoverServices(string prefix, AppDomain domain, bool cors)
 {
     IEnumerable<Assembly> possibleAssemblies = domain.GetAssemblies();
     IList<Type> possibleTypes = new List<Type>();
     foreach (Assembly assembly in possibleAssemblies)
     {
         if (!assembly.FullName.StartsWith("System"))
         {
             foreach (Type type in assembly.GetTypes())
             {
                 if (IsValidService(type))
                 {
                     string name = string.IsNullOrEmpty(prefix) ? type.Name.ToLower() : prefix + "/" + type.Name.ToLower();
                     if (cors)
                     {
                         RouteTable.Routes.Add(new ServiceRoute(name, new CorsEnabledServiceHostFactory(), type));
                     }
                     else
                     {
                         RouteTable.Routes.Add(new ServiceRoute(name, new WebServiceHostFactory(), type));
                     }
                 }
             }
         }
     }
 }

		public void Add(AppDomain appDomain)
		{
			foreach (Assembly assembly in appDomain.GetAssemblies())
			{
				Add(assembly);
			}
		}

        // Private Methods 

        private static void Print(AppDomain defaultAppDomain)
        {
            Assembly[] loadedAssemblies = defaultAppDomain.GetAssemblies();
            Console.WriteLine("Here are the assemblies loaded in {0}\n", defaultAppDomain.FriendlyName);
            foreach (Assembly a in loadedAssemblies)
                PrintAssemblyName(a.GetName());
        }

        public IEnumerable<TypeWrapper> ListLoadedTypes(AppDomain appDomain)
        {
            if (appDomain == null)
                throw new ArgumentNullException("appDomain");

            return appDomain.GetAssemblies().SelectMany(o => o.GetTypes().Select(t => new TypeWrapper(null, t)));
        }

 public static void RegisterAllAssemblies(IExecutionContext context, AppDomain domain)
 {
     foreach(Assembly assembly in domain.GetAssemblies())
     {
         context.RegisterAssembly(assembly);
     }
 }

 public Assembly GetAssembly(AppDomain _domain, string _name)
 {
     foreach (Assembly _asm in _domain.GetAssemblies ()) {
         if (_asm.GetName ().Name == _name)
             return _asm;
     }
     return null;
 }

 private static void PrintAssemblies(AppDomain appDomain)
 {
     Console.WriteLine();
     Console.WriteLine("{0} assemblies:", appDomain.FriendlyName);
     foreach (var assembly in appDomain.GetAssemblies())
     {
         Console.WriteLine("  {0}", assembly.FullName);
     }
 }

        private static IEnumerable<IPartRegistry<IContractService>> GetPublicPartRegistryInstancesInAppDomain(AppDomain domain)
        {
            var registryInstancesLocatedInDomain = domain
                .GetAssemblies()
                .SelectMany(x => PartRegistryTypeFilter.Filter(x.GetTypes()))
                .Select(CreatePartRegistryInstance);

            return registryInstancesLocatedInDomain;
        }

 public static List<IMessageHandler> CreateMessageHandlersFromDomain(AppDomain appDomain)
 {
     //http://stackoverflow.com/questions/5120647/instantiate-all-classes-implementing-a-specific-interface
     var interfaceType = typeof(IMessageHandler);
     return appDomain.GetAssemblies()
       .SelectMany(x => x.GetTypes())
       .Where(x => interfaceType.IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract)
       .Select(x => Activator.CreateInstance(x) as IMessageHandler).ToList();
 }

 private void ReadAppDomain( AppDomain appDomain )
 {
     Assembly[] loadedAssemblies = appDomain.GetAssemblies();
      Console.WriteLine( "*************** Assemblies in {0} ***************", appDomain.FriendlyName );
      foreach (Assembly assembly in loadedAssemblies)
      {
     Console.WriteLine( "->Name: {0}", assembly.GetName().Name );
     Console.WriteLine( "->Version: {0}\n", assembly.GetName().Version );
      }
 }

        private static void ListAllAssembilesInAppDomain(AppDomain appDomain) {            
            var loadedAssemblies = from asm in appDomain.GetAssemblies()
                                       orderby asm.GetName().Name
                                       select asm;
            Console.WriteLine("************************* Assembiles loaded in {0} **", appDomain.FriendlyName);

            foreach (Assembly a in loadedAssemblies) {
                Console.WriteLine("-> Name: {0}", a.GetName().Name);
                Console.WriteLine("-> Version: {0}\n", a.GetName().Version);
            }
        }

        private static void FindAndPrintAssembly(AppDomain appDomain, string assemblyName)
        {
            var anAssembly = appDomain.GetAssemblies().Where(assembly => assembly.GetName().Name.Equals(assemblyName, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

            if (anAssembly == null)
            {
                Console.WriteLine("Did not find Assembly {0} in {1})", assemblyName, appDomain.FriendlyName);
            }
            else
            {
                Console.WriteLine("Found Assembly --> {0} (version:{1}) in {2}", anAssembly.GetName().Name, anAssembly.GetName().Version, appDomain.FriendlyName);
            }
        }

        static void ListAllAssembliesInAppDomain(AppDomain ad)
        {
            var loadedAssemblies = from a in ad.GetAssemblies()
                orderby a.GetName().Name
                select a;
            Console.WriteLine("***** Here are the assemblies loaded in {0} *****\n", ad.FriendlyName);

            foreach (Assembly assembly in loadedAssemblies)
            {
                Console.WriteLine("-> Name: {0}", assembly.GetName().Name);
                Console.WriteLine("-> Version: {0}", assembly.GetName().Version);
            }
        }

        public static void Configure(
            AppDomain appDomain, IContainer container, IConventionConfigurator[] conventionConfigurators)
        {
            lock (Configured)
            {
                if (Configured.ContainsKey(appDomain) && Configured[appDomain].Contains(container))
                {
                    throw new InvalidOperationException(
                        "Application from this domain has been configured for this container already. " +
                        "AppllicationConfigurator.Configure() must be called once per AppDomain per Container.");
                }
                if (Configured.ContainsKey(appDomain))
                {
                    Configured[appDomain].Add(container);
                }
                else
                {
                    Configured.Add(appDomain, new HashSet<IContainer> {container});
                }
            }

            var assemblies = appDomain.GetAssemblies();
            foreach (var assembly in assemblies)
            {
                var assemblyTypes = assembly.GetTypes();
                Type assemblyConfiguratorType;
                try
                {
                    assemblyConfiguratorType =
                        assemblyTypes.SingleOrDefault(x => x.IsAssignableFrom(typeof (IAssemblyConfigurator)));
                }
                catch (Exception exception)
                {
                    var s = string.Join(string.Format(",{0}", Environment.NewLine),
                                        assemblyTypes.Where(x => x.IsAssignableFrom(typeof (IAssemblyConfigurator)))
                                                        .Select(x => x.FullName));
                    throw new Exception(string.Format("Found more than one assembly configurators in assembly '{0}'. " +
                                                        "There must be only one configurator in assembly. " +
                                                        "Configurator types found:{1}{2}",
                                                        assembly.FullName, Environment.NewLine, s),
                                        exception);
                }
                if (assemblyConfiguratorType != null)
                {
                    var assemblyConfigurator = (IAssemblyConfigurator)Activator.CreateInstance(assemblyConfiguratorType);
                    assemblyConfigurator.Configure(container, assemblyTypes);
                }
                assemblyTypes.ForEach(assemlyType =>
                    conventionConfigurators.ForEach(x => x.Configure(container, assemlyType)));
            }
        }