public static T GetService <T>(string name, object obj)
{
return(ResolutionExtensions.Resolve <T>(AutofacManage.container, new Parameter[]
{
new NamedParameter(name, obj)
}));
}
private static void Main()
{
var conf = new Configuration(ExecutionEnvironment.Test);
BootStrapDependencies(conf);
HostFactory.Run(x =>
{
RunAsExtensions.RunAs(x, conf.ServiceUserName, conf.ServiceUserPasswordEncrypted);
x.SetDescription("Calculates and provides calendar and product info data.");
StartModeExtensions.StartManually(x);
x.SetDisplayName(conf.ServiceDisplayName);
x.SetServiceName(conf.ServiceName);
ServiceExtensions.Service <PricingService>(x, s =>
{
s.ConstructUsing(
name =>
new PricingService(ResolutionExtensions.Resolve <Configuration>(Container)));
ServiceConfiguratorExtensions.WhenStarted <PricingService>(s, tc => tc.OnStart());
ServiceConfiguratorExtensions.WhenStopped <PricingService>(s, tc => tc.OnStop());
ServiceConfiguratorExtensions.WhenShutdown <PricingService>(s, tc => tc.OnStop());
});
InstallHostConfiguratorExtensions.BeforeInstall(x, () => NetShellCmdLineTool.RegisterHttpNamespace(conf));
UninstallHostConfiguratorExtensions.AfterUninstall(x, () => NetShellCmdLineTool.UnregisterHttpNamespace(conf));
});
}
protected sealed override IEnumerable <object> GetAllInstances(Type service)
{
return(ResolutionExtensions.Resolve(this.Container, typeof(IEnumerable <>).MakeGenericType(new Type[]
{
service
})) as IEnumerable <object>);
}
public static Registration <T> CreateRegistration <T>(RegistrationContext context, Func <ILifetimeScope, T> resolveWithLifetimeScopeFunc = null, Func <IOwinContext, T> resolveWithOwinContextFunc = null, string name = null) where T : class
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var mode = context.ConvertMode();
if (mode == RegistrationMode.Singleton)
{
// ReSharper disable once PossibleNullReferenceException
return new Registration <T>(ResolutionExtensions.Resolve <T>((IComponentContext)context.SingletonLifetimeScope), name)
{
Mode = RegistrationMode.Singleton
}
}
;
return(new Registration <T>(
dr => dr.ResolveUsingAutofac <T>(resolveWithLifetimeScopeFunc, resolveWithOwinContextFunc))
{
Mode = mode
});
}
/// <summary>
/// Resolves all requested service instances.
///
/// </summary>
/// <param name="serviceType">Type of instance requested.</param>
/// <returns>
/// Sequence of service instance objects.
/// </returns>
/// <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="serviceType"/> is <see langword="null"/>.
/// </exception>
protected override IEnumerable <object> DoGetAllInstances(Type serviceType)
{
if (serviceType == null)
{
throw new ArgumentNullException("serviceType");
}
return(Enumerable.Cast <object>((IEnumerable)ResolutionExtensions.Resolve(this._container, typeof(IEnumerable <>).MakeGenericType(serviceType))));
}
protected sealed override object GetInstance(Type service, string key)
{
if (key != null)
{
return(ResolutionExtensions.ResolveNamed(this.Container, key, service));
}
return(ResolutionExtensions.Resolve(this.Container, service));
}
public override IEnumerable <object> GetServices(Type serviceType)
{
var enumServiceType = typeof(IEnumerable <>).MakeGenericType(new Type[] { serviceType });
var instance = ResolutionExtensions.Resolve(this.lifetimeScope, enumServiceType) as IEnumerable <object>;
if (!instance.Any())
{
return(base.GetServices(serviceType));
}
return(instance);
}
/// <summary>
/// Resolves the requested service instance.
///
/// </summary>
/// <param name="serviceType">Type of instance requested.</param><param name="key">Name of registered service you want. May be <see langword="null"/>.</param>
/// <returns>
/// The requested service instance.
/// </returns>
/// <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="serviceType"/> is <see langword="null"/>.
/// </exception>
protected override object DoGetInstance(Type serviceType, string key)
{
if (serviceType == null)
{
throw new ArgumentNullException("serviceType");
}
if (key == null)
{
return(ResolutionExtensions.Resolve(this._container, serviceType));
}
return(ResolutionExtensions.ResolveNamed(this._container, key, serviceType));
}
private ISolrCoreAdmin BuildCoreAdmin()
{
SolrConnection solrConnection = new SolrConnection(SolrContentSearchManager.ServiceAddress);
int timeout;
int.TryParse(Settings.GetSetting("SolrConnectionTimeout", "200000"), out timeout);
solrConnection.Timeout = timeout;
if (SolrContentSearchManager.EnableHttpCache)
{
solrConnection.Cache = ResolutionExtensions.Resolve <ISolrCache>((IComponentContext)this.container) ?? (ISolrCache) new NullCache();
}
return((ISolrCoreAdmin) new SolrCoreAdmin((ISolrConnection)solrConnection, ResolutionExtensions.Resolve <ISolrHeaderResponseParser>((IComponentContext)this.container), ResolutionExtensions.Resolve <ISolrStatusResponseParser>((IComponentContext)this.container)));
}
/// <summary>
/// 获取InstancePerHttpRequest的组件
/// </summary>
/// <typeparam name="TService">组件类型</typeparam>
/// <returns></returns>
public static TService ResolvePerHttpRequest <TService>()
{
IDependencyResolver current = DependencyResolver.Current;
if (current != null)
{
TService service = (TService)current.GetService(typeof(TService));
if (service != null)
{
return(service);
}
}
return(ResolutionExtensions.Resolve <TService>(_container));
}
public static void Initialize()
{
var containerBuilder = new ContainerBuilder();
RegistrationExtensions.RegisterType <TaskEvaluator>(containerBuilder);
RegistrationExtensions.RegisterType <TaskTimer>(containerBuilder);
var directoryCatalog = new DirectoryCatalog(Environment.CurrentDirectory);
RegistrationExtensions.RegisterComposablePartCatalog(containerBuilder, (ComposablePartCatalog)directoryCatalog, new Service[1]
{
(Service) new TypedService(typeof(ITask))
});
((IRegistrationBuilder <IEnumerable <TaskInfo>, SimpleActivatorData, SingleRegistrationStyle>)RegistrationExtensions.Register <IEnumerable <TaskInfo> >(containerBuilder, (Func <IComponentContext, M0>)(c => Enumerable.Select <Export, TaskInfo>(RegistrationExtensions.ResolveExports <ITask>((IComponentContext)ResolutionExtensions.Resolve <IComponentContext>(c)), (Func <Export, TaskInfo>)(e => new TaskInfo(TimeSpan.FromMilliseconds((double)(int)e.Metadata["MinInterval"]), (string)e.Metadata["Name"], (Func <ITask>)(() => (ITask)e.Value))))))).As <IEnumerable <TaskInfo> >();
using (IContainer icontainer = containerBuilder.Build((ContainerBuildOptions)0))
((TaskTimer)ResolutionExtensions.Resolve <TaskTimer>((IComponentContext)icontainer)).Run();
}
public static void Initialize()
{
ContainerBuilder builder = new ContainerBuilder();
Autofac.RegistrationExtensions.RegisterType <TaskEvaluator>(builder);
Autofac.RegistrationExtensions.RegisterType <TaskTimer>(builder);
DirectoryCatalog directoryCatalog = new DirectoryCatalog(Environment.CurrentDirectory);
Autofac.Integration.Mef.RegistrationExtensions.RegisterComposablePartCatalog(builder, (ComposablePartCatalog)directoryCatalog, new Service[1]
{
(Service) new TypedService((Type)typeof(ITask))
});
Autofac.RegistrationExtensions.Register <IEnumerable <TaskInfo> >(builder, (Func <IComponentContext, IEnumerable <TaskInfo> >)(c => Enumerable.Select <Export, TaskInfo>(Autofac.Integration.Mef.RegistrationExtensions.ResolveExports <ITask>(ResolutionExtensions.Resolve <IComponentContext>(c)), (Func <Export, TaskInfo>)(e => new TaskInfo(TimeSpan.FromMilliseconds((double)(int)e.Metadata["MinInterval"]), (string)e.Metadata["Name"], (Func <ITask>)(() => (ITask)e.Value)))))).As <IEnumerable <TaskInfo> >();
using (IContainer container = builder.Build(ContainerBuildOptions.None))
ResolutionExtensions.Resolve <TaskTimer>((IComponentContext)container).Run();
}
public static T GetService <T>(IDictionary <string, object> dict)
{
if (dict == null || dict.Count == 0)
{
return(AutofacManage.GetService <T>());
}
NamedParameter[] array = new NamedParameter[dict.Count];
int num = 0;
foreach (KeyValuePair <string, object> current in dict)
{
array[num++] = new NamedParameter(current.Key, current.Value);
}
IComponentContext _contain = AutofacManage.container;
Parameter[] paramer = array;
return(ResolutionExtensions.Resolve <T>(_contain, paramer));
}
public static Registration <T> CreateRegistration <T>(Func <ILifetimeScope, T> resolveWithLifetimeScopeFunc = null, Func <IOwinContext, T> resolveWithOwinContextFunc = null, string name = null, IContainer container = null, RegistrationContext context = null, bool checkForMiddleware = true) where T : class
{
var mode = context?.ConvertMode() ?? RegistrationMode.InstancePerUse; // play it safe with InstancePerUse
if (mode == RegistrationMode.Singleton)
{
// ReSharper disable once PossibleNullReferenceException
return new Registration <T>(ResolutionExtensions.Resolve <T>((IComponentContext)context.SingletonLifetimeScope), name)
{
Mode = RegistrationMode.Singleton
}
}
;
return(new Registration <T>(
dr => dr.ResolveUsingAutofac <T>(resolveWithLifetimeScopeFunc, resolveWithOwinContextFunc, container ?? context?.Container, checkForMiddleware))
{
Mode = mode
});
}
private static void OnComponentActivated(object sender, ActivatedEventArgs <object> args)
{
if (args == null)
{
return;
}
IHandle handler;
if ((handler = (args.get_Instance() as IHandle)) == null)
{
return;
}
ILifetimeScope lifetimeScope = ResolutionExtensions.Resolve <ILifetimeScope>(args.get_Context());
IEventAggregator eventAggregator = ResolutionExtensions.Resolve <IEventAggregator>(lifetimeScope);
eventAggregator.Subscribe(handler);
EventAggregationAutoSubscriptionModule.DisposableAction disposableAction = new EventAggregationAutoSubscriptionModule.DisposableAction(delegate
{
eventAggregator.Unsubscribe(handler);
});
lifetimeScope.get_Disposer().AddInstanceForDisposal(disposableAction);
}
protected override void Load(ContainerBuilder builder)
{
RegistrationExtensions.Register(builder, c => new CustomWebDownloader()).As <IWebDownloader>().ExternallyOwned();
RegistrationExtensions.Register(builder, c => new HashtagIndependentInMemoryCrawlerHistoryService()).As <ICrawlerHistory>().InstancePerDependency();
RegistrationExtensions.Register(builder, c => new InMemoryCrawlerQueueService()).As <ICrawlerQueue>().InstancePerDependency();
RegistrationExtensions.Register(builder, c => new LogLoggerBridge(CreateLogger())).As <ILog>().InstancePerDependency();
RegistrationExtensions.Register(builder, c => new NativeTaskRunnerService()).As <ITaskRunner>().InstancePerDependency();
RegistrationExtensions.Register(builder, (c, p) => new RobotService(ParameterExtensions.TypedAs <IEnumerable <Uri> >(p), ResolutionExtensions.Resolve <IWebDownloader>(c))).As <IRobot>().InstancePerDependency();
RegistrationExtensions.Register(builder, (c, p) => new CrawlerRulesService(ParameterExtensions.TypedAs <Crawler>(p), ResolutionExtensions.Resolve <IRobot>(c, p), ParameterExtensions.TypedAs <IEnumerable <Uri> >(p))).As <ICrawlerRules>().InstancePerDependency();
}
private static T ResolveAllWithParameters <T>(IEnumerable <Parameter> parameters)
{
return(ResolutionExtensions.Resolve <T>(ServiceLocator._container, parameters));
}
protected T Resolve <T>()
{
return(ResolutionExtensions.Resolve <T>(this.Container));
}
public static object GetInstance(Type serviceType)
{
ServiceLocator.CheckReady();
return(ResolutionExtensions.Resolve(ServiceLocator._container, serviceType));
}
public static T GetService <T>()
{
return(ResolutionExtensions.Resolve <T>(AutofacManage.container));
}
/// <summary>
/// 按参数获取组件
/// </summary>
/// <typeparam name="TService">组件类型</typeparam>
/// <returns>返回获取的组件</returns>
public static TService Resolve <TService>()
{
return(ResolutionExtensions.Resolve <TService>(_container));
}
public void Initialize()
{
if (!SolrContentSearchManager.IsEnabled)
{
throw new InvalidOperationException("Solr configuration is not enabled. Please check your settings and include files.");
}
foreach (string coreId in SolrContentSearchManager.Cores)
{
this.AddCore(coreId, typeof(Dictionary <string, object>), string.Format("{0}/{1}", (object)SolrContentSearchManager.ServiceAddress, (object)coreId));
}
builder.RegisterModule((IModule) new SolrNetModule(this.Cores));
RegistrationExtensions.RegisterType <SolrFieldBoostingDictionarySerializer>(this.builder).As <ISolrDocumentSerializer <Dictionary <string, object> > >();
if (SolrContentSearchManager.EnableHttpCache)
{
RegistrationExtensions.RegisterType <HttpRuntimeCache>(this.builder).As <ISolrCache>();
foreach (SolrServerElement solrServerElement in (ConfigurationElementCollection)this.Cores)
{
((IRegistrationBuilder <object, ConcreteReflectionActivatorData, SingleRegistrationStyle>)RegistrationExtensions.WithParameters <object, ConcreteReflectionActivatorData, SingleRegistrationStyle>(RegistrationExtensions.RegisterType(this.builder, typeof(SolrConnection)).Named(solrServerElement.Id + (object)typeof(SolrConnection), typeof(ISolrConnection)), (IEnumerable <Parameter>) new NamedParameter[1]
{
new NamedParameter("serverURL", (object)solrServerElement.Url)
})).OnActivated((Action <IActivatedEventArgs <object> >)(args => ((SolrConnection)args.Instance).Cache = ResolutionExtensions.Resolve <ISolrCache>(args.Context)));
}
}
this.container = this.builder.Build(ContainerBuildOptions.None);
ServiceLocator.SetLocatorProvider((ServiceLocatorProvider)(() => (IServiceLocator) new AutofacServiceLocator((IComponentContext)this.container)));
SolrContentSearchManager.SolrAdmin = this.BuildCoreAdmin();
SolrContentSearchManager.Initialize();
}
/// <summary>
///
/// </summary>
/// <typeparam name="TService">组件类型</typeparam>
/// <param name="parameters">Autofac.Core.Parameter</param>
/// <returns>返回获取的组件</returns>
public static TService Resolve <TService>(params Parameter[] parameters)
{
return(ResolutionExtensions.Resolve <TService>(_container, parameters));
}
public static T GetInstance <T>(params object[] prms)
{
ServiceLocator.CheckReady();
return(ResolutionExtensions.Resolve <T>(ServiceLocator._container, from p in prms
select new TypedParameter(p.GetType(), p)));
}
public T Resolve <T>()
{
ResolutionExtensions.Resolve <T>(AutofacContainer);
return(ResolutionExtensions.Resolve <T>(AutofacContainer));
}
internal IVpnServiceManager <Load> b__0_0(IComponentContext ctx, IVpnServiceManager inner)
{
return(new VpnServiceManagerLoggingDecorator(inner, ResolutionExtensions.Resolve <ILogger>(ctx)));
}
public static T GetInstance <T>()
{
ServiceLocator.CheckReady();
return(ResolutionExtensions.Resolve <T>(ServiceLocator._container));
}
