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;
        }
    }
}

; MyApp.ini
[Logging]
File Name = MyApp.log
MessageColumns = 5
MaxFileSize = 40000000000000

// Usando C#                                                                                                                
using Nini.Config;
 
IConfigSource source = new IniConfigSource("MyApp.ini");
 
string fileName = source.Configs["Logging"].Get("File Name");
int columns = source.Configs["Logging"].GetInt("MessageColumns");
long fileSize = source.Configs["Logging"].GetLong("MaxFileSize");

'E usando VB.Net
Imports Nini.Config
 
Dim source As New IniConfigSource("MyApp.ini")
 
Dim fileName As String = source.Configs("Logging").Get("File Name")
Dim columns As Integer = source.Configs("Logging").GetInt("MessageColumns")
Dim fileSize As Long = source.Configs("Logging").GetLong("MaxFileSize")

using System;
 
using System.Text;
using System.Windows.Forms;
 
namespace AlcoolGasolina
 
{
 
    public partial class frmPrincipal : Form
    {
        public frmPrincipal()
        {
            InitializeComponent();
        }
 
        /// Método de validação da entrada. Considera inválidos strings vazias e 
        /// valores menores ou iguais a zero.
        private bool isValid(string valor)
        {
            // Não deve ser uma string vazia ou nula
            if (String.IsNullOrEmpty(valor))
                return false;
            try
            {
                // deve ser um valor numérico válido
                double num = Convert.ToDouble(valor);
 
                // não deve ser menor ou igual a zero
                if (num > 0)
                    return true;
                else
                    return false;
            }
 
            catch (Exception)
            {
                return false;
            }
        }
 
 
		/// Verifica se os valores digitados são válidos e, em caso positivo, 
        /// faz o cálculo e apresenta a mensagem para o usuário informando
        /// qual é mais viável abastecer, álcool ou gasolina. Se os valores 
        /// não forem válidos para o cálculo, será exibida uma mensagem de 
        /// alerta, informando que os valores de entrada são inválidos.
        private void btnCalcular_Click(object sender, EventArgs e)
        {
            if (isValid(txtAlcool.Text.Trim()) && isValid(txtGasolina.Text.Trim()))
            {
                double alcool = Convert.ToDouble(txtAlcool.Text.Trim());
                double gasolina = Convert.ToDouble(txtGasolina.Text.Trim());
 
                double resultado = alcool / gasolina;
                if (resultado >= 0.7)
                    lblResultado.Text = "Abasteça com Gasolina";
                else
                    lblResultado.Text = "Abasteça com Álcool";
            }
            else
            {
                MessageBox.Show("Valores de entrada inválidos.",
                                "Erro",
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Exclamation,
                                MessageBoxDefaultButton.Button1);
 
            }
 
            txtAlcool.Text = string.Empty;
            txtGasolina.Text = string.Empty;
        }
 
        /// Fecha a aplicação.
        private void mnuSair_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }
 
        /// Menu "Sobre...", exibe uma mensagem com o nome da aplicação, 
        /// nome do autor e endereço do blog do autor.
        private void mnuSobre_Click(object sender, EventArgs e)
        {
            StringBuilder mensagem = new StringBuilder("Álcool ou Gasolina\n\n");
            mensagem.Append("Por Rogério Bragil\n\nBlog do Bragil - www.bragil.net");
            MessageBox.Show(mensagem.ToString(),
                            "Sobre",
                            MessageBoxButtons.OK,
                            MessageBoxIcon.None,
                            MessageBoxDefaultButton.Button1);
        }
    }
}