C# Assembly.GetExportedTypes方法代码示例

        public IEnumerable<MigrationMetadata> FindMigrationsIn(Assembly assembly, string @namespace)
        {
            IEnumerable<Type> matchedTypes = assembly.GetExportedTypes().Where(t => Conventions.TypeIsMigration(t));

            if (!string.IsNullOrEmpty(@namespace))
                matchedTypes = assembly.GetExportedTypes().Where(t => t.Namespace == @namespace && Conventions.TypeIsMigration(t));

            foreach (Type type in matchedTypes)
                yield return Conventions.GetMetadataForMigration(type);
        }

        public void ScanAssembly(Assembly assembly)
        {
            assembly
                .GetExportedTypes()
                .Where(x => x.CanBeCastTo<StringToken>())
                .Each(ScanStringTokenType);

            assembly
                .GetExportedTypes()
                .Where(x => x.IsConcreteTypeOf<ILocalizedProperties>())
                .Each(type => ScanProperties(type.Create<ILocalizedProperties>()));
        }

 static string RunScript(Assembly script)
 {
     string res = "Error";
     foreach (Type type in script.GetExportedTypes())
         foreach (Type iface in type.GetInterfaces())
             if (iface == typeof(IScript))
             {
                 ConstructorInfo constructor = type.GetConstructor(System.Type.EmptyTypes);
                 if (constructor != null && constructor.IsPublic)
                 {
                     IScript scriptObject = constructor.Invoke(null) as IScript;
                     if (scriptObject != null)
                     {
                         res = scriptObject.RunScript();
                     }
                     else
                     {
                     }
                 }
                 else
                 {
                 }
             }
     return res;
 }

        /// <summary>
        /// Stellt sicher, dass der Serialisierer alle benötigten Datentypen kennt.
        /// </summary>
        /// <param name="assembly">Eine Erweiterungsbibliothek.</param>
        internal static void AddTypes( Assembly assembly )
        {
            // Nothing to do
            if (assembly == null)
                return;

            // Process all
            lock (m_ExtraTypes)
            {
                // Check for update
                bool mustUpdate = false;

                // Check all
                foreach (var type in assembly.GetExportedTypes())
                {
                    // Resolve to base
                    var genericBase = FindCustomActionBase( type );
                    if (genericBase != null)
                        if (m_ExtraTypes.Add( typeof( CustomActionRequest<,> ).MakeGenericType( genericBase.GetGenericArguments() ) ))
                            mustUpdate = true;
                }

                // Reload serializer
                if (mustUpdate)
                    CreateSerializer();
            }
        }

 /// <summary>
 /// Adds all the exported (public) types in the given assembly to the scope of used types.
 /// </summary>
 public static void AddTypes(this IStringlyScope scope, Assembly assembly)
 {
     foreach (var type in assembly.GetExportedTypes())
     {
         scope.AddType(type);
     }
 }

        /// <summary>
        /// Initializes a new instance of the ExtensionInfoBuilder class for the given assembly.
        /// </summary>
        /// <param name="fileName">The file name and path to the assembly to check.</param>
        public ExtensionInfoBuilder(string fileName)
        {
            ExtensionInfo ei;
            Type[] types;
            resultExtensions = new ExtensionInfoCollection();
            Type ropt = typeof(Extension);

            sourceAssembly = Assembly.ReflectionOnlyLoadFrom(fileName);

            ropt = ReflectionOnlyTypeFromAssembly(sourceAssembly, ropt);
            try
            {
                types = sourceAssembly.GetExportedTypes();
                foreach (Type t in types)
                {
                    try
                    {
                        if (t.IsSubclassOf(ropt) && !t.IsAbstract)
                        {
                            ei = new ExtensionInfo(t);
                            resultExtensions.Add(ei);
                        }
                    }
                    catch (ArgumentOutOfRangeException)
                    {
                        ei = null;
                    }
                }
            }
            catch (ReflectionTypeLoadException)
            {
                return;
            }
        }

        /// <summary>
        /// Calls <see cref="Verify(Type[])" /> for each public Type in
        /// <paramref name="assembly" />.
        /// </summary>
        /// <param name="assembly">The assembly.</param>
        public virtual void Verify(Assembly assembly)
        {
            if (assembly == null)
                throw new ArgumentNullException("assembly");

            this.Verify(assembly.GetExportedTypes());
        }

 private static IEnumerable<Type> GetLoadableTypes(Assembly assembly)
 {
     if (assembly == null) throw new ArgumentNullException("assembly");
     try
     {
         return assembly.GetExportedTypes();
     }
     catch (TypeLoadException)
     {
         return new Type[0];
     }
     catch (FileNotFoundException)
     {
         return new Type[0];
     }
     catch (ReflectionTypeLoadException ex)
     {
         var types = ex.Types;
         IList<Type> list = new List<Type>(types.Length);
         foreach (var t in types)
             if (t != null && t.IsPublic)
                 list.Add(t);
         return list;
     }
 }

 public IEnumerable<ISupplementSpecificationResults> FindSpecificationSupplementsIn(Assembly assembly)
 {
   return assembly.GetExportedTypes()
     .Where(x =>
            x.GetInterfaces().Contains(typeof(ISupplementSpecificationResults)))
     .Select(x => (ISupplementSpecificationResults) Activator.CreateInstance(x));
 }

 public IEnumerable<ICleanupAfterEveryContextInAssembly> FindAssemblyWideContextCleanupsIn(Assembly assembly)
 {
   return assembly.GetExportedTypes()
     .Where(x =>
            x.GetInterfaces().Contains(typeof(ICleanupAfterEveryContextInAssembly)))
     .Select(x => (ICleanupAfterEveryContextInAssembly) Activator.CreateInstance(x));
 }

        public static void MapAttributeRoutesInAssembly(this RouteCollection routes, Assembly assembly, IInlineConstraintResolver constraintResolver, IDirectRouteProvider routeProvider)
        {
            var controllers = (assembly.GetExportedTypes()
                .Where(IsControllerType)).ToList();

            MapAttributeRoutesInControllers(routes, controllers, constraintResolver, routeProvider);
        }

 public EventTypeResolver(Assembly assembly)
 {
     _typeMap = assembly
         .GetExportedTypes()
         .Where(x => x.Name.EndsWith("Event", StringComparison.OrdinalIgnoreCase))
         .ToDictionary(x => x.Name);
 }

 private static void RegisterViewModelsWithLocator(Assembly assembly)
 {
     foreach (var viewModel in assembly.GetExportedTypes().Where(x => x.IsPublic && !x.IsInterface && x.Name.EndsWith("ViewModel")))
     {
         RegisterKnownViewModel(viewModel);
     }
 }

		protected void DiscoverTypes( Assembly assembly )
		{
			Type[] types = null;

			try
			{
				types = assembly.GetExportedTypes();
			}
			catch(Exception)
			{
				// Ok, Dynamic assemblies don't support GetExportedTypes
				types = new Type[0];
			}
			
			foreach( Type type in types )
			{
				String nameSpace = type.Namespace;

				if (nameSpace == null)
				{
					continue;
				}
				
				Tree.DefineNamespace( nameSpace ).AddType( type );
			}
		}

        public static void MapMvcAttributeRoutes(
            this RouteCollection routeCollection,
            Assembly controllerAssembly,
            IInlineConstraintResolver constraintResolver = null)
        {
            var controllerTypes = (from type in controllerAssembly.GetExportedTypes()
                                   where
                                       type != null && type.IsPublic
                                       && type.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase)
                                       && !type.IsAbstract && typeof(IController).IsAssignableFrom(type)
                                   select type).ToList();
            routeCollection.MapMvcAttributeRoutes();
            var attributeRoutingAssembly = typeof(RouteCollectionAttributeRoutingExtensions).Assembly;
            var attributeRoutingMapperType =
                attributeRoutingAssembly.GetType("System.Web.Mvc.Routing.AttributeRoutingMapper");

            var mapAttributeRoutesMethod = attributeRoutingMapperType.GetMethod(
                "MapAttributeRoutes",
                BindingFlags.Public | BindingFlags.Static,
                null,
                new[] { typeof(RouteCollection), typeof(IEnumerable<Type>), typeof(IInlineConstraintResolver) },
                null);

            constraintResolver = constraintResolver ?? new DefaultInlineConstraintResolver();
            mapAttributeRoutesMethod.Invoke(null, new object[] { routeCollection, controllerTypes, constraintResolver });
        }