Como aplicar alguns conceitos de DDD ao código real? Perguntas específicas dentro

Estou estudando DDD e atualmente estou lutando para encontrar uma maneira de aplicar os conceitos no código real. Tenho cerca de 10 anos de experiência com o N-tier, por isso é muito provável que a razão pela qual estou lutando seja que meu modelo mental esteja muito acoplado a esse design.

Criei um aplicativo Web Asp.NET e estou começando com um domínio simples: um aplicativo de monitoramento da Web. Requisitos:

• O usuário deve poder registrar um novo aplicativo da Web para monitorar. O aplicativo da web tem um nome amigável e aponta para um URL;
• O aplicativo da web pesquisará periodicamente um status (online / offline);
• O aplicativo Web pesquisará periodicamente sua versão atual (espera-se que ele tenha um "/version.html", que é um arquivo que declara sua versão do sistema em uma marcação específica).

Minhas dúvidas dizem respeito principalmente à divisão de responsabilidades, encontrar o local apropriado para cada coisa (validação, regra de negócios, etc.). Abaixo, escrevi um código e adicionei comentários com perguntas e considerações.

Por favor, critique e aconselhe . Desde já, obrigado!

MODELO DE DOMÍNIO

Modelado para encapsular todas as regras de negócios.

// Encapsulates logic for creating and validating Url's.
// Based on "Unbreakable Domain Models", YouTube talk from Mathias Verraes
// See https://youtu.be/ZJ63ltuwMaE
public class Url: ValueObject
{
    private System.Uri _uri;

    public string Url => _uri.ToString();

    public Url(string url)
    {
        _uri = new Uri(url, UriKind.Absolute); // Fails for a malformed URL.
    }
}

// Base class for all Aggregates (root or not).
public abstract class Aggregate
{
    public Guid Id { get; protected set; } = Guid.NewGuid();
    public DateTime CreatedAt { get; protected set; } = DateTime.UtcNow;
}

public class WebApp: Aggregate
{
    public string Name { get; private set; }
    public Url Url { get; private set; }
    public string Version { get; private set; }
    public DateTime? VersionLatestCheck { get; private set; }
    public bool IsAlive { get; private set; }
    public DateTime? IsAliveLatestCheck { get; private set; }

    public WebApp(Guid id, string name, Url url)
    {
        if (/* some business validation fails */)
            throw new InvalidWebAppException(); // Custom exception.

        Id = id;
        Name = name;
        Url = url;
    }

    public void UpdateVersion()
    {
        // Delegates the plumbing of HTTP requests and markup-parsing to infrastructure.
        var versionChecker = Container.Get<IVersionChecker>();
        var version = versionChecker.GetCurrentVersion(this.Url);

        if (version != this.Version)
        {
            var evt = new WebAppVersionUpdated(
                this.Id, 
                this.Name, 
                this.Version /* old version */, 
                version /* new version */);
            this.Version = version;
            this.VersionLatestCheck = DateTime.UtcNow;

            // Now this eems very, very wrong!
            var repository = Container.Get<IWebAppRepository>();
            var updateResult = repository.Update(this);
            if (!updateResult.OK) throw new Exception(updateResult.Errors.ToString());

            _eventDispatcher.Publish(evt);
        }

        /*
         * I feel that the aggregate should be responsible for checking and updating its
         * version, but it seems very wrong to access a Global Container and create the
         * necessary instances this way. Dependency injection should occur via the
         * constructor, and making the aggregate depend on infrastructure also seems wrong.
         * 
         * But if I move such methods to WebAppService, I'm making the aggregate
         * anaemic; It will become just a simple bag of getters and setters.
         *
         * Please advise.
         */
    }

    public void UpdateIsAlive()
    {
        // Code very similar to UpdateVersion().
    }
}

E uma classe DomainService para lidar com Cria e Exclui, que eu acredito que não são da responsabilidade do próprio Agregado.

public class WebAppService
{
    private readonly IWebAppRepository _repository;
    private readonly IUnitOfWork _unitOfWork;
    private readonly IEventDispatcher _eventDispatcher;

    public WebAppService(
        IWebAppRepository repository, 
        IUnitOfWork unitOfWork, 
        IEventDispatcher eventDispatcher
    ) {
        _repository = repository;
        _unitOfWork = unitOfWork;
        _eventDispatcher = eventDispatcher;
    }

    public OperationResult RegisterWebApp(NewWebAppDto newWebApp)
    {
        var webApp = new WebApp(newWebApp);

        var addResult = _repository.Add(webApp);
        if (!addResult.OK) return addResult.Errors;

        var commitResult = _unitOfWork.Commit();
        if (!commitResult.OK) return commitResult.Errors;

        _eventDispatcher.Publish(new WebAppRegistered(webApp.Id, webApp.Name, webApp.Url);
        return OperationResult.Success;
    }

    public OperationResult RemoveWebApp(Guid webAppId)
    {
        var removeResult = _repository.Remove(webAppId);
        if (!removeResult) return removeResult.Errors;

        _eventDispatcher.Publish(new WebAppRemoved(webAppId);
        return OperationResult.Success;
    }
}

CAMADA DE APLICAÇÃO

A classe abaixo fornece uma interface para o domínio WebMonitoring para o mundo externo (interfaces da web, APIs de descanso, etc.). É apenas um shell no momento, redirecionando chamadas para os serviços apropriados, mas cresceria no futuro para orquestrar mais lógica (sempre realizada por meio de modelos de domínio).

public class WebMonitoringAppService
{
    private readonly IWebAppQueries _webAppQueries;
    private readonly WebAppService _webAppService;

    /*
     * I'm not exactly reaching for CQRS here, but I like the idea of having a
     * separate class for handling queries right from the beginning, since it will
     * help me fine-tune them as needed, and always keep a clean separation between
     * crud-like queries (needed for domain business rules) and the ones for serving
     * the outside-world.
     */

    public WebMonitoringAppService(
        IWebAppQueries webAppQueries, 
        WebAppService webAppService
    ) {
        _webAppQueries = webAppQueries;
        _webAppService = webAppService;
    }

    public WebAppDetailsDto GetDetails(Guid webAppId)
    {
        return _webAppQueries.GetDetails(webAppId);
    }

    public List<WebAppDetailsDto> ListWebApps()
    {
        return _webAppQueries.ListWebApps(webAppId);
    }

    public OperationResult RegisterWebApp(NewWebAppDto newWebApp)
    {
        return _webAppService.RegisterWebApp(newWebApp);
    }

    public OperationResult RemoveWebApp(Guid webAppId)
    {
        return _webAppService.RemoveWebApp(newWebApp);
    }
}

Fechando os assuntos

Depois de reunir as respostas aqui e nesta outra pergunta , que eu abri por um motivo diferente, mas ultimamente cheguei ao mesmo ponto que este, criei esta solução melhor e mais limpa:

Proposta de solução no Github Gist

Após longas linhas de aconselhamento sobre o seu WebAppagregado, concordo plenamente que repositorynão é a abordagem correta aqui. Na minha experiência, o Agregado tomará a 'decisão' de decidir se uma ação está correta ou não, com base em seu próprio estado. Portanto, não no estado, ele pode receber outros serviços. Se você precisar de tal verificação, geralmente eu o moveria para o serviço que chama o agregado (no seu exemplo, o WebAppService).

Além disso, você pode acessar o caso de uso que vários aplicativos desejam chamar simultaneamente de agregado. Se isso acontecer, enquanto você estiver fazendo chamadas de saída como essa, que podem levar muito tempo, estará bloqueando sua agregação para outros usos. Isso acabaria desacelerando a manipulação de agregados, algo que eu acho que também não é desejável.

Portanto, embora possa parecer que seu agregado se torne muito fino se você mover esse pouco de validação, acho melhor movê-lo para o WebAppService.

Eu também sugeriria mover a publicação do WebAppRegisteredevento para o seu agregado. O agregado é o cara que está sendo criado; portanto, se o processo de criação for bem-sucedido, faz sentido deixá-lo publicar esse conhecimento no mundo.

Espero que isso ajude você @Levidad!