C# Assembly.GetLoadableTypes方法代码示例

 /// <summary>
 /// All IRouteRegistration instances and all delegates
 /// </summary>
 /// <param name="assembly"></param>
 /// <returns></returns>
 public IEnumerable<IRouteRegistration> Scan(Assembly assembly)
 {
     return Enumerable.Concat(
             assembly.GetLoadableTypes().SelectMany(t => Enumerable.Concat(new[] { t }, t.GetLoadableNestedTypes()))
                 .Where(IsConstructableRouteRegistration)
                 .Select(t => (IRouteRegistration)Activator.CreateInstance(t)),
             assembly.GetLoadableTypes().Where(t => typeof(Handler).IsAssignableFrom(t))
                 .SelectMany(t => t.GetFields(BindingFlags.NonPublic | BindingFlags.Static)
                     .Where(IsRegister)
                     .Select(f => new DelegatedRouteRegistration((Handler.Register)f.GetValue(null)))
                 ));
 }

        public static DotvvmConfiguration InitDotVVM(Assembly webSiteAssembly, string rootPath)
        {
            var dotvvmStartups = webSiteAssembly.GetLoadableTypes()
                .Where(t => typeof(IDotvvmStartup).IsAssignableFrom(t) && t.GetConstructor(Type.EmptyTypes) != null).ToArray();

            if (dotvvmStartups.Length == 0) throw new Exception("Could not find any implementation of IDotvvmStartup.");
            if (dotvvmStartups.Length > 1) throw new Exception($"Found more than one implementation of IDotvvmStartup ({string.Join(", ", dotvvmStartups.Select(s => s.Name)) }).");

            var startup = (IDotvvmStartup)Activator.CreateInstance(dotvvmStartups[0]);
            var config = OwinExtensions.CreateConfiguration(rootPath);
            startup.Configure(config, rootPath);
            config.CompiledViewsAssemblies = null;
            return config;
        }

        private static object LoadConfiguration(
            Assembly configAssembly,
            DashingSettings dashingSettings,
            ConnectionStringSettings connectionStringSettings) {
            // fetch the to state
            var configType = configAssembly.GetLoadableTypes().SingleOrDefault(t => t.FullName == dashingSettings.ConfigurationName);

            if (configType == null) {
                using (Color(ConsoleColor.Red)) {
                    var candidates = configAssembly.GetLoadableTypes().Where(t => t.GetInterface(typeof(IConfiguration).FullName) != null).ToArray();
                    if (candidates.Any()) {
                        throw new CatchyException(
                            "Could not locate {0}, but found candidates: {1}",
                            dashingSettings.ConfigurationName,
                            string.Join(", ", candidates.Select(c => c.FullName)));
                    }

                    throw new CatchyException("Could not locate {0}, and found no candidate configurations", dashingSettings.ConfigurationName);
                }
            }

            // attempt to find the call to ConfigurationManager and overwrite the connection string
            InjectConnectionString(dashingSettings, connectionStringSettings);

            // TODO add in a factory way of generating the config for cases where constructor not empty
            return Activator.CreateInstance(configType);
        }

 private IEnumerable<Type> GetTypesSafe(Assembly a)
 {
     try
     {
         return a.GetLoadableTypes();
     }
     catch (Exception ex)
     {
         _trace.TraceWarning("None of the classes from assembly '{0}' could be loaded when searching for Hubs. [{1}]",
                            a.FullName,
                            a.Location,
                            ex.GetType().Name,
                            ex.Message);
         return Enumerable.Empty<Type>();
     }
 }

        private void ConfigureAssembly(Assembly assembly) {
            var types = assembly.GetLoadableTypes().Where(type =>
                type.IsPublic &&
                type.IsSubclassOf(typeof(DirectController)) &&
                !type.HasAttribute<DirectIgnoreAttribute>()
            );

            foreach (Type type in types) {
                var action = new DirectAction(type);
                if (_actions.ContainsKey(action.Name)) {
                    throw new Exception(String.Format(DirectResources.DirectProvider_ActionExists, action.Name));
                }
                _actions.Add(action.Name, action);
            }
        }

 public ClassScanner(Assembly assembly, Func<Type, bool> filter)
 {
     Throw.IfNullArgument(assembly, "assembly");
     Types = new List<Type>(assembly.GetLoadableTypes().Where(filter));
 }

        internal void RegisterFunctions(Assembly assembly)
        {
            foreach(Type type in assembly.GetLoadableTypes())
            {
                // Not a class or abstract?
                if(!type.IsClass || type.IsAbstract)
                {
                    continue;
                }
                // Is the type not assignable from the function base class?
                if(!typeof(MathExpressionFunction).IsAssignableFrom(type))
                {
                    continue;
                }

                // Make sure there is at least one parameterless constructor.
                ConstructorInfo[] constructors = type.GetConstructors();
                ConstructorInfo constructor = constructors.FirstOrDefault(x => x.GetParameters().Length == 0);
                if(constructor == null)
                {
                    string message = string.Format("Function of type '{0}' has no parameterless constructor.", type.FullName);
                    throw new MathExpressionException(message);
                }

                // Register the function.
                MathExpressionFunction function = Activator.CreateInstance(type) as MathExpressionFunction;
                this.RegisterFunction(function);
            }
        }