Eu tenho um aplicativo da web. Não acredito que a tecnologia seja importante. A estrutura é um aplicativo de camada N, mostrado na imagem à esquerda. Existem 3 camadas.
UI (padrão MVC), Business Logic Layer (BLL) e Data Access Layer (DAL)
O problema que tenho é que meu BLL é enorme, pois possui a lógica e os caminhos através da chamada de eventos do aplicativo.
Um fluxo típico através do aplicativo pode ser:
Evento disparado na interface do usuário, vá para um método na BLL, execute a lógica (possivelmente em várias partes da BLL), eventualmente para o DAL, retorne à BLL (onde provavelmente há mais lógica) e retorne algum valor à interface do usuário.
O BLL neste exemplo está muito ocupado e estou pensando em como dividir isso. Eu também tenho a lógica e os objetos combinados dos quais não gosto.
A versão à direita é o meu esforço.
A lógica ainda é como o aplicativo flui entre a interface do usuário e o DAL, mas provavelmente não há propriedades ... Somente métodos (a maioria das classes nessa camada pode ser estática, pois não armazena nenhum estado). A camada Poco é onde existem classes que possuem propriedades (como uma classe Person, onde haveria nome, idade, altura etc.). Isso não teria nada a ver com o fluxo do aplicativo, eles apenas armazenam o estado.
O fluxo pode ser:
Mesmo acionado a partir da interface do usuário e passa alguns dados para o controlador de camada de interface do usuário (MVC). Isso traduz os dados brutos e os converte no modelo poco. O modelo poco é então passado para a camada lógica (que era o BLL) e, eventualmente, para a camada de consulta de comando, potencialmente manipulada no caminho. A camada de consulta de comando converte o POCO em um objeto de banco de dados (que é quase a mesma coisa, mas uma foi projetada para persistência e a outra para o front end). O item é armazenado e um objeto de banco de dados é retornado à camada de Consulta de Comando. Em seguida, é convertido em um POCO, onde retorna à camada Lógica, potencialmente processado posteriormente e, finalmente, volta à interface do usuário.
A lógica e as interfaces compartilhadas é onde podemos ter dados persistentes, como MaxNumberOf_X e TotalAllowed_X e todas as interfaces.
A lógica / interfaces compartilhadas e o DAL são a "base" da arquitetura. Eles não sabem nada sobre o mundo exterior.
Tudo sabe sobre o poco além da lógica / interfaces compartilhadas e do DAL.
O fluxo ainda é muito semelhante ao primeiro exemplo, mas tornou cada camada mais responsável por uma coisa (seja estado, fluxo ou qualquer outra coisa) ... mas estou rompendo a OOP com essa abordagem?
Um exemplo para demonstrar a lógica e o Poco pode ser:
public class LogicClass
{
private ICommandQueryObject cmdQuery;
public PocoA Method1(PocoB pocoB)
{
return cmdQuery.Save(pocoB);
}
/*This has no state objects, only ways to communicate with other
layers such as the cmdQuery. Everything else is just function
calls to allow flow via the program */
public PocoA Method2(PocoB pocoB)
{
pocoB.UpdateState("world");
return Method1(pocoB);
}
}
public struct PocoX
{
public string DataA {get;set;}
public int DataB {get;set;}
public int DataC {get;set;}
/*This simply returns something that is part of this class.
Everything is self-contained to this class. It doesn't call
trying to directly communicate with databases etc*/
public int GetValue()
{
return DataB * DataC;
}
/*This simply sets something that is part of this class.
Everything is self-contained to this class.
It doesn't call trying to directly communicate with databases etc*/
public void UpdateState(string input)
{
DataA += input;
}
}