LINQ para classes de entidade e dados de contexto SQL: objeto de negócios encapsulamento

Question

Quais são as suas favoritas maneiras para encapsular LINQ to SQL classes de entidade e classes de contexto de dados em objetos de negócios?

O que você encontrou para trabalhar em uma determinada situação?

Você já inventou ou levados para quaisquer padrões específicos?

Answer 1

Eu encontrei um padrão que eu acho que funciona melhor - No meu caso, pelo menos.
Dirijo classes de entidade usando classes parciais. Eu uso classes parciais de modo a assinatura da entidade não muda (veja a chamada DeleteOnSubmit no método Delete).

Eu já preparado um um pequeno exemplo. Aqui está uma imagem do banco de dados e LINQ para configurar classe SQL:

E aqui está a classe parcial em que eu implementar lógica de negócios:

/// <summary>
/// This class extends BusinessLogicDataContext.Products entity class
/// </summary>
public partial class Product
{
    /// <summary>
    /// New up a product by column: dbo.Products.ProductId in database
    /// </summary>
    public Product(Int32 id)
    {
        var dc = new BusinessLogicDataContext();

        // query database for the product
        var query = (
            from p in dc.Products 
            where p.ProductId == id 
            select p
        ).FirstOrDefault();

        // if database-entry does not exist in database, exit
        if (query == null) return;

        /* if product exists, populate self (this._ProductId and
           this._ProductName are both auto-generated private
           variables of the entity class which corresponds to the
           auto-generated public properties: ProductId and ProductName) */
        this._ProductId = query.ProductId;
        this._ProductName = query.ProductName;
    }


    /// <summary>
    /// Delete product
    /// </summary>
    public void Delete()
    {
        // if self is not poulated, exit
        if (this._ProductId == 0) return;

        var dc = new BusinessLogicDataContext();

        // delete entry in database
        dc.Products.DeleteOnSubmit(this);
        dc.SubmitChanges();

        // reset self (you could implement IDisposable here)
        this._ProductId = 0;
        this._ProductName = "";
    }
}

Usando a lógica de negócios implementados:

// new up a product
var p = new Product(1); // p.ProductId: 1, p.ProductName: "A car"

// delete the product
p.Delete(); // p.ProductId: 0, p.ProductName: ""

Além disso: LINQ to SQL classes de entidade são muito abertos na natureza. Isto significa que a propriedade correspondente ao dbo.Products.ProductId implementos coluna tanto um getter e um setter -. Este campo não deve ser mutável

Para o meu conhecimento que você não pode substituir as propriedades usando classes parciais, então o que eu costumo fazer é implementar um gerenciador que restringe o objeto usando uma interface:

public interface IProduct
{
    Int32 ProductId { get; }

    void Delete();
}

Answer 2

I tendem a usar o padrão Repository para DataContexts Encapsular.

Pattern Repository

Eu gostaria de encontrar uma maneira melhor para emitir POCO objetos da minha camada de dados durante a utilização LINQ2SQL embora.

Answer 3

Eu só publicou um exemplo de como você pode estruturar seu aplicativo que usa Linq para Sql para o armazenamento, usando IoC e T4-templates.

http://daniel.wertheim.se/2010/03/14/linq-to-sql-how-to-separate-the-entities-and-the-datacontext/

Answer 4

Agora eu estou tentando usar o LINQ to SQL classes de entidade como objetos de negócios, para passá-los ao redor entre funções e serviços.

Claro, você deve ter classes de entidades separadas para acessar banco de dados , para que o seu esquema de banco de dados pode mudar sem mudar os objetos de negócios!

Eu estaria mais interessado em uma solução boa para isso, também!

Answer 5

Confira o código-fonte para o aplicativo Sample MVC que Rob Conery está montando:

http://www.codeplex.com/mvcsamples/

Ele tem uma camada entidade separada que mapeia para o LINQ para classes SQL.

Answer 6

Eu fiz algumas experiências usando Entity Framework e LINQ to Entities como uma maneira de separar ainda mais o meu código de cliente do banco de dados, mas eu achei que desajeitado para usar e estava preocupado com o desempenho.

No meu projeto atual eu usar LINQ to SQL como minha camada de dados, mas tem classes separadas onde eu implementar todas as consultas LINQ. As classes retornar entidades definidas no meu Linq ao contexto SQL, mas as consultas estão escondidos em métodos.

Answer 7

Eu encontrei os artigos de Ian Cooper em CodeBetter.com e série Stephen Walther na inestimável compreender a necessidade de escrever as entidades POCO em primeiro lugar e, em seguida, mapeá-los para o banco de dados ao invés de fazê-lo o contrário (que é o que eu sempre costumava fazer).

Answer 8

Eu estou brincando com a idéia de ter uma camada separada do modelo OO (melhor suporte para práticas OO), mas que o uso de LINQ to SQL sob o capô. A idéia é ter um arquivo xml que uma ferramenta personalizada irá usar para gerar o código. Desde LINQ to SQL entites são muito confuso para as minhas preferências, vou auto-gerar novas classes para usar como meus entidades e, claro, o DataContext será completamente escondido para o código do cliente. Fazer a resposta curta é:. Criar novas classes de entidade, mas usar o LINQ subjacente a entidades SQL e DataContext