C# Container.RegisterPackages方法代码示例

        public static Container RegisterServices(Assembly mvcControllersAssembly)
        {
            var container = new Container();

            container.RegisterPackages(new[] { Assembly.GetExecutingAssembly() });

            container.RegisterMvcControllers(mvcControllersAssembly);

            container.Verify();

            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));

            return container;
        }

        public static void Main() {
            System.Diagnostics.Trace.Listeners.Add(new NLogTraceListener());
            if (ExceptionlessClient.Current.Configuration.Enabled) {
                ExceptionlessClient.Current.Log = new NLogExceptionlessLog();
                ExceptionlessClient.Current.Startup();
            }

            var container = new Container();

            // try and load modules from all assemblies referenced in the job configuration
            container.RegisterPackages(GetSchedulerAssemblies());
            JobManager.Current.SetDependencyResolver(new SimpleInjectorCoreDependencyResolver(container));

            ServiceBase.Run(new ServiceBase[] { new Scheduler() });
        }

        protected void Application_Start(object sender, EventArgs e)
        {
            var container = new Container();

            //Package registration;
            container.RegisterPackages();

            //ILogger registration;
            container.RegisterWithContext<ILogger>(context => LogManager.GetLogger(context.ImplementationType.Name));

            //WCF integration;
            SimpleInjectorServiceHostFactory.SetContainer(container);

            //Service initialisation;
            var initialiser = container.GetInstance<IInitialiser>();
            initialiser.Initialise();
        }

        public override IServiceProvider Bootstrap() {
            var container = new Container();
            container.Options.AllowOverridingRegistrations = true;
            
            container.RegisterPackage<Bootstrapper>();

            Assembly insulationAssembly = null;
            try {
                insulationAssembly = Assembly.Load("Exceptionless.Insulation");
            } catch (Exception ex) {
                Logger.Error().Message("Unable to load the insulation assembly.").Exception(ex).Write();
            }

            if (insulationAssembly != null)
                container.RegisterPackages(new[] { insulationAssembly });

            return container;
        }

        public static void Configure()
        {
            var container = new Container();
            container.Options.DefaultScopedLifestyle = Lifestyle.CreateHybrid(() =>
                container.GetCurrentLifetimeScope() != null,
                new LifetimeScopeLifestyle(),
                new WebRequestLifestyle()
            );

            var assemblies = new[]
            {
                Assembly.GetExecutingAssembly(), // This
                Assembly.GetAssembly(typeof (InquiryRequest)), // Domain
                Assembly.GetAssembly(typeof (CompositionRoot)) // Infrastructure
            };

            // Register the Web Configuration Manager
            container.Register<IConfigurationManager, WebConfigurationManager>(Lifestyle.Singleton);

            // Register ScaffoldR in Simple Injector
            container.RegisterScaffoldR(settings =>
            {
                settings.EventAssemblies = assemblies;
                settings.TransactionAssemblies = assemblies;
                settings.FluentValidationAssemblies = assemblies;
                settings.ViewModelAssemblies = assemblies;
            });

            // Register the controllers in Simple Injector
            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            container.RegisterPackages(assemblies);

            // Register validation in Simple Injector
            FluentValidationModelValidatorProvider.Configure(provider => {
                    provider.ValidatorFactory = new SimpleInjectorValidatorFactory(container);
                    provider.AddImplicitRequiredValidator = false;
                }
            );

            // Verify that the container is all setup
            container.Verify();

            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
        }

        /// <summary>
        /// Dependency Injection init.
        /// Alle Componenten registrieren, Integration mit ASP.NET MVC, ASP.NET WebApi.
        /// </summary>
        /// <param name="container"></param>
        private void _InitDependencyInjection(Container container)
        {
            if (container == null) throw new ArgumentNullException("container");

            container.RegisterPackages(new Type[] { 
                typeof(DependencyInjectionConfig),
                typeof(Llprk.Application.DependencyInjectionConfig),
            }.Select(t => Assembly.GetAssembly(t)));

            // Controller für DI registrieren.
            container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
            container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
            container.RegisterMvcIntegratedFilterProvider();

            container.Verify();

            // Container mit MVC verbinden.
            DependencyResolver.SetResolver(new SimpleInjectorDependencyResolver(container));
            GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
        }

        /// <summary>
        /// Initializes this instance.
        /// </summary>
        public static void Initialize(Container container)
        {
            try
            {
                //var container = SimpleDependencyInjector.Instance;
                container.RegisterPackages();

                container.RegisterWebApiControllers(GlobalConfiguration.Configuration);
                container.RegisterWebApiFilterProvider(GlobalConfiguration.Configuration);

                container.RegisterMvcControllers(Assembly.GetExecutingAssembly());
                container.RegisterMvcIntegratedFilterProvider();
                container.Verify();

                MapperInitializer.RegisterMapper(container);
                System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver = new SimpleInjectorWebApiDependencyResolver(container);
                System.Web.Mvc.DependencyResolver.SetResolver(new SimpleInjector.Integration.Web.Mvc.SimpleInjectorDependencyResolver(container));
            }
            catch (Exception ex)
            {
                ex.ExceptionValueTracker();
            }
        }

        public override IServiceProvider Bootstrap() {
            var container = new Container();
            container.Options.AllowOverridingRegistrations = true;
            container.Options.PropertySelectionBehavior = new InjectAttributePropertySelectionBehavior();

            container.RegisterPackage<Bootstrapper>();

            if (Settings.Current.EnableRedis)
                container.RegisterSingle<IQueue<EventMigrationBatch>>(() => new RedisQueue<EventMigrationBatch>(container.GetInstance<ConnectionMultiplexer>(), retries: 5, workItemTimeout: TimeSpan.FromHours(2)));
            else
                container.RegisterSingle<IQueue<EventMigrationBatch>>(() => new InMemoryQueue<EventMigrationBatch>(retries: 5, workItemTimeout: TimeSpan.FromHours(2)));

            Assembly insulationAssembly = null;
            try {
                insulationAssembly = Assembly.Load("Exceptionless.Insulation");
            } catch (Exception ex) {
                Log.Error().Message("Unable to load the insulation asssembly.").Exception(ex).Write();
            }

            if (insulationAssembly != null)
                container.RegisterPackages(new[] { insulationAssembly });

            return container;
        }

        public static Container CreateContainer(bool includeInsulation = true) {
            var container = new Container();
            container.Options.AllowOverridingRegistrations = true;
            container.Options.DefaultScopedLifestyle = new WebApiRequestLifestyle();
            container.Options.ResolveUnregisteredCollections = true;

            container.RegisterPackage<Core.Bootstrapper>();
            container.RegisterPackage<Bootstrapper>();

            if (!includeInsulation)
                return container;

            Assembly insulationAssembly = null;
            try {
                insulationAssembly = Assembly.Load("Exceptionless.Insulation");
            } catch (Exception ex) {
                Logger.Error().Message("Unable to load the insulation assembly.").Exception(ex).Write();
            }

            if (insulationAssembly != null)
                container.RegisterPackages(new[] { insulationAssembly });

            return container;
        }

        public static Container CreateContainer(bool includeInsulation = true) {
            var container = new Container();
            container.Options.AllowOverridingRegistrations = true;
            container.Options.PropertySelectionBehavior = new InjectAttributePropertySelectionBehavior();

            container.RegisterPackage<Core.Bootstrapper>();
            container.RegisterPackage<Bootstrapper>();

            if (!includeInsulation)
                return container;

            Assembly insulationAssembly = null;
            try {
                insulationAssembly = Assembly.Load("Exceptionless.Insulation");
            } catch (Exception ex) {
                Log.Error().Message("Unable to load the insulation assembly.").Exception(ex).Write();
            }

            if (insulationAssembly != null)
                container.RegisterPackages(new[] { insulationAssembly });

            return container;
        }