C# IContainer.RegisterDelegate方法代码示例

 private static void RegisterDependencies(IContainer container)
 {
     container.Register<IBrowserConfigService, BrowserConfigService>(Reuse.InWebRequest);
     container.Register<ICacheService, CacheService>(Reuse.InWebRequest);
     container.Register<IFeedService, FeedService>(Reuse.InWebRequest);
     container.Register<ILoggingService, LoggingService>(Reuse.InResolutionScope);
     container.Register<IManifestService, ManifestService>(Reuse.Transient);
     container.Register<IOpenSearchService, OpenSearchService>(Reuse.Transient);
     container.Register<ISitemapService, SitemapService>(Reuse.Transient);
     container.Register<ISitemapPingerService, SitemapPingerService>(Reuse.Transient);
     container.RegisterDelegate<IRobotsService>(resolver => new RobotsService(), Reuse.Singleton);
     container.Register<HomeController>(Reuse.InWebRequest);
 }

        public void ConfigureContainer(IContainer container)
        {
            container.RegisterDelegate<IProvideHashing>(r => _CryptograhyManager.HashProvider);
            container.Register<IResourceVersionProvider, DefaultResourceVersionProvider>(Reuse.Singleton);
            container.Register<ICanonicalizationService, DefaultCanonicalizationService>(Reuse.Singleton);
            container.Register<IResourceValidatorFactory, ServiceLocatorResourceValidatorFactory>();
            container.Register<IManagePasswords, DefaultPasswordManager>(Reuse.Singleton);

            // register all resource and resource extension validators
            container.Register<ResourceExtensionValidators>(Reuse.Singleton);
            _ServerConfiguration
                .ResourceTypeDefinitions
                .ForEach(rtd =>
                {
                    if (rtd.SchemaExtensions.Any())
                    {
                        rtd.SchemaExtensions
                            .ForEach(
                                ext =>
                                    container.Register(
                                        typeof(IResourceExtensionValidator),
                                        ext.ExtensionValidatorType,
                                        reuse: Reuse.Singleton));
                    }

                    container.Register(rtd.ValidatorType, reuse: Reuse.Singleton);
                });
            
            container.Register<IUserRepository, InMemoryUserRepository>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep);
            container.Register<IGroupRepository, InMemoryGroupRepository>(Reuse.Singleton, ifAlreadyRegistered: IfAlreadyRegistered.Keep);

            // register all business logic services for built-in endpoints
            container.RegisterDelegate(r => r.Resolve<IServiceProviderConfigurationService>(AmbientRequestService.ProtocolVersion));
            container.RegisterDelegate(r => r.Resolve<ISchemaService>(AmbientRequestService.ProtocolVersion));
            container.Register<IUserService, UserService>(Reuse.Singleton);
            container.Register<IGroupService, GroupService>(Reuse.Singleton);
        }

        public App(Action<IContainer> setupContainer)
        {
            this.container = new Container().WithMefAttributedModel();
            this.container.RegisterExports(GetAssemblies());
            container.RegisterDelegate<IContainer>(r => container, Reuse.Singleton);
            if (setupContainer != null)
            {
                setupContainer(this.container);
            }

            var mainPage = container.Resolve<MainPage>();

            var navPage = new NavigationPage(mainPage);
            var navService = container.Resolve<INavigationService>();
            navService.Initialize(navPage);
            this.MainPage = navPage;
        }

        /// <summary>
        /// Configures the DryIoc <see cref="T:DryIoc.IContainer" /> instance.
        /// </summary>
        /// <param name="container">The container.</param>
        public void ConfigureContainer(IContainer container)
        {
            // Since the priority is lower than Owin.Scim's default registry, this method will execute after all
            // default registrations occur.

            // Configure AutoMapper to translate ScimUser and your application's user.
            var mapperConfiguration = new MapperConfiguration(
                config =>
                {
                    config.CreateMap<KernelUser, ScimUser2>();
                    config.CreateMap<ScimUser, KernelUser>()
                        .ReverseMap()
                        .Include<KernelUser, ScimUser2>();
                });
            container.RegisterDelegate<IMapper>(resolver => mapperConfiguration.CreateMapper());

            // Replace any IUserRepository implementation with our own.
            container.Register<IUserRepository, CustomUserRepository>(ifAlreadyRegistered: IfAlreadyRegistered.Replace);
        }

		internal static void RegisterToContainer(IContainer cb, IObjectFactoryBuilder rb)
		{
			foreach (var item in rb.Types)
			{
				switch (item.Scope)
				{
					case InstanceScope.Transient:
						if (item.AsType == null || item.AsType.Length == 0)
							cb.Register(item.Type, Reuse.Transient);
						else foreach (var t in item.AsType)
								cb.Register(t, item.Type);
						break;
					case InstanceScope.Singleton:
						if (item.AsType == null || item.AsType.Length == 0)
							cb.Register(item.Type, Reuse.Singleton);
						else foreach (var t in item.AsType)
								cb.Register(t, item.Type, Reuse.Singleton);
						break;
					default:
						if (item.AsType == null || item.AsType.Length == 0)
							cb.Register(item.Type, Reuse.InResolutionScope);
						else foreach (var t in item.AsType)
								cb.Register(t, item.Type, Reuse.InResolutionScope);
						break;
				}
			}
			foreach (var item in rb.Instances)
			{
				var type = item.AsType ?? item.Instance.GetType();
				cb.RegisterInstance(type, item.Instance);
			}
			foreach (var it in rb.Funcs)
			{
				var item = it;
				if (item.AsType == null || item.AsType.Length == 0)
					throw new NotSupportedException("Result type must be defined. Declared Func result is not defined");
				switch (item.Scope)
				{
					case InstanceScope.Transient:
						foreach (var t in item.AsType)
							cb.RegisterDelegate(t, c => item.Func(c.Resolve<IObjectFactory>()), Reuse.Transient);
						break;
					case InstanceScope.Singleton:
						foreach (var t in item.AsType)
							cb.RegisterDelegate(t, c => item.Func(c.Resolve<IObjectFactory>()), Reuse.Singleton);
						break;
					default:
						foreach (var t in item.AsType)
							cb.RegisterDelegate(t, c => item.Func(c.Resolve<IObjectFactory>()), Reuse.InResolutionScope);
						break;
				}
			}
		}