C# IServiceLocator.Resolve方法代码示例

 public HttpServer(ILogFactory logFactory, IServiceLocator locator)
 {
     Logger = logFactory.Create("Http server");
     Listener = new HttpListener();
     Listener.IgnoreWriteExceptions = true;
     foreach (string key in ConfigurationManager.AppSettings.Keys)
     {
         if (key.StartsWith("HttpAddress", StringComparison.InvariantCultureIgnoreCase))
             Listener.Prefixes.Add(ConfigurationManager.AppSettings[key]);
     }
     if (Listener.Prefixes.Count == 0)
     {
         Listener.Prefixes.Add("http://*:80/");
         Listener.Prefixes.Add("https://*:443/");
     }
     Routes = new Routes(locator);
     var customAuth = ConfigurationManager.AppSettings["CustomAuth"];
     if (!string.IsNullOrEmpty(customAuth))
     {
         var authType = Type.GetType(customAuth);
         if (!typeof(HttpAuth).IsAssignableFrom(authType))
             throw new ConfigurationErrorsException("Custom auth does not inherit from HttpAuth. Please inherit from " + typeof(HttpAuth).FullName);
         Authentication = locator.Resolve<HttpAuth>(authType);
     }
     else Authentication = locator.Resolve<HttpAuth>();
 }

        public MailService(IServiceLocator locator)
        {
            Contract.Requires(locator != null);

            this.Serialization = locator.Resolve<ISerialization<byte[]>>();
            this.Repository = locator.Resolve<Func<string, IMailMessage>>();
        }

 protected static void VerifyContainer(IServiceLocator serviceLocator, int expected)
 {
     Assert.That(serviceLocator.Resolve(typeof(EventStore)), Is.Not.Null);
     var array = serviceLocator.ResolveAll(typeof(IEventHandler<AggregateChanged>));
     Assert.That(array, Is.Not.Null);
     Assert.That(array.Length, Is.EqualTo(expected));
     if (expected == 1)
         Assert.That(serviceLocator.Resolve(typeof(IEventHandler<AggregateChanged>)), Is.Not.Null);
 }

 internal ILGeneratorInstructionVisitor(
         IServiceLocator serviceLocator,
         IILGenerator generator,
         IDictionary<VariableReference, LocalBuilder> locals)
     : this(serviceLocator,
         generator,
         locals,
         serviceLocator.Resolve<ITypeResolver>(),
         serviceLocator.Resolve<IOpCodeMapper>())
 {
 }

        private void RegisterMsmqOneWay(AbstractRhinoServiceBusConfiguration c, IBusContainerBuilder b, IServiceLocator l)
        {
            var oneWayConfig = (OnewayRhinoServiceBusConfiguration)c;

            b.RegisterSingleton<IMessageBuilder<Message>>(() => (IMessageBuilder<Message>)new MsmqMessageBuilder(
                l.Resolve<IMessageSerializer>(),
                l.Resolve<IServiceLocator>()));

            b.RegisterSingleton<IOnewayBus>(() => (IOnewayBus)new MsmqOnewayBus(
                oneWayConfig.MessageOwners,
                l.Resolve<IMessageBuilder<Message>>(),oneWayConfig.ConfigurationSection.Bus.UseDeadLetterQueue));
        }

        private static IMenuRegistry GetMenuRegistryOrRegisterDefaultInstance(IServiceLocator serviceLocator)
        {
            try
            {
                return serviceLocator.Resolve<IMenuRegistry>();
            }
            catch(ServiceResolutionException)
            {
                serviceLocator.Register<IMenuRegistry>(new MenuRegistry());
            }

            return serviceLocator.Resolve<IMenuRegistry>();
        }

		private void RegisterSqlQueuesTransport(AbstractRhinoServiceBusConfiguration c, IBusContainerBuilder b, IServiceLocator l)
		{
			var busConfig = c.ConfigurationSection.Bus;

			b.RegisterSingleton<IStorage>(() => new SqlStorage(busConfig.Path ?? QueueConnectionStringContainer.ConnectionString));

			b.RegisterSingleton<ISubscriptionStorage>(() => new GenericSubscriptionStorage(
			                                                	l.Resolve<IStorage>(),
			                                                	c.Endpoint.ToString(),
			                                                	l.Resolve<IMessageSerializer>(),
			                                                	l.Resolve<IReflection>()));

			b.RegisterSingleton<ITransport>(() => new SqlQueuesTransport(
			                                      	c.Endpoint,
			                                      	l.Resolve<IEndpointRouter>(),
			                                      	l.Resolve<IMessageSerializer>(),
			                                      	c.ThreadCount,
													busConfig.Path ?? QueueConnectionStringContainer.ConnectionString,
			                                      	c.NumberOfRetries,
			                                      	l.Resolve<IMessageBuilder<MessagePayload>>()));

			b.RegisterSingleton<IMessageBuilder<MessagePayload>>(() => new SqlQueuesMessageBuilder(
			                                                           	l.Resolve<IMessageSerializer>(),
			                                                           	l.Resolve<IServiceLocator>()));
		}

		private void RegisterSqlQueuesOneWay(AbstractRhinoServiceBusConfiguration c, IBusContainerBuilder b, IServiceLocator l)
		{
			var oneWayConfig = (OnewayRhinoServiceBusConfiguration)c;
			var busConfig = c.ConfigurationSection.Bus;

			b.RegisterSingleton<IMessageBuilder<MessagePayload>>(() => new SqlQueuesMessageBuilder(
				l.Resolve<IMessageSerializer>(),
				l.Resolve<IServiceLocator>()));

			b.RegisterSingleton<IOnewayBus>(() => new SqlQueuesOneWayBus(
				oneWayConfig.MessageOwners,
				l.Resolve<IMessageSerializer>(),
				busConfig.Path ?? QueueConnectionStringContainer.ConnectionString,
				l.Resolve<IMessageBuilder<MessagePayload>>()));
		}

        private void RegisterRhinoQueuesOneWay(AbstractRhinoServiceBusConfiguration c, IBusContainerBuilder b, IServiceLocator l)
        {
            var oneWayConfig = (OnewayRhinoServiceBusConfiguration)c;
            var busConfig = c.ConfigurationSection.Bus;

            b.RegisterSingleton<IMessageBuilder<MessagePayload>>(() => (IMessageBuilder<MessagePayload>)new RhinoQueuesMessageBuilder(
                l.Resolve<IMessageSerializer>(),
                l.Resolve<IServiceLocator>()));

            b.RegisterSingleton<IOnewayBus>(() => (IOnewayBus)new RhinoQueuesOneWayBus(
                oneWayConfig.MessageOwners,
                l.Resolve<IMessageSerializer>(),
                busConfig.QueuePath,
                busConfig.EnablePerformanceCounters,
                l.Resolve<IMessageBuilder<MessagePayload>>()));
        }

 public static ITypeCatalog GetTypeCatalog(IServiceLocator serviceLocator)
 {
     var typeCatalog = serviceLocator.Resolve<ITypeCatalog>();
     if (typeCatalog != null)
     {
         return typeCatalog;
     }
     var assemblies = serviceLocator.Resolve<List<Assembly>>();
     if (assemblies == null || assemblies.Count < 1)
     {
         assemblies = AppDomain.CurrentDomain.GetAssemblies().ToList();
     }
     serviceLocator.RegisterInstance(assemblies);
     typeCatalog = new AppDomainTypeCatalog(assemblies);
     serviceLocator.Register(() => typeCatalog);
     return typeCatalog;
 }

 /// <summary>
 /// Gets the <see cref="IEmbeddedViewResolver"/> resolver for the system.
 /// </summary>
 /// <param name="serviceLocator"></param>
 /// <returns></returns>
 protected virtual IEmbeddedViewResolver GetEmbeddedViewResolver(IServiceLocator serviceLocator) {
     try {
         return serviceLocator.Resolve<IEmbeddedViewResolver>();
     }
     catch {
         return new EmbeddedViewResolver();
     }
 }

        private void RegisterRhinoQueuesTransport(AbstractRhinoServiceBusConfiguration c, IBusContainerBuilder b, IServiceLocator l)
        {
            var busConfig = c.ConfigurationSection.Bus;
            var fileManagerConfiguration = new QueueManagerConfiguration();

            b.RegisterSingleton<ISubscriptionStorage>(() => (ISubscriptionStorage)new FileSubscriptionStorage(
                busConfig.SubscriptionPath,
                l.Resolve<IMessageSerializer>(),
                l.Resolve<IReflection>()));

            b.RegisterSingleton<ITransport>(() => (ITransport)new RhinoFilesTransport(
                c.Endpoint,
                l.Resolve<IEndpointRouter>(),
                l.Resolve<IMessageSerializer>(),
                c.ThreadCount,
                busConfig.QueuePath,
                c.IsolationLevel,
                c.NumberOfRetries,
                busConfig.EnablePerformanceCounters,
                l.Resolve<IMessageBuilder<MessagePayload>>(),
                fileManagerConfiguration));

            b.RegisterSingleton<IMessageBuilder<MessagePayload>>(() => (IMessageBuilder<MessagePayload>)new RhinoFilesMessageBuilder(
                l.Resolve<IMessageSerializer>(),
                l.Resolve<IServiceLocator>()));

            b.RegisterSingleton<QueueManagerConfiguration>(() => fileManagerConfiguration);
        }

        protected virtual void RegisterViewEngine(IServiceLocator locator) {
            try {
                var engineManager = locator.Resolve<IViewEngineManager>();
                if (engineManager == null) return;

                engineManager.RegisterEngines();
            }
            catch { }           
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="locator"></param>
        /// <param name="resetEvent">invoked after all region defined</param>
        public MainWindow(IServiceLocator locator, ManualResetEvent resetEvent)
        {
            _locator = locator;
            InitializeComponent();

            var regionManager = locator.Resolve<RegionManager>();

            regionManager.AttachRegion("mainTab", OurTabcontrol);
            resetEvent.Set();
        }

        public void Register(IServiceLocator locator)
        {
            locator.Register<IAdminAccountRepository, AdminAccountRepository>();
            locator.Register<IAdminAccountListPageViewModelMapper, AdminAccountListPageViewModelMapper>();
            locator.Register<IAdminAccountEditFormStore, AdminAccountEditFormStore>();
            locator.Register<IAdminAccountIdGenerator, AdminAccountIdGenerator>();

            locator.Register<IDatabaseRetriever>(() =>
                                                     {
                                                         var adminAccountSettings = locator.Resolve<IAdminAccountSettings>();
                                                         return new DatabaseRetriever(adminAccountSettings.ConnectionString);
                                                     });

            locator.Register<IPasswordHasher>(() =>
                                                  {
                                                      var adminAccountSettings = locator.Resolve<IAdminAccountSettings>();
                                                      return new PasswordHasher(adminAccountSettings);
                                                  });
        }