static void UpdateControllerService <T>(ServicesContainer services, IComponentContext container, ControllerTypeKey serviceKey) where T : class
{
var instance = container.ResolveOptionalKeyed <Meta <T> >(serviceKey);
var baseControllerType = serviceKey.ControllerType.BaseType;
while (instance == null && baseControllerType != typeof(ApiController))
{
var baseServiceKey = new ControllerTypeKey(baseControllerType);
instance = container.ResolveOptionalKeyed <Meta <T> >(baseServiceKey);
baseControllerType = baseServiceKey.ControllerType.BaseType;
}
if (instance != null)
{
services.Replace(typeof(T), instance.Value);
}
}
public static IEndPointValidator ResolveValidator(IComponentContext cxt, string endPointType, string providerName)
{
IEndPointValidator result = null;
result = cxt.ResolveOptionalKeyed <IEndPointValidator>(endPointType + providerName);
if (result == null)
{
throw new ComponentNotRegisteredException($"An attempt to resolve an EndPointValidator for EndPointType { endPointType } failed. Use the RegisterEndPointValidator method on the RegistrationHelper to register an EndPointValidator for each EndPointType.");
}
return(result);
}
public static IPerimeter ResolvePerimeter(IComponentContext cxt, Type typ)
{
IPerimeter result = null;
result = cxt.ResolveOptionalKeyed <IPerimeter>(typ);
if (result == null)
{
throw new ComponentNotRegisteredException($"Interface { typ.Name } has not been registered. Use RegistrationHelper to register { typ.Name } with one or more implementations, EndPointConfiguration, and API names.");
}
return(result);
}
private static void UpdateControllerFormatters(ICollection <MediaTypeFormatter> collection, IComponentContext container, ControllerTypeKey serviceKey)
{
var formatters = container.ResolveOptionalKeyed <IEnumerable <Meta <MediaTypeFormatter> > >(serviceKey).ToArray();
if (formatters.Any(service => ClearExistingServices(service.Metadata)))
{
collection.Clear();
}
foreach (var formatter in formatters)
{
collection.Add(formatter.Value);
}
}
static void UpdateControllerServices <T>(ServicesContainer services, IComponentContext container, ControllerTypeKey serviceKey) where T : class
{
var resolvedInstances = container.ResolveOptionalKeyed <IEnumerable <Meta <T> > >(serviceKey).ToArray();
if (resolvedInstances.Any(service => ClearExistingServices(service.Metadata)))
{
services.Clear(typeof(T));
}
foreach (var instance in resolvedInstances)
{
services.Add(typeof(T), instance.Value);
}
}
public INodeViewModel Create(INodeViewModel parent, string nodeType)
{
IDocumentNodeFactory factory = _container.ResolveOptionalKeyed <IDocumentNodeFactory>(nodeType);
if (factory == null)
{
factory = _container.ResolveKeyed <IDocumentNodeFactory>("default_node");
}
INodeViewModel node = factory.Create(parent, nodeType);
if (parent != null)
{
parent.Children.Add(node);
}
return(node);
}
private async Task <ISmtpCommand> GetCommandAsync(CancellationToken token)
{
string line = await _connection.ReadLineAsync(Encoding.UTF8, token);
_log.Verbose($"SMTP <- {line}");
if (line.Length < 4)
{
await this.SendReplyAsync(SmtpReplyCode.SyntaxError, "No command found", token);
return(null);
}
int spaceIndex = line.IndexOf(" ", StringComparison.Ordinal);
string command;
string arguments;
if (spaceIndex == -1)
{
command = line;
arguments = null;
}
else
{
command = line.Substring(0, spaceIndex).ToUpperInvariant();
arguments = line.Substring(spaceIndex + 1);
}
var commandExecutor = _context.ResolveOptionalKeyed <ISmtpCommand>(command);
if (commandExecutor == null)
{
await this.SendReplyAsync(SmtpReplyCode.SyntaxError, "Command not implemented", token);
return(null);
}
commandExecutor.Initialize(arguments);
return(commandExecutor);
}
/// <summary>
/// Retrieve a service from the context, or null if the service is not
/// registered.
/// </summary>
/// <param name="context">The context from which to resolve the service.</param>
/// <param name="parameters">Parameters for the service.</param>
/// <param name="serviceKey">The key of the service.</param>
/// <typeparam name="TService">The service to resolve.</typeparam>
/// <returns>
/// The component instance that provides the service, or null.
/// </returns>
/// <exception cref="DependencyResolutionException"/>
public static TService ResolveOptionalKeyed <TService>(this IComponentContext context, object serviceKey, params Parameter[] parameters)
where TService : class
{
return(context.ResolveOptionalKeyed <TService>(serviceKey, (IEnumerable <Parameter>)parameters));
}
/// <summary>
/// Retrieve a service from the context, or null if the service is not
/// registered.
/// </summary>
/// <param name="context">The context from which to resolve the service.</param>
/// <param name="parameters">Parameters for the service.</param>
/// <param name="serviceName">The name of the service.</param>
/// <typeparam name="TService">The service to resolve.</typeparam>
/// <returns>
/// The component instance that provides the service, or null.
/// </returns>
/// <exception cref="DependencyResolutionException"/>
public static TService ResolveOptionalNamed <TService>(this IComponentContext context, string serviceName, params Parameter[] parameters)
where TService : class
{
return(context.ResolveOptionalKeyed <TService>(serviceName, parameters));
}
public IHandler <T> Resolve <T>() where T : IPersonCommand
{
return(_context.ResolveOptionalKeyed <IHandler <T> >("DecoratedHandler"));
}
/// <summary>
/// Retrieve a service from the context, or null if the service is not
/// registered.
/// </summary>
/// <param name="context">The context from which to resolve the service.</param>
/// <param name="serviceKey">The name of the service.</param>
/// <typeparam name="TService">The service to resolve.</typeparam>
/// <returns>
/// The component instance that provides the service, or null.
/// </returns>
/// <exception cref="DependencyResolutionException"/>
public static TService?ResolveOptionalKeyed <TService>(this IComponentContext context, object serviceKey)
where TService : struct
{
return(context.ResolveOptionalKeyed <TService>(serviceKey, NoParameters));
}