minha pergunta é mais de natureza arquitetônica, menos envolvida com a implementação rea

Criei uma API baseada no WCF, mas não consigo decidir como separar o PL do BL. Eu diminuí meu serviço, para que ele tenha apenas um mínimo de implementação, algo como:

public TagItemResponse TagItem(TagItemRequest request)
{
   return (new ItemTagRequestProcessor()).GetResponse(request);
}

Naturalmente, surge a primeira pergunta: em que camada os RequestProcessors pertencem? Eu acho que seria errado chamá-los de fachada, mas, ao mesmo tempo, eles não têm nada a ver com apresentação. Por enquanto, decidi que eles ainda pertencem ao PL. Os métodos do processador tomam meus DTOs (DataContracts) como entrada, valida a mensagem de solicitação (classe base), autentica (classe base) e, eventualmente, retorna uma única resposta DTO, da seguinte forma:

protected override void Process(TagItemRequest request, TagItemResponse response, Host host)
{
    var profile = ProfileFacade.GetProfile(host, request.Profile);
    var item = ItemFacade.GetItemId(host, request.Item);
    var tags = new List<Tag>();

    foreach (var name in request.Tags)
    {
        var tag = TagFacade.GetTag(profile, name);
        ItemFacade.TagItem(item, tag);
        tags.Add(tag);
    }

    ItemFacade.UntagItem(item, tags);
}

Agora me pergunto: por que preciso das classes de fachada 1: 1 relacionadas aos meus objetos de negócios? Por exemplo, eu tenho um HostFacade que atua como uma camada entre o hostDAO e os processadores. No entanto, possui muito pouca lógica, apenas lida com as chamadas DA

public static Host GetHost(HostDTO dto)
{
   return HostDAO.GetHostByCredentials(dto.Username, dto.Password);
}

Pergunta: Eu também poderia mesclar os processadores e as fachadas, cert

Eu li muitos artigos / livros sobre o assunto, mas ainda não consigo decidir o caminho 'certo' a seguir e tento escolher uma abordagem diferente sempre que enfrento o problema. Gostaria de saber se existe uma abordagem correta.

Encontrei f.ex. o exemplo doFactory, em que eles conversaram com as classes DAO diretamente na implementação do serviço. Eu realmente não gosto disso, pois a maioria dos métodos ServiceContract compartilha alguma lógica e, portanto, se presta bem para uso com classes base compartilhada

Também encontrei outros exemplos em que apenas as fachadas são chamadas de dentro dos serviços, mas isso parece funcionar bem apenas para mensagens muito refinadas. Minhas mensagens são 'gordas' e compostas para reduzir ao máximo o número de chamadas para o serviço. Minha camada extra de processamento parece ser o meu verdadeiro problema.

Provavelmente não há uma resposta única sobre como colocar corretamente um serviço WCF em camadas, mas espero que alguns de vocês tenham uma opinião que conformar meus instintos ou lançar uma nova luz sobre o assunto para mim.

Thanx!

Geoffrey