GetHandlerFactory(SingleInstanceFactory factory, ref Collection <Exception> resolveExceptions)
{
if (GetHandler <IRequestHandler <TRequest, TResponse> >(factory, ref resolveExceptions) != null)
{
return((request, token, fac) => () =>
{
var handler = GetHandler <IRequestHandler <TRequest, TResponse> >(fac);
return Task.FromResult(handler.Handle(request));
});
}
if (GetHandler <IAsyncRequestHandler <TRequest, TResponse> >(factory, ref resolveExceptions) != null)
{
return((request, token, fac) =>
{
var handler = GetHandler <IAsyncRequestHandler <TRequest, TResponse> >(fac);
return () => handler.Handle(request);
});
}
if (GetHandler <ICancellableAsyncRequestHandler <TRequest, TResponse> >(factory, ref resolveExceptions) != null)
{
return((request, token, fac) =>
{
var handler = GetHandler <ICancellableAsyncRequestHandler <TRequest, TResponse> >(fac);
return () => handler.Handle(request, token);
});
}
return(null);
}
public override Task <TResult> HandleAsync(IQuery <TResult> query, CancellationToken cancellationToken,
SingleInstanceFactory singleFactory)
{
var handler = GetHandler((TQuery)query, cancellationToken, singleFactory);
return(handler.Invoke());
}
/// <summary>
/// Initializes a new instance of the <see cref="Mediator"/> class.
/// </summary>
/// <param name="singleInstanceFactory">The single instance factory.</param>
/// <param name="multiInstanceFactory">The multi instance factory.</param>
public Mediator(SingleInstanceFactory singleInstanceFactory, MultiInstanceFactory multiInstanceFactory)
{
_singleInstanceFactory = singleInstanceFactory;
_multiInstanceFactory = multiInstanceFactory;
_genericHandlerCache = new ConcurrentDictionary <Type, ConcurrentDictionary <Type, Type> >();
_wrapperHandlerCache = new ConcurrentDictionary <Type, ConcurrentDictionary <Type, Type> >();
}
GetHandlerFactory(SingleInstanceFactory factory, ref Collection <Exception> resolveExceptions)
{
if (GetHandler <ICommandHandler <TCommand, TResult> >(factory, ref resolveExceptions) != null)
{
return (command, token, fac) => () =>
{
var handler = GetHandler <ICommandHandler <TCommand, TResult> >(fac);
return Task.FromResult(handler.Handle(command));
}
}
;
if (GetHandler <IAsyncCommandHandler <TCommand, TResult> >(factory, ref resolveExceptions) != null)
{
return (command, token, fac) =>
{
var handler = GetHandler <IAsyncCommandHandler <TCommand, TResult> >(fac);
return () => handler.HandleAsync(command);
}
}
;
if (GetHandler <ICancellableAsyncCommandHandler <TCommand, TResult> >(factory, ref resolveExceptions) != null)
{
return (command, token, fac) =>
{
var handler = GetHandler <ICancellableAsyncCommandHandler <TCommand, TResult> >(fac);
return () => handler.HandleAsync(command, token);
}
}
;
return(null);
}
//public Mediator(SingleInstanceFactory singleInstanceFactory, MultiInstanceFactory multiInstanceFactory, IDependencyResolver dependencyResolver)
//{
// _singleInstanceFactory = singleInstanceFactory;
// _multiInstanceFactory = multiInstanceFactory;
// _dependencyResolver = dependencyResolver;
// _genericHandlerCache = new ConcurrentDictionary<Type, Type>();
// _wrapperHandlerCache = new ConcurrentDictionary<Type, Type>();
//}
public Mediator(SingleInstanceFactory singleInstanceFactory, MultiInstanceFactory multiInstanceFactory, IDependencyResolver dependencyResolver)
{
_singleInstanceFactory = singleInstanceFactory;
_multiInstanceFactory = multiInstanceFactory;
_dependencyResolver = dependencyResolver;
_genericHandlerCache = new ConcurrentDictionary <Type, Type>();
_wrapperHandlerCache = new ConcurrentDictionary <Type, Type>();
}
public void InstanceCreationTest()
{
var factory = new SingleInstanceFactory(() => new object());
var instanceA = factory.CreateInstance();
var instanceB = factory.CreateInstance();
instanceA.ShouldBeSameAs(instanceB);
}
public UpdateOptionValidator(SingleInstanceFactory singleInstanceFactory)
{
RuleFor(update => update.OptionId)
.Required("Option Id is required");
RuleFor(update => update.SavedById)
.Required("Saved By Id is required")
.MustBe(singleInstanceFactory(typeof(UpdateOptionOnOwnQuestionnaireRule)));
}
public override Task <TResponse> Handle(IRequest <TResponse> request, CancellationToken cancellationToken,
SingleInstanceFactory singleFactory, MultiInstanceFactory multiFactory)
{
var handler = GetHandler((TRequest)request, cancellationToken, singleFactory);
var pipeline = GetPipeline((TRequest)request, handler, multiFactory);
return(pipeline);
}
/// <summary>
/// Initializes a new instance of the <see cref="Mediator"/> class.
/// </summary>
/// <param name="singleInstanceFactory">The single instance factory.</param>
/// <param name="multiInstanceFactory">The multi instance factory.</param>
/// <param name="configuration">The configuration options</param>
public Mediator(SingleInstanceFactory singleInstanceFactory, MultiInstanceFactory multiInstanceFactory, MediatorConfiguration configuration)
{
_singleInstanceFactory = singleInstanceFactory;
_multiInstanceFactory = multiInstanceFactory;
_genericHandlerCache = new ConcurrentDictionary <Type, Type>();
_wrapperHandlerCache = new ConcurrentDictionary <Type, Type>();
_publishOption = configuration.PublishAsyncOptions;
}
public override Task <TResult> HandleAsync(ICommand <TResult> command, CancellationToken cancellationToken,
SingleInstanceFactory singleFactory, MultiInstanceFactory multiFactory)
{
var handler = GetHandler((TCommand)command, cancellationToken, singleFactory);
var pipeline = GetPipeline((TCommand)command, handler, multiFactory);
return(pipeline);
}
public DeleteQuestionnaireValidator(SingleInstanceFactory singleFactory)
{
RuleFor(request => request.DeletedById)
.Required("Delete by Id is required")
.MustBe(singleFactory(typeof(DeleteOwnQuestionnaireRule)));
RuleFor(request => request.QuestionnaireId)
.Required("Questionnaire Id is required")
.MustBe(singleFactory(typeof(QuestionnaireExistsRule)));
}
public override Task <TResponse> Handle(IRequest <TResponse> request, CancellationToken cancellationToken,
SingleInstanceFactory singleFactory, MultiInstanceFactory multiFactory)
{
Task <TResponse> Handler() => GetHandler <IRequestHandler <TRequest, TResponse> >(singleFactory).Handle((TRequest)request, cancellationToken);
return(multiFactory(typeof(IPipelineBehavior <TRequest, TResponse>))
.Cast <IPipelineBehavior <TRequest, TResponse> >()
.Reverse()
.Aggregate((RequestHandlerDelegate <TResponse>)Handler, (next, pipeline) => () => pipeline.Handle((TRequest)request, cancellationToken, next))());
}
public FeaturesService(
IOptions <XabarilOptions> options,
ILogger <XabarilModule> logger,
IFeaturesStore featuresStore,
SingleInstanceFactory singleInstanceFactory)
{
_featuresStore = featuresStore ?? throw new ArgumentNullException(nameof(featuresStore));
_singleInstanceFactory = singleInstanceFactory ?? throw new ArgumentNullException(nameof(singleInstanceFactory));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_xabarilOptions = options?.Value ?? new XabarilOptions();
}
protected static object GetHandler(Type requestType, SingleInstanceFactory singleInstanceFactory)
{
try
{
return(singleInstanceFactory(requestType));
}
catch (Exception)
{
return(null);
}
}
public ManageSeasonControllerTests()
{
LeagueDbInstance db = new LeagueDbInstance();
_testContext = db.NewContext();
_verifyContext = db.NewContext();
SingleInstanceFactory factory = request => new CreateSeasonCommandHandler(_testContext);
_mediator = new Mediator(factory, null);
}
protected static object GetHandler(Type requestType, SingleInstanceFactory singleInstanceFactory, ref Collection <Exception> resolveExceptions)
{
try
{
return(singleInstanceFactory(requestType));
}
catch (Exception e)
{
resolveExceptions?.Add(e);
return(null);
}
}
private CommandHandlerDelegate <TResult> GetHandler(TCommand command, CancellationToken cancellationToken,
SingleInstanceFactory factory)
{
var resolveExceptions = new Collection <Exception>();
LazyInitializer.EnsureInitialized(ref _handlerFactory, ref _initialized, ref _syncLock,
() => GetHandlerFactory(factory, ref resolveExceptions));
if (!_initialized || _handlerFactory == null)
{
throw BuildException(command, resolveExceptions);
}
return(_handlerFactory(command, cancellationToken, factory));
}
public UpdateQuestionnaireValidator(SingleInstanceFactory singleFactory)
{
RuleFor(update => update.QuestionnaireId)
.Required("Questionnaire Id is required");
RuleFor(createQuestionnaire => createQuestionnaire.Name)
.MaxLength(100, "Name cannot be longer than 100 characters");
RuleFor(createQuestionnaire => createQuestionnaire.Description)
.MaxLength(200, "Description cannot be longer than 200 characters");
RuleFor(update => update.SavedById)
.Required("User Id is Required")
.MustBe(singleFactory(typeof(OnlySaveOwnQuestionnaireRule)));
}
public KafkaConsumerService(ConsumerServiceOptions options, ILogger <KafkaConsumerService> logger, ISchemaConsumerFactory consumerFactory,
SingleInstanceFactory factory)
{
_callbackCts = new CancellationTokenSource();
_cancelled = false;
_logger = logger;
_factory = factory;
_options = options;
_consumerFactory = consumerFactory;
_consumers = new List <IConsumer>();
//var actionBlockOptions = new ExecutionDataflowBlockOptions { MaxDegreeOfParallelism = 10, CancellationToken = _callbackCts.Token };
//_workerBlock = new ActionBlock<Message<TKey, TValue>>(async item => await OnMessageReceivedAsync(item, _callbackCts.Token), actionBlockOptions);
}
public CreateQuestionValidator(SingleInstanceFactory singleFactory)
{
RuleFor(create => create.QuestionId)
.MustBeDefault("Question Id must be unset");
RuleFor(create => create.QuestionnaireId)
.Required("Questionnaire Id is required");
RuleFor(create => create.SavedById)
.Required("Saved By Id is required")
.MustBe(singleFactory(typeof(CanOnlySaveQuestionsOnOwnQuestionnaire)));
RuleFor(create => create.Text)
.NotNull("Text cannot be null")
.NotEmpty("Text cannot by empty")
.MaxLength(200, "Text cannot be longer than 200 characters");
}
public CreateOptionValidator(SingleInstanceFactory singleInstanceFactory)
{
RuleFor(create => create.OptionId)
.MustBeDefault("Option Id must be unset.");
RuleFor(create => create.QuestionId)
.Required("Question Id is required.");
RuleFor(create => create.SavedById)
.Required("Saved By Id is required.")
.MustBe(singleInstanceFactory(typeof(CreateOptionOnOwnQuestionnaireRule)));
RuleFor(create => create.Text)
.NotEmpty("Text must not be empty")
.NotNull("Text must not be null")
.MaxLength(100, "Text must be less than 100 characters");
}
public void InstanceInjectionParameterTest()
{
var factory = new SingleInstanceFactory(() => new FactoryTest());
var instance = (FactoryTest)factory.CreateInstance(
new InjectProperty("TestProperty", "abc"),
new InjectProperty("Test42", "xyz"),
new InjectProperty("RandomProperty", 42));
instance.TestProperty.ShouldBe("abc");
instance.TestPropertyWithName.ShouldBe("xyz");
instance.RandomProperty.ShouldNotBe(42);
instance = (FactoryTest)factory.CreateInstance(
new InjectProperty("TestPropertyWithName", "xyz"));
instance.TestProperty.ShouldBe("abc");
instance.TestPropertyWithName.ShouldBe("xyz");
instance.RandomProperty.ShouldNotBe(42);
}
protected static THandler GetHandler <THandler>(SingleInstanceFactory factory)
{
THandler handler;
try
{
handler = (THandler)factory(typeof(THandler));
}
catch (Exception e)
{
throw new InvalidOperationException($"Error constructing handler for request of type {typeof(THandler)}. Register your handlers with the container. See the samples in GitHub for examples.", e);
}
if (handler == null)
{
throw new InvalidOperationException($"Handler was not found for request of type {typeof(THandler)}. Register your handlers with the container. See the samples in GitHub for examples.");
}
return(handler);
}
public CreateUserValidator(SingleInstanceFactory singleFactory)
{
RuleFor(createUser => createUser.Username)
.NotNull("Username cannot be null")
.NotEmpty("Username cannot be empty")
.MaxLength(50, "Username cannot be longer than 50 characters")
.MustBe(singleFactory(typeof(UniqueUsernameRule)));
RuleFor(createUser => createUser.FirstName)
.NotNull("First Name cannot be null")
.NotEmpty("First Name cannot be empty")
.MatchesPattern(@"^[a-zA-Z]+$", "First Name can only contain letters")
.MaxLength(50, "First Name cannot be longer than 50 characters");
RuleFor(createUser => createUser.LastName)
.NotNull("Last Name cannot be null")
.NotEmpty("Last Name cannot be empty")
.MatchesPattern(@"^[a-zA-Z]+$", "Last Name can only contain letters")
.MaxLength(100, "Last Name cannot be longer than 100 characters");
RuleFor(createUser => createUser.Email)
.NotNull("Email cannot be null")
.NotEmpty("Email cannot be empty")
.MaxLength(100, "Email cannot be longer than 100 characters")
.MustBe(value => ValidEmailFormat((string)value), "Email is invalid format");
RuleFor(createUser => createUser.Password)
.NotNull("Password cannot be null")
.NotEmpty("Password cannot be empty")
.MatchesPattern(
@"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
"Password must contain at least 8 characters, 1 uppercase letter, 1 lowercase letter, 1 number, and 1 special character"
);
RuleFor(createUser => createUser.BirthDate)
.NotNull("Birth Date cannot be null")
.MinDate(DateTime.Now.AddDays(-1).AddYears(-18), "Must be at least 18 years old to register");
}
GetHandlerFactory(SingleInstanceFactory factory, ref Collection <Exception> resolveExceptions)
{
if (GetHandler <IQueryHandler <TQuery, TResult> >(factory, ref resolveExceptions) != null)
{
return (query, token, fac) => () =>
{
var handler = GetHandler <IQueryHandler <TQuery, TResult> >(fac);
return Task.FromResult(handler.Handle(query));
}
}
;
if (GetHandler <IAsyncQueryHandler <TQuery, TResult> >(factory, ref resolveExceptions) != null)
{
return (query, token, fac) => () =>
{
var handler = GetHandler <IAsyncQueryHandler <TQuery, TResult> >(fac);
return handler.HandleAsync(query);
}
}
;
if (GetHandler <ICancellableAsyncQueryHandler <TQuery, TResult> >(factory, ref resolveExceptions) != null)
{
return (query, token, fac) => () =>
{
var handler = GetHandler <ICancellableAsyncQueryHandler <TQuery, TResult> >(fac);
return handler.HandleAsync(query, token);
}
}
;
return(null);
}
}
}
public Mediator(SingleInstanceFactory singleInstanceFactory, MultiInstanceFactory multiInstanceFactory)
{
_singleInstanceFactory = singleInstanceFactory;
_multiInstanceFactory = multiInstanceFactory;
}
public CommandProcessor(SingleInstanceFactory factory)
{
_factory = factory;
}
public QueryProcessor(SingleInstanceFactory factory)
{
_factory = factory;
}
public SequentialMediator(SingleInstanceFactory singleInstanceFactory, MultiInstanceFactory multiInstanceFactory)
: base(singleInstanceFactory, multiInstanceFactory)
{
}
public Bus(SingleInstanceFactory singleInstanceFactory, ITelemetrySink telemetrySink)
{
_singleInstanceFactory = singleInstanceFactory;
_telemetrySink = telemetrySink;
}
