/// <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();
}
/// <summary>
/// Stores the bus instance
/// </summary>
public void SetBus(IBus bus)
{
_kernel.Bind <IBus>().ToConstant(bus);
_kernel.Bind <IMessageContext>().ToMethod(c =>
{
var currentMessageContext = MessageContext.Current;
if (currentMessageContext == null)
{
throw new InvalidOperationException(
"Attempted to inject the current message context from MessageContext.Current, but it was null! Did you attempt to resolve IMessageContext from outside of a Rebus message handler?");
}
return(currentMessageContext);
});
ResolutionExtensions.Get <IBus>(_kernel);
}
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);
}
public void Execute()
{
NinjectTaskScopeObject ninjectTaskScopeObject = new NinjectTaskScopeObject();
#if NET
CallContext.SetData(NinjectExtensionInTaskScope.InTaskScopeName, ninjectTaskScopeObject);
#endif
try
{
lock (lockObject)
{
ResolutionExtensions.Get <ITask>(this.kernel, this.taskName, new IParameter[0]).Execute();
}
}
finally
{
ninjectTaskScopeObject.Dispose();
#if NET
CallContext.FreeNamedDataSlot(NinjectExtensionInTaskScope.InTaskScopeName);
#endif
}
}
void ThreadWorks(UpdaterFlags flags, ILifetimeScope threadScope)
{
string checkVersion = String.Empty, checkResult = String.Empty;
var application = threadScope.Resolve <IApplicationInfo>();
dynamic parametersService = ResolutionExtensions.ResolveOptional <ParametersService>(threadScope);
var updateService = threadScope.Resolve <IUpdateService>();
var skip = threadScope.Resolve <ISkipVersionState>();
var uI = threadScope.Resolve <IUpdaterUI>();
try {
logger.Info("Запрашиваем информацию о новых версиях с сервера");
string parameters = String.Format("product.{0};edition.{1};serial.{2};major.{3};minor.{4};build.{5};revision.{6}",
application.ProductName,
application.Modification,
parametersService?.serial_number,
application.Version.Major,
application.Version.Minor,
application.Version.Build,
application.Version.Revision);
var updateResult = updateService.checkForUpdate(parameters);
if (flags.HasFlag(UpdaterFlags.ShowAnyway) || (updateResult.HasUpdate && !skip.IsSkipedVersion(updateResult.NewVersion)))
{
uI.ShowAppNewVersionDialog(updateResult, flags);
}
}
catch (Exception ex) {
logger.Error(ex, "Ошибка доступа к серверу обновления.");
if (flags.HasFlag(UpdaterFlags.ShowAnyway))
{
uI.InteractiveMessage.ShowMessage(Dialog.ImportanceLevel.Error, "Не удалось подключиться к серверу обновлений.\nПожалуйста, повторите попытку позже.");
}
if (flags.HasFlag(UpdaterFlags.UpdateRequired))
{
Environment.Exit(1);
}
}
}
/// <summary>
/// Stores the bus instance
/// </summary>
public void SetBus(IBus bus)
{
if (_kernel.CanResolve(typeof(IBus)))
{
throw new InvalidOperationException("Cannot register IBus because it has already been registered. If you want to host multiple Rebus instances in a single process, please use separate container instances for them.");
}
_kernel.Bind <IBus>().ToConstant(bus);
_kernel.Bind <ISyncBus>().ToMethod(c => bus.Advanced.SyncBus);
_kernel.Bind <IMessageContext>().ToMethod(c =>
{
var currentMessageContext = MessageContext.Current;
if (currentMessageContext == null)
{
throw new InvalidOperationException(
"Attempted to inject the current message context from MessageContext.Current, but it was null! Did you attempt to resolve IMessageContext from outside of a Rebus message handler?");
}
return(currentMessageContext);
});
ResolutionExtensions.Get <IBus>(_kernel);
}
protected T Resolve <T>(string name)
{
return(ResolutionExtensions.ResolveNamed <T>(this.Container, name));
}
protected T Resolve <T>()
{
return(ResolutionExtensions.Resolve <T>(this.Container));
}
protected sealed override void BuildUp(object instance)
{
ResolutionExtensions.InjectProperties <object>(this.Container, instance);
}
/// <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 object TryGet(Type type, params IParameter[] parameters)
{
return(ResolutionExtensions.Get(Kernel, type, parameters));
}
public static object TryGet(Type type)
{
return(ResolutionExtensions.Get(Kernel, type, Array.Empty <IParameter>()));
}
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();
}
public IBus ResolveBus()
{
return(ResolutionExtensions.Get <IBus>(_kernel));
}
public T Resolve <T>()
{
ResolutionExtensions.Resolve <T>(AutofacContainer);
return(ResolutionExtensions.Resolve <T>(AutofacContainer));
}
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();
}
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)));
}
private void ConfigureJournal()
{
ViewModel.DataLoader.ItemsListUpdated += ViewModel_ItemsListUpdated;
ViewModel.DataLoader.LoadingStateChanged += DataLoader_LoadingStateChanged;
ViewModel.DataLoader.TotalCountChanged += DataLoader_TotalCountChanged;
if (ThrowExceptionOnDataLoad)
{
ViewModel.DataLoader.LoadError += DataLoader_LoadError;
}
checkShowFilter.Clicked += (sender, e) => { hboxFilter.Visible = checkShowFilter.Active; };
buttonRefresh.Clicked += (sender, e) => { ViewModel.Refresh(); };
tableview.ButtonReleaseEvent += Tableview_ButtonReleaseEvent;
tableview.Selection.Changed += Selection_Changed;
SetSeletionMode(ViewModel.SelectionMode);
ConfigureActions();
//FIXME Этот код только для водовоза
var filterProp = ViewModel.GetType().GetProperty("Filter");
if (DialogHelper.FilterWidgetResolver != null && filterProp != null && filterProp.GetValue(ViewModel) is IJournalFilter filter)
{
Widget filterWidget = DialogHelper.FilterWidgetResolver.Resolve(filter);
FilterView = filterWidget;
hboxFilter.Add(filterWidget);
filterWidget.Show();
checkShowFilter.Visible = true;
checkShowFilter.Active = hboxFilter.Visible = !filter.HidenByDefault;
}
if (ViewModel.JournalFilter is ViewModelBase filterViewModel)
{
var viewResolver = ViewModel.AutofacScope.Resolve <IGtkViewResolver>();
FilterView = viewResolver.Resolve(filterViewModel);
if (FilterView == null)
{
throw new InvalidOperationException($"Не найдена View для {filterViewModel.GetType()}");
}
hboxFilter.Add(FilterView);
FilterView.Show();
checkShowFilter.Visible = true;
checkShowFilter.Active = hboxFilter.Visible = ViewModel.JournalFilter.IsShow;
ViewModel.JournalFilter.PropertyChanged += JournalFilter_PropertyChanged;
}
Widget searchView = ViewModel.AutofacScope != null?ResolutionExtensions.ResolveOptionalNamed <Widget>(ViewModel.AutofacScope, "GtkJournalSearchView", new TypedParameter(typeof(SearchViewModel), ViewModel.Search)) : null;
//FIXME В будущем надо бы наверно полностью отказаться от создания SearchView здесь в ручную.
if (searchView == null)
{
searchView = new SearchView((SearchViewModel)ViewModel.Search);
}
hboxSearch.Add(searchView);
searchView.Show();
tableview.ColumnsConfig = TreeViewColumnsConfigFactory.Resolve(ViewModel);
GtkScrolledWindow.Vadjustment.ValueChanged += Vadjustment_ValueChanged;
tableview.ItemsDataSource = ViewModel.Items;
ViewModel.Refresh();
UpdateButtons();
SetTotalLableText();
ViewModel.PropertyChanged += OnViewModelPropertyChanged;
ViewModel.UpdateJournalActions += UpdateButtons;
}
internal IVpnServiceManager <Load> b__0_0(IComponentContext ctx, IVpnServiceManager inner)
{
return(new VpnServiceManagerLoggingDecorator(inner, ResolutionExtensions.Resolve <ILogger>(ctx)));
}
/// <summary>
/// 按名称获取组件
/// </summary>
/// <typeparam name="TService">组件类型</typeparam>
/// <param name="serviceName">组件名称</param>
/// <returns>返回获取的组件</returns>
public static TService ResolveNamed <TService>(string serviceName)
{
return(ResolutionExtensions.ResolveNamed <TService>(_container, serviceName));
}
/// <summary>
/// 按参数获取组件
/// </summary>
/// <typeparam name="TService">组件类型</typeparam>
/// <returns>返回获取的组件</returns>
public static TService Resolve <TService>()
{
return(ResolutionExtensions.Resolve <TService>(_container));
}
public override object GetService(Type serviceType)
{
return(ResolutionExtensions.ResolveOptional(this.lifetimeScope, serviceType) ?? base.GetService(serviceType));
}
public static T TryGet <T>()
{
return(ResolutionExtensions.TryGet <T>(Kernel, Array.Empty <IParameter>()));
}
public static T TryGet <T>(params IParameter[] parameters)
{
return(ResolutionExtensions.Get <T>(Kernel, parameters));
}
protected override IEnumerable <object> DoGetAllInstances(Type serviceType)
{
return(ResolutionExtensions.GetAll((IResolutionRoot)this.Kernel, serviceType, new IParameter[0]));
}
/// <summary>
/// 按key获取组件
/// </summary>
/// <typeparam name="TService">组件类型</typeparam>
/// <param name="serviceKey">枚举类型的Key</param>
/// <returns>返回获取的组件</returns>
public static TService ResolveKeyed <TService>(object serviceKey)
{
return(ResolutionExtensions.ResolveKeyed <TService>(_container, serviceKey));
}
