/// <summary> /// Returns true if the parameter is able to provide a value to a particular site. /// </summary> /// <param name="pi">Constructor, method, or property-mutator parameter.</param> /// <param name="context">The component context in which the value is being provided.</param> /// <param name="valueProvider">If the result is true, the valueProvider parameter will /// be set to a function that will lazily retrieve the parameter value. If the result is false, /// will be set to null.</param> /// <returns>True if a value can be supplied; otherwise, false.</returns> public override bool CanSupplyValue(ParameterInfo pi, IComponentContext context, out Func<object> valueProvider) { IComponentRegistration registration; if (context.ComponentRegistry.TryGetRegistration(new TypedService(pi.ParameterType), out registration)) { valueProvider = () => context.ResolveComponent(registration, Enumerable.Empty<Parameter>()); return true; } valueProvider = null; return false; }
/* * This method create instance via reflection. Try evaluating its parameters and * inject them using componentContext. * * No public members are allowed to add. */ public object Activate(IComponentContext componentContext) { var constructors = serviceType.GetConstructors(); if (constructors.Length != 1) { throw new DependencyResolutionException(); } var constructor = constructors.First(); ParameterInfo[] parametesTypess = constructor.GetParameters(); var parameters = parametesTypess.Select(p => componentContext.ResolveComponent(new TypedService(p.ParameterType))).ToArray(); return(Activator.CreateInstance(serviceType, parameters)); }
/* * This method create instance via reflection. Try evaluating its parameters and * inject them using componentContext. * * No public members are allowed to add. */ public object Activate(IComponentContext componentContext) { var constructorInfos = serviceType .GetConstructors(BindingFlags.Instance | BindingFlags.Public).ToList(); if (!constructorInfos.Any() || constructorInfos.Count > 1) { throw new DependencyResolutionException(); } return(Activator .CreateInstance( serviceType, constructorInfos.Single().GetParameters() .Select(param => componentContext.ResolveComponent(new TypedService(param.ParameterType))).ToArray())); }
/* * This method create instance via reflection. Try evaluating its parameters and * inject them using componentContext. * * No public members are allowed to add. */ public object Activate(IComponentContext componentContext) { var constructorInfos = serviceType.GetConstructors(); if (!constructorInfos.Any() || constructorInfos.Length > 1) { throw new DependencyResolutionException(); } ConstructorInfo constructorInfo = constructorInfos[0]; var parameters = constructorInfo.GetParameters() .Select(p => componentContext.ResolveComponent(new TypedService(p.ParameterType))) .ToArray(); return(Activator.CreateInstance(serviceType, parameters)); }
public static T ResolveUnregistered <T>( this IComponentContext context, Type serviceType, IEnumerable <Parameter> parameters) { var scope = context.Resolve <ILifetimeScope>(); using (var innerScope = scope.BeginLifetimeScope(b => b.RegisterType(serviceType))) { innerScope.ComponentRegistry.TryGetRegistration( new TypedService(serviceType), out var reg); return((T)context.ResolveComponent(reg, parameters)); } }
public override bool CanSupplyValue(ParameterInfo pi, IComponentContext context, out Func <object> valueProvider) { IComponentRegistration registration; Func <object> func = null; if (context.ComponentRegistry.TryGetRegistration(new TypedService(pi.ParameterType), out registration)) { if (func == null) { func = () => context.ResolveComponent(registration, Enumerable.Empty <Parameter>()); } valueProvider = func; return(true); } valueProvider = null; return(false); }
/* * This method create instance via reflection. Try evaluating its parameters and * inject them using componentContext. * * No public members are allowed to add. */ public object Activate(IComponentContext componentContext) { var constructors = serviceType.GetConstructors(); if (1 != constructors.Length) { throw new DependencyResolutionException(); } var constructorInfo = constructors[0]; var parameters = constructorInfo .GetParameters() .Select(p => componentContext.ResolveComponent(new TypedService(p.ParameterType))) .ToArray(); return(constructors[0].Invoke(parameters)); }
/* * This method create instance via reflection. Try evaluating its parameters and * inject them using componentContext. * * No public members are allowed to add. */ public object Activate(IComponentContext componentContext) { var constructorInfos = serviceType.GetConstructors(BindingFlags.Instance | BindingFlags.Public); if (constructorInfos.Length != 1) { throw new DependencyResolutionException(); } var constructor = constructorInfos.Single(); var parameters = new List <object>(); foreach (var i in constructor.GetParameters()) { Type paramtype = i.ParameterType; var instance = componentContext.ResolveComponent(new TypedService(paramtype)); parameters.Add(instance); } return(constructor.Invoke(parameters.ToArray())); }
/// <summary> /// Returns true if the parameter is able to provide a value to a particular site. /// </summary> /// <param name="pi">Constructor, method, or property-mutator parameter.</param> /// <param name="context">The component context in which the value is being provided.</param> /// <param name="valueProvider">If the result is true, the valueProvider parameter will /// be set to a function that will lazily retrieve the parameter value. If the result is false, /// will be set to null.</param> /// <returns>True if a value can be supplied; otherwise, false.</returns> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="pi" /> or <paramref name="context" /> is <see langword="null" />. /// </exception> public override bool CanSupplyValue(ParameterInfo pi, IComponentContext context, out Func <object> valueProvider) { if (pi == null) { throw new ArgumentNullException("pi"); } if (context == null) { throw new ArgumentNullException("context"); } IComponentRegistration registration; if (context.ComponentRegistry.TryGetRegistration(new TypedService(pi.ParameterType), out registration)) { valueProvider = () => context.ResolveComponent(registration, Enumerable.Empty <Parameter>()); return(true); } valueProvider = null; return(false); }
/* * This method create instance via reflection. Try evaluating its parameters and * inject them using componentContext. * * No public members are allowed to add. */ public object Activate(IComponentContext componentContext) { ConstructorInfo constructorInfo; try { constructorInfo = serviceType.GetConstructors(BindingFlags.Instance | BindingFlags.Public).Single(); } catch { throw new DependencyResolutionException(); } var parameters = constructorInfo .GetParameters() .Select(p => componentContext.ResolveComponent(new TypedService(p.ParameterType))) .ToArray(); return(constructorInfo.Invoke(parameters)); }
public bool TryResolve( Type serviceType, out object instance) { if (_componentContext.TryResolve(serviceType, out instance)) { return(true); } // Try resolving registrationless. var scope = _componentContext.Resolve <ILifetimeScope>(); using (var innerScope = scope.BeginLifetimeScope(b => b.RegisterType(serviceType))) { var componentRegistration = default(IComponentRegistration); if (innerScope.ComponentRegistry.TryGetRegistration( new TypedService(serviceType), out componentRegistration)) { try { instance = _componentContext.ResolveComponent( componentRegistration, new Parameter[0]); return(true); } catch (DependencyResolutionException) { } } } instance = null; return(false); }
/// <summary> /// Returns true if the parameter is able to provide a value to a particular site. /// </summary> /// <param name="pi">Constructor, method, or property-mutator parameter.</param> /// <param name="context">The component context in which the value is being provided.</param> /// <param name="valueProvider">If the result is true, the valueProvider parameter will /// be set to a function that will lazily retrieve the parameter value. If the result is false, /// will be set to null.</param> /// <returns>True if a value can be supplied; otherwise, false.</returns> /// <exception cref="System.ArgumentNullException"> /// Thrown if <paramref name="pi" /> or <paramref name="context" /> is <see langword="null" />. /// </exception> public override bool CanSupplyValue(ParameterInfo pi, IComponentContext context, [NotNullWhen(returnValue: true)] out Func <object?>?valueProvider) { if (pi == null) { throw new ArgumentNullException(nameof(pi)); } if (context == null) { throw new ArgumentNullException(nameof(context)); } var service = new TypedService(pi.ParameterType); if (context.ComponentRegistry.TryGetServiceRegistration(service, out var implementation)) { valueProvider = () => context.ResolveComponent(new ResolveRequest(service, implementation, Enumerable.Empty <Parameter>())); return(true); } valueProvider = null; return(false); }
static void StartStartableComponents(IComponentContext componentContext) { // We track which registrations have already been auto-activated by adding // a metadata value. If the value is present, we won't re-activate. This helps // in the container update situation. const string started = "__AutoActivated"; object meta; foreach (var startable in componentContext.ComponentRegistry.RegistrationsFor(new TypedService(typeof(IStartable))).Where(r => !r.Metadata.TryGetValue(started, out meta))) { try { var instance = (IStartable)componentContext.ResolveComponent(startable, Enumerable.Empty<Parameter>()); instance.Start(); } finally { startable.Metadata[started] = true; } } foreach (var registration in componentContext.ComponentRegistry.RegistrationsFor(new AutoActivateService()).Where(r => !r.Metadata.TryGetValue(started, out meta))) { try { componentContext.ResolveComponent(registration, Enumerable.Empty<Parameter>()); } catch (DependencyResolutionException ex) { throw new DependencyResolutionException(String.Format(CultureInfo.CurrentCulture, ContainerBuilderResources.ErrorAutoActivating, registration), ex); } finally { registration.Metadata[started] = true; } } }
public static T ResolveNamed <T>( this IComponentContext componentContext, string name) { return((T)componentContext.ResolveComponent(new TypedNameService(typeof(T), name))); }
public static object Resolve( this IComponentContext componentContext, Type serviceType) { return(componentContext.ResolveComponent(new TypedService(serviceType))); }
/// <inheritdoc/> protected override object ResolveInstance <T>(IComponentContext ctx, ResolveRequest request) => new Meta <T>((T)ctx.ResolveComponent(request), request.Registration.Target.Metadata);
public object ResolveComponent(IComponentRegistration registration, IEnumerable <Parameter> parameters) { _profile.RecordDependency(_registration, registration); return(_context.ResolveComponent(registration, parameters)); }
static void StartStartableComponents(IComponentContext componentContext) { var ts = new TypedService(typeof(IStartable)); foreach (var startable in componentContext.ComponentRegistry.RegistrationsFor(ts)) { var instance = (IStartable)componentContext.ResolveComponent(ts, startable, Enumerable.Empty<Parameter>()); instance.Start(); } }
protected override object ResolveInstance <T>(IComponentContext ctx, ResolveRequest request) { return(new Mapped <T>((T)ctx.ResolveComponent(request))); }
private static THandler ResolveComponent(IComponentContext context, IComponentRegistration registration) { return((THandler)context.ResolveComponent(registration, AutofacHelper.NoParameters)); }
public object ResolveComponent(global::Autofac.Core.IComponentRegistration registration, IEnumerable <global::Autofac.Core.Parameter> parameters) { return(_context.ResolveComponent(registration, parameters)); }