C# IComponentContext.Resolve方法代码示例

        static RequestContext RequestContextFactory(IComponentContext context)
        {
            var httpContextAccessor = context.Resolve<IHttpContextAccessor>();
            var httpContext = httpContextAccessor.Current();
            if (httpContext != null)
            {

                var mvcHandler = httpContext.Handler as MvcHandler;
                if (mvcHandler != null)
                {
                    return mvcHandler.RequestContext;
                }

                var hasRequestContext = httpContext.Handler as IHasRequestContext;
                if (hasRequestContext != null)
                {
                    if (hasRequestContext.RequestContext != null)
                        return hasRequestContext.RequestContext;
                }
            }
            else
            {
                httpContext = HttpContextBaseFactory(context);
            }

            return new RequestContext(httpContext, new RouteData());
        }

 public static BusBuilderConfiguration WithAutofacDefaults(this BusBuilderConfiguration configuration, IComponentContext componentContext)
 {
     return configuration
         .WithTypesFrom(componentContext.Resolve<ITypeProvider>())
         .WithDependencyResolver(componentContext.Resolve<IDependencyResolver>())
         ;
 }

        internal void Start(IComponentContext context)
        {
            var engine = context.Resolve<ClientEngine>();
            var dhtListner = context.Resolve<DhtListener>();
            var dht = context.Resolve<IDhtEngine>();
            var settingsUtility = context.Resolve<ISettingsUtility>();

            var port = settingsUtility.Read(ApplicationConstants.TorrentPortKey,
                   ApplicationConstants.DefaultTorrentPort);

          OpenPort(port);

            // register the dht engine
            engine.RegisterDht(dht);

            // start the dht listener
            dhtListner.Start();

            // annnnnddd start the dht engine
            engine.DhtEngine.Start();
            
            // clear up torrent folder
            Task.Factory.StartNew(async () =>
            {
                var torrentsFolder = engine.Settings.SaveFolder;
                await StorageHelper.DeleteFolderContentAsync(torrentsFolder);
            });
        }

 private static ITwitterFeed OnStartupExtracted(IComponentContext ctx, bool useTwitter)
 {
     if (useTwitter)
         return ctx.Resolve<TwitterFeedAsync>();
     else
         return ctx.Resolve<FakeTwitterFeed>();
 }

 public AgencyBanks(IComponentContext container)
 {
         this.iContainer = container;
         queueConfiguration = iContainer.Resolve<IQueueConfiguration>();
         publisher = iContainer.Resolve<IExchangePublisher<Job>>();
         publisher.Declare(queueConfiguration.ResponseExchangeName);
 }

        private static ISessionFactory ConfigureSessionFactory(IComponentContext context)
        {
            var connectionStringProvider = context.Resolve<IConnectionStringProvider>();
            EntryMapping.CurrentSchema = connectionStringProvider.Schema;
            var databaseProvider = context.ResolveNamed<IDatabaseProvider>(connectionStringProvider.DatabaseProvider.ToLower());

            var databaseConfiguration = databaseProvider.GetDatabaseConfiguration(connectionStringProvider);
            var configuration =
                Fluently
                    .Configure()
                    .Database(databaseConfiguration)
                    .Mappings(m =>
                                  {
                                      m.FluentMappings.AddFromAssembly(System.Reflection.Assembly.GetExecutingAssembly());

                                      //Scan extensions for nHibernate mappings
                                      var extension = context.Resolve<IEnumerable<ScriptedExtension>>();
                                      foreach (var assembly in extension.Select(provider => provider.SourceAssembly))
                                      {
                                          m.FluentMappings.AddFromAssembly(assembly);
                                      }
                                  })
                    .ProxyFactoryFactory(typeof (DefaultProxyFactoryFactory));

            return configuration.BuildSessionFactory();
        }

 private static IServiceRunner CreateRunner(RunMode mode, IComponentContext c)
 {
     if (mode == RunMode.Console)
     {
         return c.Resolve<ConsoleRunner>();
     }
     return c.Resolve<ServiceRunner>();
 }

 static RuntimeProviders RuntimeProviders(IComponentContext c)
 {
     return CloudStorage
         .ForAzureAccount(c.Resolve<CloudStorageAccount>())
         .WithObserver(c.Resolve<ICloudStorageObserver>())
         .WithRuntimeFinalizer(c.ResolveOptional<IRuntimeFinalizer>())
         .BuildRuntimeProviders(c.ResolveOptional<ILog>());
 }

 protected virtual ITransportMessages BuildTransport(IComponentContext c)
 {
     var threadSafeContext = c.Resolve<IComponentContext>();
     return new MessageQueueTransport(
         () => threadSafeContext.Resolve<IReceiveMessages>(),
         c.Resolve<ISendToEndpoints>(),
         this.maxThreads);
 }

 protected virtual IReceiveMessages BuildMessageReceiver(IComponentContext c)
 {
     var threadSafeContext = c.Resolve<IComponentContext>();
     return new MessageReceiverWorkerThread(
         c.Resolve<IReceiveFromEndpoints>(),
         () => threadSafeContext.Resolve<IRouteMessagesToHandlers>(),
         action => new BackgroundThread(() => action()));
 }

 static IQueueStorageProvider QueueStorageProvider(IComponentContext c)
 {
     return CloudStorage
         .ForAzureAccount(c.Resolve<CloudStorageAccount>())
         .WithDataSerializer(c.Resolve<IDataSerializer>())
         .WithObserver(c.Resolve<IStorageObserver>())
         .BuildQueueStorage();
 }

 public static BusBuilderConfiguration WithAutofacDefaults(this BusBuilderConfiguration configuration, IComponentContext componentContext)
 {
     return configuration
         .WithMulticastEventBroker(componentContext.Resolve<IMulticastEventBroker>())
         .WithCompetingEventBroker(componentContext.Resolve<ICompetingEventBroker>())
         .WithCommandBroker(componentContext.Resolve<ICommandBroker>())
         .WithRequestBroker(componentContext.Resolve<IRequestBroker>())
         .WithLogger(componentContext.Resolve<ILogger>());
 }

 static IBlobStorageProvider BlobStorageProvider(IComponentContext c)
 {
     return CloudStorage
         .ForAzureAccount(c.Resolve<CloudStorageAccount>())
         .WithDataSerializer(c.Resolve<IDataSerializer>())
         .WithObserver(c.Resolve<ICloudStorageObserver>())
         .WithRuntimeFinalizer(c.ResolveOptional<IRuntimeFinalizer>())
         .BuildBlobStorage();
 }

        IMessageSender BuildDefaultMessageSender(IComponentContext c)
        {
            var observer = c.Resolve<ISystemObserver>();
            var registry = c.Resolve<QueueWriterRegistry>();

            var factory = registry.GetOrAdd(_endpoint, s => _construct(c, s));
            var queues = _queueNames.Select(factory.GetWriteQueue).ToArray();
            return new DefaultMessageSender(queues, observer, _keyGenerator);
        }

		public ResGroup(IResourceManager resourceManager, IResourceFile resourceFile, IComponentContext context)
		{
			this.resourceManager = resourceManager;
			this.resourceFile = resourceFile;
			this.context = context;

			//TODO: make public properties read-only
			this.externalResources = context.Resolve<IList<IResourceFile>>();
			this.embeddedResources = context.Resolve<IList<Managed>>();
		}