C# IContainer.Bind方法代码示例

        public override void Initialize(IContainer container)
        {
            container.Bind<IUncommittedEventStreamCoordinator>(UncommittedEventStreamCoordinatorType);

            container.Bind<IEventStore>(EventStoreType, BindingLifecycle.Singleton);

            container.Bind<IEventSubscriptions>(EventSubscriptionsType, BindingLifecycle.Singleton);

            if (EntityContextConfiguration != null)
            {
                EntityContextConfiguration.BindEntityContextTo<IEvent>(container);
                EntityContextConfiguration.BindEntityContextTo<EventSubscription>(container);
                base.Initialize(container);
            }
        }

 Configure(IContainer container)
 {
     SystemName = "[Not Set]";
     container.Bind<IConfigure>(this);
     Container = container;
     InitializeProperties();
 }

        public void Initialize(IContainer container)
        {
            container.Bind(typeof(ICommandFor<>), (Type t) =>
            {
                var commandForProxies = container.Get<ICommandForProxies>();
                return commandForProxies.CallGenericMethod<object, ICommandForProxies>(cc => cc.GetFor<Bifrost.Commands.Command>, t.GenericTypeArguments[0]);
            });

            var dispatcher = System.Windows.Threading.Dispatcher.CurrentDispatcher;
            Bifrost.Execution.DispatcherManager.Current = new Bifrost.Execution.Dispatcher(dispatcher);
            container.Bind<System.Windows.Threading.Dispatcher>(dispatcher);
            Configure.Instance.Container.Bind<IDispatcher>(Bifrost.Execution.DispatcherManager.Current);

            var proxyGenerator = new ProxyGenerator();
            Configure.Instance.Container.Bind<IProxyBuilder>(proxyGenerator.ProxyBuilder);
            Configure.Instance.Container.Bind(typeof(ICanHandleInvocationsFor<,>), typeof(InvocationHandler<,>));
        }

 public override void Resolve(IContainer container, Type service)
 {
     var serviceInstanceType = GetServiceInstanceType(service);
     if (serviceInstanceType != null )
     {
         var scope = GetScopeForTarget(serviceInstanceType);
         container.Bind(service,serviceInstanceType, scope);
     }
 }

        public override void Initialize(IContainer container)
        {
            if (CommandCoordinatorType != null)
                container.Bind<ICommandCoordinator>(CommandCoordinatorType);

            if (EntityContextConfiguration != null)
            {
                base.Initialize(container);
            }
        }

#pragma warning disable 1591 // Xml Comments
        public void Initialize(IContainer container)
        {
            var typeDiscoverer = container.Get<ITypeDiscoverer>();

            var resolverType = typeof(DefaultPrincipalResolver);
            var resolverTypes = typeDiscoverer.FindMultiple<ICanResolvePrincipal>().Where(t => t.Assembly != typeof(SecurityConfiguration).Assembly);
            if (resolverTypes.Count() > 1) throw new MultiplePrincipalResolversFound();
            if (resolverTypes.Count() == 1) resolverType = resolverTypes.First();

            container.Bind<ICanResolvePrincipal>(resolverType);
        }

#pragma warning disable 1591 // Xml Comments
		public void Initialize(IContainer container)
        {
            container.Bind(container);
#if(!SILVERLIGHT)
            container.Bind<_AppDomain>(AppDomain.CurrentDomain);
            container.Bind<IContractToImplementorsMap>(_contractToImplentorsMap);
#endif
            container.Bind<AssembliesConfiguration>(_assembliesConfiguration);
            container.Bind<IAssemblyProvider>(_assemblyProvider);
            container.Bind<IAssemblies>(typeof(global::Bifrost.Execution.Assemblies), BindingLifecycle.Singleton);
            container.Bind<ITypeDiscoverer>(typeof(TypeDiscoverer), BindingLifecycle.Singleton);
            container.Bind<ITypeFinder>(typeof(TypeFinder), BindingLifecycle.Singleton);
		}

		public App()
		{
            
			Startup += Application_Startup;
			Exit += Application_Exit;
			UnhandledException += Application_UnhandledException;

            var kernel = new StandardKernel();
            Container = new Container(kernel);
            var serviceLocator = new ContainerServiceLocator(Container);
            Container.Bind<IServiceLocator>(serviceLocator);
            ServiceLocator.SetLocatorProvider(() => serviceLocator);
            Container.Bind<ISerializer>(typeof(Serializer));

            var bindings = new DefaultBindings();
            bindings.Initialize(Container);

            var conventions = new DefaultConventions(Container);
            conventions.Initialize();

			InitializeComponent();
		}

		public override void Initialize(IContainer container)
		{
			if( LibrarianType != null )
				container.Bind<ISagaLibrarian>(LibrarianType);


            if (EntityContextConfiguration != null)
            {
                EntityContextConfiguration.BindEntityContextTo<SagaHolder>(container);
                EntityContextConfiguration.BindEntityContextTo<ChapterHolder>(container);
            }

            base.Initialize(container);
		}

        Configure(IContainer container, BindingLifecycle defaultLifecycle,  IDefaultConventions defaultConventions, IDefaultBindings defaultBindings)
        {
            SystemName = "[Not Set]";

            container.DefaultLifecycle = defaultLifecycle;
            container.Bind<IConfigure>(this);

            Container = container;
            ExcludeNamespacesForTypeDiscovery();

            defaultBindings.Initialize(Container);
            defaultConventions.Initialize();
            
            InitializeProperties();
        }

        Configure(IContainer container, BindingLifecycle defaultObjectLifecycle,  IDefaultConventions defaultConventions, IDefaultBindings defaultBindings)
        {
            DefaultObjectLifecycle = defaultObjectLifecycle;

            container.Bind<IConfigure>(this);

            Container = container;
            ExcludeNamespacesForTypeDiscovery();
            SetupServiceLocator();

            defaultBindings.Initialize(container);
            defaultConventions.Initialize();

            InitializeProperties();
        }

        Configure(IContainer container, BindingLifecycle defaultLifecycle,  IDefaultConventions defaultConventions, IDefaultBindings defaultBindings, AssembliesConfiguration assembliesConfiguration)
        {
            SystemName = "[Not Set]";

            AssembliesConfiguration = assembliesConfiguration;

            container.DefaultLifecycle = defaultLifecycle;
            container.Bind<IConfigure>(this);

            Container = container;

            defaultBindings.Initialize(Container);
            defaultConventions.Initialize();
            
            InitializeProperties();
        }

        public void Initialize (IContainer container)
		{
			if( SerializerType != null )
				container.Bind<ISerializer>(SerializerType, BindingLifecycle.Singleton);
		}

 public override void Resolve(IContainer container, Type service)
 {
     var proxy = _weaver.GetProxyType(service);
     container.Bind(service,proxy);
 }

		public override void Resolve(IContainer container, Type service)
		{
			var interceptor = container.Get<ResourceInterceptor>();
			var proxy = _proxyGenerator.CreateClassProxy(service, interceptor);
			container.Bind(service,proxy);
        }