public static bool TryResolveWithoutException <T>(this IComponentContext context, [NotNullWhen(returnValue: true)] out T?instance) where T : class { if (context == null) { throw new ArgumentNullException(nameof(context)); } instance = default(T); try { if (context.TryResolve(typeof(T), out object?component)) { instance = (T)component; return(true); } return(false); } catch (Exception e) { if (e is InvalidCastException || e is DependencyResolutionException) { return(false); } throw; } }
public async System.Threading.Tasks.Task DispatchAsync <T>(params T[] events) where T : IEvent { foreach (var @event in events) { if (@event == null) { throw new ArgumentNullException(nameof(@event), "Event can not be null."); } var eventType = @event.GetType(); var handlerType = typeof(IEventHandler <>).MakeGenericType(eventType); _componentContext.TryResolve(handlerType, out var handler); if (handler == null) { return; } var method = handler.GetType() .GetRuntimeMethods() .First(x => x.Name.Equals("HandleAsync")); await(System.Threading.Tasks.Task) ((dynamic)handler).HandleAsync(@event); } }
public (bool Successful, object Value) Resolve(IComponentContext context, InjectResolverParam param) { var type = param.Type; var attr = param.Attribute; var key = attr.Key; if (key != null) { if (context.TryResolveKeyed(key, type, out var value)) { return(true, value); } Assertion.IsTrue(!attr.Required, $"required inject type {type.Name} with key {key} not resolved."); return(false, null); } { if (context.TryResolve(type, out var value)) { return(true, value); } Assertion.IsTrue(!attr.Required, $"required inject type {type.Name} not resolved."); return(false, null); } }
//I need to find out how to get generic handler in Autofac public async Task DispatchAsync <T>(params T[] events) where T : IEvent { foreach (var @event in events) { if (@event == null) { throw new ArgumentNullException(nameof(@event), "Event can not be null."); } var eventType = @event.GetType(); var handlerType = typeof(IEventHandler <>).MakeGenericType(eventType); object handler; _context.TryResolve(handlerType, out handler); if (handler == null) { return; } //GetRuntimeMethods() works with .NET Core, otherwise simply use GetMethod() var method = handler.GetType() .GetMethods() .First(x => x.Name.Equals("HandleAsync")); await(Task) ((dynamic)handler).HandleAsync(@event); //var handler2 = _context.Resolve<IEventHandler<T>>(); //await handler.HandleAsync(@event); } }
/// <summary> /// 装配 /// </summary> /// <param name="classType"></param> /// <param name="type"></param> /// <param name="context"></param> /// <param name="typeDescription"></param> /// <returns></returns> /// <exception cref="DependencyResolutionException"></exception> private object Resolve(Type classType, Type type, IComponentContext context, string typeDescription) { object obj = null; if (!string.IsNullOrEmpty(this.Name)) { context.TryResolveKeyed(this.Name, type, out obj); } else { if (type.IsGenericEnumerableInterfaceType()) { var genericType = type.GenericTypeArguments[0]; if (genericType.FullName != null && genericType.FullName.StartsWith("System.Lazy`1")) { genericType = genericType.GenericTypeArguments[0]; } context.TryResolveKeyed("`1System.Collections.Generic.IEnumerable`1" + genericType.FullName, type, out obj); } else { context.TryResolve(type, out obj); } } if (obj == null && this.Required) { throw new DependencyResolutionException($"Autowire error,can not resolve class type:{classType.FullName},${typeDescription} name:{type.Name} " + (!string.IsNullOrEmpty(this.Name) ? $",with key:[{this.Name}]" : "")); } return(obj); }
/// <summary> /// The create instance. /// </summary> /// <param name="context"> /// The context. /// </param> /// <param name="type"> /// The type. /// </param> /// <param name="nonPublic"> /// The non public. /// </param> /// <returns> /// The create instance. /// </returns> /// <exception cref="ArgumentNullException"> /// </exception> /// <exception cref="ArgumentNullException"> /// </exception> public static object CreateInstance(this IComponentContext context, Type type, bool nonPublic) { if (type == null) { throw new ArgumentNullException("type"); } if (context == null) { throw new ArgumentNullException("context"); } object res; if (context.TryResolve(type, out res)) { return(res); } var a = new ReflectionActivator( type, new BindingFlagsConstructorFinder(nonPublic ? BindingFlags.NonPublic : BindingFlags.Public), new MostParametersConstructorSelector(), new Parameter[] { }, new Parameter[] { }); return(a.ActivateInstance(context, new Parameter[] { })); }
private async Task DispatchAsync(Type handlerType, IEvent @event) { if (_context.TryResolve(handlerType, out object handler)) { var method = handler.GetType().GetMethod("HandleAsync"); await(Task) method.Invoke(handler, new object[] { @event }); } }
public static bool TryResolve <T>(this IComponentContext componentContext, out T instance) { var result = componentContext.TryResolve(typeof(T), out var instanceObj); instance = (T)instanceObj; return(result); }
public AccountBaseApplication(IComponentContext context) { if (!context.IsNull()) { if (context.TryResolve(typeof(IConnection), out var connection)) { Connection = connection as IConnection; } if (context.TryResolve(typeof(INotifier), out var notifier)) { Notifier = notifier as INotifier; } this.context = context; } }
public override IValidator CreateInstance(Type validatorType) { object instance; _componentContext.TryResolve(validatorType, out instance); var validator = instance as IValidator; return(validator); }
public async Task <TResult> DispatchAsync <TCommand, TResult>(TCommand command) where TCommand : ICommand { AppAbstractValidation <TCommand> validator; if (_context.TryResolve(out validator)) { var validationResult = validator.Validate(command); if (!validationResult.IsValid) { throw new ValidationException(validationResult.Errors); } } var handler = _context.Resolve <ICommandHandler <TCommand, TResult> >(); var result = await handler.ExecuteAsync(command).ConfigureAwait(false); return(result); }
/// <summary> /// /// </summary> /// <param name="services"></param> /// <param name="jsonSerializerSettings"></param> public CompactServer(IComponentContext services) { this.services = services; if (!services.TryResolve(out serviceTypes)) { throw new Exception($"Type '{nameof(CompactServerTypes)}' was not registerd in AutoFace. Please register it as instance and add controller types to it."); } this.jsonSerializerSettings = services.Resolve <JsonSerializerSettings>(); }
public override IValidator CreateInstance(Type validatorType) { if (_context.TryResolve(validatorType, out var validator)) { return((IValidator)validator); } return(null); }
public void Send <T>(T command) where T : ICommand { ICommandHandler <T> commandHandler; if (container.TryResolve(out commandHandler)) { commandHandler.Execute(command); } }
public static object Resolve(this IComponentContext componentContext, Type instanceType) { if (!componentContext.TryResolve(instanceType, out var instance)) { ContextException.ResolveErr(instanceType); } return(instance); }
public IValidator?GetValidator(Type type) { var genericType = typeof(IValidator <>).MakeGenericType(type); if (container.TryResolve(genericType, out object validator)) { return((IValidator)validator); } return(null); }
public override IValidator CreateInstance(Type validatorType) { if (_context.TryResolve(validatorType, out object instance)) { var validator = instance as IValidator; return(validator); } return(null); }
public MediatorPlan(Type handlerTypeTemplate, string handlerMethodName, Type messageType, IComponentContext componentContext) { var handlerType = handlerTypeTemplate.MakeGenericType(messageType, typeof(TResponse)); _handleMethod = GetHandlerMethod(handlerType, handlerMethodName, messageType); if (!componentContext.TryResolve(handlerType, out _handlerInstance)) { throw new InvalidOperationException(string.Format("Failed to find a handler for {0} => {1}", messageType.Name, typeof(TResponse).Name)); } }
private static void RegisterLogger(IComponentContext context, PostgreSQLOptions options) { ILogger logger = null; if (context.TryResolve <ILogger>(out logger)) { NpgsqlLogManager.IsParameterLoggingEnabled = true; NpgsqlLogManager.Provider = new PostgreSQLLoggingProvider(logger, options.LogLevel); } loggerRegistered = true; }
public object CreateValidator <TModel>() { IValidator <TModel> validator; if (_context.TryResolve(out validator)) { return(validator); } return(null); }
public T TryResolve <T>() { T result; if (_componentContext.TryResolve(out result)) { return(result); } return(default(T)); }
private IValidator GetValidator <T>() { Type validatorType = typeof(IValidator <>).MakeGenericType(typeof(T)); if (_container.TryResolve(validatorType, out object validator)) { return((IValidator)validator); } return(null); }
private static bool TryResolveAtScope(IComponentContext scope, string key, Type serviceType, out object value) { if (scope != null) { return(key == null ? scope.TryResolve(serviceType, out value) : scope.TryResolveKeyed(key, serviceType, out value)); } value = null; return(false); }
public IExtendedXmlSerializerConfig GetConfiguration(Type type) { var genericTyep = typeof(ExtendedXmlSerializerConfig <>).MakeGenericType(type); object result; if (_context.TryResolve(genericTyep, out result)) { return(result as IExtendedXmlSerializerConfig); } return(null); }
public static void Register(this IComponentContext context, Action <ContainerBuilder> action) { object register; if (!context.TryResolve(typeof(IAutofacRegister), out register)) { throw new NotSupportedException(); } ((IAutofacRegister)register).Register(action); }
public void TryResolve() { ChromeOptions chromeOptions = null; if (componentContext.TryResolve(out chromeOptions)) { DriverOptions = chromeOptions; } FirefoxOptions firefoxOptions = null; if (componentContext.TryResolve(out firefoxOptions)) { DriverOptions = firefoxOptions; } BrowserScripts scripts = null; if (componentContext.TryResolve(out scripts)) { Scripts = scripts; } }
protected override void Load(ContainerBuilder builder) { base.Load(builder); builder.RegisterAssemblyTypes(typeof(IMediator).GetTypeInfo().Assembly).AsImplementedInterfaces(); builder.Register <ServiceFactory>(ctx => { IComponentContext componentContext = ctx.Resolve <IComponentContext>(); return(t => { object o; return componentContext.TryResolve(t, out o) ? o : null; }); }); }
public IValidator GetValidator(Type type) { var genericType = typeof(IValidator <>).MakeGenericType(type); // Search if IValidator<> exists in Autofac container. If it exists then resolve it. Otherwise, return null. if (_container.TryResolve(genericType, out var validator)) { return((IValidator)validator); } return(null); }
static void OnCodeSwitchActivation(IComponentContext context, IObservable <ICodeSwitchEvaluated> observable) { IEnumerable <IObserver <ICodeSwitchEvaluated> > observers; if (context.TryResolve(out observers)) { foreach (var observer in observers) { observable.Subscribe(observer); } } }
/// <summary> /// Publish the event /// </summary> /// <typeparam name="TEvent"></typeparam> /// <param name="event"></param> public void Send <TEvent>(TEvent @event) where TEvent : IEvent { IEnumerable <IEventHandler <TEvent> > eventHandlers = null; if (_componentContext.TryResolve <IEnumerable <IEventHandler <TEvent> > >(out eventHandlers)) { foreach (IEventHandler <TEvent> eventHandler in eventHandlers) { eventHandler.Handle(@event); } } }
private static object GetService(IComponentContext context, Type serviceType) { object service; context.TryResolve(serviceType, out service); return service; }