C# IContainer.Get方法代码示例

 static App()
 {
     _container = ContainerContext.Current;
     _container.Register<IMessenger>(new Messenger());
     ViewModelService.TypeFinder = (name) => {
         var typeDiscoverer = _container.Get<ITypeDiscoverer>();
         var types = typeDiscoverer.FindAnyByName(name);
         if (types.Length > 1) throw new ArgumentException("Ambiguous viewModel name");
         return types[0];
     };
     ViewModelService.InstanceCreator = (t) => _container.Get(t);
 }

        public void Configure(IContainer container)
        {
            var basicApiProvider = container.Get<IBasicApiProvider>();
            var registry = container.Get<IRegistry>();
            registry.Config = basicApiProvider.GetDefaultUaConfig();
            registry.LoggingConfig = basicApiProvider.GetDefaultLoggingConfig();
            registry.MediaConfig = container.Get<IMediaApiProvider>().GetDefaultConfig();

            container.RegisterAsSingleton(registry.LoggingConfig);
            container.RegisterAsSingleton(registry.Config);
            container.RegisterAsSingleton(registry.MediaConfig);

            container.RegisterAsSingleton<ISipUserAgent, ISipUserAgentInternal, DefaultSipUserAgent>();
        }

        public void Configure(IContainer container)
        {
            Helper.GuardNotNull(container);
            container.RegisterAsSingleton<IObjectFactory, DefaultObjectFactory>();
            container.RegisterAsSingleton<ILocalRegistry, DefaultLocalRegistry>();
            container.RegisterAsSingleton(container.Get<ILocalRegistry>() as IConfigurationContext);

            container.RegisterAsSingleton<IImManager, DefaultImManager>();
            container.RegisterAsSingleton(container.Get<IImManager>().As<IImManagerInternal>());
            container.Register<IMessageBuilder, DefaultMessageBuilder>();
            container.Register<IBuddyBuilder, DefaultBuddyBuilder>();
            container.Register<IBuddyInternal, Buddy>();

            container.RegisterAsSingleton<ISipUserAgent, DefaultSipUserAgent>();
            container.RegisterAsSingleton(container.Get<ISipUserAgent>() as ISipUserAgentInternal);
        }

        public GeneratedProxies(
            CommandProxies commandProxies,
            CommandSecurityProxies commandSecurityProxies,
            QueryProxies queryProxies,
            ReadModelProxies readModelProxies,
            ServiceProxies serviceProxies,
            NamespaceConfigurationProxies namespaceConfigurationProxies,
            ITypeDiscoverer typeDiscoverer,
            IContainer container)
        {
            var builder = new StringBuilder();
            builder.Append(commandProxies.Generate());
            builder.Append(commandSecurityProxies.Generate());
            builder.Append(readModelProxies.Generate());
            builder.Append(queryProxies.Generate());
            builder.Append(serviceProxies.Generate());
            builder.Append(namespaceConfigurationProxies.Generate());

            var generatorTypes = typeDiscoverer.FindMultiple<IProxyGenerator>().Where(t => !t.Namespace.StartsWith("Bifrost"));
            foreach (var generatorType in generatorTypes)
            {
                var generator = container.Get(generatorType) as IProxyGenerator;
                builder.Append(generator.Generate());
            }

            All = builder.ToString();
        }

 public void Initialize(IContainer container)
 {
     var typeDiscoverer = container.Get<ITypeDiscoverer>();
     FluentConfiguration.Mappings(m => DiscoverClassMapsAndAddAssemblies(typeDiscoverer, m));
     Configuration = FluentConfiguration.BuildConfiguration();
     SessionFactory = Configuration.BuildSessionFactory();
 }

		public static void Main (string[] args)
		{
		    var kernel = new StandardKernel();
		    Container = new Container(kernel);

		    Configure.With(Container)
                .UsingJsonStorage("JsonDB")
                .Initialize();

		    var commandCoordinator = ServiceLocator.Current.GetInstance<ICommandCoordinator>();

			var command = new CreatePerson(Guid.NewGuid(), "First", "Person");
			var result = commandCoordinator.Handle(command);
			if (!result.Success)
			{
				Console.WriteLine("Handling of command failed");
				Console.WriteLine("Exception : {0}\nStack Trace : {1}", result.Exception.Message, result.Exception.StackTrace);
			}

			var queries = Container.Get<IPersonView>();
			var persons = queries.GetAll();
			foreach (var person in persons)
			{
				Console.WriteLine("Person ({0}) - {1} {2}", person.Id, person.FirstName, person.LastName);
			}
		}

 public void Configure(IContainer container)
 {
     Helper.GuardNotNull(container);
     container.RegisterAsSingleton<IAccountManager, DefaultAccountManager>();
     container.RegisterAsSingleton(container.Get<IAccountManager>() as IAccountManagerInternal);
     container.Register<IAccountBuilder, DefaultAccountBuilder>();
     container.Register<IAccountInternal, Account>();
 }

 static IList<Assembly> DiscoverAssembliesWithHbmMappings(IContainer container)
 {
     return container
         .Get<IAssemblies>()
         .GetAll()
         .Where(a => a.GetManifestResourceNames().Any(s => s.EndsWith(".hbm.xml")))
         .ToList();
 }

 public void Configure(IContainer container)
 {
     Helper.GuardNotNull(container);
     container.RegisterAsSingleton<ICallManager, DefaultCallManager>();
     container.RegisterAsSingleton(container.Get<ICallManager>() as ICallManagerInternal);
     container.Register<ICallBuilder, DefaultCallBuilder>();
     container.Register<ICallInternal, Call>();
 }

 public void Configure(IContainer container)
 {
     Helper.GuardNotNull(container);
     container.RegisterAsSingleton<IConferenceBridge, DefaultConferenceBridge>();
     container.RegisterAsSingleton<IMediaManager, DefaultMediaManager>();
     container.RegisterAsSingleton(container.Get<IMediaManager>() as IMediaManagerInternal);
     container.Register<CodecInfo, CodecInfo>();
     container.Register<IWavPlayer, WavPlayer>();
 }

        public UIPort(IContainer container, ScrollViewer scrollViewer, StackPanel mainStack)
        {
            _container = container;
            _normalMode = _container.Get<IHasNormalMode>();

            _mainStack = mainStack;

            _stackPanelWrapper = new StackPanelWrapper(mainStack, scrollViewer, false);
        }

 static IList<Assembly> DiscoverAssembliesWithFluentMappings(IContainer container)
 {
     return container
         .Get<IImplementorFinder>()
         .GetImplementorsFor(typeof(IMappingProvider))
         .Select(t => t.Assembly)
         .Distinct()
         .ToList();
 }

#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);
        }

        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 NoteCollection(IContainer container)
        {
            _container = container;
            #if DEBUG
            var file = new FileInfo(@"..\..\notes.xml");
            #else
            var file = new FileInfo("notes.xml");
            #endif

            _document = file.Exists
                            ? XDocument.Load(file.FullName)
                            : new XDocument(new XElement("notes"));

            _children = _document
                .Elements("notes")
                .Single()
                .Elements("note")
                .Select(noteElement => (object) _container.Get<NoteItem>(noteElement))
                .ToArray();
        }