Blog do Bragil

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Metadata.Edm;
using System.Data.Objects;
using System.Data.Objects.DataClasses;
using System.Linq;
using System.Linq.Expressions;
using Net.Bragil.Data.Context;
 
namespace Net.Bragil.Data.DAO
{
 
    /// Repositório genérico para o Entity Framework com as operações mais 
    /// comuns de persistência, como inserção, atualização,
    /// exclusão e seleção.
    public class GenericDAO<E, C> : IDAO<E, C>, IDisposable
        where E : EntityObject
        where C : ObjectContext
    {
 
        /// Contexto do Entity Framework
        private C context;
 
        /// Contexto do Entity Framework
        public C Context
        {
            get { return context; }
            set { context = value; }
        }
 
 
        /// Retorna o nome do EntitySet do objeto persistente
        private string entitySetName;
 
        /// Retorna o nome do EntitySet do objeto persistente
        protected string EntitySetName
        {
            get
            {
                if (String.IsNullOrEmpty(entitySetName))
                {
                    entitySetName = GetEntitySetName(typeof(E).Name);
                }
 
                return entitySetName;
            }
        }
 
        /// Construtor padrão, sem argumentos. Obtém o contexto do 
        /// Entity Framework usando o ContextManager.
        public GenericDAO()
        {
            // Obtém o contexto
            this.context = ContextManager.GetContext<C>();
        }
 
        /// Insere um novo objeto persistente
        public void Insert(E entity)
        {
            context.AddObject(EntitySetName, entity);
        }
 
        /// Atualiza um objeto existente.
        public virtual void Update(E entity)
        {
            EntityKey key;
            object originalItem;
 
            if (entity.EntityKey == null)
                // Obtém o entity key do objeto que será atualizado
                key = Context.CreateEntityKey(EntitySetName, entity);
            else
                key = entity.EntityKey;
            try
            {
                // Obtém o objeto original
                if (Context.TryGetObjectByKey(key, out originalItem))
                {
                    if (originalItem is EntityObject &&
                        ((EntityObject)originalItem).EntityState != EntityState.Added)
                    {
                        // Autaliza o objeto
                        context.ApplyPropertyChanges(key.EntitySetName, entity);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
 
        /// Exclui um objeto persistente
        public void Delete(E entity)
        {
            context.DeleteObject(entity);
        }
 
        /// Retorna um objeto que satisfaça a cláusula passada como parâmetro.
        public E SelectOne(Expression<Func<E, bool>> where)
        {
            return context.CreateQuery<E>(EntitySetName).Where(where).FirstOrDefault();
        }
 
 
        /// Salva as alterações no banco de dados.
        public void SaveChanges()
        {
            context.SaveChanges();
        }
 
        /// Retorna todos os objetos persistentes.
        public List<E> SelectAll()
        {
            return context.CreateQuery<E>(EntitySetName).ToList();
        }
 
        /// Retorna um IQueryable com todos os objetos
        public IQueryable<E> QueryAll()
        {
            return context.CreateQuery<E>(EntitySetName).AsQueryable<E>();
        }
 
        /// Retorna todos os objetos usando paginação.
        public List<E> SelectAll(int maximumRows, int startRowIndex)
        {
            return context.CreateQuery<E>(EntitySetName).Skip<E>(startRowIndex).Take(maximumRows).ToList();
        }
 
        /// Retorna um IQueryable com todos os objetos usando paginação
        public IQueryable<E> QueryAll(int maximumRows, int startRowIndex)
        {
            return context.CreateQuery<E>(EntitySetName).Skip<E>(startRowIndex).Take(maximumRows);
        }
 
        /// Retorna todos os objetos que satisfaçam a cláusula passada
        public List<E> SelectWhere(Expression<Func<E, bool>> where)
        {
            return context.CreateQuery<E>(EntitySetName).Where(where).ToList();
        }
 
        /// Retorna todos os objetos que satisfaçam a cláusula passada, usando paginação
        public List<E> SelectWhere(Expression<Func<E, bool>> where, int maximumRows, int startRowIndex)
        {
            return context.CreateQuery<E>(EntitySetName).Where(where)
 
                          .Skip<E>(startRowIndex).Take(maximumRows).ToList();
        }
 
        /// Retorna o número de objetos
        public int GetCount()
        {
            return context.CreateQuery<E>(EntitySetName).Count();
        }
 
        /// Retorna o número de objetos que satisfaçam a cláusula passada
        public int GetCount(Expression<Func<E, bool>> where)
        {
            return context.CreateQuery<E>(EntitySetName).Where(where).Count();
        }
 
        /// Libera os recursos do Entity Framework.
        public void Dispose()
        {
            if (context != null)
                context.Dispose();
        }
 
        /// Retorna o nome do EntitySet, possibilitando a criação de métodos genéricos.
        private string GetEntitySetName(string entityTypeName)
        {
            var container = context.MetadataWorkspace
                                            .GetEntityContainer(context.DefaultContainerName,
                                                                       DataSpace.CSpace);
            string entitySetName = (from meta in container.BaseEntitySets
                                    where meta.ElementType.Name == entityTypeName
                                    select meta.Name).FirstOrDefault();
 
            return entitySetName;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
 
namespace Net.Bragil.Data.DAO
{
    /// Interface para a implementação do padrão Repository usando o Entity Framework.
    public interface IDAO<E, C>
    {
        /// Contexto do Entity Framework
        C Context { get; set; }
 
        /// Inserção
        void Insert(E entity);
 
        /// Atualização
        void Update(E entity);
 
        /// Exclusão
        void Delete(E entity);
 
        /// Retorna o objeto que satisfaça a cláusula passada como argumento (cláusula WHERE)
        E SelectOne(Expression<Func<E, bool>> where);
 
        /// Retorna todos os objetos de um tipo
        List<E> SelectAll();
 
        /// Retorna os objetos usando paginação
        List<E> SelectAll(int maximumRows, int startRowIndex);
 
        /// Retorna todos os objetos que satisfaçam a cláusula passada
        List<E> SelectWhere(Expression<Func<E, bool>> where);
 
        /// Retorna os objetos que satisfaçam a cláusula passada, usando paginação
        List<E> SelectWhere(Expression<Func<E, bool>> where, int maximumRows, int startRowIndex);
 
        /// Retorna um objeto IQueryable, possibilitando formar queries usando expressões Lambda
        IQueryable<E> QueryAll();
 
        /// Retorna um IQueryable com os objetos usando paginação
        IQueryable<E> QueryAll(int maximumRows, int startRowIndex);
 
        /// Retorna a quantidade de objetos persistentes.
        int GetCount();
 
        /// Retorna a quantidade de objetos persistentes que satisfaçam a cláusula WHERE
        int GetCount(Expression<Func<E, bool>> where);
    }
}

using System.Web;
using System.Data.Objects;
 
namespace Net.Bragil.Data.Context
{
    /// Classe gerenciadora do contexto do Entity Framework. Utiliza generics 
    /// para determinar em tempo de execução o tipo do contexto e Reflection 
    /// para instanciar o tipo genérico. Armazena o contexto no HttpContext, 
    /// de modo que não seja necessário instanciar o contexto nas próximas 
    /// chamadas dentro da requisição web.
    public sealed class ContextManager
    {
 
        /// Construtor privado, não será possível instanciar a classe usando new
        private ContextManager()
        {
 
        }
 
        /// Obtém o contexto do Entity Framework usando generics.
        public static T GetContext<T>()
            where T: ObjectContext
        {
            string ocKey = "ocm_" + HttpContext.Current.GetHashCode().ToString("x");
 
            if (HttpContext.Current != null)
            {
                if (!HttpContext.Current.Items.Contains(ocKey))
                {
                    // Instancia o contexto através de Reflection
                    T ctx = typeof(T).GetConstructor(System.Type.EmptyTypes)
                    				 .Invoke(System.Type.EmptyTypes) as T;
 
                    // Armazena na requisição
                    HttpContext.Current.Items.Add(ocKey, ctx);
                }
 
                return HttpContext.Current.Items[ocKey] as T;
            }
            else
                // Caso a aplicação não seja web, instancia e retorna o contexto.
                return typeof(T).GetConstructor(System.Type.EmptyTypes)
                				.Invoke(System.Type.EmptyTypes) as T;
        }
    }
}