O Padrão de “Unidade de Trabalho” do Entity Framework 4 é o caminho a seguir para repositórios genéricos?

Question

Estou pensando em criar uma estrutura de entidade 4 repositório genérico para um novo projeto ASP.NET MVC em que estou trabalhando. Eu tenho analisado vários tutoriais e todos parecem usar a unidade de padrão de trabalho ...

Pelo que tenho lido, a EF já está usando isso no ObjectContext e você está simplesmente estendendo isso para fazer suas próprias unidades de trabalho.

Fonte: http://dotnet.dzone.com/news/using-unit-work-pattern-entity?utm_source=feedburner&utm_medium=feed&utm_campaign=feed%3a+zones%2fdotnet+(.net+zona)

Por que alguém se esforçaria para fazer isso? Esta é a maneira preferida de trabalhar com repositórios genéricos?

Muito obrigado, Kohan.

Answer 1

Não é assim que eu trabalharia com repositórios genéricos. Primeiro de tudo, eu compartilharia o ObjectContext entre ClassArpository, CalssSbrepository e outros repositórios na solicitação atual. Usando o contêiner do IOC, recomenda -se o comportamento de injeção e solicitação:

É assim que meus repositórios genéricos se parecem:

public interface IRepository<T>
{
    //Retrieves list of items in table
    IQueryable<T> List();
    IQueryable<T> List(params string[] includes);
    //Creates from detached item
    void Create(T item);
    void Delete(int id);
    T Get(int id);
    T Get(int id, params string[] includes);
    void SaveChanges();
}

public class Repository<T> : IRepository<T> where T : EntityObject
{
    private ObjectContext _ctx;

    public Repository(ObjectContext ctx)
    {
        _ctx = ctx;
    }


    private static string EntitySetName
    {
        get
        {
            return String.Format(@"{0}Set", typeof(T).Name);
        }
    }

    private ObjectQuery<T> ObjectQueryList()
    {
        var list = _ctx.CreateQuery<T>(EntitySetName);
        return list;
    }

    #region IRepository<T> Members

    public IQueryable<T> List()
    {
        return ObjectQueryList().OrderBy(@"it.ID").AsQueryable();
    }

    public IQueryable<T> List(params string[] includes)
    {
        var list = ObjectQueryList();

        foreach(string include in includes)
        {
            list = list.Include(include);
        }

        return list;
    }

    public void Create(T item)
    {
        _ctx.AddObject(EntitySetName, item);
    }

    public void Delete(int id)
    {
        var item = Get(id);
        _ctx.DeleteObject(item);
    }

    public T Get(int id)
    {
        var list = ObjectQueryList();
        return list.Where("ID = @0", id).First();
    }

    public T Get(int id, params string[] includes)
    {
        var list = List(includes);
        return list.Where("ID = @0", id).First();
    }

    public void SaveChanges()
    {
        _ctx.SaveChanges();
    }

    #endregion

}

ObjectContext é injetado através do construtor. Métodos List () retornam iQueryable para processamento adicional em objetos de camada de negócios (serviço). Lista de devoluções da camada de serviço ou ienumerable, portanto, não há execução diferida nas visualizações.

Este código foi criado usando o EF1. A versão EF4 pode ser um pouco diferente e mais simples.