public async Task <HttpResponseMessage> ResolveByQueue(ResolveRequest request)
{
if (string.IsNullOrWhiteSpace(request.queueaddress))
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "QueueAddress"));
}
DateTime from, to;
try
{
from = DateTime.Parse(request.from, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
to = DateTime.Parse(request.to, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "From/To"));
}
await messageSession.SendLocal <MarkPendingRetriesAsResolved>(m =>
{
m.QueueAddress = request.queueaddress;
m.PeriodFrom = from;
m.PeriodTo = to;
}).ConfigureAwait(false);
return(Request.CreateResponse(HttpStatusCode.Accepted));
}
internal static object TryDecorateRegistration(
Service service,
IComponentRegistration registration,
object instance,
IComponentContext context,
IEnumerable <Parameter> parameters)
{
if (service is DecoratorService ||
!(service is IServiceWithType serviceWithType) ||
registration is ExternalComponentRegistration)
{
return(instance);
}
var decoratorRegistrations = context.ComponentRegistry.DecoratorsFor(serviceWithType);
if (decoratorRegistrations.Count == 0)
{
return(instance);
}
var serviceType = serviceWithType.ServiceType;
var resolveParameters = parameters as Parameter[] ?? parameters.ToArray();
var instanceType = instance.GetType();
var decoratorContext = DecoratorContext.Create(instanceType, serviceType, instance);
var decoratorCount = decoratorRegistrations.Count;
for (var index = 0; index < decoratorCount; index++)
{
var decoratorRegistration = decoratorRegistrations[index];
var decoratorService = decoratorRegistration.Services.OfType <DecoratorService>().First();
if (!decoratorService.Condition(decoratorContext))
{
continue;
}
var serviceParameter = new TypedParameter(serviceType, instance);
var contextParameter = new TypedParameter(typeof(IDecoratorContext), decoratorContext);
var invokeParameters = new Parameter[resolveParameters.Length + 2];
for (var i = 0; i < resolveParameters.Length; i++)
{
invokeParameters[i] = resolveParameters[i];
}
invokeParameters[invokeParameters.Length - 2] = serviceParameter;
invokeParameters[invokeParameters.Length - 1] = contextParameter;
var resolveRequest = new ResolveRequest(decoratorService, decoratorRegistration, invokeParameters);
instance = context.ResolveComponent(resolveRequest);
if (index < decoratorCount - 1)
{
decoratorContext = decoratorContext.UpdateContext(instance);
}
}
return(instance);
}
public async Task <IActionResult> MineBlock([FromQuery] int proof, [FromQuery] ulong nodeId)
{
if (!_chain.MineBlock(proof, nodeId))
{
return(Ok(false));
}
System.IO.File.WriteAllText(_options.ChainFilePath, JsonConvert.SerializeObject(_chain));
var last2 = _chain.Blocks.TakeLast(2).ToArray();
var resolveRequest = new ResolveRequest
{
LastBlockHash = last2[0].LastBlockHash,
LastBlockIndex = last2[0].Index,
NewBlock = last2[1]
};
var httpClient = new HttpClient();
var body = new StringContent(JsonConvert.SerializeObject(resolveRequest), Encoding.UTF8, "application/json");
foreach (var node in _nodes)
{
await httpClient.PostAsync(new Uri(node.Url).AbsoluteUri + "api/resolve", body).ConfigureAwait(false);
}
return(Ok(true));
}
public object Execute(ResolveRequest request)
{
object result;
try
{
result = ResolveComponent(request);
}
catch (ObjectDisposedException)
{
throw;
}
catch (DependencyResolutionException dependencyResolutionException)
{
End(dependencyResolutionException);
throw;
}
catch (Exception exception)
{
End(exception);
throw new DependencyResolutionException(ResolveOperationResources.ExceptionDuringResolve, exception);
}
End();
return(result);
}
public InstanceLookup(
IResolveOperation context,
ISharingLifetimeScope mostNestedVisibleScope,
ResolveRequest request)
{
_context = context;
_service = request.Service;
ComponentRegistration = request.Registration;
Parameters = request.Parameters;
try
{
_activationScope = ComponentRegistration.Lifetime.FindScope(mostNestedVisibleScope);
}
catch (DependencyResolutionException ex)
{
var services = new StringBuilder();
foreach (var s in ComponentRegistration.Services)
{
services.Append("- ");
services.AppendLine(s.Description);
}
var message = string.Format(CultureInfo.CurrentCulture, ComponentActivationResources.UnableToLocateLifetimeScope, ComponentRegistration.Activator.LimitType, services);
throw new DependencyResolutionException(message, ex);
}
}
static IComponentRegistration CreateMetaRegistration <T>(Service providedService, ServiceRegistration serviceRegistration) where T : class
{
var rb = RegistrationBuilder.ForDelegate(
(c, p) =>
{
var accessor = c.Resolve <ILifetimeScopeAccessor>();
return(new Work <T>(w =>
{
var scope = accessor.LifetimeScope;
if (scope == null)
{
return default;
}
var workValues = scope.Resolve <WorkValues <T> >();
if (!workValues.Values.TryGetValue(w, out T value))
{
var request = new ResolveRequest(providedService, serviceRegistration, p);
value = (T)workValues.ComponentContext.ResolveComponent(request);
workValues.Values[w] = value;
}
return value;
}));
})
.As(providedService)
.Targeting(serviceRegistration.Registration)
.SingleInstance();
return(rb.CreateRegistration());
}
/// <summary>
/// Invoke this method to execute the operation for a given request.
/// </summary>
/// <param name="request">The resolve request.</param>
/// <returns>The resolved instance.</returns>
private object ExecuteOperation(ResolveRequest request)
{
object result;
try
{
InitiatingRequest = request;
if (DiagnosticSource.IsEnabled())
{
DiagnosticSource.OperationStart(this, request);
}
result = GetOrCreateInstance(CurrentScope, request);
}
catch (ObjectDisposedException disposeException)
{
if (DiagnosticSource.IsEnabled())
{
DiagnosticSource.OperationFailure(this, disposeException);
}
throw;
}
catch (DependencyResolutionException dependencyResolutionException)
{
if (DiagnosticSource.IsEnabled())
{
DiagnosticSource.OperationFailure(this, dependencyResolutionException);
}
End(dependencyResolutionException);
throw;
}
catch (Exception exception)
{
End(exception);
if (DiagnosticSource.IsEnabled())
{
DiagnosticSource.OperationFailure(this, exception);
}
throw new DependencyResolutionException(ResolveOperationResources.ExceptionDuringResolve, exception);
}
finally
{
ResetSuccessfulRequests();
}
End();
if (DiagnosticSource.IsEnabled())
{
DiagnosticSource.OperationSuccess(this, result);
}
return(result);
}
public void OperationRaisesFailureTraceEvents()
{
var builder = new ContainerBuilder();
builder.Register <string>(ctxt => throw new InvalidOperationException());
var container = builder.Build();
var mockTracer = Mocks.GetTracer();
container.SubscribeToDiagnostics(mockTracer);
var scope = container.Resolve <ILifetimeScope>() as ISharingLifetimeScope;
var resolveOp = new ResolveOperation(scope, container.DiagnosticSource);
var raisedEvents = new List <string>();
var request = new ResolveRequest(new TypedService(typeof(string)), scope.ResolvableImplementationFor <string>(), Enumerable.Empty <Parameter>());
mockTracer.OperationStarting += (op, req) =>
{
raisedEvents.Add("opstart");
Assert.Equal(resolveOp, op);
Assert.Equal(request, req);
};
mockTracer.RequestStarting += (op, ctxt) =>
{
raisedEvents.Add("reqstart");
Assert.Equal(resolveOp, op);
Assert.Equal(request.Service, ctxt.Service);
};
mockTracer.RequestFailing += (op, ctxt, ex) =>
{
raisedEvents.Add("reqfail");
Assert.Equal(resolveOp, op);
Assert.IsType <DependencyResolutionException>(ex);
};
mockTracer.OperationFailing += (op, ex) =>
{
raisedEvents.Add("opfail");
Assert.IsType <DependencyResolutionException>(ex);
};
try
{
resolveOp.Execute(request);
}
catch
{
}
Assert.Equal(new[] { "opstart", "reqstart", "reqfail", "opfail" }, raisedEvents);
}
private T ResolveComponentAttributeService(TKey key)
{
if (_registrations.Value.ContainsKey(key))
{
var resolveRequest = new ResolveRequest(new UniqueService(), _registrations.Value[key], Enumerable.Empty <Parameter>());
return((T)_componentContext.ResolveComponent(resolveRequest));
}
throw new KeyNotFoundException($"No component registered with key '{key}'");
}
private void InvokePipeline(ResolveRequest request, DefaultResolveRequestContext requestContext)
{
request.ResolvePipeline.Invoke(requestContext);
if (requestContext.Instance == null)
{
throw new DependencyResolutionException(ResolveOperationResources.PipelineCompletedWithNoInstance);
}
_successfulRequests.Add(requestContext);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultResolveRequestContext" /> class.
/// </summary>
/// <param name="owningOperation">The owning resolve operation.</param>
/// <param name="request">The initiating resolve request.</param>
/// <param name="scope">The lifetime scope.</param>
/// <param name="diagnosticSource">
/// The <see cref="System.Diagnostics.DiagnosticListener" /> to which trace events should be written.
/// </param>
internal DefaultResolveRequestContext(
IResolveOperation owningOperation,
ResolveRequest request,
ISharingLifetimeScope scope,
DiagnosticListener diagnosticSource)
{
Operation = owningOperation;
ActivationScope = scope;
Parameters = request.Parameters;
_resolveRequest = request ?? throw new ArgumentNullException(nameof(request));
PhaseReached = PipelinePhase.ResolveRequestStart;
DiagnosticSource = diagnosticSource;
}
/// <summary>
/// Resolves an unregistered service.
/// </summary>
/// <param name="context">The <see cref="IComponentContext"/>.</param>
/// <param name="serviceType">Service type.</param>
/// <param name="parameters"><see cref="IEnumerable{T}"/> of <see cref="Parameter"/>.</param>
/// <returns>Resolved component.</returns>
public static object ResolveUnregistered(this IComponentContext context, Type serviceType, IEnumerable <Parameter> parameters)
{
var scope = context.Resolve <ILifetimeScope>();
using (var innerScope = scope.BeginLifetimeScope(b => b.RegisterType(serviceType)))
{
var typedService = new TypedService(serviceType);
innerScope.ComponentRegistry.TryGetRegistration(typedService, out IComponentRegistration reg);
var request = new ResolveRequest(typedService, reg, parameters);
return(context.ResolveComponent(request));
}
}
public void OperationRaisesSuccessTraceEvents()
{
var builder = new ContainerBuilder();
builder.RegisterInstance("Hello");
var container = builder.Build();
var mockTracer = Mocks.GetTracer();
container.SubscribeToDiagnostics(mockTracer);
var scope = container.Resolve <ILifetimeScope>() as ISharingLifetimeScope;
var resolveOp = new ResolveOperation(scope, container.DiagnosticSource);
var raisedEvents = new List <string>();
var request = new ResolveRequest(new TypedService(typeof(string)), scope.ResolvableImplementationFor <string>(), Enumerable.Empty <Parameter>());
mockTracer.OperationStarting += (op, req) =>
{
raisedEvents.Add("opstart");
Assert.Equal(resolveOp, op);
Assert.Equal(request, req);
};
mockTracer.RequestStarting += (op, ctxt) =>
{
raisedEvents.Add("reqstart");
Assert.Equal(resolveOp, op);
Assert.Equal(request.Service, ctxt.Service);
};
mockTracer.RequestSucceeding += (op, ctxt) =>
{
raisedEvents.Add("reqsuccess");
Assert.Equal(resolveOp, op);
};
mockTracer.OperationSucceeding += (op, instance) =>
{
raisedEvents.Add("opsuccess");
Assert.Equal("Hello", instance);
};
resolveOp.Execute(request);
Assert.Equal(new[] { "opstart", "reqstart", "reqsuccess", "opsuccess" }, raisedEvents);
}
/// <inheritdoc/>
protected override object ResolveInstance <T>(IComponentContext ctx, ResolveRequest request)
{
var lifetime = ctx.Resolve <ILifetimeScope>().BeginLifetimeScope(request.Service);
try
{
var value = (T)lifetime.ResolveComponent(request);
return(new Owned <T>(value, lifetime));
}
catch
{
lifetime.Dispose();
throw;
}
}
public ActionResult Resolve([FromBody] ResolveRequest resolveRequest)
{
securityManager.Verify(new SecurityAssertion()
{
Payload = resolveRequest
});
logger.Info("Resolve: " + CustomJsonSerializer.Serialize(resolveRequest));
ResolveResponse resolveResponse = new ResolveResponse();
resolveResponse.Endpoints = storageManager.Resolve(resolveRequest);
return(new JsonResult(resolveResponse));
}
private IComponentRegistration CreateLazyRegistration <T>(Service providedService, Service valueService, IComponentRegistration valueRegistration)
{
var rb = RegistrationBuilder.ForDelegate(
(c, p) =>
{
var context = c.Resolve <IComponentContext>();
var request = new ResolveRequest(valueService, valueRegistration, p);
return(new Lazy <T>(() => (T)context.ResolveComponent(request)));
})
.As(providedService)
.Targeting(valueRegistration, IsAdapterForIndividualComponents)
.InheritRegistrationOrderFrom(valueRegistration);
return(rb.CreateRegistration());
}
/// <inheritdoc />
public object ResolveComponent(ResolveRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
CheckNotDisposed();
var operation = new ResolveOperation(this);
var handler = ResolveOperationBeginning;
handler?.Invoke(this, new ResolveOperationBeginningEventArgs(operation));
return(operation.Execute(request));
}
/// <summary>
/// Executes the startable and auto-activate components in a context.
/// </summary>
/// <param name="properties">The set of properties used during component registration.</param>
/// <param name="componentContext">
/// The <see cref="IComponentContext"/> in which startable services should execute.
/// </param>
internal static void StartStartableComponents(IDictionary <string, object?> properties, IComponentContext componentContext)
{
var componentRegistry = componentContext.ComponentRegistry;
try
{
properties[MetadataKeys.StartOnActivatePropertyKey] = true;
// 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.
var startableService = new TypedService(typeof(IStartable));
foreach (var registration in componentRegistry.RegistrationsFor(startableService).Where(r => !r.Metadata.ContainsKey(MetadataKeys.AutoActivated)))
{
try
{
var request = new ResolveRequest(startableService, registration, Enumerable.Empty <Parameter>());
componentContext.ResolveComponent(request);
}
finally
{
registration.Metadata[MetadataKeys.AutoActivated] = true;
}
}
var autoActivateService = new AutoActivateService();
foreach (var registration in componentRegistry.RegistrationsFor(autoActivateService).Where(r => !r.Metadata.ContainsKey(MetadataKeys.AutoActivated)))
{
try
{
var request = new ResolveRequest(autoActivateService, registration, Enumerable.Empty <Parameter>());
componentContext.ResolveComponent(request);
}
catch (DependencyResolutionException ex)
{
throw new DependencyResolutionException(string.Format(CultureInfo.CurrentCulture, ContainerBuilderResources.ErrorAutoActivating, registration), ex);
}
finally
{
registration.Metadata[MetadataKeys.AutoActivated] = true;
}
}
}
finally
{
properties.Remove(MetadataKeys.StartOnActivatePropertyKey);
}
}
/// <summary>
/// Retrieve registrations for an unregistered service, to be used
/// by the container.
/// </summary>
/// <param name="service">The service that was requested.</param>
/// <param name="registrationAccessor">A function that will return existing registrations for a service.</param>
/// <returns>Registrations providing the service.</returns>
public IEnumerable <IComponentRegistration> RegistrationsFor(Service service, Func <Service, IEnumerable <IComponentRegistration> > registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (registrationAccessor == null)
{
throw new ArgumentNullException(nameof(registrationAccessor));
}
var ts = service as IServiceWithType;
if (ts == null || !ts.ServiceType.IsGenericTypeDefinedBy(typeof(Owned <>)))
{
return(Enumerable.Empty <IComponentRegistration>());
}
var ownedInstanceType = ts.ServiceType.GetTypeInfo().GenericTypeArguments.First();
var ownedInstanceService = ts.ChangeType(ownedInstanceType);
return(registrationAccessor(ownedInstanceService)
.Select(r =>
{
var rb = RegistrationBuilder.ForDelegate(ts.ServiceType, (c, p) =>
{
var lifetime = c.Resolve <ILifetimeScope>().BeginLifetimeScope(ownedInstanceService);
try
{
var context = new ResolveRequest(ownedInstanceService, r, p);
var value = lifetime.ResolveComponent(context);
return Activator.CreateInstance(ts.ServiceType, new[] { value, lifetime });
}
catch
{
lifetime.Dispose();
throw;
}
})
.ExternallyOwned()
.As(service)
.Targeting(r, IsAdapterForIndividualComponents)
.InheritRegistrationOrderFrom(r);
return rb.CreateRegistration();
}));
}
CacheInSession <TLimit, TActivatorData, TSingleRegistrationStyle>(
this IRegistrationBuilder <TLimit, TActivatorData, TSingleRegistrationStyle> registration)
where TActivatorData : IConcreteActivatorData
where TSingleRegistrationStyle : SingleRegistrationStyle
{
if (registration == null)
{
throw new ArgumentNullException(nameof(registration));
}
var services = registration.RegistrationData.Services.ToArray();
registration.RegistrationData.ClearServices();
return(registration
.ExternallyOwned()
.OnRegistered(e =>
{
foreach (var service in services)
{
e.ComponentRegistryBuilder.Register(RegistrationBuilder
.ForDelegate((c, p) =>
{
var session = HttpContext.Current.Session;
object result;
lock (session.SyncRoot)
{
result = session[e.ComponentRegistration.Id.ToString()];
if (result == null)
{
var resolveRequest = new ResolveRequest(service, e.ComponentRegistration, p);
result = c.ResolveComponent(resolveRequest);
session[e.ComponentRegistration.Id.ToString()] = result;
}
}
return result;
})
.As(service)
.InstancePerLifetimeScope()
.ExternallyOwned()
.CreateRegistration());
}
}));
}
private IComponentRegistration CreateRegistration <T>(Service providedService, Service valueService, ServiceRegistration serviceRegistration)
where T : notnull
{
var registrationDelegate = RegistrationBuilder.ForDelegate(
(c, p) =>
{
var request = new ResolveRequest(valueService, serviceRegistration, p);
return(ResolveInstance <T>(c, request));
});
var rb = BuildRegistration(registrationDelegate)
.As(providedService)
.Targeting(serviceRegistration.Registration)
.InheritRegistrationOrderFrom(serviceRegistration.Registration);
return(rb.CreateRegistration());
}
private IComponentRegistration CreateLazyRegistration <T, TMeta>(Service providedService, Service valueService, IComponentRegistration valueRegistration)
{
var metadataProvider = MetadataViewProvider.GetMetadataViewProvider <TMeta>();
var rb = RegistrationBuilder.ForDelegate(
(c, p) =>
{
var context = c.Resolve <IComponentContext>();
var lazyType = ((IServiceWithType)providedService).ServiceType;
var request = new ResolveRequest(valueService, valueRegistration, p);
var valueFactory = new Func <T>(() => (T)context.ResolveComponent(request));
var metadata = metadataProvider(valueRegistration.Target.Metadata);
return(Activator.CreateInstance(lazyType, valueFactory, metadata));
})
.As(providedService)
.Targeting(valueRegistration, IsAdapterForIndividualComponents);
return(rb.CreateRegistration());
}
/// <summary>
/// Executes the newly-registered build callbacks for a given scope/container..
/// </summary>
/// <param name="scope">The new scope/container.</param>
internal static void RunBuildCallbacks(ILifetimeScope scope)
{
var buildCallbackServices = scope.ComponentRegistry.RegistrationsFor(CallbackServiceType);
foreach (var srv in buildCallbackServices)
{
// Use the metadata to track whether we've executed already, to avoid issuing a resolve request.
if (srv.Metadata.ContainsKey(BuildCallbacksExecutedKey))
{
continue;
}
var request = new ResolveRequest(CallbackServiceType, srv, Enumerable.Empty <Parameter>());
var component = (BuildCallbackService)scope.ResolveComponent(request);
srv.Metadata[BuildCallbacksExecutedKey] = true;
// Run the callbacks for the relevant scope.
component.Execute(scope);
}
}
public async Task <HttpResponseMessage> ResolveBy(ResolveRequest request)
{
if (request.uniquemessageids != null)
{
if (request.uniquemessageids.Any(string.IsNullOrEmpty))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
foreach (var id in request.uniquemessageids)
{
await messageSession.SendLocal(new MarkPendingRetryAsResolved { FailedMessageId = id })
.ConfigureAwait(false);
}
return(Request.CreateResponse(HttpStatusCode.Accepted));
}
DateTime from, to;
try
{
from = DateTime.Parse(request.from, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
to = DateTime.Parse(request.to, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
}
catch (Exception)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "From/To"));
}
await messageSession.SendLocal <MarkPendingRetriesAsResolved>(m =>
{
m.PeriodFrom = from;
m.PeriodTo = to;
}).ConfigureAwait(false);
return(Request.CreateResponse(HttpStatusCode.Accepted));
}
public object ResolveComponent(ResolveRequest request)
{
return(GetCurrentScope().ResolveComponent(request));
}
/// <inheritdoc />
public object ResolveComponent(ResolveRequest request)
{
return(_rootLifetimeScope.ResolveComponent(request));
}
/// <summary>
/// Resolve an instance of the provided registration within the context.
/// </summary>
/// <param name="request">The resolve request.</param>
/// <returns>
/// The component instance.
/// </returns>
/// <exception cref="ComponentNotRegisteredException"/>
/// <exception cref="Autofac.Core.DependencyResolutionException"/>
public object ResolveComponent(ResolveRequest request)
{
return(_containerProvider.RequestLifetime.ResolveComponent(request));
}
public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<ServiceRegistration>> registrationAccessor)
{
if (service == null)
{
throw new ArgumentNullException(nameof(service));
}
if (registrationAccessor == null)
{
throw new ArgumentNullException(nameof(registrationAccessor));
}
if (!(service is IServiceWithType swt) || service is DecoratorService)
{
return Enumerable.Empty<IComponentRegistration>();
}
var serviceType = swt.ServiceType;
Type? elementType = null;
Type? limitType = null;
Func<int, IList>? factory = null;
if (serviceType.IsGenericTypeDefinedBy(typeof(IEnumerable<>)))
{
elementType = serviceType.GenericTypeArguments[0];
limitType = elementType.MakeArrayType();
factory = GenerateArrayFactory(elementType);
}
else if (serviceType.IsArray)
{
elementType = serviceType.GetElementType();
limitType = serviceType;
factory = GenerateArrayFactory(elementType);
}
else if (serviceType.IsGenericListOrCollectionInterfaceType())
{
elementType = serviceType.GenericTypeArguments[0];
limitType = typeof(List<>).MakeGenericType(elementType);
factory = GenerateListFactory(elementType);
}
if (elementType == null || factory == null || limitType == null)
{
return Enumerable.Empty<IComponentRegistration>();
}
var elementTypeService = swt.ChangeType(elementType);
var activator = new DelegateActivator(
limitType,
(c, p) =>
{
var itemRegistrations = c.ComponentRegistry
.ServiceRegistrationsFor(elementTypeService)
.Where(cr => !cr.Registration.Options.HasOption(RegistrationOptions.ExcludeFromCollections))
.OrderBy(cr => cr.Registration.GetRegistrationOrder())
.ToList();
var output = factory(itemRegistrations.Count);
var isFixedSize = output.IsFixedSize;
for (var i = 0; i < itemRegistrations.Count; i++)
{
var itemRegistration = itemRegistrations[i];
var resolveRequest = new ResolveRequest(elementTypeService, itemRegistration, p);
var component = c.ResolveComponent(resolveRequest);
if (isFixedSize)
{
output[i] = component;
}
else
{
output.Add(component);
}
}
return output;
});
var registration = new ComponentRegistration(
Guid.NewGuid(),
activator,
CurrentScopeLifetime.Instance,
InstanceSharing.None,
InstanceOwnership.ExternallyOwned,
new[] { service },
new Dictionary<string, object?>());
return new IComponentRegistration[] { registration };
}
public object ResolveComponent(ResolveRequest request)
{
return(_context.GetOrCreateInstance(_activationScope, request));
}
/// <summary>
/// Resolves an instance of the implicit type.
/// </summary>
/// <typeparam name="T">The child type used in the implicit type.</typeparam>
/// <param name="ctx">A component context to resolve services.</param>
/// <param name="request">A resolve request.</param>
/// <returns>An implicit type instance.</returns>
protected abstract object ResolveInstance <T>(IComponentContext ctx, ResolveRequest request)
where T : notnull;
