/// <summary>
/// Gets the current validator
/// </summary>
internal AbstractValidator <T> GetValidator(ServiceProviderDelegate sp)
{
if (sp == null)
{
throw new ArgumentNullException(nameof(sp));
}
var validator = new InlineValidator <T>();
_tracking.ForEach(cfg => cfg.Invoke(sp, validator));
return(validator);
}
protected static THandler GetHandler <THandler>(ServiceProviderDelegate serviceProvider)
{
THandler handler;
try
{
handler = serviceProvider.GetInstance <THandler>();
}
catch (Exception e)
{
throw new InvalidOperationException($"Error constructing handler for request of type {typeof(THandler)}. Register your handlers with the container.", e);
}
if (handler is null)
{
throw new InvalidOperationException($"Handler was not found for request of type {typeof(THandler)}. Register your handlers with the container.");
}
return(handler);
}
/// <summary>
/// Validates the <see cref="ValidationContext{T}"/> asynchronous
/// </summary>
/// <param name="context">instance to validate</param>
/// <param name="serviceProviderDelegate">the delegate to resolve instances from</param>
/// <returns>
/// Returns a <see cref="RuleResultCollection"/> indicating whether or not the validation was a success.
/// If the validation was unsuccessful, the <see cref="RuleResultCollection"/> contains a list of error messages.
/// </returns>
/// <exception cref="ArgumentNullException">if <paramref name="context"/> or <paramref name="serviceProviderDelegate"/> is null</exception>
internal async Task <RuleResultCollection> ValidateAsync(ValidationContext <T> context, ServiceProviderDelegate serviceProviderDelegate)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (serviceProviderDelegate == null)
{
throw new ArgumentNullException(nameof(serviceProviderDelegate));
}
var validator = GetValidator(serviceProviderDelegate);
var result = await validator.ValidateAsync(context).ConfigureAwait(false);
return(RuleResultCollection.From(result.Errors.Select(r => new RuleResult(r.ErrorCode, r.ErrorMessage))));
}
public override TryOptionAsync <TResponse> Dispatch(IQuery <TResponse> query, ServiceProviderDelegate serviceProvider, CancellationToken token) => GetHandler <IQueryHandler <TQuery, TResponse> >(serviceProvider).Execute((TQuery)query, token);
public abstract TryOptionAsync <TResponse> Dispatch(IQuery <TResponse> query, ServiceProviderDelegate serviceProvider, CancellationToken token);
public QueryDispatcher(ServiceProviderDelegate serviceProvider)
{
Guard.Against.Null(serviceProvider, nameof(serviceProvider));
this.serviceProvider = serviceProvider;
}
public override TryAsync <TResponse> Dispatch(ICommand <TResponse> command, ServiceProviderDelegate serviceProvider, CancellationToken token) => GetHandler <ICommandHandler <TCommand, TResponse> >(serviceProvider).Execute((TCommand)command, token);
public abstract TryAsync <Unit> Dispatch(ICommand command, ServiceProviderDelegate serviceProvider, CancellationToken token);
public static T GetInstance <T>(this ServiceProviderDelegate serviceProvider) => (T)serviceProvider(typeof(T));
/// <summary>
/// Initializes a new instance of the <see cref="FluentHybridRuleEngine{T}"/> class.
/// </summary>
public FluentHybridRuleEngine(RuleCollection <T> ruleCollection, ServiceProviderDelegate serviceProviderDelegate)
{
_ruleCollection = ruleCollection ?? throw new ArgumentNullException(nameof(ruleCollection));
_serviceProviderDelegate = serviceProviderDelegate ?? throw new ArgumentNullException(nameof(serviceProviderDelegate));
}
public override Result <TResponse> Dispatch(IQuerySync <TResponse> query, ServiceProviderDelegate serviceProvider) => GetHandler <IQueryHandlerSync <TQuery, TResponse> >(serviceProvider).Execute((TQuery)query);
public abstract Result <TResponse> Dispatch(IQuerySync <TResponse> query, ServiceProviderDelegate serviceProvider);
public abstract Task <Result <TResponse> > Dispatch(IQuery <TResponse> query, ServiceProviderDelegate serviceProvider, CancellationToken token);
