Após baixar e instalar o Debugger Canvas, você pode configurar a ativar as opções no menu Tools/Options/Debugger do Visual Studio:

Depois é só executar o seu código:

A diferença é aque você pode alternar entre o Debugger Canvas e o Debugger convencional, através da opção “Debugger Canvas” do menu Debug.

Quando você não conhece bem o código, o Debugger Canvas é uma excelente alternativa para você entender como os métodos são chamados, visto que conforme você vai navegando pelo Debug, as caixas com os códigos vão aparecendo e suas ligações também:

Valeu pessoal e até a próxima.
Carlos dos Santos.

Hoje vou mostrar uma maneira bem simples e interessante de fazer validação de dados com EntityFramework, classes POCO e uma aplicação Windows Forms.

Como eu já comentei em outros posts, quando você utiliza DataAnnotations em classes POCO na sua camada de dados e faz a camada de apresentação com WPF/Silverlight ou MVC, o tratamento dos campos é feito automaticamente, praticamente sem nenhum tipo de código. Mas e se você ainda programa para WindowsForms ou precisa validar os dados da classe em uma camada e retornar o erro para outra camada, como fazer ? Isto é o que veremos a seguir.

Primeiro vamos criar um projeto Windows Forms no Visual Studio 2010:

Agora vamos adicionoar o EntityFramework CodeFirst usando o NuGet, como eu expliquei neste post. E logo após vamos criar uma classes chamada Produto e vamos adicionar os annotations nela. Annotations são marcações acima dos campos que definem várias informações ao engine do Entitu Framework, como por exemplo, os valores permitidos no campo.

Nossa classe produto ficará da seguinte maneira:

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.ComponentModel.DataAnnotations;

  6:

  7: namespace WindowsFormsValidacao

  8: {

  9:     [Table("Produto")]

 10:     public class Produto : ValidacaoEntidade

 11:     {

 12:         public int ID { get; set; }

 13:         [Required(ErrorMessage="Descrição em branco"])

 14:         public string Descricao { get; set; }

 15:         [Range(1,10000,ErrorMessage="Valor deve estar entre 1 e 10000")]

 16:         public double SaldoMinimo { get; set; }

 17:         [Required(ErrorMessage="Custo em branco")]

 18:         public decimal Custo { get; set; }

 19:         public decimal Venda { get; set; }

 20:         [MaxLength(20,ErrorMessage="Tamanho máximo = 20")]

 21:         public string Localizacao { get; set; }

 22:     }

 23: }

Veja que a nossa classe está herdando de ValidacaoEntidade, que é onde iremos fazer o método de validaçao dos campos, veja abaixo:

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.ComponentModel;

  6: using System.ComponentModel.DataAnnotations;

  7: using System.Xml.Serialization;

  8:

  9: namespace WindowsFormsValidacao

 10: {

 11:     public class ValidacaoEntidade : IDataErrorInfo

 12:     {

 13:         [NotMapped]

 14:         public string Error

 15:         {

 16:             get { return ""; }

 17:         }

 18:

 19:         [NotMapped]

 20:         public string this[string columnName]

 21:         {

 22:             get

 23:             {

 24:                 return ValidateProperty(columnName);

 25:             }

 26:         }

 27:

 28:         protected string ValidateProperty(string propertyName)

 29:         {

 30:             var info = this.GetType().GetProperty(propertyName);

 31:

 32:             if (!info.CanWrite)

 33:             {

 34:                 return null;

 35:             }

 36:

 37:             var value = info.GetValue(this, null);

 38:             IEnumerable<string> errorInfos =

 39:                   (from va in info.GetCustomAttributes(true).OfType<ValidationAttribute>()

 40:                    where !va.IsValid(value)

 41:                    select va.FormatErrorMessage(string.Empty)).ToList();

 42:

 43:

 44:             if (errorInfos.Count() > 0)

 45:             {

 46:                 return errorInfos.FirstOrDefault<string>();

 47:             }

 48:             return null;

 49:         }

 50:

 51:         public IEnumerable<string> Validate(bool Formatar=false)

 52:         {

 53:             foreach (var prop in this.GetType().GetProperties())

 54:             {

 55:                 string err = ValidateProperty(prop.Name);

 56:                 if (!String.IsNullOrWhiteSpace(err))

 57:                 {

 58:                     yield return prop.Name + ": " + err + ((Formatar) ? "<br>" : "").ToString();

 59:                 }

 60:             }

 61:         }

 62:     }

 63: }

Nesta classe está o segredo da validação, o método Validate(). Este método percorre todos os campos da nossa classe e verifica seu CustomAttribute(), procurando pelo ValidationAttribute, que é o nosso DataAnnotations, se o valor não for for válido, ele retorna a mensagem de erro que atribuímos ao campos e vai adicionando a uma lista, que poderemos usar em nossa camada de apresentação.

Adicionamos agora vamos adicionar a nossa classe de contexto:

  1: using System;

  2: using System.Collections.Generic;

  3: using System.Linq;

  4: using System.Text;

  5: using System.Data.Entity;

  6:

  7: namespace WindowsFormsValidacao

  8: {

  9:     public class Contexto : DbContext

 10:     {

 11:         public DbSet<Produto> Produto { get; set; }

 12:     }

 13: }

Agora vamos adicionar os campos em nosso formulário, que ficará desta forma:

O TextBox (txtErros) abaixo do botão Salvar é onde iremos mostrar os erros.

Vamos adicionar um DataSource para podermos trabalhar com nossa classe Produto, para isto vá no menu Data/Add New DataSource e escolha Object:

Depois escolha a classe produto:

Agora você precisa ligar todos os campos TextBox do formulário aos campos da classe. Para fazer isto, clique sobre o TextBox, vá em propriedades/DataBindings/Text e escolha o campo correspondente ao controle. Faça isto para todos os controles:

Após o primeiro campo, escolha os campos sempre a partir do bindingsource:

Agora vamos ao código do botão incluir, que simplesmente adiciona um novo objeto Produto vinculado a tela:

  1: private void btnNovo_Click(object sender, EventArgs e)

  2:         {

  3:             produtoBindingSource.AddNew();

  4:         }

E por fim vamos ao código que valida os dados e depois insere no BD:

  1:  private void btnSalvar_Click(object sender, EventArgs e)

  2:         {

  3:             var db = new Contexto();

  4:             db.Database.CreateIfNotExists();

  5:

  6:             var pro = (Produto)produtoBindingSource.Current;

  7:             var erros = pro.Validate();

  8:             if (erros.Count() > 0)

  9:             {

 10:                 txtErros.Text = "";

 11:                 foreach (var err in erros)

 12:                 {

 13:                     txtErros.Text += err + Environment.NewLine;

 14:                 }

 15:             }

 16:             else

 17:             {

 18:                 db.Produto.Add(pro);

 19:                 db.SaveChanges();

 20:                 MessageBox.Show("Produto inserido!");

 21:                 produtoBindingSource.ResetCurrentItem();

 22:             }

 23:         }

Observação: A criação do banco de dados neste ponto é meramente didática, para facilitar o exemplo e não é uma prática recomendável em uma aplicação em produção.

Agora vamos recuperar o produto que está vinculado a tela e logo após vamos chamar o método Validate() que irá retornar a lista de erros que vamos exibir. . Recuperamos o Produto acessando a propriedade Current do BindingSource, mas como ela armazena somente objetos, precisamos converter o valor de Current para o tipo Produto e logo após isto chamamos a validação e caso não exista erros, inserimos o Produto no BD e atualizamos a tela. Os erros são mostrados no campo txtErros na tela.

Você pode formatar a saída do erro modificando o método Validate() na classe ValidacaoEntidade.

Espero que este pequeno exemplo tenha mostrado o quanto é simples fazer validações mesmo em plataformas não tão novas, como o Windows Forms, e isto pode também ser utilizado para validar objetos em camadas separadas da aplicação.

Você pode baixar o código fonte deste exemplo aqui.

Abraços e até a próxima.

Carlos dos Santos.

Então vamos agora usar uma abordagem diferente, mas nem tão diferente assim do artigo anterior. Nossa necessidade ainda é manter o isolamento do banco de dados e trabalhar somente com objetos. O CodeFirst, como o próprio nome sugere, nos leva a criar primeiramente as classes POCO e depois o banco de dados, mas é possível também pegar um banco de dados existente e gerar o CodeFirst.

O Entity Framework faz uma ponte entre as classes POCO e o banco de dados utilizando um container que chamamos de Contexto. O contexto é o responsável por mapear as nossas classes com o banco de dados e também por informar ao engine quem é o banco de dados, através da string de conexão, e isto é o que mais me agrada no Code First, você precisa trocar somente a string de conexão para mudar de banco. Nenhum tipo de alteração no código é necessária.

Instalando o Entity Framework Code First:

Antes de começarmos a escrever as classes, precisamos instalar o Entity Framework CodeFirst, que é basicamente composto pela EntityFramework.DLL. Faremos isto isando o NuGet, que é um instalador de pacotes para o Visual Studio. Se você ainda não o possui, vá até o Extension Manager do Visual Studio (Tools/Extension Manager) e instale:

Depois de instalado o NuGet, vá em Tools/Library Package Manager/Package Manager Console. Isto vai abrir o gerenciador do NuGet:

Agora digite o comando: Install-Package EntityFramework dentro do console, isto irá instalara o EF CodeFirst e suas dependências:

Criando um projeto com o EntityFramework CodeFirst:

Vamos criar uma classe de contexto que chamaremos de Contexto.cs, esta classe irá herdar de DbContext e nela iremos mapear nossas tabelas:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.Data.Entity;

   6:  

   7: namespace EFCodeFirst

   8: {

   9:     public class Contexto : DbContext

  10:     {

  11:         public DbSet<Grupo> Grupo { get; set; }

  12:         public DbSet<Produto> Produto { get; set; }

  13:     }

  14: }

O segredo aqui é o DBSet<>, pois ele faz o mapeamento da nossa classe para o banco e vincula a um objeto, que utilizaremos para fazer as operações com o BD.

Veja o código da classe Grupo:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.ComponentModel.DataAnnotations;

   6:  

   7: namespace EFCodeFirst

   8: {

   9:     [Table("Grupo")]

  10:     public class Grupo

  11:     {

  12:         public int ID { get; set; }

  13:         [Required(ErrorMessage="Nome não pode ser branco.")]

  14:         public string Nome { get; set; }

  15:  

  16:         public virtual IQueryable<Produto> Produtos { get; set; }

  17:     }

  18: }

E da classe Produto:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5: using System.ComponentModel.DataAnnotations;

   6:  

   7: namespace EFCodeFirst

   8: {

   9:     [Table("Produto")]

  10:     public class Produto

  11:     {

  12:         public int ID { get; set; }

  13:         [Required(ErrorMessage="Nome não pode ser branco.")]

  14:         public string Descricao { get; set; }

  15:         public int GrupoID { get; set; }

  16:  

  17:         [ForeignKey("GrupoID")]

  18:         public virtual Grupo Grupo { get; set; }

  19:     }

  20: }

No CodeFirst podemos controlar todos os aspectos do mapeamento das classes com o banco de dados, desde o nome da tabela no banco, obrigatoriedade dos campos, tamanho, etc.

Na classe Grupo, eu determinei o nome da tabela no banco de dados (linha 9), ou seja, podemos ter um nome para a classes e outro para a tabela no banco de dados. Informei também que o nome não pode ser banco e vinculei uma mensagem, que pode ser usada em projetos MVC e WPF (linha 13). Finalmente criei o relacionamento entre Grupo e Produto (linha 16).

Na classe Produto, eu determinei também o nome da tabela no banco de dados, e o campo obrigatório. Fiz também o relacionamento com a tabela grupo através do campo GrupoID (linhas 15 e 17,18).

O EF identifica também automaticamente as chaves primárias das tabelas, desde que você as chame por ID ou nome_da_tabelaID, exemplo: GrupoID ou ProdutoID.

Um coisa muito legal que o EF CodeFirst faz para nós é criar o banco de dados, mas isto depende do provider do seu banco de dados, nem todos aceitam a criação do banco.

Vamos agora montar um exemplo para carregar dados no nosso banco:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

   4: using System.Text;

   5:  

   6: namespace EFCodeFirst

   7: {

   8:     class Program

   9:     {

  10:         static void Main(string[] args)

  11:         {

  12:             var db = new Contexto();

  13:  

  14:             db.Database.CreateIfNotExists();

  15:  

  16:             var g1 = new Grupo() { Nome = "Peças" };

  17:             var g2 = new Grupo() { Nome = "Serviços" };

  18:  

  19:             db.Grupo.Add(g1);

  20:             db.Grupo.Add(g2);

  21:  

  22:             var p1 = new Produto() { Descricao = "Pneu", Grupo = g1 };

  23:             var p2 = new Produto() { Descricao = "Roda", Grupo = g1 };

  24:             var p3 = new Produto() { Descricao = "Alinhamento", Grupo = g2 };

  25:             var p4 = new Produto() { Descricao = "Balanceamento", Grupo = g2 };

  26:  

  27:             db.Produto.Add(p1);

  28:             db.Produto.Add(p2);

  29:             db.Produto.Add(p3);

  30:             db.Produto.Add(p4);

  31:  

  32:             db.SaveChanges();

  33:  

  34:             var dados = from p in db.Produto

  35:                         select p;

  36:  

  37:             foreach (var linha in dados)

  38:             {

  39:                 Console.WriteLine("{0,-30} - {1}", linha.Grupo.Nome, linha.Descricao);

  40:             }

  41:  

  42:         }

  43:     }

  44: }

O código acima cria o nosso banco de dados no SQL, caso ele não exista (linha 14). Após isto eu inseri os dados em Grupo e Produto, mas percebam que eu simplesmente vinculei os objetos, sem me preocupar com as chaves primárias ou estrangeiras, pois o EF resolve isto para nós desde que seu mapeamento esteja correto.

Assim ao final do código temos o banco de dados criado e os dados inseridos. Veja como ficou o banco de dados no Management Studio:

Veja que o nome do banco de dados é o nome da aplicação mais o nome do Contexto, mas podemos resolver isto adicionando um arquivo App.Config e informando os dados do banco, então vamos adicionar um arquivo de configuração ao nosso exemplo e colocar a seguinte linha:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:   <connectionStrings>

   4:     <add name ="Contexto" providerName="System.Data.SqlClient" connectionString="data source=(local); initial catalog=ExemploEF; user id=teste; password=teste;"/>

   5:   </connectionStrings>

   6: </configuration>

O nome da string de conexão é o mesmo nome da nossa classe de Contexto. O providerName indica que usamos SQL Server e a string de conexão é padrão de ADO.Net, informando Servidor/Banco de Dados/Usuário. Eu já fiz outro post falando só sobre Gerenciamento de Strings de Conexão.

Executando nosso código novamente o banco chamado EFExemplo será criado e preenchido com os dados.

Visualizando o modelo do CodeFirst:

Mas e se você quiser ver como está ficando seu modelo se você está usando somente código ? Para isto existe o Entity Framework PowerTools que permite visualizar o modelo a partir das classes e também gerar um script para o banco de dados. Vejamos como ver o modelo visual do nosso exempo.

Após instalar o PowerTools, clique com o botão direito do mouse sobre a classe Contexto.cs no seu projeto, irá aparecer um menu de contexto EntityFramework, com várias opções:

A primeira opção é justamente a que mostra o modelo gráfico, vamos vê-lo então:

Já tenho um banco de dados e quero usar o CodeFirst:

Se você já tiver um banco de dados, o EF PowerTools permite que você faça engenharia reversa e gere o contexto e as classes, para isto clique com o botão direito do mouse em sua Solution no Visual Studio e escolhar Entity Framework no menu:

Esta opção gera todas as classes e relacionamentos do seu modelo, basta informar qual o banco de dados e o servidor na janela abaixo:

Não se esquece de adicionar o EntityFramework CodeFirst com o NuGet antes de fazer a engenharia reversa.

Quando usar Designer ou CodeFirst:

Esta é um pergunta bem complicada, eu diria que se você usa somente um banco de dados e precisa trabalhar com Stored Procedures é melhor usar o Designer, principalmenet porquê o CodeFirst ainda não suporta procedures nativamente.

Se você quer criar uma aplicação multibanco, de maneira mais rápida e simples através de classes POCO, então o CodeFirst é sua escolha.

Muito importante saber também que o Entity Framework Designer e o CodeFirst são independentes e podem não compartilhar alguns recursos.

Espero que o artigo seja útil para vocês e se assim desejarem façam seus comentários ou sugestões.

Até a próxima,
Carlos dos Santos.

Hoje em um desenvolvimento de projeto é muito comum  o programador ter que saber vários comando de bancos de dados (Insert, Delete, Update, Select) para poder desenvolver, além de saber sobre a linguagem de progração. O EntityFramework vem para ajudar nesta tarefa, criando uma correspondência entre as tabelas do banco de dados, o que chamamos de ORM, ou mapeamento Objeto-Relacional.

Existem, basicamente, duas maneiras de se trabalhar com o Entity Framework, usando o Entity Designer ou o Entity Framework Code First. A diferença é simples, no Designer você precisa criar um diagrama do banco de dados visualmente, usando um arquivo EDMX, que deve ser específico para cada banco de dados da sua aplicação, ou seja, para cada banco de dados é necessário usar um arquivo EDMX. Neste artigo vamos vamos criar um modelo visual e analisar seus aspectos.

Mapeando o Banco de dados com o Entity Designer:

Abra o Visual Studio 2010 e crie um projeto no .Net Framework 4 do tipo Console Application, depois vá em adcionar novo item. Você verá a janela abaixo, escolha ADO.Net Entity Data Model:

Podemos ainda escolher se iremos nosso modelo a partir de um banco de dados pronto ou em branco:

Vamos gerar nosso exemplo a partir do banco de dados NorthWind, escolhendo a opção “Generate from database”. Na tela seguinte crie a conexão para o banco de dados e depois escolha quais tabelas, views ou stored procedures você quer mapear:

No nosso exemplo ou escolher todas as tabelas, views e stored procedures. Feito isto teremos o modelo visual pronto:

Este processo gerou um modelo EDMX, que contém basicamente três partes:

1. Storage Model Content: que contém as informações do banco de dados, como tabelas, tipos dos dados, etc;
2. Conceptual Model Content: contém a definição do modelo, o que você pode ver no diagrama, como as classes, tipos complexos, associações, etc.
3. Mapping Content: faz a ligação entre o Storage e o modelo Conceitual.

O código fonte das classes também faz parte do modelo,dentro do arquivo de Designer:

Este arquivo contém o código fonte de todas as classes de nosso modelo. Mas então se eu criar um modelo novo as classes serão geradas novamente ? A resposta é SIM.

Opa, mas então temos um problema, teremos classes duplicadas e como vamos resolver isto ? Com classes POCO, que podem ser independentes do modelo. Para isto faremos algumas pequenas modificações no nosso modelo.

Se você for utilizar somente um banco de dados não precisa trabalhar com classes POCO.

Trabalhando com POCO no Entity Designer:

A primeira coisa que precisamos fazer é desativar a geração de código pelo designer. Isto é simples, basta desligarmos a propriedade Code Generation Strategy do modelo, colocando em none:

Agora precisamos adicionar novamente as classes e para isto iremos utilizar um gerador automático de código, que iremos adicionar ao nosso projeto:

Ao adicionarmos o ADO.Net POCO Entity Generator, dois novos arquivos irão aparecer em nosso projeto: Model1.Context.tt e Model1.tt. Para gerar as classes precisamos abrir cada um deles e colocar o nome do nosso arquivo EDMX, Veja o exemplo:

No nosso exemplo ficará assim: string inputFile = @”model1.edmx”. Faça o mesmo no arquivo Model1.tt. Depois de fazer isto salve o arquivo e o nosso projeto ficará assim:

Agora temos classes POCO, que são independentes do designer. Se você modificar o designer, assim que salvá-lo as classes serão atualizadas automaticamente.

Agora você pode adicionar um novo EDMX apontando para um outro banco de dados, por exemplo: MySQL ou Oracle, desde que tenham a mesma estrutura logicamente, e você usará as mesmas classes.

Usando o modelo para recuperar os dados:

Vamos agora criar um pequeno código para listar os Products e Categories do nosso modelo, usando LINQ:

   1: var db = new NorthwindEntities();

   2:  

   3:             var dados = from p in db.Products

   4:                         select p;

   5:  

   6:             foreach (var linha in dados)

   7:             {

   8:                 Console.WriteLine("{0,-35} - {1}", linha.ProductName, linha.Categories.CategoryName);

   9:             }

No próximo artigo iremos falar sobre o Entity Framework Code First.

Espero que tenham gostado.

Até a próxima.

Carlos dos Santos.

Para baixar acesse os links abaixo:

Usando EF com Oracle: http://www.oracle.com/technetwork/issue-archive/2011/11-sep/o51odt-453447.html

Provider 32 bits: http://www.oracle.com/technetwork/topics/dotnet/utilsoft-086879.html

Provider 64 bits: http://www.oracle.com/technetwork/database/windows/downloads/index-090165.html

[]s,

Carlos dos Santos.

Tenho acompanhado que muitas pessoas estão estudando para tirar alguma tipo de certificação Microsoft. Uma boa dica é usarem os livros Self-Paced, que além de conterem material específico para a prova, têm também um software que simula a prova e que você pode usar para ver como está seu conhecimento, antes de realizar a prova.

Veja um exemplo de livro aqui no Amazon: http://www.amazon.com/MCTS-Self-Paced-Training-Exam-70-515/dp/0735627401. Este é para a prova de Web do .Net 4.0

Junto com o livro vem também um arquivo PDF, que você pode utilizar em seu tablet e assim estudar com mais facilidade. Eu particularmente prefiro desta maneira.

Outra coisa muito boa e melhor ainda que a certificação em si, é o conhecimento que você vai ganhar estudar focando em ganhar conhecimento e não somente para passar na prova.

Fique atendo também aos webcasts feitos com dicas sobre as provas!

Abraços e até mais!

Carlos.

Semana passada estive em Natal/RN para um encontro de Centrais de Negócios do Sebrae e algo inusitado aconteceu. Tenho um grande amigo que mora em Natal, o Glebe Duarte, que trabalha no Senac. Eu já tinha falado com ele que estaria em Natal, e tínhamos até combinado um bate papo sobre comunidades e tecnologia.

O mais incrível foi que o Glebe me chamou para fazer uma palestra sobre Windows Phone no Senac, algo que eu nem imaginava quando fúi para lá. Isto me deixou muito contente e tive que montar algo rápido para mostrar na palestra. Enfim, fiz a palestra e foi um bate papo bem legal com a galera de Natal, onde pude mostrar as vantagens para o desenvolvimento com Windows Phone, como é possível ganhar dinheiro com este mercado e até mostrar o meu Samsung Focus para todos.

Gostaria de agradecer ao Glebe e ao Fernando, que me recepcionaram de maneira excepcional em Natal, fizeram até um tour na cidade comigo. Para mim é sempre um prazer poder estar ajudando a comunidade.

Vejam as Fotos:

[]s,
Carlos.

Neste treinamento os alunos tiveram a oportunidade de conhecer a plataforma Microsoft.Net e o Visual Studio 2010, num total de 8 horas de curso.

Abraços,
Carlos.

Este ano tive o prazer de ser palestrante no maior evento de tecnologia Microsoft do Brasil, o TechEd 2011. Confesso que fiquei muito ansioso e também nervoso, pois a responsabilidade em um evento destes é muito grande, e sempre procuramos fazer o melhor. Fiquei muito feliz que a sala ficou praticamente lotada e mais feliz ainda porquê vários amigos foram me prestigiar, então muito obrigado aos amigos Renato Haddad, Fernando Cerqueira, Israel Aece e Bruno Sonnino.

Espero que o evento tenha sido excelente para todos, não só pelo conteúdo técnico, que foi de altíssimo nível, mas também pela oportunidade de fazer contato com novas pessoas, fazer network.

Vejam as fotos da minha palestra:

O código fonte da palestra pode ser baixado aqui.

Abraços,
Carlos dos Santos.

Acabei de receber um reconhecimento da Microsoft que me deixou muito contente. Já é o segundo prémio do Translation Wiki que recebo por participar dos trabalhos de moderação da MSDN Library (http://msdn.microsoft.com/pt-br/library), onde basicamento corrigimos os textos traduzidos automaticamente e também os textos da comunidade.

Costumo dizer que é um trabalho interessante e que ajuda também a aumentar meus conhecimentos, pois frequentemente estou acessando os mais variados assuntos.

Vejam abaixo o belíssimo troféu que recebi, juntamente com uma carta de agradecimentos assinada pelo Somasegar (Senior Vice President a Developer Division) e um Microsoft Arc Mouse.

Abraços,
Carlos.