Objetos ignorantes de persistência são capazes de implementar carregamento lento?

A ignorância de persistência é uma aplicação do princípio de responsabilidade única, que na prática significa que os Objetos de Domínio ( DO ) não devem conter código relacionado à persistência; em vez disso, devem conter apenas lógica de domínio.

a) Suponho que isso significa que o código que contata as camadas inferiores (isto é, as camadas de persistência) vive fora do modelo de domínio em outras classes ( OC ) de uma camada de lógica de negócios?

b) Se minha suposição em a) estiver correta, DO , digamos Customer, nunca contém métodos como GetCustomersou GetCustomerByID?

c) Se os pressupostos sob a) e b) estão correctos, e assumindo Customerobjecto de domínio utiliza o carregamento lento para algumas das suas propriedades, em seguida, em algum momento Customerda lógica interna deve contactar OC , o que por sua vez recupera dados diferida. Mas se Customerprecisar entrar em contato com a OC para receber dados adiados, não podemos realmente afirmar que os Objetos de Domínio não contêm lógica relacionada à persistência ?!

Obrigado

RESPONDENDO A jkohlhepp

1) Eu assumo OrderProvidere CustomerProvideraulas estão contidos dentro de camada de lógica de negócios?

2) Pela sua resposta, deduzo que minhas suposições em b) estão corretas?

3)

... Verificaria se algum campo de pedidos particulares foi preenchido ou se era nulo. Se for nulo ...

Mas até onde eu sei, assim que o código de domínio precisar verificar se o ordercampo privado foi preenchido e, se não estiver, entrando em contato com o OrderProvider, já estamos violando o princípio do PI ?!

Acredito que você esteja correto em suas suposições A e B em relação à ignorância da persistência.

A melhor maneira de realizar o carregamento lento de objetos de banco de dados depende muito do seu problema e implementação. No entanto, tentarei uma resposta genérica para como fazer carregamento lento, mantendo a separação de preocupações entre as classes de persistência e lógica de domínio.

Costumo implementar a ignorância da persistência usando as seguintes classes:

• Classes de domínio - por exemplo, Cliente
• Classes de fornecedor / repositório - por exemplo, CustomerProvider
• Classes genéricas de consulta ao banco de dados - por exemplo, DatabaseQuery

A classe DatabaseQuery seria responsável pelo uso do driver do banco de dados para consultar o banco de dados e reunir os dados resultantes em um conjunto de resultados genéricos, como um DataTable. O CustomerProvider seria responsável por usar a classe DatabaseQuery para executar o SQL no banco de dados e usar os resultados desse SQL para montar instâncias do Cliente. O cliente seria um objeto de domínio "puro" que continha dados e lógica relacionados aos clientes.

Quanto a saber se as classes de provedor devem estar na camada de negócios ou na de dados, não tenho uma opinião forte. Eu posso ver um caso para ambos. A parte importante é que você separe as responsabilidades entre as classes.

Então agora vamos discutir o carregamento lento. Digamos que eu queria que o Cliente tivesse uma coleção de pedidos, mas não quero retirar os pedidos do banco de dados, a menos que o consumidor tente acessá-los. Eu criaria uma propriedade no Cliente chamada Orders. No getter dessa propriedade, eu verificaria se algum campo de pedidos particulares foi preenchido ou se era nulo. Se for nulo, carregue os pedidos do banco de dados usando um OrderProvider. Caso contrário, basta retornar a coleção que já foi carregada.

Na minha opinião, a necessidade de o Cliente entrar em contato com o OrderProvider não viola o PI. O cliente ainda não sabe como recebe os pedidos. Apenas sabe que os obtém do OrderProvider. Pode haver outros motivos para dissociar o Customer do OrderProvider, mas não acho que o PI seja um problema aqui.

Isso pressupõe que você esteja ignorando a persistência manualmente. Se você estiver usando uma estrutura ORM, como Entity Framework ou Hibernate, essas estruturas geralmente terão recursos para dar suporte ao carregamento lento automaticamente.

Você tem apenas uma classe de conexão que preenche os objetos do domínio (por exemplo, algo chamado "repositório"). Você pode implementar carregamento lento ou qualquer tipo de esquema de coerência de cache que desejar e os objetos do domínio não são os mais sábios. Você está separando a responsabilidade de preencher objetos de domínio de objetos de domínio.