C# IDependencyResolver.ResolveAll方法代码示例

        private static void RunContainerInitializers(IDependencyResolver dependencyResolver)
        {
            var appdomainHelpers = dependencyResolver.ResolveAll<IAppDomainHelper>();
            if (appdomainHelpers == null || appdomainHelpers.Count() == 0)
            {
                appdomainHelpers = new[] {AppDomainHelper.CreateDefault()};
            }

            var initTasks =
                appdomainHelpers.SelectMany(helper => helper.GetTypes(
                    t => t.IsClass && !t.IsAbstract && typeof (IContainerInitializer).IsAssignableFrom(t)));
            //register them:
            foreach (var taskType in initTasks)
            {
                dependencyResolver.RegisterType(typeof(IContainerInitializer), taskType);
            }
            //run them:
            var allTasks = dependencyResolver.ResolveAll<IContainerInitializer>();
            if (allTasks != null)
            {
                //first user's tasks:
                foreach (var task in allTasks.Where(t => !t.GetType().Namespace.StartsWith("BoC.")))
                {
                    task.Execute();
                }
                //now ours:
                foreach (var task in allTasks.Where(t => t.GetType().Namespace.StartsWith("BoC.")))
                {
                    task.Execute();
                }
            }
        }

 public TwoPhasedPipelineAdaptor(IDependencyResolver resolver)
 {
   _graphs = resolver.HasDependency<IGenerateCallGraphs>()
       ? resolver.Resolve<IGenerateCallGraphs>()
       : new WeightedCallGraphGenerator();
   Contributors = resolver.ResolveAll<IPipelineContributor>()
                          .ToList()
                          .AsReadOnly();
 }

        public static ISessionFactory InitializeSessionFactory(IDependencyResolver dependencyResolver)
        {
            String databaseName = null;
            foreach (ConnectionStringSettings connectionString in ConfigurationManager.ConnectionStrings)
            {
                if (!String.IsNullOrEmpty(connectionString.Name) &&
                    connectionString.Name.EndsWith("db4o", StringComparison.InvariantCultureIgnoreCase))
                {
                    databaseName = connectionString.ConnectionString;
                }
            }

            if (databaseName == null)
            {
                throw new Exception("Could not find a connectionstring that ends with 'db4o'.");
            }

            databaseName = databaseName.Replace(
                "|DataDirectory|",
                AppDomain.CurrentDomain.GetData("DataDirectory") + "\\");

            IEmbeddedConfiguration config = Db4oEmbedded.NewConfiguration();
            config.Common.Add(new TransparentActivationSupport());
            config.Common.Add(new TransparentPersistenceSupport());
            config.Common.DetectSchemaChanges = true;
            config.Common.ExceptionsOnNotStorable = true;
            config.Common.OptimizeNativeQueries = true;
            config.Common.UpdateDepth = Int32.MaxValue;

            dependencyResolver.RegisterInstance<IEmbeddedConfiguration>(config);

            var configExtenders = dependencyResolver.ResolveAll<IConfigurationExtender>() ?? new IConfigurationExtender[0];
            foreach (var extender in configExtenders)
            {
                extender.Configure(config);
            }

            var db = Db4oEmbedded.OpenFile(config, databaseName);
            AutoIncrementSupport.Install(db);
            return new Db4oSessionFactory(db);
        }

 public DefaultHubManager(IDependencyResolver resolver)
 {
     _hubProviders = resolver.ResolveAll<IHubDescriptorProvider>();
     _methodProviders = resolver.ResolveAll<IMethodDescriptorProvider>();
     _activator = resolver.Resolve<IHubActivator>();
 }

 // TODO: Remove when impelemntation of array injection in containers is complete
 public MetaModelRepository(IDependencyResolver resolver) : this(resolver.ResolveAll<IMetaModelHandler>().ToArray())
 {
 }

 //// TODO: Remove when support for arrays is added to containers
 public MethodBasedOperationCreator(IDependencyResolver resolver, IObjectBinderLocator binderLocator)
     : this(resolver.ResolveAll<IMethodFilter>().ToArray(), resolver, binderLocator)
 {
 }

        public static void GenerateRepositories(IDependencyResolver dependencyResolver, Type defaultBaseType, Type[] constructorParams)
        {
            const string idPropertyName = "Id";
            var interfaceToFind = typeof(IRepository<>);

            var isbasetype = new Func<Type, bool>(basetype =>
                                                  basetype.IsGenericType &&
                                                  basetype.GetGenericTypeDefinition() == typeof (BaseEntity<>));

            //below should work fine for all situations :)
            ModuleBuilder mb = null;
            var types = dependencyResolver.ResolveAll<IAppDomainHelper>().SelectMany(
                helper => helper.GetTypes(t => true)).ToArray();

            var entities = from t in types
                           where t.IsClass
                                 && !t.IsAbstract
                                 && typeof (IBaseEntity).IsAssignableFrom(t)
                                 && !isbasetype(t)
                           select t;

            int typeNum = 0;
            foreach (var type in entities.ToArray())
            {
                var idProp = type.GetProperty(idPropertyName);
                var idType = idProp == null ? typeof(object) : idProp.PropertyType;
                var interfaceType = interfaceToFind.MakeGenericType(new Type[] { type });

                if (interfaceType == null)
                {
                    continue;
                }

                var toFind = (from i in types
                              where i.IsInterface &&
                                    interfaceType.IsAssignableFrom(i)
                              select i).FirstOrDefault() ?? interfaceType;

                if (dependencyResolver.IsRegistered(toFind))
                {
                    //this repository is already registered, if you have multiple repositories implementing the same interface,
                    //you'll have to register the correct one 'by hand'
                    continue;
                }

                var repo = (from r in types
                            where !r.IsInterface &&
                                  toFind.IsAssignableFrom(r)
                            select r
                           ).FirstOrDefault();

                if (repo == null)
                {
                    if (mb == null)
                        mb = GetRepositoriesModuleBuilder();
                    var name = "DynamicGeneratedRepository" + typeNum++;

                    var baseType = defaultBaseType.MakeGenericType(new Type[] { type });
                    var baseConstructor = baseType.GetConstructor(constructorParams);
                    var tb = mb.DefineType(name, TypeAttributes.AutoLayout | TypeAttributes.Public,
                                           baseType,
                                           new Type[] {toFind});
                    var constructor = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard,
                                                           constructorParams);
                    for (int i = 1; i <= constructorParams.Length; i++)
                    {
                        constructor.DefineParameter(i, ParameterAttributes.None, "param" + i);
                    }

                    ILGenerator ilGenerator = constructor.GetILGenerator();
                    ilGenerator.Emit(OpCodes.Ldarg_0);                      // Load "this"
                    for (int i = 1; i <= constructorParams.Length; i++)
                    {
                        ilGenerator.Emit(OpCodes.Ldarg, i);
                    }
                    ilGenerator.Emit(OpCodes.Call, baseConstructor);    // Call the base constructor
                    ilGenerator.Emit(OpCodes.Ret);
                    try
                    {
                        repo = tb.CreateType();
                    }
                    catch (TypeLoadException exception)
                    {
                        throw new TypeLoadException("Error creating an automatic generated Repository for " + toFind, exception);
                    }
                }
                dependencyResolver.RegisterType(interfaceType, repo);
                dependencyResolver.RegisterType(toFind, repo);
            }
        }

 public SystemAndAttributesOperationInterceptorProvider(IDependencyResolver resolver)
     : this(resolver.ResolveAll<IOperationInterceptor>().ToArray())
 {
 }

		public DefaultHubManager(IDependencyResolver resolver) : this(
			resolver.ResolveAll<IHubDescriptorProvider>(), 
			resolver.ResolveAll<IMethodDescriptorProvider>(), 
			resolver.Resolve<IHubActivator>())
        {
        }