Renato Guimarães

Olá amigos,

Há alguns dias publiquei os dois vídeos abaixo com explicando o conceito de árvores de expressão com objetivo prover as informações importantes para o entendimento deste vídeo de hoje. Durante a criação de uma expressão dinâmica é importante conhecer os métodos da classe Expression e as classes derivadas desta.

[PAC.NET]: Como criar a expressão x => x - 2 dinamicamente?

[PAC.NET]: Vídeo sobre árvores de expressão (expression trees, classe Expression)

Outra coisa importante, pense na sua query como uma árvore que será formada por vários nós, onde cada nó representa um expressão.

Abaixo segue o link para o vídeo onde explico o exemplo abaixo:

[PAC.NET]: Vídeo sobre criação de query dinâmica com LINQ

  
Video: [PAC.NET]: Vídeo sobre criação de query dinâmica com LINQ

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

namespace RenatoGuimaraes.Pac.Net.ExemploQueriesDinamicas
{
    //Exemplo mostra como trabalhar com queries dinâmicas no LINQ to Objects. 
    //A query retornará o c cujo o modelo é um Fusca ou nome do modelo tem mais de 6 letras
    public class QueriesDinamicas
    {
        static void Main(string[] args)
        {
            string[] carros = new string[] { 
                 "Monza",  "Escort", "Belina", "Fusca", "Brasília", 
                "Chevette", "Corcel I"};

            //Query Expression
            var queryExp = from c in carros
                          where c.ToLower() == "fusca" || c.Length >= 6
                          orderby c
                          select c;

            //Query Methods
            var queryMethods = carros.
                Where(c => c.ToLower() == "fusca" || c.Length >= 6).
                OrderBy(c => c);

            //PASSO 1: Obtém a fonte de dados do IQueryable do provider 
            //         LINQ da coleção
            IQueryable<string> provider = carros.AsQueryable<string>();

            //PASSO 2: Definição do parâmetro "c" da expressão: 
            //         c => c.ToLower() == "fusca" || c.Length >= 6
            ParameterExpression param = 
                Expression.Parameter(typeof(string), "c");

            //PASSO 3: Cria os nós esquerdo e direito da expressão 
            //         c => c.ToLower() == "fusca"
            Expression opEsquerdo = 
                Expression.Call(param, 
                    typeof(string).GetMethod("ToLower", 
                        System.Type.EmptyTypes));

            Expression opDireito = Expression.Constant("fusca");

            //PASSO 4: Conclui a construção da primeira expressão 
            //         c.ToLower() == "fusca" com o operador ==
            BinaryExpression expParte1 = 
                Expression.Equal(opEsquerdo, opDireito);

            //PASSO 5: Cria a segunda parte da expressão: c.Length >= 6
            opEsquerdo = Expression.Property(param, "Length");
            opDireito = Expression.Constant(6);

            //PASSO 6: Conclui a construção da segunda expressão 
            //         c.Length >= 6 com o operador >=
            BinaryExpression expParte2 = 
                Expression.GreaterThanOrEqual(opEsquerdo, opDireito);
 
            //PASSO 7: Conclui a expressão completa 
            //         c => c.ToLower() == "fusca" || c.Length >= 6 com 
            //         o operador ||
            Expression expCompleta = Expression.OrElse(expParte1, expParte2);

            //PASSO 8: Cria a expressão que representa uma 
            //         chamada ao método Where do provider
            MethodCallExpression expWhere = Expression.Call(
                       typeof(Queryable), 
                       "Where", //Nome método
                       new Type[] { provider.ElementType }, 
                       provider.Expression, 
                       Expression.Lambda<Func<string, bool>>(
                            expCompleta, new ParameterExpression[] { param })
                     );

            //PASSO 9: Cria a expressão que representa uma 
            //         chamada ao método OrderyBy do provider
            MethodCallExpression expOrderBy = Expression.Call(
                       typeof(Queryable), 
                       "OrderBy", 
                       new Type[]{provider.ElementType, provider.ElementType},
                       expWhere, 
                       Expression.Lambda<Func<string, string>>(
                            param, new ParameterExpression[]{param}));

            //PASSO 10: Cria a query completa
            IQueryable<String> query = 
                provider.Provider.CreateQuery<String>(expOrderBy);

            //Executa e lista os itens resultantes da query
            foreach (string item in query)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
        }
    }
}

Abraço,

Renato Guimarães, MS MVP Visual C#

Olá amigos,

        Não é um post falando sobre algo específico relacionado a C# ou .NET, mas é do interesse da galera que trabalha com TI, especialmente, com .NET :-). E como tem C# no meio, então resolvi divulgar também :-) Peguei esta informação de um e-mail enviado por um colega. Não tenho detalhes das vagas e para mais informações recomendo navegar nos links abaixo.

         De uma coisa eu tenho certeza, Fortaleza é uma cidade maravilhosa, mesmo ainda não ter vivido a experiência de morar lá. Já estive lá outro dia fazendo palestras sobre .NET...

A BRQ, uma das principais fornecedoras de Serviços de TI do país, certificada CMMI 5, anuncia a abertura de 116 vagas de emprego na área de Tecnologia da Informação em Fortaleza. As ofertas estão disponíveis conforme tabela abaixo e são para contratação imediata. Os interessados devem cadastrar o currículo no site http://www.brq.com/recursos-humanos/vagas-fortaleza.

As principais tecnologias utilizadas pela BRQ são Java, J2EE, MVC, EJB, .Net, ASP, VB6.0, C#, SAP, PL/SQL, Mainframe, Websphere,C, C++, WebLogic, UML, HTML, Javascript, Webserver, Lótus Notes, PL/1, Cobol. Banco de Dados - Oracle, DB2 Metodologia - RUP/UML. Sistema Operacional: Unix, Linux, Windows, MVS, VM.

A BRQ atingiu faturamento de R$ 150 milhões em 2007, um crescimento superior a 40% ao ano desde a sua fundação em 1993 e tem como meta faturar R$ 1 bilhão em 2012. A BRQ conta com mais de 2.000 profissionais que desenvolvem e perfeiçoam soluções para diferentes áreas de negócios.

Gerente de Projetos: 10 vagas
Líder de Configuração e Mudanças: 2 vagas
Arquiteto de Software Powerbuilder: 2 vagas
Analista de Sistemas Powerbuilder: 8 vagas
Arquiteto de Software .NET: 3 vagas
Arquiteto de Software Visual Basic e ASP: 3 vagas
Analista de Sistemas .Net, Visual Basic ou ASP: 12 vagas
Analista de Testes: 5 vagas
Testador de Software: 15 vagas
Desenvolvedor .Net, Visual Basic ou ASP: 30 vagas
Especialista em Suporte Técnico IBM DB2: 2 vagas
Especialista em Suporte Técnico IBM Rational: 2 vagas
Especialista em Suporte Técnico IBM Websphere: 2 vagas

abraço,

Renato Guimarães, MS MVP Visual C#

Olá amigos,

        Segue mais um vídeo sobre árvore de expressão. No primeiro vídeo sobre árvore de expressão fiz uma breve introdução do conceito e depois fiz um exemplo onde desmembrei a expressão x => x > 10.  Nesta segunda parte, o objetivo deste vídeo é mostrar como criar uma expressão lambda dinamicamente, por exemplo, a expressão x => x - 2. Este exemplo será a base para o vídeo onde explicarei como criar queries dinamicamente no LINQ.

        A expressão deve ser vista como um nó da árvore, onde o corpo (um BinaryExpression que representa o menos) tem seus operandos o parâmetro x (um ParameterExpression) e a constante 2 (um ConstantExpression).

[PAC.NET]: Como criar a express�o x = x - 2 dinamicamente?

  
Video: [PAC.NET]: Como criar a express�o x = x - 2 dinamicamente?

        Abaixo segue o exemplo do código que foi mostrado no vídeo.

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

using System.Linq.Expressions;

//ASSUNTO DE HOJE: ÁRVORES DE EXPRESSÃO
namespace RenatoGuimaraes.Videos.Pac.Net.VideoArvoreDeExpressao
{
    //Expression é código em formato de dados
    //O dado é armazenado numa estrutura de árvore
    //Cada nó da árvore representa uma expressão.
    public class Program {
        static void Main(string[] args){
           // x => x - 2 

            //Preparação do parãmetro da expressão
            ParameterExpression paramExp = Expression.Parameter(typeof(double), "x");
            //Definição da constante
            ConstantExpression consExp = Expression.Constant(2d);

            //Criação da expressao binária que representa o operador -
            BinaryExpression expMenos = Expression.Subtract(paramExp, consExp);

            //Criação da expressão lambda
            Expression<Func<double, double>> expLambda = Expression.Lambda<Func<double, double>>(expMenos, new ParameterExpression[] { paramExp });

            //Compilação da expressão.
            Func<double, double> del = expLambda.Compile();

            Console.WriteLine(del(10));

            Console.ReadLine();
        }
    }
}

Abraço,

Renato Guimarães, MS MVP Visual C#

Olá amigos,

       Entre os vários recursos do C# 3.0, um dos que mais gosto é possibilidade de criação de queries dinamicamente. Sem falar a capacidade de você estender o LINQ e criar seu próprio provider, por exemplo, hoje já temos LINQ to Amazon, LINQ to LDAP, LINQ to SQL, LINQ to XML, LINQ to Entities...

       Antes de explicar sobre criação de queries dinâmicas, vou falar sobre um assunto que é a base de tudo: árvores de expressão, ou Expression Trees. Uma expressão é uma forma de representar código em formato de dados. Este dado é armazenado numa estrutura de árvore e cada nó representa uma expressão, ou seja, uma instância de algumas das classes derivadas da classe System.Linq.Expressions.Expression.

        Alguns exemplos de classes de expressão são:

• System.Linq.Expressions.ParameterExpression
• System.Linq.Expressions.ConstantExpression
• System.Linq.Expressions.BinaryExpression
• System.Linq.Expressions.LambdaExpression

      O código abaixo mostra o desmembramento da expressão x => x > 10, que pode ser lida da seguinte forma:

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

using System.Linq.Expressions;

//ASSUNTO DE HOJE: ÁRVORES DE EXPRESSÃO
namespace RenatoGuimaraes.Videos.Pac.Net.VideoArvoreDeExpressao
{
    //Expression é código em formato de dados
    //O dado é armazenado numa estrutura de árvore
    //Cada nó da árvore representa uma expressão.
   public class Program
   {
        static void Main(string[] args)
        {
            Func<double, bool> del = x => x > 10;
            Console.WriteLine(del(30));

            Expression<Func<double, bool>> exp = x => x > 10;

            BinaryExpression corpo = (BinaryExpression)exp.Body;
            ParameterExpression param = exp.Parameters[0];
            ParameterExpression opEsquerdo = (ParameterExpression)corpo.Left;
            ConstantExpression opDireito = (ConstantExpression)corpo.Right;

            Console.WriteLine("{0} => {1} {2} {3}", param.Name, opEsquerdo.Name, corpo.NodeType, opDireito.Value);

            Func<double, bool> lambda = exp.Compile();

            Console.WriteLine(lambda(10));
            Console.ReadLine();
        }
    }
}

Abraço,

Renato Guimarães, MS MVP Visual C#

Olá amigos,

Segue mais um vídeo da série de vídeos do Pac.nET. Neste vídeo de 4 minutos, explico o recurso de propriedades automáticas do Visual C# 3.0. Este recurso permite que você definda em uma linha de código uma propriedade com get e set, sem se preocupar em criar um campo privado e sem ter que digitar o corpo do get e set.

Quando você precisa ter um método set que executa alguma lógica de validação, por exemplo, não dá para usar este recurso. Além disso, imagine que você quer colocar algum atributo no campo privado da propriedade.. Também naõ será possível pois o campo é gerado pelo próprio compilador, um campo anônimo.  

Por exemplo, veja o código da classe abaixo:

class Cliente {
    public String Nome { get; set; }
    public String Cpf { get; set; }
}

É equivalente ao código, com exceção dos nomes dos campos privados, que da forma acima são nomes gerados pelo próprio compilador:

class Cliente {
    private String _nome;

    public String Nome {
        get { return _nome; }
        set { _nome = value;}
    }

    private String _cpf;

    public String Cpf
    {
        get { return _cpf; }
        set { _cpf = value; }
    }
}

Se você analisar o código gerado pelo compilador com propriedades automáticas, temos:

internal class Cliente
{
    // Fields
    [CompilerGenerated]
    private string <Cpf>k__BackingField;
    [CompilerGenerated]
    private string <Nome>k__BackingField;

    // Properties
    public string Cpf
    {
        [CompilerGenerated]
        get
        {
            return this.<Cpf>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            this.<Cpf>k__BackingField = value;
        }
    }

    public string Nome
    {
        [CompilerGenerated]
        get
        {
            return this.<Nome>k__BackingField;
        }
        [CompilerGenerated]
        set
        {
            this.<Nome>k__BackingField = value;
        }
    }
}

abraço,

Renato Guimarães, MS MVP Visual C#

Olá,

        Para você que se preocupa com a qualidade do seu código, gostaria de recomendar este projeto do Codeplex: Clone Detective for Visual Studio. Como em alguns casos o Copy-And-Paste pode ser o mais fácil e rápido, mas tem o seu lado ruim. Utilize esta ferramenta para melhorar a qualidade do seu código...

        Embora seja o primeiro release e ainda bem recente, acredito que vale a pena umas poucas horas para testá-lo. Abaixo segue uma figura de exemplo da interface da ferramenta, bem interessante. Para fazer download, clique aqui. Ainda não testei mas dei uma olhada no vídeo que tem uma boa explicação do que é a ferramenta e como ela funciona.

abraço,

Renato Guimarães, MS MVP Visual C#

Olá amigos,

     Retomando a minha série de vídeos do PAC.NET, hoje estou publicando um vídeo onde explico o código abaixo. O meu objetivo é mostrar como filtrar os números pares de uma coleção usando desde o Foreach até o LINQ. Ao mesmo, tempo aproveito para explicar a utilização de delegates, métodos anônimos (anonymous methods), expressões lambda (lambda expressions) e algumas queries em LINQ usando Where e Groupby, por exemplo.

PAC.NET: Usando m�todos an�nimos, delegates, lambda expression...

  
Video: PAC.NET: Usando m�todos an�nimos, delegates, lambda expression...

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

namespace RenatoGuimaraes.Videos.Pac.Net
{
    //Usando do Foreach até o LINQ
    class Program
    {
        static void Main(string[] args)
        {
            List<int> numeros = new List<int> { 12, 24, 45, 56, 67, 98, 78, 67, 54, 90, 76};
            List<int> pares = new List<int>();

            //Usando a instrução Foreach
            foreach (int n in numeros) {
                if (n % 2 == 0)
                    pares.Add(n);
            }
            Console.WriteLine("Usando Foreach");
            Imprime(pares);

            //Usando o FindAll e o delegate Predicate
            Predicate<int> param = new Predicate<int>(IsPar);
            pares = numeros.FindAll(param);
            Console.WriteLine("Usando Delegate Predicate com Método");
            Imprime(pares);
            
            //Usando o método anôniomo
            pares = numeros.FindAll(delegate(int n) {
                return (n % 2 == 0);  
            });

            Console.WriteLine("Usando Método Anônimo do C# 2.0");
            Imprime(pares);

            //Usando Lambda Expression
            pares = numeros.FindAll(n => n % 2 == 0 );

            Console.WriteLine("Usando Lamba Expression");
            Imprime(pares);

            //Usando LINQ
            var query = from n in numeros
                        where n % 2 == 0
                        orderby n 
                        select n;

            pares = query.ToList<int>();
            Console.WriteLine("Usando LINQ");
            Imprime(pares);

            var query2 = from n in numeros
                         group n by n % 2 into grupo
                         where grupo.Count() >= 1
                         orderby grupo.Key
                         select grupo;

            foreach (var item in query2)
            {
                Console.WriteLine("Grupo: {0}: ",item.Key );

                foreach (var n in item)
                {
                    Console.WriteLine(n);
                }
            }

            Console.ReadLine();
        }

        static bool IsPar(int n) { 
            return (n % 2 == 0);
        }

        static void Imprime(List<int> colecao) {
            foreach (int n in colecao)
            {
                Console.WriteLine(n);
            }
        }
    }
}

     Há alguns dias publiquei outros posts onde falava sobre ossuntos relacionados a este vídeo:

[PAC.NET]: Delegate => Func, Action e Predicate

[PAC.NET]: Ainda sobre "var"... Expressões para criação de arrays

[PAC.NET]: Estender um tipo sem usar herança? Como?

[PAC.NET]: Não é "variant" e nem "late binding": A palavra-chave "var"

[PAC.NET]: Métodos Anônimos

     Embora seja um vídeo bem simples, acredito que dá para dar uma boa introdução para quem está começando no assunto. Tenhos planos de publicar outros vídeos sobre o assunto...

Abraço,

Renato Guimarães, MS MVP Visual C#