Oto moje rozwiązanie i projekty:
- BookStore (rozwiązanie)
- BookStore.Coupler (projekt)
- Bootstrapper.cs
- BookStore.Domain (projekt)
- CreateBookCommandValidator.cs
- CompositeValidator.cs
- IValidate.cs
- IValidator.cs
- ICommandHandler.cs
- BookStore.Infrastructure (projekt)
- CreateBookCommandHandler.cs
- ValidationCommandHandlerDecorator.cs
- BookStore.Web (projekt)
- Global.asax
- BookStore.BatchProcesses (projekt)
- Program.cs
- BookStore.Coupler (projekt)
Bootstrapper.cs :
public static class Bootstrapper.cs
{
// I'm using SimpleInjector as my DI Container
public static void Initialize(Container container)
{
container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), typeof(CreateBookCommandHandler).Assembly);
container.RegisterDecorator(typeof(ICommandHandler<>), typeof(ValidationCommandHandlerDecorator<>));
container.RegisterManyForOpenGeneric(typeof(IValidate<>),
AccessibilityOption.PublicTypesOnly,
(serviceType, implTypes) => container.RegisterAll(serviceType, implTypes),
typeof(IValidate<>).Assembly);
container.RegisterSingleOpenGeneric(typeof(IValidator<>), typeof(CompositeValidator<>));
}
}CreateBookCommandValidator.cs
public class CreateBookCommandValidator : IValidate<CreateBookCommand>
{
public IEnumerable<IValidationResult> Validate(CreateBookCommand book)
{
if (book.Author == "Evan")
{
yield return new ValidationResult<CreateBookCommand>("Evan cannot be the Author!", p => p.Author);
}
if (book.Price < 0)
{
yield return new ValidationResult<CreateBookCommand>("The price can not be less than zero", p => p.Price);
}
}
}CompositeValidator.cs
public class CompositeValidator<T> : IValidator<T>
{
private readonly IEnumerable<IValidate<T>> validators;
public CompositeValidator(IEnumerable<IValidate<T>> validators)
{
this.validators = validators;
}
public IEnumerable<IValidationResult> Validate(T instance)
{
var allResults = new List<IValidationResult>();
foreach (var validator in this.validators)
{
var results = validator.Validate(instance);
allResults.AddRange(results);
}
return allResults;
}
}IValidate.cs
public interface IValidate<T>
{
IEnumerable<IValidationResult> Validate(T instance);
}IValidator.cs
public interface IValidator<T>
{
IEnumerable<IValidationResult> Validate(T instance);
}ICommandHandler.cs
public interface ICommandHandler<TCommand>
{
void Handle(TCommand command);
}CreateBookCommandHandler.cs
public class CreateBookCommandHandler : ICommandHandler<CreateBookCommand>
{
private readonly IBookStore _bookStore;
public CreateBookCommandHandler(IBookStore bookStore)
{
_bookStore = bookStore;
}
public void Handle(CreateBookCommand command)
{
var book = new Book { Author = command.Author, Name = command.Name, Price = command.Price };
_bookStore.SaveBook(book);
}
}ValidationCommandHandlerDecorator.cs
public class ValidationCommandHandlerDecorator<TCommand> : ICommandHandler<TCommand>
{
private readonly ICommandHandler<TCommand> decorated;
private readonly IValidator<TCommand> validator;
public ValidationCommandHandlerDecorator(ICommandHandler<TCommand> decorated, IValidator<TCommand> validator)
{
this.decorated = decorated;
this.validator = validator;
}
public void Handle(TCommand command)
{
var results = validator.Validate(command);
if (!results.IsValid())
{
throw new ValidationException(results);
}
decorated.Handle(command);
}
}Global.asax
// inside App_Start()
var container = new Container();
Bootstrapper.Initialize(container);
// more MVC specific bootstrapping to the container. Like wiring up controllers, filters, etc..Program.cs
// Pretty much the same as the Global.asaxPrzepraszam za długą konfigurację problemu, nie mam lepszego sposobu na wyjaśnienie tego niż opisanie mojego rzeczywistego problemu.
Nie chcę tworzyć mojego CreateBookCommandValidator public. Wolałbym, internalale jeśli to internalzrobię, nie będę mógł zarejestrować go w moim kontenerze DI. Powodem, dla którego chciałbym, aby był wewnętrzny, jest to, że jedynym projektem, który powinien mieć pojęcie o moich implementacjach IValidate <>, jest projekt BookStore.Domain. Każdy inny projekt musi po prostu zużyć IValidator <>, a CompositeValidator powinien zostać rozwiązany, co spełni wszystkie kryteria sprawdzania poprawności.
Jak korzystać z Dependency Injection bez przerywania enkapsulacji? A może źle to robię?
Tylko nitpick: to, czego używasz, nie jest prawidłowym wzorcem poleceń, więc wywołanie go może być błędną informacją. Ponadto CreateBookCommandHandler wydaje się łamać LSP: co się stanie, jeśli przekażesz obiekt, który pochodzi z CreateBookCommand? I myślę, że to, co tu robisz, to w rzeczywistości antypateriał Anemic Domain Model. Rzeczy takie jak zapisywanie powinny znajdować się w domenie, a sprawdzanie poprawności powinno być częścią encji.
—
Euforia
@Euphoric: Zgadza się. To nie jest wzorzec poleceń . W rzeczywistości OP działa według innego wzorca: wzorzec polecenia / procedury obsługi .
—
Steven
Było tak wiele dobrych odpowiedzi, które chciałbym oznaczyć jako odpowiedź. Dziękuję wszystkim za pomoc.
—
Evan Larsen,
@Euforia, po ponownym przemyśleniu układu projektu, myślę, że CommandHandlers powinien być w domenie. Nie jestem pewien, dlaczego umieściłem je w projekcie infrastruktury. Dzięki.
—
Evan Larsen,
Powiązane: stackoverflow.com/q/31121611/264697
—
Steven