O processo é bem simples. Na instância de seus adapter basta utilizar o comando FillSchema. Veja o código abaixo:

public void FillDataTable(out DataTable table, DbCommand command)

{
   var tableReturn = new DataTable();
   var adapter = new SqlDataAdapter((SqlCommand)command);
   adapter.Fill(tableRetorno);
   FillSchemasDaTaTable(tableReturn, adapter);
   table = tableRetorno;
}

private static void FillSchemasDaTaTable(DataTable table, SqlDataAdapter adapter)
{
   adapter.FillSchema(table, SchemaType.Source);
}

O código acima retorna um DataTable preenchido juntamente com os metadados. Em posse desta informação você pode varrer o DataColumnCollection contido no Table.Columnsrecuperando todos os seus atributos: como Nome da coluna, tamanho máximo, DataType etc. Veja o código a baixo:

public List<string> Read(DataTabletable)

{
   var fields = new List<string>();

varcolumns = table.Columns;

for (int i = 0; contador < columns.Count; contador++)
      fields.Add(colunas[i].ColumnName);

return fields;
}

Concluindo este artigo, descobrimos que a manipulação de estruturas de uma tabela de banco de dados pode ser feita com os recursos do próprio ADO.Net, que oferece uma forma rápida e fácil de se obter os metadados de uma tabela.

Para saber mais:

Aprofunde seus conhecimentos sobre este tema na comunidade C# (Csharp)
Aprofunde seus conhecimentos sobre este tema na comunidade ADO.NET

O Template Method é um Padrão de Projeto muito utilizado, bem provável que você já o implementou talvez sem se quer saber, ou que você futuramente o implementará, esse padrão possui uma abstração simples de assimilação o que torna o mesmo mais popular a grande comunidade de desenvolvedores , diferente de outros padrões de nível complexo.

Qual é a proposta do Template Method? 

O Template Method tem como proposta facilitar a implementação de cenários onde se deseja encapsular algoritmos, fornecendo as classes derivadas o poder de definir as pré-condições (input) do algoritmo e deixando a classe Base responsável pela estrutura do algoritmo, pré-condições globais que fazem sentido a todas classes deviradas, bem como, as pós-condições (output).

A idéia básica por trás desse modelo é disponibilizar uma única classe base que ficará responsável pela estrutura do algoritmo, evitando ter "pedaços" do algoritmo espalhados pelas classes deviradas o que gera redundância no código, a classe derivada será responsável de implementar o algoritmo de forma independente, cada classe devirada implementará o algoritmo de uma forma diferente ou igual porém sempre respeitando a estrutura do algoritmo que estará definida na classe Base.

Diagrama de classe de um Template Method 

Interessante observar que existe uma classe abstrata que será herdada pelas demais classes, sendo que dentro dessa classe abstrata nós temos um templateMethod() no corpo do templateMethod temos outros dois métodos que serão implementados pelas classes deviradas. 

Contextualizando com a realidade

Como o objetivo principal desse padrão é encapsular algoritmo, nada melhor que definir um processo.

Existe uma Empresa em São Paulo chamada "Docearia DevBrasil" sua especialidade é fazer bolos, porém devida a desorganização os bolos estão saindo diferentes, ou seja, você compra um bolo de chocolate hoje o sabor é x e se você comprar amanhã o mesmo bolo o sabor é y, isso acontece porque dentro da docearia existem 2 funcionários (Padeiro e Confeiteiro) que fazem bolos de chocolate e cada um faz de uma forma.

O Departamento de Marketing constatou o problema e para evitar o declínio do negócio pediu uma automação desse processo com extrema urgencia ao Departamento de TI. 

Depois de uma longa conversa a equipe de TI, resolveu mudar o processo que obrigou o Padeiro, Confeiteiro ou qualquer outro funcionário (Classe Derivada) da docearia a seguir um modelo de fazer bolo(template method) estabelecido por uma cartilha (Classe Base) para fazer um bolo.

Observando esse processo pela ótica OO

No código que segue abaixo é interessante observar que o padeiro e o confeiteiro não sabem como se faz um bolo eles apenas dizem eu quero o bolo de chocolate ou de morango e a classe Bolo fará todo o trabalho que já esta estruturado dentro da classe BoloBase que é herdada pela classe Bolo.

using System;

namespace DevBrasil

{

     public class EBolo

     {

          public enum TipoBolo { Chocolate = 1, Morango = 2}

     }

} 

using System;

namespace DevBrasil

{

     public abstract class BoloBase

     {  

         // template method

         public void FazerBolo

         {

             Passo1();

             Passo2();

         }

     }

     // esqueleto dos métodos

     public abstract void Passo1();

     public abstract void Passo2();

}

using System;

namespace DevBrasil

{

      public class Bolo : BoloBase

      {

            private EBolo.TipoBolo tipoBolo;

            public Bolo(EBolo.TipoBolo _tipoBolo)

            {

                 tipoBolo = _tipoBolo;

            }

            public override void Passo1()

            {

                 if(EBolo.TipoBolo.Chocolate == tipoBolo)

                 {

                      Console.WriteLine("Pega os ingredientes do bolo de chocolate");

                 }

                 else if(EBolo.TipoBolo.Morango == tipoBolo)

                 {

                      Console.WriteLine("Pega os ingredientes do bolo de morango");

                 }

             }

             public override void Passo2()

             {

                  if(EBolo.TipoBolo.Chocolate == tipoBolo)

                  {

                        Console.WriteLine("Mistura os ingredientes de chocolate e leva ao forno");

                  }

                  else if(EBolo.TipoBolo.Morango == tipoBolo)

                  {

                        Console.WriteLine("Mistura os ingredientes de morango e leva ao forno");

                  }

             }

     }

}

using System;

namespace DevBrasil

{

      public class Padeiro

      {

           public void FazerBolo(EBolo.TipoBolo tipoBolo)

           {

                 Bolo bolo = new Bolo(tipoBolo);

                 // chama o template method da classe BoloBase

                 bolo.FazerBolo();

           }

      }

}

using System;

namespace DevBrasil

{

       public class Confeiteiro

       {

             public void FazerBolo(EBolo.TipoBolo tipoBolo)

             {

                   Bolo bolo = new Bolo(tipoBolo);

                   // chama o template method da classe BoloBase

                   bolo.FazerBolo();

             }

       }

} 

using System;

namespace DevBrasil

{

       public class Program

       {

             static void Main(string[] args)

             {

                  // instancia um objeto do tipo padeiro

                  Padeiro padeiro = new Padeiro();

                  padeiro.FazerBolo(EBolo.TipoBolo.Chocolate);

                  // instancia um objeto do tipo confeiteiro

                  Confeiteiro confeiteiro = new Confeiteiro();

                  confeiteiro.FazerBolo(EBolo.TipoBolo.Morango);

             }

       }

} 

Nesse artigo, foi explicado como implementar um Template Method, e o quanto é importante definir a estrutura de um algoritmo numa única classe abstrata quando inúmeras classes podem precisar implementar esse algoritmo, basicamente a idéia do artigo consistiu em passar o conceito através de uma implementação simples, não envolvendo recursos complexos.

Para saber mais:

Aprofunde seu conhecimento sobre C#

GoFactory

Figura 1: T-SQL Encontrar Coluna por Nome

      O script acima retornará uma lista com os nomes de todas as tabelas do banco de dados AdventureWorks que contém uma coluna denominada “CustomerID”. Observe a Figura 2.

Figura 2: Resultado do processamento do script da Figura 1

      Existem formas diferentes para solucionar o problema proposto neste cenário. O exemplo acima, ilustra uma forma simples e prática. Você pode encapsular esse scritp numa stored procedure ou função para facilitar sua utilização pela equipe, até mesmo modificar o script para acrescentar informações relevantes para sua pesquisa.

Para saber mais:

Aprofunde seus conhecimentos sobre este tema na comunidade sql server

Com a versão do sql server express não temos como criar um backup automático pois a versão não dá suporte ao sql agent onde é responsável pelo processo.

Então para criar uma forma automatizada vamos usar :

NomeDoArquivo.sql : guarda comando de backup do sql server.
NomeDoArquivo.Bat : guarda usuário, senha( SQL server ) e caminho do arquivo .sql está salvo.

Agendador de tarefas do windows

Detalhando :
Os arquivos são criados em blocos de notas.
Dentro do NomeDoArquivo.Bat deverá conter o comando
osql -U usuário -P senha -i c:\pasta\NomeDoArquivo.sql.SQL
Dentro do NomeDoArquivo.sql deverá conter o comando
Backup Database NomeBanco to disk="C:\pasta\backup.Bak"

Agendador de tarefas do windows.

Caminho : Painel de Controle\Ferramentas Administrativas\Agendador de Tarefas.

Exemplo :

Escolha a opção que seja feita o backup automático.

Definir horário e data de início.

Escolher a opção "iniciar um programa".

Programar o script. Nesse caso será o arquivo .bat e concluir.

Com esses passos conseguimos definir um processo automatizado para criar backups agendados eliminando o uso manual do usuário. Lembrando que existe outras formas de
criar este processo como por exemplo usando stored procedure.

Para saber mais:
Aprofunde seus conhecimentos sobre este tema na comunidade sql server
Download do sql server express

Segundo o prestigiado Engenheiro de Software dinamarquês Anders Hejlsberg responsável pela criação da linguagem C#, o "milestone", ou seja, o grande marco da versão C# 4.0 é o recurso Dynamic Programming, esse artigo tem por objetivo explicar sobre esse recurso que visa mudar o paradigma de desenvolvimento atual em alguns cenários.

Programação dinâmica 

Linguagens como PHP, Perl, Python, Javascript e Ruby possuem portabilidade a programação dinâmica porque essas linguagens permitem que o desenvolvedor inclua um novo código ou altere métodos de objetos em tempo de execução e não em tempo de compilação.

Dynamic Language Runtime

Anders Hejlsberg tinha como objetico fornecer a os desenvolvedores .NET uma maneira simples de programar de forma dinâmica dentro de uma linguagem tipada estaticamente, parece contraditório, porém foi possível atráves de uma nova camada incluída dentro do Framework 4.0.

O DLR fornece a disposição dos desenvolvedores o "Dynamic Type" que deve ser utilizado usando a palavra reservava dynamic, que nada mais é do que um tipo estático, o dynamic pode ser qualquer tipo a diferença dele para os demais tipos é que ele força o compilador a não fazer nenhuma validação em tempo de compilação, fazendo com que as operações sejam validadas apenas em tempo de execução.  

Usabilidade

Sintaxe básica de um Dynamic Type.

dynamic var1 = "1";
dynamic var2 = 2;
dynamic var3 = new { DevBrasil = "Submmit 2012"};

Acima foi colocado alguns tipos de objetos que o dynamic aceita, lembrando que ele aceita qualquer tipo, e que podemos passar esses tipos por parâmetro ou como tipo de retorno de um método.

Antes do c# 4.0 sem Dynamic Programming

using System;

namespace DevBrasil
{
    public class Program
    {
        static void Main(string[] args)
        {
            SelecionarNomeMembro(new { NomeMembro = "Leandro Rodrigues" });
        }

        public static void SelecionarNomeMembro<T>(T t)
        {
            string nome = typeof(T).GetProperty("NomeMembro").GetValue(t, null) as string;

            Console.WriteLine(nome);
            Console.ReadLine();
        }
    }
}

Depois do c# 4.0 com Dynamic Programming

using System;

namespace DevBrasil
{
    public class Program
    {
        static void Main(string[] args)
        {
            SelecionarNomeMembro(new { NomeMembro = "Leandro Rodrigues" });
        }

        public static void SelecionarNomeMembro(dynamic obj)
        {
            Console.WriteLine(obj.NomeMembro);
            Console.ReadLine();
        }
    }
}

Com esses dois exemplos de código acima ficou fácil mensurar o ganho, antes era muito mais complexo, precisava ser empregado Reflection, de forma simples economizamos uma linha e deixamos o código muito fácil de ser entendido! =D.

Abaixo segue outro exemplo onde é extremamente vantajoso o uso do tipo dinâmico.

// Antes do c# 4.0 sem Dynamic Programming
var xmlDoc = new XmlDocument("arquivo.xml");
var xmlElement = xmlDoc.GetElement("membro").GetElement("nome");

// Depois do c# 4.0 com Dynamic Programming
dynamic xmlDoc = new XmlDocument("arquivo.xml");
var xmlElement = xmlDoc.membro.nome;

Outro nível de utilização e também muito importante é a portabilidade a componentes COM, bem como, a linguagens dinâmicas como IronRuby, porém deixaremos isso para um próximo artigo ;) ...

Vantagens

- Permite uma maior flexibilidade

- Melhora a utilização de objetos de componentes COM

- Portabilidade total a linguagens como IronPython e IronRuby

- Diminiu a complexidade existentes na manipulação de tipos anônimos.

Desvantagens

- Forte tendencia a gerar BUG.

Remediando a desvantagem  

O recurso dynamic type na minha concepção é muito interessante, no entando em alguns cenários temos alguns problemas,como tudo é resolvido apenas em tempo de execução, em tempo de compilação nada é verificado, ou seja, em tempo de execução uma variável do tipo inteiro pode ter atribuida para um tipo DateTime o que irar gerar bug.

O remédio para esses erros não existirem é a utilização de teste unitário, então todo desenvolvedor que for trabalhar com dynamic type dentro de um cenário complexo, deve saber que é de extrema necessidade realizar o teste unitário.

Nesse artigo, foi explicado a importancia da utilização do Dynamic Programming através do dynamic type, o objetivo foi mostrar em quais cenários podemos utilizar esse recurso, bem como, popularizar a utilização desse recurso na comunidade de desenvolvedores .NET.

Para saber mais:

Aprofunde seu conhecimento sobre C#  

MSDN Dynamic Type

Optional Arguments 

Optional Arguments é um recurso que permite ao desenvolvedor escrever um método definindo parâmetros com um valor padrão , dessa forma não existe a obrigatoriedade de especificar esse parâmetro na chamada desse método, porque internamente o CLR(Common Language Runtime) identifica esse valor padrão.

O código que segue a baixo ilustra como tinhamos que chamar um método nas versões anteriores, ou seja, não existia outra alternativa a não ser passar todos os parâmetros. 

using System;

namespace DevBrasil
{
    public class Program
    {
        static void Main(string[] args)
        {
           // chamada do método
           // é necessário informar os 3 parâmetros
          DevBrasil.SelecionarProduto(1, 10, 15);
        }
    }

    public class DevBrasil
    {
       public DevBrasil() { }
       public static void SelecionarProduto(int codProduto, int codCategoria, int qtdProduto)
       {
          // conteúdo do método
       }   
     }
} 

Para os parâmetros serem opcionais basta apenas utilizar o operador = (igual) mais o valor padrão.

Dessa forma quando o método é chamado não precisa informar os dois últimos parâmetros caso não ocorra necessidade. 

using System;

namespace DevBrasil
{
     public class Program
     {
        static void Main(string[] args)
        {
           // chamada do método
           // é passado apenas o primeiro parâmetro os outros dois são opcionais
           // porque codCategoria por padrão é 10 e qtdProduto é 20
          DevBrasil.SelecionarProduto(1);
        }
     }

    public class DevBrasil
    {
       public DevBrasil() { }
       public static void SelecionarProduto(int codProduto, int codCategoria = 10, int qtdProduto = 20)
       {
         // conteúdo do método
       }  
    }
} 

Antes do c# 4.0 sem Optional Arguments

// Salvar um objeto Workbook 
Workbooks.SaveAs(@"C:\DevBrasil.xlsx", 
Type.Missing, Type.Missing, Type.Missing, Type.Missing,
Type.Missing, Type.Missing, Type.Missing, Type.Missing,
Type.Missing, Type.Missing, Type.Missing, Type.Missing,
Type.Missing, Type.Missing); 

Depois do c# 4.0 com Optional Arguments

Workbooks.SaveAs(@"C:\DevBrasil.xlsx");  

Tivemos melhoras ;)  Lembrando que tudo isso o Framework faz para a gente por de trás dos panos! =D

Named Arguments

Named Arguments é uma alternativa para que o parâmetro possa ser informado em qualquer ordem na chamada do método, no exemplo anterior tinhamos que informar os parâmetros na mesma ordem que eles foram atribuídos no corpo do método, o Named Arguments resolve isso para nós! 

Segue a sintaxe utilizada para passar um argumento nomeado.  

using System;

namespace DevBrasil
{
     public class Program
     {
        static void Main(string[] args)
        {
           // chamada do método
           // são passados todos parâmetros utilizando named optional
           DevBrasil.SelecionarProduto(codProduto:1,codCategoria:40,qtdProduto:50);
        }
     }

     public class DevBrasil
     {
        public DevBrasil() { }
        public static void SelecionarProduto(int codProduto, int codCategoria = 10, int qtdProduto = 20)
        {
           // conteúdo do método
        } 
     }
}

Agora que acontece a mágica! Como internamente o CLR irá procurar pelo nome, não importará mais a posição que o parâmetro seja passado!!! =D

A chamada do método é realizada passando os parâmetros da forma inversa que eles foram declarados no corpo do método!

using System;

namespace DevBrasil
{
    public class Program
    {
       static void Main(string[] args)
       {
          // chamada do método
          // são passados todos parâmetros de forma invertida utilizando named optional
          DevBrasil.SelecionarProduto(qtdProduto: 50, codCategoria: 40, codProduto: 1);
       }
    }

    public class DevBrasil
    {
       public DevBrasil() { }
       public static void SelecionarProduto(int codProduto, int codCategoria = 10, int qtdProduto = 20)
       {
           // conteúdo do método
       } 
    }
}

Outra dica é que o Named e Optional Arguments também pode ser utilizados em métodos construtores.

Para saber mais:

Aprofunde seu conhecimento sobre C#

Artigo sobre Named e Optional Arguments MSDN 

Caso de Uso de Named e Optional Arguments

Desenho e Reuso

Desenhar software Orientado a Objeto não é uma tarefa fácil, desenhar um software Orientado a Objeto que seja reusável é uma tarefa muito mais difícil.

Algumas das tarefas são:

- Identificar as abstrações corretas.

- Definir classes na granularidade apropriada.

- Estabelecer interfaces, hierarquias e relacionamento.

Ou seja, deve-se pensar em tudo isso de forma a evitar o re-desenho, pois precisamos que o software seja flexível, desenhistas experiêntes conseguem criar bons desenhos OO, os que não tem experiência quase sempre entram numa modelagem estruturada.

Quais são as diferenças?

- Desenhistas experiêntes não tentam resolver todos os problemas usando "receita de bolo" eles procuram reusar soluções que funcionaram bem no passado, são capazes de identificar "padrões" recorrentes nos problemas enfrentados e nas soluções encontradas.

Definição de Padrão:

" Um padrao é uma solução recorrente para um problema em um determinado contexto " Erich Gamma

" Cada padrão descreve um problema que acontece repetidas vezes no nossos ambiente e então descreve a essência da solução para aquele problema, de forma que você possa usar essa solução um milhão de vezes, mas nunca fazendo duas vezes a mesma coisa " Chistofher Alexander

Padrão Adapter  

Ser adaptável é ser capaz de mudar para se enquadrar em outro contexto, como o camaleão que muda de cor se camuflando no ambiente para confundir seu predador, no entanto, em OO a palavra mudança não é verdadeira porque esse padrão respeita um dos príncípios gerais de OO "o código deve estar fechado para modificação e aberto para extensão".

Dessa forma quero dizer que o padrão adapter só deve ser usado se você não poder modificar sua(s) classe(s).

As vezes, precisamos utilizar métodos de uma classe existente para trabalhar com uma biblioteca também já existente, o desenho ideal para trabalhar dentro desse cenário é criar uma outra classe chamada Adapter que herdará de uma classe existente enquanto ao mesmo tempo implementará uma interface de uma biblioteca existente. O resultado final é que o Adapter pode chamar o método de uma classe existente através da herança, bem como, pode trabalhar com a existente biblioteca, desde que implemente a interface dessa biblioteca.

Segue UML do Padrão Adapter

- O Adaptee é uma classe existente

- A IInterface é um interface definida numa existente biblioteca

- O Adapter é a classe que você cria, é herdade da classe Adaptee e implementa a interface IInterface.

  Importante notar que você pode invocar o método OperationA da classe Adaptee utilizando o método OperationB da classe Adapter, por isso é muito comum pessoas dizerem que a classe Adapter tem o objetivo de converte uma interface.

Utilizaremos agora um exemplo no mundo real.

Vamos imaginar que temos uma classe chamada Aluno e toda classe Aluno acessa o método de um Adapter que implementa a interface IEstudante de uma biblioteca já existente.

Aluno precisa estar plugado dentro de um Adapter. O Aluno class é o Adaptee.

A forma de fazer isso é criar um Adapter class chamada AlunoAdapter, que herdada classe Aluno, enquanto que ao mesmo tempo implementa a interface IEstudante.

No adapter nos podemos chamar um método, o método Estudar da classe parente Aluno, então na classe AlunoAdapter nós podemos chamar o método Estudar através da implementação da interface IEstudante que a classe AlunoAdapter faz por meio do método Ler.

Agora vamos ver como isso funciona programaticamente, para isso teremos que pegar um avião e fazer uma breve viagem a objetolandia ;)

Importante notar que não precisamos mudar nenhum código da classe Aluno.

using System;
using System.Collections.Generic;

namespace DevBrasil
{
     class Program
     {
         static void Main(string[] args)
         {

            List <IEstudante>  listaEstudante = new List <IEstudante>();
            listaEstudante.Add(new Estudante("Pedro José"));
            listaEstudante.Add(new Estudante("Juca Cipó"));
            listaEstudante.Add(new AlunoAdapter("Ana Maria")); //Aluno de classe já existente
            Ler(listaEstudante);
            Console.Read();
         }

         // O código abaixo é de uma biblioteca existente e não precisa ser mudado
         static void Ler(List <IEstudante> listaEstudante)
         {
             foreach (IEstudante estudante in listaEstudante)
             {
                estudante.Ler();
             }
         }
     }

     // O código abaixo é de uma biblioteca existente e não precisa ser mudado
     public interface IEstudante
     {
        void Ler();
     }

     public class Estudante : IEstudante
     {
         private string nome;
         public Estudante(string nome)
         {
            this.nome = nome;
         }

        void IEstudante.Ler()
        {
           Console.WriteLine("Estudante " + this.nome + " precisa ler");
        }
     }

     // O código abaixo é de uma biblioteca existente e não precisa ser mudado
     public class Aluno
     {
         private string nome;
         public Aluno(string nome)
         {
             this.nome = nome;
         }

         protected void Estudar()
         {
             Console.WriteLine("Aluno" + this.nome + " precisa estudar.");
         }
     }

     public class AlunoAdapter : Aluno, IEstudante
     {
         public AlunoAdapter(string nome) : base(nome) { }
         void IEstudante.Ler()
         {
             base.Estudar(); // chama o construtor da classe Aluno
         }
     } 

} 

Quando aplicar :

- Deseja-se usar uma classe existente, mas a sua interface não bate com aquela esperada.

- Quer-se criar uma classe reusável que coopera com classes não-relacionadas e não-previstas, que podem não ser compatíveis.

Nesse artigo a gente pode notar a importância do Padrão Adapter dentro de um cenário no qual não podemos mudar nossas classes e sim apenas extendê-las, bem como, avaliamos o quanto é importante uma modelagem coesa, experimentada e aprovada, o que garante a qualidade do código e a facilidade para dar manutenção ao mesmo.  

Para saber mais:

Aprofunde seu conhecimento sobre C# 

Forum discussão sobre padrões 

Livro : GAMMA, Erich; HELM, Richard; JHONSON, Ralph; VLISSIDES; Jhon. Designer Patterns: Elemens of Reusable Object-Oriented Software. USA: Addilson-Wesley Professional Computing Series. 1995

Livro: FREEMAN, Eric; FREEMAN, Elisabeth. Head First Designer Patterns. USA O'Really, 2004

Livro: FOWLER, Martin, Patterns of Enterprise Application Architecture. USA: Hardcover, 2002

Para quem já conhece o EF (Entity Framework) com a utilização do Code First (Código primeiro) sabe como era incomodo ter que recriar o banco toda vez que realizasse uma nova alteração no modelo, isso a título de desenvolvimento. Com o pacote EntityFramework.Migrations disponibilizado no EF 4.2 é possível melhorar este cenário permitindo o desenvolvedor ter um controle maior do modelo do banco de dados, no qual permitirá até criar versões dos modelos gerados pelo EF.

Normalmente se utilizava classes de inicialização que recriavam o modelo do banco. Algo como:

context.Database.CreateIfNotExists();

Com isso o banco era recriado toda vez que encontrasse uma alteração no modelo de código ao comparar com os dados que são informados na tabela EdmMetadata que também era necessário. Na imagem abaixo é possível ver a tabela que é criada automaticamente pelo framework para seu controle.

EntityFramework.Migrations

No EF 4.2 não necessitamos criar uma classe de inicialização ou ficar recriando o banco de dados, apenas iremos gerar versões de nosso modelo e atualizar o banco para a versão desejada inclusive mantendo os dados existentes.

Para utilização da migração é necessário possuir obviamente o pacote EntityFramework e também do pacote EntityFramework.Migrations. Se você não possui os pacotes adicionados em seu projeto, acompanhe os seguintes passos da instalação através do NuGet que é uma extensão do Visual Studio e possui um console com diversas funcionalidades, dentre elas, baixar pacotes diretamente para seu projeto de maneira muito simples.

Com o NuGet instalado vá em: Tools –> Library Package Manager –> Package Manager Console

Você verá esta tela que é o console do Nuget. Para nosso exemplo, crie um projeto qualquer, irei demonstrar com um simples projeto Class Library de nome “DevBrasil”como mostrado abaixo, duas classes ainda sem relacionamento e o nosso contexto que não será explicado neste artigo, pois não é nosso objetivo e espera-se que o leitor conheça um pouco de EF.

Explicando apenas o “modelBuilder.Conventions.Remove<IncludeMetadataConvention>();” esta linha é adicionada para remover a necessidade da tabela EdmMetadata como mostrada no início e assim termos uma maior independência do controle do framework.

Importando os Pacotes Necessários 

Agora vamos adicionar os pacotes do EntityFramework e EntityFramework.Migrations ao nosso projeto.

Abra o console do NuGet e verifique primeiramente se o Default Project é o que você está utilizando e no console digite:

“Install-Package EntityFramework” e digite enter.

Você verá o processo de instalação e logo depois de obter a mensagem de confirmação:

“Successfully installed 'EntityFramework 4.2.0.0” e

“Successfully added 'EntityFramework 4.2.0.0' to DevBrasil”

Você pode conferir na pasta de referências se foi devidamente baixado conforme a figura a seguir.

Realize o mesmo processo para a instalação do pacote EntityFramework.Migrations pois ele ainda não está disponível dentro do pacote EntityFramework o que deverá acontecer futuramente assim como o EntityFramework também fazer parte do .Net Framework. Ao instalar o pacote no projeto é criada uma pasta chamada “Migrations” contendo um arquivo “Configuration.cs” como podemos ver na imagem abaixo da nossa solução.

Na imagem acima podemos ver a estrutura do arquivo “Configuration.cs”, por enquanto iremos apenas adicionar o contexto onde é indicado na primeira marcação e no construtor setamos uma propriedade “AutomaticMigrationEnabled” como false para mantermos mais controle ainda em nossas migrações sendo necessário gerar para cada modificação uma versão diferente. E removerei o comentário da segunda marcação para ficar mais limpa a classe. A imagem a seguir ilustra como ficará.

Agora vamos criar nossa primeira versão do Contexto (modelo) criado. Abra o console do NuGet e digite:

“Add-Migration PrimeiraVersao” e digite enter.

Será criada uma classe com o nome “PrimeiraVersao” com algumas informações relevantes no inicio. Essa classe contém dois métodos: Up e Down.

• Up: Método chamado quando é feita o Up-grade do banco ao solicitar a migração da versão.
• Down: Método chamado quando a classe é chamada como Down-grade caso já exista uma versão gerada posteriormente em uso.

Com a nossa primeira versão gerada só nos resta atualizar o banco, como não foi setado nenhum banco padrão no contexto, o Visual Studio fará com que seja criando no banco local, caso exista é claro. Para atualizar devemos abrir o Console do NuGet e digitar:

“Update-Database -TargetMigration:"PrimeiraVersao" –Verbose” e digitar enter.

Não é necessário digitar todo esse comando para se realizar uma atualização, na verdade só é necessário o “Update-Database” o “-TargetMigration” serve para nos garantir para qual versão estamos migrando, inclusive é com ele que realizamos down-grade, basta informar o nome da versão desejada. E “-Verbose” serve para exibir todo SQL que é executado dentro do próprio console do NuGet, então acho uma boa prática utilizar a atualização desta maneira.

Na imagem a seguir podemos ver o banco que foi gerado. A tabela foi gerada com nome “Opcaos” pela pluralização do Entity Frameworkque pode ser contornado quando as classes forem bem configuradas, o que não é nosso caso aqui.

Para testar uma atualização adicione na classe “Pessoa.cs” a propriedade:

public List<Opcao> Opcoes { get; set; }

E gere uma nova versão chamada “SegundaVersao” através do console do NuGet como já demonstrado antes, e depois atualize o banco informando a “SegundaVersao”. Ao conferir o banco você verá que foi adicionada a chave estrangeira a tabela "opcaos" sem deletar o banco, apenas realizando as modificações necessárias.

Neste artigo pudemos aprender como fazer migrações/atualizações no banco de dados de maneira rápida, simples e 100% ao controle do desenvolvedor quando se utiliza o Entity Framework Code First, a partir deste exemplo você será capaz de partir para outros estudos.

Para saber mais:

Aprofunde seus conhecimentos sobre ADO.NET

Blog ADO.NET

Blog da Julie Lerman's

Download do Nuget

Importante

Porém o foco do artigo não será ensinar o básico do MVC e nem a integração da aplicação com o banco de dados. O foco será totalmente voltado para a questão da autenticação. É interessante que o leitor já tenha um conhecimento prévio sobre o framework ASP.NET MVC para que não fique perdido.

Eu irei disponibilizar o download de uma aplicação básica, e nós iremos implementar nela um controle de login e depois definir os locais que um dado usuário poderá acessar.A estrutura dessa aplicação que iremos tomar como ponto de partida é a seguinte:

(O download da aplicação que usaremos está no final do artigo)

Imagem 1 - Estrutura básica da aplicação

Bom, primeiro é importante entendermos a lógica utilizada para modelar o banco de dados utilizado.

Imagem 2 - Estrutura do banco de dados

Podemos ver que a relação entre Usuários e Permissões é uma relação de muitos para muitos, pois um usuário pode ter várias permissões, e uma permissão pode pertencer a vários usuários. O Entity Framework já mapeou essa relação entre as entidades, como pode ser visto ali, o Usuario possui uma lista de Permissoes e vice-versa.

Autenticação

Para iniciarmos, crie um novo diretório no nosso projeto, chamado Repositories. É nele que iremos guardar os repositórios da aplicação, que nada mais são do que classes que irão manipular a parte de dados da aplicação. Criado o diretório, crie dentro dele uma classe chamada UsuarioRepositorio, que será o repositório de Usuários, é nele que iremos implementar funcionalidades, como o método que irá tentar autenticar uma pessoa entre outros. (Que fique claro aqui que essa maneira como estou criando os diretórios, trabalhar com repositório, é uma opinião pessoal, cada um desenvolve da maneira que achar mais organizada, se você preferir organizar a estrutura de outra maneira não tem problema algum. Feito os passos acimas deveremos ter algo como a imagem abaixo:

Imagem 3 - Novo repositório

Agora abra a nova classe criada "UsuarioRepositorio", e vamos implementar alguns métodos e propriedades nela. Primeiramente iremos criar um método estático chamado AutenticarUsuario que receberá como parâmetro duas strings, uma é o Login e a outra é a Senha. O resultado final será esse:

Imagem 4 - Código para autenticar o usuário

O código acima se auto-explica facilmente. Primeiro nós verificamos se os dados informados realmente existem no banco de dados e se pertencem, caso se obtenha sucesso, é setado o cookie de autenticação. O próximo passo agora é criamos um método estático que irá retornar o Usuario que está logado, caso existir um usuário logado é claro. O código final desse outro método será o seguinte:

Imagem 5 - Código para buscar o usuário logado

O código acima também é simples, ele apenas verifica se existe algum usuário logado (existência do cookie encriptado), caso exista ele faz uma busca no banco de dados e retorna um objeto Usuario.

Vamos implementar também no repositório Usuário, um método que irá desfazer a autenticação, ou seja, vai "Deslogar". Ele é bem simples:

A próxima etapa agora é implementar a autenticação na hora que usuário tentar logar. Se você verificar, no controlador "UsuarioController" já existe o ambiente preparado para exibir a página de login, e também para tratar o processamento lógico, que é quando o usuário envia o formulário preenchido. Na aplicação que estamos usando como base, já está criado o View para o usuário fazer o login. A URL dessa página de login é por convenção "/Usuarios/Logar", pois o nome do controller é Usuarios e o do método é Logar.

Abra a classe "UsuarioController", que se encontra no namespace Controllers da aplicação. Vá até o método "public ActionResult Logar(UsuarioLogin_M model)". É aqui que iremos disparar aquele método estático "AutenticaUsuario" que criamos lá no repositório do Usuario. Observe como ficará o código:

Imagem 6 - Código disparado quando o usuário tenta logar

Se você executou todas etapas corretamente, rode a aplicação e vamos testar, para ver se o login está funcionando corretamente. Já existe um usuário de testes cadastrado, os dados para logar nele é teste/teste. Se você conseguiu efetuar o login e chegou na página abaixo, significa que a parte da autenticação está completa.

Imagem 7 - Resultado da autenticação

Permissões

Bem, com a autenticação funcionando, vamos partir para as permissões. Se você reparar no controller "UsuarioController", no método que retorna o View da página que somente usuários logados podem acessar, existe uma anotação "[Authorize]" nele.

Imagem 8 - Anotação Authorize

A anotação Authorize é um recurso do modo que estamos utilizando para autenticar nossos usuários (FormsAuthentication). Todo método que tiver essa anotação, quando requisitado, passará por uma verificação para ver se existe um usuário logado ou não.

O problema é o seguinte, e se nós possuirmos dois tipos de usuários, por exemplo, os usuários comuns e um outro tipo, que seria os administradores. É obvio que os administradores teriam acessos a outras áreas do site. Conforme falado lá no inicio, o nosso banco de dados foi estruturado para funcionar desta maneira, com vários tipos de usuários.

A seguir iremos fazer algumas implementações para que a anotação Authorize receba as permissões por parâmetros. Quando o Authorize é executado, ele busca as "Roles" que seriam no nosso caso, as permissões disponíveis para o usuário. O que acontece é que como estamos fazendo isso de uma maneira alternativa, armazenando as permissões em nosso DB, precisamos sobrescrever o método que lista as "Roles" de um certo usuário.

Para iniciar, nós iremos criar um outro diretório em nossa aplicação, chamado "Security". Dentro desse diretório, crie uma nova classe em branco chamada "PermissaoProvider" e estenda essa classe a classe "RoleProvider" que faz parte do namespace "System.Web.Security". O próximo passo é selecionarmos a opção para que o Visual Studio implemente para nós todos métodos da classe abstrata "RoleProvider" como mostra a imagem abaixo:

Imagem 9 - Implementação automática dos métodos da RoleProvider

Após clicar na opção mostrada na imagem, será criado vários métodos em nossa classe, mas apenas um nos interessa no momento. Esse que nos interessa se chama "GetRolesForUser". Nós iremos sobrescrever ele, esse método é o que foi falado acima, ele é responsável por retornar um array de strings que são as Permissões de um usuário. Veja como ficará o método:

Imagem 10 - Sobrescrevendo o método GetRolesForUser

Bom amigos, agora nós precisamos informar a nossa aplicação, que nós alteramos a classe que fornece as Permissões de um usuário. Iremos fazer isso modificando ou inserindo uma tag no arquivo de configuração "Web.config".

Abra este arquivo, e procure pela tag <roleManager> e delete ela. Feito isso, insira ela novamente só que informando agora o local da nova classe que criamos (PermissoesProvider) conforme a imagem abaixo:

Imagem 11 - Alterando o Web.config

O que nós fizemos acima, foi interceptar e alterar o jeito com que as permissões de um usuário são buscadas. 

Agora é o ultimo passo para se concretizar o processo. Nós iremos sobrescrever um método da classe "AuthorizeAttribute" que é a classe responsável pela anotação "[Authorize]". 

Crie uma nova classe no diretorio "Security" chamada "PermissoesFiltro" e estenda ela a classe "AuthorizeAttribute" que pertence ao namespace System.Web.Mvc. Feito isso, sobrescreva o método "OnAuthorization(AuthorizationContext filterContext)" conforme a imagem abaixo:

Imagem 12 - Sobrescrevendo o método OnAuthorization

Nós sobrescrevemos esse método "OnAuthorization" para poder dizer para a aplicação o que fazer quando um acesso for negado.

Agora finalmente, vamos voltar lá no Controller "UsuarioController". Delete a anotação "[Authorize]" dele, e vamos implementar nele agora as permissões do nosso modo.

Vamos supor que a página "/Usuarios/Principal" só poderá ser acessada por usuários que possuem a permissão de "Gerente". Veja como ficaria a anotação do método:

Imagem 13 - Configurando as permissões de uma localização

E vamos supor novamente, que para o usuário acessar a página acima, ele precisa ter duas permissões (Gerente e Avançado). Veja como ficaria a definição:

Imagem 14 - Duas permissões em uma localização

Bom pessoal, é isso. O artigo ficou meio cansativo pois é muita coisa para se tratar, mais o MVC é uma forma muito inteligente para trabalhar com aplicações web. Espero que meu compartilhamento tenha sido útil. Obrigado.

Para saber mais:
Confira outras publicações sobre este assunto na comunidade ASP.NET
ExemploAutenticacao - Basica.rar
ExemploAutenticacao - Final.rar

Inner Join

O Inner Join é o Join Padrão utilizado nas operações de relacionamento nos bancos de dados quando nenhum outro Join é utilizado.

Ele gera o produto cartesiano entre as tabelas.

Gerar o produto cartesiano significa basicamente que esse tipo de join combina todas as linhas da primeira tabela com todas as linhas da segunda que satisfaçam as condições da cláusula especificada no relacionamento.

Um exemplo de Inner Join pode ser visto no seguinte comando SQL:
 

Repare que o resultado do SQL retorna 6 colunas, ou seja,  todas as colunas da tabela USUARIO e também todas as colunas da tabela DEPARTAMENTO.

Repare também que no resultado nós obtemos dois retornos de "COD_DEPARTAMENTO". Isso ocorre porque ao especificarmos "*" em nosso SELECT, ele retorna todas as colunas das tabelas que solicitamos.

Vale ressaltar também que para montar relacionamentos não é obrigatório que os campos utilizados na condição do relacionamento tenham os mesmos nomes, eles podem ter nomes diferentes desde que seja informada a condição do relacionamento no SQL.

Equi Join

O Equi Join é similar ao primeiro join apresentado, com a característica que as chaves do relacionamento apresentado devem haver os mesmos nomes.

Na verdade o Equi Join é uma forma simplificada de escrever o Inner Join quando temos os campos relacionados com os mesmos nomes.

Analise o SQL abaixo:

Select *

From Usuario
Join Departamento USING (Cod_Departamento);

O SQL acima retornará todos os campos de ambas as tabelas visto que ambas tem a coluna com o nome "COD_DEPARTAMENTO", contudo, no  SQL Server e Sybase a clausula "USING" não é suportada.

Non Equi Join

É possível também criar relacionamentos entre tabelas que não possuam campos em comum.

Considere as seguintes tabelas:

 E os dados populados: 

A tabela PESSOAS apresenta algumas pessoas de uma empresa e seus salários e a tabela SALARIO representa alguns cargos com faixa salarial cadastrada.

Para que possamos criar um relacionamento onde o resultado seja o nome da pessoa, seu salário e qual é o seu cargo baseado na sua faixa salarial, podemos fazer a expressão SQL dessa forma:

SELECT P.NOME, S.CARGO, P.SALARIO

FROM PESSOAS P
INNER JOIN SALARIO S ON P.SALARIO BETWEEN S.SALARIO_INICIAL AND S.SALARIO_FINAL

Note que após o parâmetro "FROM", temos o nome da tabela "PESSOAS" e logo em seguida um "P". Essa é uma forma de criar "alias" (apelidos) para as tabelas.

O intuito de criar apelidos para as tabelas é facilitar a forma como escrevemos a expressão SQL, ou seja, estamos dizendo que P é igual PESSOAS na expressão SQL.

O operador BETWEEN é utilizado para estabelecer um range entre um valor inicial e um valor final.

O resultado dessa expressão SQL é: 

Note que o Non Equi Join é apenas o nome dado ao termo de qualquer uma das outras expressão JOIN que não possua um campo em comum entre as tabelas.

Left Join

Esse tipo de JOIN obtém no resultado algumas linhas que não satisfazem a condição especificada do relacionamento em questão.

A propriedade LEFT que existe nesse JOIN, indica que as linhas da tabela à esquerda irão aparecer no resultado, mesmo que os registros não satisfaçam as condições especificadas no relacionamento.

Para exemplificar melhor a idéia, considere as tabelas abaixo populadas:

Tabela PESSOAS:
 

Tabela VEICULOS:
 

Ao executarmos o SQL:

SELECT * FROM PESSOAS
LEFT JOIN VEICULOS ON PESSOAS.CPF = VEICULOS.CPF

O resultado será:
 

Repare que o todos os dados da tabela da ESQUERDA (LEFT) foram selecionados.

Com esse exemplo acima, podemos entender perfeitamente como o RIGHT JOIN funciona, considerando que os dados serão retornados da tabela da direita por sua vez.

Full Join

Utilizando o mesmo exemplo de tabelas acima, o Full Join atua de forma que TODOS os registros, independentes do relacionamento feito serão apresentados. Podemos considerar que o Full Join nesse caso traria o resultado tanto do LEFT JOIN quanto do RIGHT Join.

Self Join

Até então nós falamos como relacionar diferentes tabelas, contudo, também é possível fazer um relacionamento da tabela com ela mesma.

Considere a tabela populada abaixo para esse exemplo:

Tabela INDICADOS
 

A idéia da tabela é salvar o nome, cpf e cidade de um usuário e se ele foi indicado por alguém. Podemos considerar então que a indicação seja feita através da coluna CPF. Dessa forma, Eduardo foi indicado por Ray.

Para conseguirmos essa informação, temos que fazer um relacionamento da tabela com ela mesma!

Considere a expressão SQL abaixo:

SELECT A.NOME, B.NOME AS INDICADO_POR

FROM INDICADOS A JOIN INDICADOS B ON A.INDICADO = B.CPF

O resultado será:

Nesse artigo pudemos aprender algumas maneiras de trabalhar com relacionamentos no SQL. É muito importante que a modelagem do seu banco de dados seja feita da melhor maneira possível para assegurar que não hajam redundâncias e também melhorar o desempenho do seu banco de dados e das aplicações que acessarem o banco.

Para saber mais:

Aprofunde seus conhecimentos sobre este tema na comunidade SQL Server
Aprofunde seus conhecimentos sobre normalização de banco de dados

Visual Studio 2010

Visual Studio é a ferramenta de desenvolvimento da Microsoft.

O java SDK

O Java Development Kit( JDK ) produto destinado para desenvolvedores em Java liberada pela Oclare Corporation.

Android SDK
 O Android SDK é o kit de desenvolvimento para a plataforma Android.

Mono Android
O mono android é o plugin desenvolvido pela xamarin, o plugin não é grátis, porém é possível efetuar o download e testá-lo.

Após instalação no visual studio apacerá da seguinte forma:
 

Entendendo o escopo : 

[Activity(Label ] : Nome do aplicativo que será exibido na tela após a execução.

Icon = "@drawable/icon" = Pasta do ícone do aplicativo que ficará nos aplicativos instalados.

MainLauncher : Verifica se a tela é principal do aplicativo.

Class activity : classe principal, toda classe para aplicação android deve ser derivada da classe activity.

SetContentView : Responsável pela exibição da tela da aplicação.

Button.Click : Inserção do código no botão.

Com o mono Android você está preparado a desenvolver para plataforma Android usando todo o seu conhecimento na linguagem C#. É óbvio que existe outras ferramentas destinadas para o desenvolvimento na plataforma android, mas quem gosta do Visual Studio e tem todo o conhecimento na ferramenta vale a pena instalar e tirar as conclusões.

Para saber mais:
Aprofunde seus conhecimentos sobre este tema na comunidade mono android
Download do android sdk
Download do java sdk
Download do mono android

O Método que mais me satisfaz, é a Comparação Bit-A-Bit, ao qual comparamos cada Bit do Arquivo A, com o do Arquivo B, ao invés de fazermos Comparações com o Nome dos dois Arquivos, que acaba sendo uma maneira errada de se proceder.

 Para começar a trabalhar com este tipo de comparação, criaremos um Aplicativo de Console, indo em: FILE->New-> Project->Windows->ConsoleApplication, dentro de nosso Visual Studio 2010.   Nomearemos o Projeto como: "ComparandoArquivosCSharp", como mostra a figura:

Agora, precisamos "chamar" as Bibliotecas: System.IO e System no Cabeçalho de nosso Código. Dessas Bibliotecas, tiraremos várias Classes essenciais para o que queremos fazer.

  O próximo passo é começar a Trabalhar com a verificação dos Arquivos, para isso, vamos criar duas Variáveis que armazenarão o Diretórios de cada Arquivo, e depois fazer com que cada Arquivo seja convertido para uma "Arrays" do tipo byte[]:

Agora ficou fácil, basta que comparemos cada Bit de cada "Array", daí o nome: Comparação BIT-A-BIT, e caso o Arquivo A seja igual ao Arquivo B, mostraremos uma Mensagem no Console dizendo que "São Iguais", senão, mostraremos uma Mensagem dizendo: "São diferentes":  

 Trabalhamos com um Arquivo pré-definido, porém, com a finalidade de mostrar o poder desta Técnica, poderíamos possibilitar que o Usuário selecionasse um Arquivo dentro de seu Computador, ou mesmo usar isso em um Aplicativo ASP.NET.

 Comparações "Bit-a-Bit", são eficazes quando queremos comparar dois arquivos com mais "certeza" e com mais "Segurança" em C#, porém existe vários outros Métodos. 

Para Saber Mais:

Informações sobre a Biblioteca System.IO no MSDN 

Aprenda mais sobre C# no Grupo correspondente no DevBrasil

Antes de falar de Box e unboxing é importante saber um pouco sobre a arquitetura e os tipos de dados dentro do .NET Framework.

CTS - Common Type System

Os tipos são fundamentais em qualquer linguagem de programação. A Microsoft tem a idéia de tornar tudo o mais padrão e integrado possível, ela criou uma especificação de tipos chamada de "Common Type System" (CTS) que descreve bem os tipos de dados e como eles se comportam.

É importante ressaltar que esses tipos são compartilhados em todas as linguagens do .NET Framework, ou seja, os mesmos tipos que você utiliza em uma aplicação C# você também consegue trabalhar em VB.NET.

Não tem como falar de CTS e não citar a mais importante regra definida por ele: Todos os tipos devem herdar direta ou inderetament de System.Object. Esta é a raiz de todos os tipos dentro do .NET Framework e também é a raiz para todos os tipos que você eventualmente vier a criar.

CLS - Common Language Specification

Já que dissemos que CTS é compartilhada em todas as linguagens, vale ressaltar que a Microsoft criou a CLS (Common Language Specification) que é responsável por especificar o conjunto mínimo de recursos que devem ser suportados quando os códigos são gerados na CLR.

CLR - Common Language RunTime

O coração da plataforma .NET é o CLR (Common Language Runtime), que é uma aplicação similar a uma máquina virtual (igual aquela mesma do Java) que se encarrega de providenciar a execução das aplicações para ela escritas.

São oferecidos a estas aplicações numerosos serviços que facilitam seu desenvolvimento e manutenção que favorece sua confiança e segurança. O CLR é o verdadeiro responsável pela interoperabilidade entre as linguagens suportadas pela plataforma .NET.

O CLR suporta duas espécies de tipos: Tipos-Valor (Value types) e Tipos-Referência (Reference Types).

Os tipo-valor são variáveis que diretamente contém o seu próprio valor, sendo assim, cada variável mantém a cópia dos seus dados. Se você fizer alguma operação que manipule os valores dessa váriavel, consequentemente o seu valor não será afetado.

Já os tipos-referência contém a referência em memória que aponta para o valor dos dados ao invés dos valores propriamente ditos. Como os tipos-referência apontam para um local, uma operação poderá manipular seu valor original.

Tendo esse conhecimento básico, agora sim podemos falar de Box e Unboxing.

Boxing

Boxing é o processo de converter um tipo-valor para um tipo-objeto ou qualquer tipo de interface implementada por esse tipo-valor. Quando a CLR faz um "box" em um tipo-valor, ele "encapsula" o valor dentro de um System.Object e guarda esse valor na memória heap.

Por sua vez, o Unboxing retira o tipo-valor do objeto. O boxing é implícito e o unboxing também.

O conceito de boxing e unboxing recai na idéia que os tipos de dados de uma forma geral pode ser tratado como um objeto.

No exemplo a seguir, a variável inteira realiza um "box" e é assimilada ao objeto.

int i = 123;             
 //A linha a seguir faz um box na variável i, copiando o valor de i para um objeto.
object o = i;

Também é possível fazer o boxing implicitamente mas o boxing explícito nunca é requerido.

Unboxing

O Unboxing é a conversão explícita de um tipo objeto ou algum tipo interface para o tipo-valor.

O processo de unboxing consiste em:

- Checar a instância do objeto para ter certeza que os valores são do mesmo tipo

- Copiar o valor da instância para a variável tipo-valor.

int i = 123;
// a é uma variável tipo-valor
object o = i;             
 //boxing foi feito, ou seja, o valor foi colocado em um objeto
int j = (int)o;             
 // unboxing foi feito na variável j

A figura a seguir representa o resultado do código anterior:



Para o unbox ter sucesso em tempo de execução, o ítem que estiver sofrendo o Unbox tem que conter
uma referência para o objeto que foi criado previamente pelo box feito da instância do tipo-valor.

Tentativas de Unbox com valores null causam exceção "NullReferenceException".

Tentativas de fazer Unbox com uma referência que tenha um tipo-valor incompatível resulta em
uma exceção "InvalidCastException".

Performance

Com relação a performance, boxing e unboxing são computacionalmente processos custosos para a CPU. Quando é feito boxing em um tipo-valor, um novo objeto deve ser alocado e construído. Também quando é custoso para a CPU quando é feito um Cast no unboxing;

Esse artigo relatou uma noção básica sobre CTS, CLS, CLR, tipos-valor e tipos-referência e
por fim uma breve explicação sobre Box e Unboxing. É muito importante que nós, desenvolvedores,
saibamos como a arquitetura do .NET Framework funciona para que estejamos aptos a escrever
código com qualidade!

Para saber mais:

Aprofunde seus conhecimentos sobre este tema na comunidade C#

Aprofunde seus conhecimentos sobre tipos-referência

Aprofunde seus conhecimentos sobre tipo-valor

Aprofunde seus conhecimentos sobre performance

Referência dos códigos fontes

O Project Server 2010 funcionando sobre o Sharepoint Server 2010, entrega aos gerentes de projetos soluções flexíveis para acompanhar o status atualizado de cada projeto , bem como gerenciar a disponibilidade de recursos, tanto nas equipes que utilizam metodologia ágil como nas formais que trabalham no TFS.

Essa integração permite sincronizar as informações dos itens de trabalho do TFS 2010 com as tarefas dos planos de projetos que estão armazenados no Project Server 2010. Dessa forma os Gerentes e o time de desenvolvimento podem usar os recursos que desejarem, ter as informações atualizadas com precisão e compartilhando as informações.

Após os produtos serem devidamente configurados, o pacote de sincronização mantem todas as informações de planejamento e uso de recursos de acordo com o mapeamento feito entre os projetos do Project Server e os Team Projects do TFS 2010.

Irei abordar principais praticas para fazer a integração do TFS 2010 com o Project Server, porém ,antes de mais nada, para ativar essa troca de informações entre os produtos, tenha instalado e configurado na seu servidor o Sharepoint Server, Project Server 2007 com SP2 ou o Project Server 2010 e o Team Foundation Server 2010. Os Gerentes e o time de desenvolvimento deverão ter em seus computadores instalados o Office Project Professional 2007 ou 2010, o Visual Studio 2010 com o SP1 e principalmente implantar o Active Directory.

Etapas executadas pelo Administrador

Instalação

Iremos ver agora o que é necessário instalar para fazer a integração:

• Instalar o SP 1 para o TFS 2010, em cada computador que tiver o App Tier  e que vai participar da integração
• Instalar o Feature Pack para Integração do Project Server com o TFS, em cada servidor que tiver o Project Server instalado e que iria participar da integração.
• Instalar o SP1 do Visual Studio 2010 em cada máquina cliente que tiver o Visual Studio 2010 ou o Team Explorer instalado.

Permissões

Para executar os procedimentos da integração você deve pertencer aos seguintes grupos e possuir as seguintes permissões:

• A conta que irá configurar a integração deverá ser adicionada ao grupo de administradores do TFS 2010.
• Adicionar ao grupo com permissões para  fazer o gerenciamento dos Enterprise Project e os Team Projects para que consiga fazer o mapeamento entre os mesmos.
• Atribuir permissões administrativas para as instâncias do PWA, possibilitando assim, o registro das instancias do PWA com as instancias do TFS 2010.
• Caso esteja usando o Project Server 2007 você deve atribuir permissão total ao Shared Services Provider (SSP)
• Caso esteja usando o Project Server 2010 você deve atribuir controle total ao usuário para que tenha permissões suficiente para invocar o Service Aplication do Project Server. Além disso você precisa conceder ao usuário permissão ao pool de aplicativos do PWA Reporting database , para alterar qualquer schema, criar tabelas, excluir, executar, inserir, selecionar e atualizar.
• Deve conceder aos membros do Team Project do TFS ao grupo de acesso do PWA, para que ao menos consiga abrir o projeto e visualizar o site no Sharepoint.
• Inserir os usuários do Office Project no grupo de Readers do Team Project ou conceder a eles View Project – Level Information, para que possam ter acesso e atualizar os planos de projeto no TFS.

Configuração da integração

A seguir iriei informar um resumo dos procedimentos a serem efetuados para que a integração entre os dois produtos ocorra perfeitamente. Cada etapa usa TFSAdmin, ferramenta de linha de comando. Você irá encontrar essa ferramenta em um computador que esteja com o SP1 do Visual Studio instalado.

Para conseguir executar os comandos é necessário que execute esse prompt como Administrador, clicando com o botão direito.

Registrar Instância do PWA com TFS:

1. devemos registrar a instância do PWA com a APP Tier do TFS que armazena os Team Projects. Para isso devemos usar o comando abaixo:

TfsAdmin ProjectServer /RegisterPWA /pwa:pwaUrl /tfs:tfsUrl

Troque pwaUrl pela url da instância do seu PWA e o tfsUrl pela url do servidor que é usada para conectar o Team Explorer ao TFS, como no exemplo abaixo:

TfsAdmin ProjectServer /RegisterPWA /pwa:http://PWAServerName/PWAInstance /tfs:http://AdventureWorksServer:8080/tfs/

2. Mapear a instância do PWA com uma Collection:

TfsAdmin ProjectServer /MapPWAtoCollection /pwa:pwaUrl /collection:tpcUrl 

Troque o tcpUrl para a URL da Collection em questão, como no exemplo abaixo:

TfsAdmin ProjectServer /MapPWAToCollection /pwa:http://PWAServerName/PWAInstance /collection:http://AdventureWorksServer:8080/tfs/Collection0

3. Atualizar o mapeamento dos campos para cada Project collection que você tiver mapeado com uma instância do PWA:

TfsAdmin ProjectServer /UploadFieldMappings /collection:tpcUrl /useDefaultFieldMappings

Troque tcpURL pela url da Collection em questão, como no exemplo abaixo:

TfsAdmin ProjectServer /UploadFieldMappings /collection:http://AdventureWorksServer:8080/tfs/Collection0 /useDefaultFieldMappings

4.  Você deve associar um Plano de Projeto Coorporativo ou Enterprise Project Plan a um Team Project, esse Plano de Projejo já deve estar publicado no Project Server e o Team Project criado na determinada collection que já foi mapeada anteriormente. Nessa etapa também você deve listar os Work Itens que você deseja deixar sincronizado entre o Project Server e o TFS:

TfsAdmin ProjectServer /MapPlanToTeamProject /collection:tpcUrl /enterpriseproject:PlanName /teamproject:ProjectName /workitemtypes:ListOfTypes

Troque a tcpUrl pela URL da collection que esta sendo mapeada, o PlanName pelo nome do Enterprise Project que já esta hospedado no Project Server e já foi mapeado, o ProjectName pelo nome do Team Project criado na collecion e ListOfTypes pelos work itens que você deseja sincronizar, por exemplo se estiver usando um template agile , “User Storie, Task, Bugs”, sem espaços depois da vírgula como no exemplo abaixo:

TfsAdmin ProjectServer /MapPlanToTeamProject /collection:http://AdventureWorksServer:8080/tfs/Collection0/ enterpriseproject:MyEnterpriseProjA /teamproject:MyTeamProjB /workitemtypes:"User Story,Task"

5. Adicionar os membros do Team Project ao pool de recursos do plano de projeto coorporativo mapeado, para que consiga sincronizar os work itens atribuidos a cada membro do Team Project com as tarefas do Enterprise Project .

Etapas executadas pelo  Gerente e o Líder da equipe

Verificar a Sincronização dos dados é uma etapa crucial para que a integração do Project Server com o TFS tenha sucesso. Execute as etapas a seguir no Enterprise Project e no Team Project que você mapeou.

1.  Adicione uma tarefa no cronograma e coloque para sincronizar com o Team Project do TFS, definindo nome do recurso,o team Project e o work item, em seguida publique no Project server.
2. No Team explorer verfique a lista de pendências do projeto. Os novos work itens devem aparecer. Abra um work item e verifique em seu histórico se exibe a mensagem de sincronização com o Project Server.
3.  Altere um dos Work Itens que foi replicado pelo Project Serve para o TFS. Vá na aba Project Server e modifique o item. Em seguida crie um novo item e selecione a opção Submit To Project Server e confirme para salvar o novo Work Item.
4. No navegador, abra o PWA  e entre no Approval Center, para verificar o Work Item que você alterou e o novo que acabou de ser criado. Aceite a atualização do status e adicione um comentário a ele.
5. Abra o Enterprise Project Plan e verifique se aparece os Work Itens aprovados.
6. No Team Explorer atualize o Team explorer , abra os Work Itens que foram sincronizados com o Project Server e verifique as mensagens no histórico. Entre na aba Project Server e verifique se as atualizações que você aprovou no Project Server estão corretas, existe um tempo aproximado de 1 a 3 minutos para que essas atualizações apareçam.

Caso essas tarefas sejam executadas com sem erros , então processo de sincronização foi concluído com êxito.

Nesse artigo vimos que o processo de integração exige muito planejamento, atenção e paciência, para que no final tenhamos duas ferramentas muito poderosas em perfeita sincronia de dados e de forma transparente, conseguindo assim uma excelente plataforma para o gerenciamento de projetos.

Para saber mais:

Aprofunde seus conhecimentos na comunidade ALM DevBrasil

Fórum Team Foundation Server and Project Server Integration

Configuration Quick Reference

Configuring the Integration of Team Foundation Server and Project Server

Assigning Permissions to Support Integration of Project Server and Team Foundation Server

Vou colocar aqui alguns pontos de vista que não são somente de autoria minha mas que possam ser debatidos por todos nós. O intuito não é orientar tecnicamente a comunidade mas sim deixar a questão em aberto para que você dê o seu ponto sobre o assunto!

Conheça bem o seu framework!

É muito comum ver desenvolvedores muito experientes vindo de outras tecnologias querendo reescrever classes já existentes ou criando alternativas desnecessárias para resolver o mesmo problema.

O framework está pronto, usufrua dele e saiba como trabalhar e aproveitar o melhor que ele tem a oferecer!

Melhore a roda, não invente.

Existem diversos tipos de solução para o mesmo problema, mas que tal seguir um padrão? Aprenda Design Patterns! Saiba o que é melhor para cada situação, o que é melhor para o seu projeto e como você pode entregar melhor um projeto!

Padronizando e utilizando melhores práticas, você facilita a sua vida e da sua equipe.

Escreva artigos técnicos, faça video-aulas, participe de uma comunidade técnica!

Ensinar é uma forma muito válida de aprender! Ao ensinar, você precisa saber o que está falando e dessa forma "se obriga" a estudar.

Iniciar seu próprio blog, escrever artigos e compartilhar é a melhor maneira de você mostrar o que você sabe, errar, aprender e no fim de tudo continuar evoluindo.

Uma longa jornada começa com o primeiro passo!

Faça apresentação / palestras

Fazendo uma apresentação ou palestra é outra forma de força o seu conhecimento a evoluir sobre um determinado assunto. 

Você pode começar a fazer apresentações para poucos amigos, na sua empresa, não importa! Hoje o profissional que capacita pessoas é o profissional que mais é procurado no mercado. 

Seja o diferencial!

Escreva código com qualidade

Se você é apto para fazer algo da melhor maneira possível, faça da melhor maneira possível!

Existe uma enorme quantidade de material sobre boas práticas, leia, aprimore-se e evite a "gambiarra".

Qualidade importa, teste seu código!

Não importa se você usa TDD (Test Driven Development Unit Testing) ou Plain Old Unit testing, certifique-se que o seu software tem qualidade!

Os testes unitários são uma forma incrível de garantir que os bugs passem longe do seu produto! É muito bom que você encontre os bugs, não os usuários.

E você? O que adicionaria a essa lista?

Para saber mais:

Aprofunde seus conhecimentos sobre este tema na comunidade ALM

Como participar da comunidade publicando artigos 

Sugestão de livro sobre o Gerenciamento de Projetos de Softwre

Os Web Services constam atualmente com diversos recursos, tais como coordenação de transações distribuídas, comunicação segura e o mais importante, segurança.

O Windows Communication Foundation (WCF) é uma parte do .NET Framework que fornece um modelo de programação unificado para criar rapidamente aplicativos orientados a serviços que se comunicam pela Web e por toda a empresa.

O WCF foi desenvolvido para oferecer ampla interoperabilidade baseada no modelo de computação distribuída e no suporte direto à orientação a objetos.

Com o Visual Studio 2010 temos ferramentas que nos possibilitam construir aplicações distribuídas utilizando WCF.

Figura 1 -WCF no Visual Studio 2010

No .NET Framework 4, foram feitas melhorias significativas nos namespaces do Windows Communication Foundation (WCF) 4.

Os desenvolvedores do .NET podem usar essas tecnologias, seja de forma independente ou em conjunto, para não precisar abrir mão da facilidade de criação dos serviços nem dos serviços escaláveis de alto desempenho.

A seguir, um breve descritivo sobre:

Serviços

Os serviços são partes de código do sistema, os quais podem ser consumidos por uma aplicação cliente que por sua vez pode estar em qualquer ambiente e sistema operacional.

O serviço WCF se baseia em uma interface que define um contrato entre serviço e um cliente, o mesmo ficando marcado como [ServiceContract].

Os métodos são expostos por meio do atributo [OperationContract].

Atributo [ServiceContract]

Esse atributo nos permite definir um contrato de serviço e pode ser aplicado a uma classe ou interface.

Na realidade, ele mapeia uma interface do Common Language Runtime (CLR) para uma tecnologia de contrato de serviço neutra. 

Tenha em mente que sem esse atributo, a classe não será visível para os clientes do serviço.

Atributo [OperationContract]

Os métodos que serão publicados com o WCF precisam desse atributo, o qual pode ser configurado com propriedades a seguir:

Action:

Obtém ou define o WS-Addressing da mensagem solicitada

AsyncPattern:

Este atributo indica que a operação é implementada de forma assíncrona usando métodos Begin/End no serviço.

IsInitiating:
Indica que a operação pode ser inicial no serviço.

IsOneWay:

Indica que a operação consiste somente em uma única mensagem de entrada.

IsTerminating:

Indica que o runtime deve tentar encerrar a sessão atual após a operação ser concluída 

Atributo [DataContract]

Este atributo é um acordo entre o cliente e o serviço que descreve os dados que serão trocados, ou seja, um contrato que define para cada parâmetro ou tipo de retorno, qual dado será serializado para ser transferido.

Serializar o objeto significa converter o objeto para um formato XML ou binário para possa ser transferido.

Atributo [DataMember]

Este atributo indica que o membro de uma classe fará parte do contrato de dados, fazendo com que esse membro seja serializado e fique disponível ao cliente do serviço.

Se tivermos a intenção de controlar como esse atributo será serializado, basta utilizar a propriedade Name do atributo [DataMember], exemplo:

[DataMember(Name = "nome")]

public string nome;

Alguns dos recursos do WCF:

Além de ser baseado nos princípios de SOA, o WCF ainda conta com vários recursos interessantes:

- Modelo de segurança integrado

- Suporte a gerenciamento de estado utilizando Sessions

- Interoperabilidade e integração com muitas APIs

- Contadores de desempenho, suporte a comunicação transacional

Nesse artigo, pudemos analisar o quão importante é estar a par de novas tecnologias e o quanto uma tecnologia como o WCF pode nos auxiliar no sentido de interoperabilidade.

A idéia de que vários clientes em diversos ambientes usufruam do mesmo serviço é essencial para qualquer projeto de Software hoje em dia.

Para saber mais:
Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net
Aprofunde seus conhecimentos sobre WCF
Guia para Iniciantes do Windows Communication Foundation
Aprofunde seus conhecimentos sobre CLR

System.Data.OleDB.

System.Data.OracleClient: Contém classes para conectar em um banco de dados Oracle.

Quando acessamos um banco de dados, precisamos de algumas classes que nos auxiliam a executar tarefas, tais como conectar, ler e executar comandos.

Para cada banco de dados temos uma classe diferente:

Os nomes dos objetos são bem similares e diferem-se pelas iniciais, facilitando o aprendizado do ADO.NET.

Caso seja necessário utilizar um provedor de dados que não seja nativo no .NET Framework, podemos utilizar um provedor de terceiro. Alguns provedores são pagos. Podemos obter um provedor diferente diretamente com o fabricante do banco de dados ou utilizar um provedor de terceiro.

Classes do ADO.NET

Veremos algumas das classes mais utilizadas e alguns detalhes de sua utilização.

SqlConnection

Essa classe é responsável pela conexão com a base de dados. Veja algumas propriedades e métodos mais importantes que serão utilizados frequentemente em nossos projetos.

A propriedade ConnectionString do objeto de conexão pode ser configurada com a ajuda do Visual Studio ou manualmente, sendo assim, é muito importante entender a utilidade de alguns de seus atributos:

SqlCommand

Essa classe é responsável por enviar um comando ao banco de dados, porém, para utilizar um comando é necessário um objeto de conexão propriamente configurado.

Veja a tabela com as propriedades e métodos mais utilizados:

SqlDataReader

Este objeto funciona como um leitor de dados porque obtém o resultado de um comando quando executamos o método ExecuteReader() e nos permite a leitura destes dados através do método Read().

Alguns métodos e propriedades importantes dessa classe:

DataSet

Um dos objetos mais poderosos da arquitetura ADO.NET é o DataSet, que contém uma coleção de DataTables, que podem estar relacionados por meio de objetos DataRelation.

Podemos garantir a integridade dos dados de um DataSet com a ajuda dos objetos UniqueConstraint e ForeignConstraint, como se tivéssemos a estrutura de um banco de dados em memória.

Podemos preencher um DataSet através do método Fill da classe SqlDataAdapter ou criar um objeto DataTable e adicioná-lo manualmente à coleção Tables do objeto DataSet.

Ambos os objetos DataSet e DataTable estão contidos no namespace System.Data.

Veja as classes mais utilizadas e uma breve descrição:

SqlDataAdapter

A classe SqlDataAdapter é utilizada para preencher objetos DataSet ou DataTable e para enviar alterações nestes objetos para o banco de dados.

É possível enviar as alterações ou receber os dados devido à quatro importantes propriedades que essa classe contém:

Entre os métodos mais importantes da classe SqlDataAdapter, podemos citar:

O artigo retratou uma parte das informações que podemos usufruir do ADO.NET. É muito importante compreender como podemos utilizar as classes já prontas no .NET Framework!

Para saber mais:

ADO.NET Data Providers, Tools and Vendors
Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net
Aprofunde seus conhecimentos sobre namespaces
Aprofunde seus conhecimentos sobre ADO.NET

Normalmente o SQL Server é eleito como banco de dados em um projeto ASP.NET devido às facilidades e integrações das tecnologias, contudo, existem escopos que exigem a integração de tecnologias diferentes em projetos de Software.
Faremos um exemplo de aplicação em ASP.NET 4.0, C#, utilizando Visual Studio 2010.

O primeiro passo é entender como uma aplicação fará o acesso aos dados e nesse artigo utilizaremos o ADO.NET.

O ADO.NET (ou tecnologia ActiveX Data Objects) consiste num conjunto de classes definidas pelo .NET framework que pode ser utilizado para receber os dados armazenados numa base de dados local ou remota.

Considerando que usaremos o Firebird, necessitamos fazer o download do Firebird .NET Provider, o mesmo está disponível no site do terceiro, nesse link.

Figura 1 – Baixando o Firebird .NET Provider

Após fazer o download do arquivo, abra o Visual Studio 2010 e crie um novo projeto (File -> New – Project).

Figura 2 – Criando novo projeto

Selecione ASP.NET Empty Web Application, .NET Framework 4 e dê um nome a aplicação.

Agora que já temos a aplicação web criada, incluiremos as DLLs que baixamos do site do Firebird em nosso projeto:

Figura 3 – DLLs Firebird

Para incluir as DLLs em nosso projeto, clique no Solution Explorer e com o botão direito do mouse, selecione “Add Reference”.

Figura 4 – Add reference no projeto

Clique em “Browse” e siga até a localização física da DLLs no seu computador.

Repare que no seu Solution Explorer as DLLs já estarão referenciadas.

Figura 5 – Add Reference no projeto

O FirebirdSql.Data.FirebirdClienté composto por diversas classes que contém métodos para acessar os dados do Firebird.

Criaremos agora a estrutura necessária para trabalharmos no projeto.

A aplicação será organizada em camadas e como já temos a interface web resta criar a DAL (Data Access Layer), BLL (Business Logical Layer) e a DTO (Data Transfer Object), também conhecida como “Model”.

Para criar as outras camadas, clique com o botão direito no Solution Explorer, “Add” e em seguida “New Project”.

Figura 6 – Criando novo projeto

Na tab Visual C#, selecione a opção “Class Library” e dê o nome de DTO.

Repita o processo e crie o projeto BLL e o projeto DAL, ficando dessa forma:

Figura 7 – Solution Explorer exibindo projetos
Agora que temos o projeto organizado, vamos seguir com a criação das classes.

Primeiro, vamos trabalhar na camada DTO. Essa camada será responsável por “espelhar” as tabelas que temos no banco de dados em nossa aplicação. Na realidade, expressando melhor a idéia, vamos definir as propriedades de nossas classes.

Uma propriedade, é preciso entender em primeiro lugar, se parece muito com uma simples variável, mas é bem mais do que isso. Uma propriedade (também chamada de “atributo”, dependendo da forma como foi definida) é um valor ao qual é associado um método.

Toda vez que for lido ou gravado o valor da propriedade, métodos podem entrar em ação.

Essas ações são definidas pelas palavras GET e SET.

Na prática, pode-se dizer que uma propriedade é composta de três elementos: um campo (local onde se armazena o valor, também chamado de atributo), um método de leitura (get) e um método de gravação (set).

Utilizando o IB Expert (ferramenta que administra o Firebird), criei um banco de dados e uma tabela chamada “USUARIO” para utilizarmos nesse artigo.

Figura 8 – Usando IB Expert para criar tabela no Firebird

O que faremos agora é simplesmente criar uma classe em nosso projeto, na camada DTO, “espelhando” os tipos de dados da tabela Usuario do Firebird em forma de uma classe.

Para isso, clique com o botão direito na camada DTO, “Add”, “New Item” e selecione uma class. Dê o nome a classe de “UsuarioDTO”.

Figura 9 – Criando classe

Depois, é só criar as propriedades:

Figura 10 – Criando propriedades da classe

Perceba que as propriedades têm o mesmo tipo e o mesmo nome das colunas da tabela “USUARIO” no banco de dados.

Feito isso, partiremos agora para a camada DAL, a camada de acesso a dados, onde criaremos uma classe base para manipular acesso a dados.

Repita os passos acima e crie uma classe, na camada DAL, com o nome de DBManager.

Figura 11 – Criando classe

Implemente a classe de forma que utilizaremos a Interface “IDisposable” e utilize o método Dispose().

Figura 12 – Implementando classe DBManager

Criei alguns métodos simples para abrir/fechar conexão e criar um comando SQL.

Obs: atente-se a referência a FirebirdSql.Data.FirebirdClient e System.Configuration.

A classe por fim, fica dessa forma:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using FirebirdSql.Data.FirebirdClient;
using System.Configuration;
namespace DAL
{
    public class DBManager : IDisposable
    {
        public void Dispose()
        {
            GC.SuppressFinalize(this);
            GC.Collect();
        }

        //recebemos a connection string do Web.Config
        private String StringConexao =
             ConfigurationManager.ConnectionStrings["FirebirdConnectionString"].ToString();
        public FbConnection AbrirConexao()
        {
            FbConnection con = new FbConnection(StringConexao);
            if (con.State != System.Data.ConnectionState.Open)
                con.Open();
            return con;
        }
        public FbConnection FecharConexao(FbConnection con)
        {
            if (con.State != System.Data.ConnectionState.Closed)
                con.Close();
            return con;
        }
        public FbCommand CriarComandoSQL(String Query)
        {
            FbConnection Conexao = AbrirConexao();
            FbCommand ComandoSQL = new FbCommand(Query, Conexao);
            return ComandoSQL;
        }
    }
}

O próximo passo é criar a connection string no Web.Config.

Dentro da seção <System.Web>, crie a connection string conforme exemplo (lembre-se de mudar o caminho do banco de dados em DATABASE):

<connectionStrings>
 <remove name="LocalSqlServer" />
 <add name="FirebirdConnectionString"
 connectionString="User=SYSDBA;Password=masterkey;
 Database=”CAMINHO DO BANCO DE DADOS”
 Port=3050;Dialect=3;Charset=NONE;Role=;Connection lifetime=15;Pooling=false;MinPoolSize=0;MaxPoolSize=50;Packet Size=8192;ServerType=0;"
 providerName="FirebirdSql.Data.FirebirdClient" />
 </connectionStrings>
 
 

E dentro de <System.Data>não se esqueça também de incluir o DbProviderFactories:

<DbProviderFactories>
 <add name="FirebirdClient Data Provider" invariant="FirebirdSql.Data.FirebirdClient" description=".Net Framework Data Provider for Firebird" type="FirebirdSql.Data.FirebirdClient.FirebirdClientFactory, FirebirdSql.Data.FirebirdClient, Version=2.0.0.0, Culture=neutral, PublicKeyToken=3750abcc3150b00c" />
</DbProviderFactories>

Faremos agora um método na camada de acesso a dados (DAL) para obter os dados da tabela de exemplo que foi criada.

Na camada DAL, clique com o botão direito no projeto, “Add”, “New Item” e selecione uma “Class” nomeando a mesma de “UsuarioDAL”.

Figura 13 – Criando classe

Não se esqueça de referenciar a camada “DTO”, para isso, no projeto “DAL” clique em “Add Reference” e na aba “Projects” inclua a referência.

Também não se esqueça de implementar a interface IDisposable e seu método Dispose():

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DTO;

namespace DAL
{
     public class UsuarioDAL : IDisposable
     {
         public void Dispose()
         {
         GC.SuppressFinalize(this);
         GC.Collect();
         }
    }
}

Agora, vamos implementar um método que retorne uma Lista de objetos “UsuarioDTO”.

Entenda que como a aplicação está sendo construída em camadas, cada camada tem suas responsabilidades e suas chamadas.

Nesse caso, estamos fazendo a chamada da camada de negócios para a camada de acesso a dados.

Método implementado, precisamos agora criar o mesmo método na camada BLLpara fazer a chamada.

Na camada BLL, clique com o botão direito no projeto, “Add”, “New Item” e selecione uma “Class” nomeando a mesma de “UsuarioBLL”.

Figura 14 – Criando classe

Não se esqueça de referenciar a camada “DTO” e a “DAL”, para isso, no projeto “DAL” clique em “Add Reference” e na aba “Projects” inclua as referências. Também não se esqueça de implementar a interface IDisposable e seu método Dispose().

Basicamente agora precisamos criar um método que retorne uma lista de objetos “UsuarioDTO” chamando o método da camada DAL.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DTO;
using DAL;
namespace BLL
{
    public class UsuarioBLL : IDisposable
    {
        public void Dispose()
        {
            GC.SuppressFinalize(this);
            GC.Collect();
        }

        public List<UsuarioDTO> ObterUsuarios()
        {
            using (var DAL = new UsuarioDAL())
            {
                return DAL.ObterUsuarios();
            }
        }
    }
} 

Atente-se novamente ao fato que cada camada tem sua responsabilidade, nesse caso, a camada de negócios apenas faz a chamada para a camada de acesso a dados retornar os dados.

Pronto!

As camadas foram criadas, os métodos foram escritos e agora precisamos consumir esses dados na camada de InterfaceWeb que criamos.

Vamos agora incluir uma página web no projeto “Interface Web”.

Clique com o botão direito no projeto, “Add”, “New Item” e selecione uma “Webform” deixando o nome por default “Webform1.aspx”.

Figura 15 – Adicionando um webform ao projeto

Na toolbox, em “Data”, selecione um Gridview.

Figura 16 – Selecionando um Gridview

Agora, programaticamente, faremos a chamada para a camada de negócios para executar o método “ObterUsuarios()” que por sua vez fará a chamada para a camada de acesso a dados.

No Code behind, implemente o seguinte código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using BLL;

namespace FirebirdDotNet
{
    public partial class WebForm1 : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
           using (var BLL = new UsuarioBLL())
            {
                GridView1.DataSource = BLL.ObterUsuarios();
                GridView1.DataBind();
            }
        }
    }
}

Se tudo ocorrer conforme esperado, os dados serão apresentados.

Figura 17 – Exibindo dados

O artigo retratou uma forma simples de incluir o provider do Firebird em nosso projeto ASP.NET, possibilitando a utilização da classe FirebirdSql.Data.FirebirdClient e seus métodos.

Outros métodos de inserção de dados, atualização e exclusão podem ser implementados seguindo a mesma idéia apresentada.

Para saber mais:
Download do projeto

Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net
Aprofunde seus conhecimentos sobre Interfaces.
Aprofunde seus conhecimentos sobre Aplicações em Camadas.

Como trabalhamos com strings

Naturalmente trabalhamos uma soma de strings desta forma:

string Nome = "João"; // Definimos e atribuimos valor a um objeto string

Nome += " Pereira"; // Efetuamos uma operação de adição a um objeto string

O que à de errado nisso?

Na CLR não é bem assim, uma string é uma sequencia de caracteres unicode, logo após sua criação ela se torna only read e ao trocarmos seu valor uma nova sequencia é criada dando origem a um novo objeto, deixando o objeto anterior sem referência ele vai para o garbage collector.

Para operações como dado o exemplo acima onde criamos um objeto Nome, do tipo string e inicializamos o seu valor e logo em seguida adicionamos um sobrenome não sentimos diferença na performance da aplicação, mais imaginem repetir esta operação um milhão de vezes dentro de um laço de repetição.

Devido a este fato operações com string são tão custosas, devido a esta particularidade do funcionamento de strings que foi criado a classe StringBuilder que otimiza estas operações.

Temos outras formas de trabalhar com strings, uma delas é o string.Format() que facilita a formatação de textos onde podemos parametrizar informações para uma string.

Seguem exemplos:

Caso 01: operação onde existe multiplas adicições em uma string:

StringBuilder sb = new StringBuilder();
for (int i = 0; i >= int.MaxValue; i++) //int.MaxValue, constante da classe int32 de valor 2147483647
{
     sb.Append(i.ToString());
}
sb.ToString(); 

Caso 02: operação onde existe a necessidade de formatar uma informação qualquer

string Nome = "João";

string Sobrenome = "Pereira";

string NomeCompleto = string.Format("{0} {1}",Nome, Sobrenome);

Bom quando forem realizar operações que envolvam strings e alterações sobre elas, trabalhem com o StringBuilder e ou string.Format(), para obterem uma performance melhor em seus aplicativos, além de estarem escrevendo um código muito mais elegante.

Para saber mais:
csharphelp - Strings are Immutable
msdn - system.string
msdn - system.string - Immutability
Noções básicas de seqüência de caracteres (guia de programação translation from VPE for Csharp)
DevBrasil - C# (Csharp)

Build foi uma conferência realizada em setembro deste ano em Anaheim - Califórina, a conferência teve vários destaques em Windows Phone, Windows 8 com XAML e HTML5 e CSS3.

Para iniciar o desenvolvimento recomendo que instalem o Windows 8 Developer Preview com um Dual Boot, a idéia do artigo é apresentar como iniciar o desenvolvimento das novas tiles.
 

Quais as principais diferenças entre a Versão 7 e a Versão 8 do Windows?

1. O sistema operacional está sendo desenvolvido para ser responsivo, ou seja vai funcionar em diversos tamanhos de telas diferentes com experiência de usuário adaptada.
2. Na versão preview foi dividida as aplicações com o visual de "Tiles" e outra semelhante a do Windows 7.
3. O WPF e o HTML5/CSS3 serão as principais formas de desenvolvimento.
4. Além do C++/C#/VB, o JavaScript também vai ser usado nativamente.
5. O objetivo principal da Microsoft é deixar com que funcione aplicativos desenvolvidos com HTML5/CSS3 ou XAML nativamente, assim desenvolvedores de outras linguagens vão ter uma curva de aprendizado menor!

O HTML5

Nada mais é do que uma nova semântica da W3C, agora temos tags como <header>, <article>, <section> entre muitas outras, mas ele sozinho é muito pobre, e talvez até acrescente apenas uma organização muito maior e uma semântica correta para "sempre". É importante saber que nem todos os browsers vão funcionar o HTML5 e muito menos o CSS3, então veja uma tabela sobre quais deles já estão aptos a esta função.

O CSS3

Podemos dizer que a versão 3 do CSS está fazendo a diferença! Pois além de organizar as informações, está adicionando funcionalidades importantes na usabilidade, podemos dizer que a web não será mais a mesma depois da CSS3, pois com isto estamos enterrando para sempre o FLASH, e de quebra a Microsoft está se tornando mais padronizada em relação a W3C!

Produzida por vários "fabricantes", vou denominá-los assim, entre os mais conhecidos estão a Mozilla usa o prefixo -moz, e a Microsoft que usa o prefixo -ms, estes e alguns outros provavelmente, estão criando inúmeras propriedades para deixar como sugestão para a W3C adotar estes padrões, mas tudo ainda com muita incerteza.

Abaixo uma lista com as principais propriedades que estão sendo criadas:

Exemplo de uso css: style="opacity:0.50; -ms-transform: rotate(94deg);"

1. Transparency
   Agora podemos adicionar transparencia nos elementos HTML e HTML5 através do atributo "style".
   
   Exemplo com 50% de transparencia:

   opacity: 0.50;

2. Border Radius
   Com a CSS3 não é necessário usar javaScript ou imagens para deixar as bordas arredondadas, o interessante é que pode se escolher em quais arestas e quanto de radius em cada vértice.
   
   Exemplo com arestas diferentes:

   border-radius: 10px 0px 10px 10px;

3. Box Shadow
   Efeitos embassados em HTML? Isso mesmo, com o box-shadow em breve poderemos fazer a sombra nos padrões da W3C.
   
   Exemplo com sombras internas na figura:

   box-shadow: inset 5px 12px 22px 0px hsl(59,88%,54%);
   
   

4. Text Shadow
   Funciona igual ao box-shadow, porém, somente para fora das letras, o inset somente para o box-shadow.
   
   Exemplo com sombras avermelhada:
   

   text-shadow: 6.5px 0px 0px 0px hsla(6, 86%, 54%, 0.25);
   
   

5. Gradients
   Agora sem precisar do Photoshop, é possível criar gradients via código CSS3, com certeza uma grande evolução gráfica para os padrões.
   
   Exemplo com 3 cores no gradiente:
   
   

   background-image: -ms-linear-gradient(90deg, black 0%, yellow 26%, red 100%);

6. Typography
   Agora com o @font-face é possível usar fontes que jamais era possível antigamente.
   
   
   <style type="text/css">

   @font-face { font-family: FelbridgeOTSCondensed; src: url('fonts/FelbridgeOTS-Condensed.woff'); }

   @font-face { font-family: CelesteSmallSCRegular; src: url('fonts/CelesteSmallTextScWeb.woff'); }

   < /style>
   
   

7. 2D Transforms
   Com estas propriedades podemos movimentar os objetos no eixo X,Y.

   Exemplo com propriedades, rotate, scale, skew.

   -ms-transform-origin: 50% 50%;

   -ms-transform: translate(147px, 72px) rotate(23deg) scale(1.2) skew(15.99deg, 15deg) skewY(21deg) rotate(42deg);

   
   

8. 3D Transforms
   Com estas propriedades podemos movimentar os objetos no eixo X,Y,Z.
   

   Exemplo com propriedades, rotate, scale, skew.

   -ms-backface-visibility: visible;
   -ms-transform-origin: 56% 50%;
   -ms-transform: perspective(850px) rotateY(-49deg) translate3d(193px, 48px, 37px);

9. Transitions
   Com estas propriedades é possível fazer transições e animar seus objetos

   -ms-transform: rotate(94deg);
   
   -ms-transition:1.8s cubic-bezier(0.00, 0.46, 0.25, 1.00) 2.5s;

O XAML continua sendo utilizado da mesma maneira, mas agora os layouts das aplicações Windows 8 terão como padrão a Metro, o XAML está entre nós desde de 2006, não tem como descontinuar todas as inovações que já foram feitas com ele, e transportar para as propriedades em HTML5 e CSS3.
 

Para saber mais:
Comunidade de CSS na @devbrasil
Comunidade do Windows 8 na @devbrasil
Baixe o Developer Preview, e não esqueça, faça um dual boot
Conferencia sobre o Windows 8
Conheça mais propriedades em CSS3
Teste o Internet Explorer 10 e HTML5 com CSS3
Todo o desenvolvimento do Windows 8 neste link da MSDN

Feito isso, renomei a class1.cs que é criada automaticamente na solucion explorer para Soma. conforme a imagem abaixo : 

Após alteração efetuada sua classe ficará com o nome de Soma.cs. Então criaremos um método chamado "somar" com seus respectivos parâmetros : 

Para criar um teste no visual studio é muito fácil, basta clicar com o direito( mouse ) na classe criada e ir na opção create unit tests...

Aparecerá uma tela de informação nesse momento não mudamos nada apenas apertamos o OK. Definimos também o nome do projeto de teste. Automaticamente é criado uma classe de testes com todas as infomações necessárias.

Por padrão o visual studio cria o escopo de teste dependendo da quantidade de metodos criados na classe principal.

Note que aparecerá os atributos [TestClass()] para classe criada e [TestMethod()] para os metodos criados. Esses atributos são os responsáveis pela execução dos testes no Visual Studio.

Para iniciar a validação dos testes basta executar no menu Test > Run > All tests in solution.

Deve aparecer a seguinte tela : 

Consequentemente os testes irão falhar devido a chamada do método Assert.Inconclusive. O visual studio por padrão declara esse metodo para o desenvolvedor não esquecer de revisar todos os métodos criados. 

Para o teste funcionar normalmente basta remover a linha do Assert.Inconclusive e rodar novamente os testes no menu Test > Run > All tests in solution.

Enfim o teste está válido e você já deu um grande passo no desenvolvimento de seu software

Aos poucos, O uso de testes unitários tem sido adotado em pequena e grande softhouse. Com isto, os desenvolvedores garantem um código seguro, criando uma documentação muito valiosa de seu código fonte. O exemplo relatado no artigo foi apenas uma demonstração de como pode ser criado vários testes unitários conforme a usabilidade do software.Não perca tempo, participe, comente este artigo e diga sua opinião.

Para saber mais: 

Aprofunde seus conhecimentos sobre este tema na comunidade ALM

Vamos lá, primeiramente faça download do arquivo no link no final do post, extraia e teremos dois arquivos, um com extensão ".cs" que será uma classe em csharp, e o outro em ".cshtml", extensão para Webpages asp.net em razor usando csharp. O primeiro será para a classe em que se dará a lógica da paginação e o segundo é onde teremos nosso helper que cuidará dos nossos links de paginação.

Usando um webgrid ou o grid view (a depender do tipo do asp.net, se MVC ou webforms) temos um recurso pronto de paginação, porém esse recurso tem um pequeno gigante problema: ele filtra os dados a serem apresentados, mas não a serem carregados. Ou seja, ele puxa todos os registros da tabela e depois apenas filtra pra apresentação, e isso não adianta coisa nenhuma a não ser esteticamente, mas no que diz respeito a performance do seu site, isso não funciona.

Então ao descobrir isso você vai vasculhar a internet atraz de uma solução e aqui estamos. Quem está acostumado a MySQL usa a função LIMIT, mas quem usa SQL server Compact não tem esse recurso... O que fazer? Tem jeito pra isso, a classe no arquivo que ".cs" tem solução para os dois casos.

Presumindo que você sabe usar o webmatrix e entendeu como funciona a estrutura de uma aplicação asp.net mvc3, dentro do seu diretorio "App_Code" coloque os arquivos "paginar.cs" e "meusHelpers.cshtml".

Feito isso crie um documento "index.cshtml" na raiz e tenha também aí uma tabela no banco de dados que você vai usar.

Temos nosso código:

 
@{
    Page.dataCon = Database.Open("minhaConexao");
    var totalRegistros = Page.dataCon.QuerySingle("SELECT COUNT(*) AS totalReg FROM minhaTabela");
}
<!DOCTYPE html>
<html lang="pt-br">
    <head>
        <meta charset="utf-8" />
        <title>Exercício de paginação</title>
    </head>
    <body>
    </body>
</html>
Nosso objeto "totalRegistros" nos informará quantos registros temos. Você deve usar com um índice como array. Então dentro de <body> você deverá inserir o seguinte código:

@if (totalRegistros[0] > 0)
{
    int atualPagina = Convert.ToInt16(Request["pagina"]);

Paginar ObjPgnador = new Paginar(v_iPerPg: 20,
                                     v_totalReg: totalRegistros[0],
                                     v_pgna: atualPagina,
                                     v_itens: "id, nome, telefone ",
                                     v_tabela: "minhaTabela",
                                     v_orderBy: "nome",
                                     v_MySql: true);

var queryList = Page.dataCon.Query(ObjPgnador.queryStr);

<text>
        <table cellpadding="0" cellspacing="0">
            <tr>
                <th>id</th>
                <th>Nome</th>
                <th>Telefone</th>
            </tr>
            @for (int i = 0; i < queryList.Count; i++)
            {
                <text>
                    <tr>
                        <td>@(queryList[i].id)</td>
                        <td>@(queryList[i].nome)</td>
                        <td>@(queryList[i].telefone)</td>
                    </tr>
                </text>
            }
        </table>

        //abaixo aplicamos nosso helper HTML para fazer a listagens de páginas

@meusHelpers.pageHelper(pgUrl:"/index.cshtml?", pg: ObjPgnador.pagina, pgStart: ObjPgnador.pageStart, pgEnd: ObjPgnador.pageEnd, pgLinks: ObjPgnador.pageLinks)
    </text>
    }
else
{
    @:<h6>Nenhuma informação encontrada!</h6>
}

Ao instanciar nosso objeto, precisamos apenas informar os seguintes parâmetros:

v_iPerPg: 20, //quantos registros por página
v_totalReg: totalRegistros[0], //informa o total de registro da tabela
v_pgna: atualPagina, //a página atual onde está o usuário
v_itens: "id, nome, telefone ", //as colunas desejadas
v_tabela: "minhaTabela", //a tabela escolhida
v_orderBy: "nome", //a coluna que será usada para ordenação
v_MySql: true //true para string MySql, false para SQL Serber compact

Agora que entendemos como motamos nosso objeto, vamos entender nosso helper:

pgUrl:"/index.cshtml?", //informa o documento para monategm da url

pg: ObjPgnador.pagina, //informa a página atual, e é necessario ser do objeto em vez da variável "atualPagina", para evitarmos que alguém insira via url uma página que exceda nossa quantidade real.

pgStart: ObjPgnador.pageStart, //informa nossa página inicial

pgEnd: ObjPgnador.pageEnd, //informa a última página na apresentação, lembrando que não é a página final da contagem total, por exemplo, vc pode ter registros pra 50 páginas, mas só apresenta 15 por vez, no caso esse seria o 15º link.

pgLinks: ObjPgnador.pageLinks //informa o total de páginas

Como vocês puderam ver, aqui temos um sistema de paginação completo, seja pra MySql ou SQL compact, desde a filtragem de dados pela classe até o helper que trará o menu de links e ambos podem ser usados em qualquer página do seu site, dispensando que você reescreva a lógica em todas as páginas que você necessite de paginação, bastando chamar os objetos. Em ambos os casos funciona da mesma forma e não trazem registros além do que nós precisamos por cada página, diferente do modelo padrão do gridview ou do webgrid. Vocês podem personalizar adicionando parâmetros como por exemplo se vai ser ordenado em ordem crescente ou decrescente.

Para saber mais:
Download do código fonte
Download do código fonte 4Shared
Aprofunde seus conhecimentos na comunidade de ASP.NET

Criando contratos das Entidades de negócio

Primeiramente vamos escrever nossa interface que servirá de contrato para nosso repositório. Para isso usaremos os recursos da classe System.Collections.Generic. Abaixo segue o fonte de nossa interface.

Observe que "<T>" é uma representação de IEntity que não passa de uma interface usada como contrato para todas as entidades da regra de negócio.

Implementação dos contratos

Abaixo segue uma implementação da interface IEntity

Abaixo segue a implementação da interface IRepository<T>

O código acima não é o suficiente para que a "mágica" aconteça. Perceba que a criação do nosso repositório genérico é exigido um objeto DbContext. Este objeto pertence a classe System.Data.Entity. Ele faz parte do Entityframework e abstrai as tarefas de consulta e persistência no banco de dados. Abaixo segue o código desta classe

Concluindo, O EntityFramework é uma ferramenta que nos ajuda a resolver alguns problemas em desenvolver códigos massantes e repetitivos para manipulação de dados Com os recursos do .net framework e da linguagem C# podemos construir classes muito eficientes como por exemplo uma classe genérica de persistência.

Arquivos usados

IEntity.cs

Empresa.cs

IRepository.cs

GenericRepository.cs

DataContext.cs

Para saber mais:
Aprofunde seus conhecimentos sobre este tema na comunidade C# (Csharp)
Aprofunde seus conhecimentos sobre este tema na comunidade SQLServer

É justamente visando este público, que não podem arcar com os custos de uma plataforma mais robusta, mas precisam publicar suas aplicações, que a AppHarbor oferece sua plataforma de serviços escaláveis na nuvem. Para quem não conhece,  AppHarbor é um plataforma de serviços .NET na qual desenvolvedores de código publicam seu fonte usando a infraestrutura do Git ou Mercurial. Neste post apresentaremos como criar uma aplicação na plataforma do AppHabor. 

Primeiro passo: Criar uma conta no AppHarbor (ah tá!!!!)

Criando uma nova de aplicação

Confirme na sua caixa de email a criação de seu login e acesse sua conta. Ao fazer logon, vá para a área de aplicattions. Nesta área, crie uma nova aplicação.

 Defina o nome de sua aplicação:

Configurando e publicando aplicação

Ao confirmar a criação do aplicativo será criado o repositório git e as informações necessárias para acessá-lo.

Configure o git seguindo os passos indicados no guia e publique seu fonte no repositório. Ao fazer isso, a página de sua aplicação apresentará a seguinte estrutura: Um histórico do versionamento e uma url para acesso da aplicação

Conclusão

Vimos neste post que AppHarbor é uma plataforma alternativa de serviços .NET na qual desenvolvedores de código podem publicar seu fonte usando a infraestrutura do Git ou Mercurial. Também apresentamos os meios de como criar uma aplicação nesta plataforma e preparar o ambiente para publicação. 

Para saber mais:

visite o site do AppHarbor

Visite o site oficial do Windows Azure

Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net

Primeiramente, devemos criar uma Action onde instanciaremos nossa lista de valores. Veja o exemplo abaixo

Perceba que a instância de SelectList é atribuída a um objeto ViewBag. Perceba ainda que não há instância desse ViewBag. Isso porque ele é um Atributo Dinâmico do ASP.NET MVC3. Bem, criadas as listas devemos editar nosso CSHTML para recebe-las. Veja o outro exemplo abaixo

Feito tudo isso teremos o seguinte resultado:



Pronto, aí estão nossas listas renderizadas. Nesse post vimos como construir e passar listas simples para views em ASP.NET MVC3.

Para saber mais:

visite o site oficial do ASP.NET MV3

Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net

@
{

Layout = null;
}


Bem-vindo, @Model.Nome

Precisamos que você confirme sua conta de email.
Clique neste link para obter esta verificação!
@Url.Action("Index", "Conta", new { chave = @Model.Codigo }, "http")
Obrigado!

ATENÇÃO: para enviar o email como texto o arquivo cshtml deve
ser escrito da seguinte forma: <nome arquivo>.text.cshtml. Já para enviar como html

 o arquivo deve ser salvo como: <nome arquivo>.html.cshtml.


 4) Chame a classe do controler

Pronto! Agora é só realizar a chamada da classe do controller criado como no exemplo abaixo

private void EnviarEmail(Usuario usuario)
{

var email = new EmailController();
email.VerificationEmail(usuario).Deliver();
}

Para esclarecer melhor o uso desta biblioteca, disponibilizo o link de
uma video aula de Michel Banagouro demonstrando como implementar
esta biblioteca fantástica. Espero que aproveitem

Para saber mais:
Assista ao vídeo "ActionMailer.Net Uma maneira fácil de enviar email"
Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net

@section nome_da_section{

     //seu template vai aqui...

}

Para renderizar nossas sections na página layout, utilizaremos o método @RenderSection(). Esse método tem dois argumentos de entrada: o primeiro, é onde passamos o nome da section, que será renderizada na página e o segundo define se a section será ou não opcional. Se o segundo parâmetro for indicado como true, e alguma de nossas views não possuir a section passada no primeiro argumento, teremos um erro em runtime.

Para os exemplos, vou criar duas sections simples, onde a primeira irá definir um "Header" e a segunda irá definir um "Footer" para determinadas views.

Inicie um novo projeto ASP.NET MVC 3 no visual studio 2010 navegando em "File / New / Project..." e escolha ASP.NET MVC 3 Web Application. Próximo passo é selecionar o template "Internet Application" e a view engine Razor.

Como sabemos que nem sempre todas as views irão ter as sections definidas, vou explicar duas formas de aplicar um código padrão caso alguma view não retorne um bloco com a section.

Figura 1 - Página Index.cshtml com as sections Header e Footer definidas.

Figura 2 - Utilizando @RenderSection() para renderizar as section na página de layout.

Figura 3 - Sections renderizadas na página layout.

Até aqui, tudo bem, definimos a view Index.cshtml com nossas sections e rederizamos com o @RenderSection. Como eu disse logo acima, nem sempre todas as views terão as sections "Header" e "Footer" definidas, e nesse caso, queremos definir um valor padrão.

Definir valor padrão para as sections.

Opção 1: Usar o método IsSectionDefined() 

Esse método, recebe o nome da section como argumento de entrada e retorna true/false para indicar se alguma section com o nome passado, foi definido na view que está sendo renderizada no método @RenderBody.

Figura 4 - Verificar se a section foi definida na view.

Figura 5 - Página About.cshtml sem as sections "Header" e "Footer".

Bom, não tem nada de errado com os exemplos acima, porém ainda fica "feio" sujar o código com esses blocos "if". Vamos para a segunda opção.

Opção 2: Razor inline templates

O Razor fornece uma maneira de passarmos um resultado HTML como template para dentro de uma função. Para fazer isso vamos utilizar um delegate (Func<T, TResult>), disponível na biblioteca do .net, para escrever nosso template. Podemos facilmente criar um Razor template em qualquer view utilizando o bloco @ { //... }, porém fazendo isso, não poderemos reutilizar o template em outras páginas. Como não é isso que queremos, vou utilizar Extension Methods para expor esse template para todas minhas páginas.

Vou criar uma nova classe, que irá se chamar SectionExtension, com um único método, que será chamado de RenderSection. Fazendo isso, irei criar mais um overload do método @RenderSection. 

Quando as views são compiladas, o Razor gera classes que são herdadas de System.Web.Mvc.WebViewPage e, a classe WebViewPage, por sua vez, herda de WebPageBase. Esse é o motivo de passar o tipo WebPageBase para meu Extension Method. Dessa maneira todas minhas páginas poderão usar o template.

Figura 6 - Criando um novo método para expor o template para as páginas.

Figura 7 - Renderizando as sections com o overload do RenderSection.

Agora, qualquer @Html passado no segundo argumento será renderizado como código padrão, caso alguma view não tenha as sections definidas em seu layout.

Conclusão

Com a utilização das sections, podemos facilitar e muito o desenvolvimento de aplicações ASP.NET MVC. Esse é mais um poderoso recurso que o Razor nos oferece, simples de implementar, flexível, mantém nosso código limpo e é algo trivial também.

Para saber mais:

Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net

Figura 1 - Exemplo Razor x ASPX engine.

Se repararmos no código acima, ao invés de digitar 5 caracteres (<%=%>), digitamos apenas 1 (@).

Criando nossa aplicação com Razor engine

Vou criar um novo projeto ASP.NET MVC 3, utilizando o template Internet Application.

Figura 2 - Criando uma aplicação ASP.NET MVC 3 Web Application.

A seguir, vamos configurar nosso projeto escolhendo o template e a view engine. O modelo Internet Application já vem com alguns exemplos de Controllers, Models e Views.

Figura 3 - Configurando a view engine e o template.

Agora com o projeto criado, vou criar uma classe (UsuarioModels) para representar meu modelo, um controller (UsuarioController) simples para passar os dados para minha view e vou criar também uma view para representar esses dados na interface do usuário. 

Figura 4 - Model e Controller 

Se repararmos na classe que representa nosso Modelo, estou utilizando DataAnnotations para definir como meus dados serão validados e apresentados na interface do usuário.

Criado o model e o controller, o próximo passo é criar a view para representar os dados do nosso modelo. Para criar a view, posicione o cursor do mouse sobre o nome da Action Index(), clique com o botão direito e selecione a opção Add View...

Figura 5 - Criando a view para representar o UsuarioModels

Após clicar em Add View..., a IDE do visual studio irá apresentar a tela para configuração da nossa view. O nome da view continuará igual o nome da Action, que foi definido como Index(). Selecione o Razor (CSHTML - C# ou VBHTML - VB) como a view engine. Como iremos criar nossa interface baseada no modelo da classe UsuarioModels, vamos marcar a opção Create a strongly-typed view, para que possamos selecionar em Model class nosso modelo.

Figura 6 - Configurando a View

Próximo passo, é clicar em Add e conferir a View Index.cshtml que foi gerada. Reparem que o código é muito simples, sem sujeiras e fica muito fácil de ler. Podemos também, fazer qualquer formatação em nossa tela, assim como faríamos com o C# em webforms.

Figura 7 - Código gerado pela view engine

Figura 8 - Formatando datas na view

Figura 9 - Resultado final com Razor

Podemos utilizar também, em nossas views, diferentes blocos de código razor para declarar variáveis e funções. Para declarar variáveis, utilizamos o bloco @{ //...} já criado com a view e para declarar funções, utilizamos o bloco @functions { //... }.

Figura 10 - Variáveis e Funções declaradas na view com blocos de código Razor

Conclusão

Pudemos ver aqui todo poder, simplicidade e flexibilidade que o razor oferece no desenvolvimento de aplicações ASP.NET MVC.

Espero que esse artigo seja útil para aqueles que desejam iniciar os estudos em ASP.NET MVC com Razor.

Muito Obrigado.

Conheça também outros artigos relacionados a comunidade:

Comunidade ASP.NET

Comunidade C#

Configurando uma ViewEngine no ASP.NET MVC

Tenho visto muitos tutoriais ensinando o CRUD, mas de forma complicada, colocando muito código desnecessário para o iniciante, sendo assim, dificultando o aprendizado do mesmo.

O objetivo do artigo é mostrar como é feito o Insert, update e delete usando EF.

Abaixo a nossa tela utilizada. Bem simples para poder entender. Lembrando que essa tela e o ORM foram criados nesse artigo

Primeiro você deve criar um novo projeto do tipo Web Project.

Chamaremos esse projeto de CRUD. Apenas para não ficar muito extenso, mas você pode escolher o nome que quiser.

Depois que o visual studio criar o projeto, você deve adicionar um novo webform. Clicando em cima do projeto e adicionando um webforme usando master page. Chamaremos esse form de Cadastro.aspx

Depois de criado o webForm, vamos adicionar um menu Cadastro no nosso projeto.

Clique em Site.Master.

Adiciona a seguinte linha de código no projeto:

Depois de acrescentar o nosso código podemos ver como ficou o nosso layout principal.

Com o nosso menu pronto, agora vamos adicionar um modelo de dados entity.

Clique com o botão direito no projeto e adicione um novo item:

Chamaremos o model de modelo para ficar mais fácil.

Após escolher o nome o Visual Studio vai pedir para escolher uma base de dados existente ou um empty model. Vamos escolher o empty model.

Com o ORM aberto adicione uma nova entidade conforme a figura. Coloquei uma tabela bem simples.

Depois de criado o nossa entidade, vamos gerar um script sql para criar o nosso banco de dados. Clique com o botão direito do mouse no modelo e escolha Generate Database from Model.

O Visual Studio vai mostra uma tela para escolher um banco de dados. Clique em new connection. Se você tiver instalado o SQL Server Management Studio instalado, escolha o nome do servidor do mesmo, abaixo coloque o nome do banco como exemplo, como mostra a figura.

Depois clique em next, espere gerar o script e depois clique em Finish.

Após ser gerado o script clique em Execute sql. O visual Studio vai abrir a tela SQL Server Management Studio para você escolher o servidor.

Depois de criado no modelo de entidades e o banco de dados, vamos criar nosso formulário para criar nosso pequeno cadastro usando Entity Framework.

Clique em Cadastro.aspx e no modelo Source copie e cole o código abaixo:

Com o código acima podemos ver o nosso layout.

Clique agora em modelo.edmx e verifique o nome do nosso entity container name.

Agora clique 2 vezes no botão salvar.

E adicione o seguinte código:

Pronto, com apenas 7 linhas de código temos acesso ao nosso banco de dados e inserindo um cliente no mesmo.

Salve e rode o projeto. Depois de adicionar um cliente verifique no banco para saber se o mesmo está inserido.

 Agora adicione um botão Editar e Excluir, como mostra a figura a seguir:

Primeiramente criar o método para preencher o gridView.

Clique com o botão direito do mouse e escolha View code na pagina.

Galera, olha que maravilha é preencher um gridView usando EF.

public void PreencheGridView()

  {

          using(ModeloContainer ctx = new ModeloContainer())

          {              

              gridDados.DataSource = ctx.ClienteSet;

              gridDados.DataBind();

}        }

Chame o método no Page_Load para carregar os dados.

É só isso para carregar os dados no GridView. Maravilha!

Aqui usamos apenas uma instancia do nosso contexto.  Vocês podem criar o projeto usando o nome de contexto que quiser. Estou usando outro banco com apenas 2 tipos de dados: Nome e Email.

Agora vamos ver como ficou o nosso grid de exemplo:

Agora clique no smartTag do gridView e clique no editColumns. Adicione um CommandField select.

Nas propriedades altere o nome para Editar:

Clique em ok e veja como ficou o GridView:

Agora clique 2 vezes no grid view para gerar o método gridDados_SelectedIndexChanged e digite o seguinte código:

protected void gridDados_SelectedIndexChanged(object sender, EventArgs e)

{ //Este codigo vai preencher os textbox

            lblID.Text = gridDados.SelectedRow.Cells[1].Text;

            txtNome.Text = gridDados.SelectedRow.Cells[2].Text;

            txtEmail.Text = gridDados.SelectedRow.Cells[3].Text;

            txtTelefone.Text = gridDados.SelectedRow.Cells[4].Text;

}

Rode o projeto para testar se está tudo ok.

Importante: o gridview tem uma propriedade chamada DataKeyNames. acesse ela e coloque o id do cliente. Se não fizer isso vai dar erro porque ele não vai achar o id do cliente. Vá ao modelo EMDX e olhe o id da tabela(entidade).

Clique 2 vezes no botão editar e adicione o seguinte código seguinte linha:

protected void btnEditar_Click(object sender, EventArgs e)

{            using (ModeloContainer ctx = new ModeloContainer())

           {

               int id = 0;

              id = (int)gridDados.SelectedValue; //Aqui fazemos um cast e pegamos o id selecionado.

//Criamos uma variável que recebe uma busca ao id do cliente no banco             

             var update = (from u in ctx.ClienteSet where u.IdCliente == id select u).FirstOrDefault();    

             update.Nome = txtNome.Text;

             update.Email = txtEmail.Text;

             update.Telefone = txtTelefone.Text;

// O applyCurrentValues pede o EntitySetName e a instancia dele               

             ctx.ApplyCurrentValues("ClienteSet", update);//Usamos este Método para pegar os valores correntes.

                ctx.SaveChanges();              

             PreencheGridView();//Chamamos nosso método para assim que editar um dado nos mostre em tempo de execução.

           }  

    }

Rode o projeto, clique em editar para preencher os campos e depois clique no botão EDITAR para atualizar os dados.

Excluindo!

Para excluir clique em editar para preencher os campos, depois você clica em excluir. Você pode criar um commandField Select chamado excluir para selecionar o dados desejado e depois efetuar a exclusão.

De um duplo clique no botão excluir e adicione a seguinte linha de codigo:

protected void btnExcluir_Click(object sender, EventArgs e)

{

            using (ModeloContainer ctx = new ModeloContainer())

     {

                int id = 0;

                id = (int)gridDados.SelectedValue;

               //Procuramos pelo id

          var update = (from u in ctx.ClienteSet where u.IdCliente == id select u).FirstOrDefault();           

               ctx.DeleteObject(update);// O que mudou aqui é apenas essa linha. Ela faz o delete no banco

                ctx.SaveChanges();

                PreencheGridView();

            }

    }

Não vamos deixar excluir direto. Vá as propriedades do botão excluir e adicione o seguinte codigo em: onclientclick="return confirm('Deseja excluir ?')".

Terminamos o nosso pequeno projeto. Com isso você pode brincar e aprender mais.

Abraços!!

Até a próxima.

Aprofunde seus conhecimentos sobre este tema na comunidade ASP.Net 

Aprofunde seus conhecimentos e tire dúvidas sobre esse tema na comunidade SQL Server.