Renato Guimarães

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

Thu, 28 Aug 2008 12:02:40 GMT

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#

[OFF-TOPIC]: Oportunidades para TI em Fortaleza

Mon, 25 Aug 2008 17:34:03 GMT

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#

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

Sun, 24 Aug 2008 02:40:52 GMT

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#

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

Sun, 24 Aug 2008 02:32:56 GMT

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#

[PAC.NET]: Vídeo sobre propriedades automáticas com Visual C# 3.0

Sat, 23 Aug 2008 01:41:00 GMT

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#

[LINK]: Um aliado na caça a duplicação de código: Clone Detective for Visual Studio.

Wed, 20 Aug 2008 03:26:29 GMT

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#

[PAC.NET]: Vídeo sobre delegates, métodos anônimos, lambda expression e LINQ

Tue, 19 Aug 2008 16:31:32 GMT

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#

[OFF-TOPIC]: Beginner's All-purpose Symbolic Instruction Code

Wed, 13 Aug 2008 13:59:23 GMT

Pessoal,

Pura bobagem, mas só hoje eu soube o significado da palavra "Basic" do Visual Basic. Eu já sabia que a linguagem teve suas bases e premissas no BASIC, que eu, erradamente, pensava que estava relacionada a palavra "básico" do português. Mas... Na verdade o BASIC é uma sigla que significa Beginner's All-purpose Symbolic Instruction Code, o que tem tudo a ver com linguagem.

Então, pode-se dizer que o nosso Visual Basic .NET é Visual Beginner's All-purpose Symbolic Instruction Code for .NET :-):-):-):-) Desculpe-me pela bobagem.... Mas nenhum dos meus colegas que conhecem .NET, e mesmo os antigos, nunca me disseram isso.

Abraço,

Renato Guimarães, MS MVP Visual C#.

[Download]: Visual Studio 2008 Service Pack 1 and .NET Framework 3.5 Service Pack 1

Mon, 11 Aug 2008 22:56:41 GMT

Olá pessoal,

Para quem ainda não baixou, já está disponível a versão RTM do VS .NET 2008 SP 1 e .NET Framework Service Pack 1. Abaixo estão os links para o download e fique atento as instruções de instalação:

Visual Studio 2008 SP 1

.NET Framework 3.5 SP 1

From: http://msdn.microsoft.com/en-us/vstudio/products/cc533447.aspx

Overview

.NET-based Windows application development benefits from increased Windows Presentation Foundation (WPF) designer performance and updated components for Visual Basic and Visual C++ (including a MFC-based Office 2007 Ribbon). Web development improvements include enhanced the client-side script tooling (JavaScript IntelliSense). In addition to IDE performance improvements SP1 fully supports SQL Server 2008 and the ADO.NET Entity Framework.

The .NET Framework 3.5 Service Pack 1 (SP1) delivers more controls, a streamlined setup, improved start-up performance, and powerful new graphics features for client development and rich data scaffolding, improved AJAX support, and other improvements for Web development. Additionally it introduces support for the ADO.NET Entity Framework and ADO.NET Data Services, which simplify data access code in applications by providing an extensible, conceptual model for data from any data source and enabling this model to closely reflect business requirements.

Visual Studio 2008 SP1 delivers:

Improved WPF designers
SQL Server 2008 support
ADO.NET Entity Designer
Visual Basic and Visual C++ components and tools (including an MFC-based Office 2007 style ‘Ribbon’)
Visual Studio Team System Team Foundation Server (TFS) addresses customer feedback on version control usability and performance, email integration with work item tracking and full support for hosting on SQL Server 2008
Richer JavaScript support, enhanced AJAX and data tools, and Web site deployment improvements

The .NET Framework 3.5 SP1 delivers:

Performance increases between 20-45% for WPF-based applications – without having to change any code
WCF improvements that give developers more control over the way they access data and services
Streamlined installation experience for client applications
Improvements in the area of data platform, such as the ADO.NET Entity Framework, ADO.NET Data Services and support for SQL Server 2008’s new features

...

abraço,

Renato.

[LINK]: LINQ Framework Design Guidelines. Muito bom!

Mon, 11 Aug 2008 03:51:17 GMT

Tão bons quantos os guidelines do .NET Framework Design Guidelines, também estão os guidelines do LINQ Framework Design Guidelines. Para você que já está usando o LINQ nos projetos de software, vale a pena conferir as recomendações deste blog. É comum algumas empresas adotarem padrões de codificação e com este guia você pode criar mais um tópico no guia da sua empresa, assim garantirá que os programadores começarão certo...

Basicamente, o post começa com uma visão geral do LINQ, seguido por recomendações para extension methods, estendendo o LINQ, estendendo as interfaces IEnumerable<> e IQueryable<>, finalizando com a implementação do Padrão Queryable. Cada item classificado como DO, DO NOT, CONSIDER e AVOID.

Se sobrar um tempinho a mais para leitura, não deixe de visitar este blog Krzysztof Cwalina (um dia aprender a pronunciar o nome dele) :-). É um fera no assunto...

abraço,

Renato Guimarães, MS MVP Visual C#

[SEGURANÇA]: Descubra falhas de SQL Injection com Scrawlr, da HP

Wed, 09 Jul 2008 22:19:13 GMT

Dando uma lida no Blog de Segurança da Microsoft e no Blog de Segurança da HP, vi que a HP tem uma ferramenta que pode ajudar na detecção de falhas de SQL Injection. Aproveite e leia também: SQL Injection Attack e Microsoft Security Advisory (954462).Vale a pena dar uma lida neste post para entender porque as duas empresas reforçam a importante de mitigar este tipo de falha.

Para baixá-la, basta acessar o site e preencher um formulário bem simples. Para dúvidas ou mais informações, acessar o fórum do Scrawler. Se quiser saber mais sobre segurança, só acessar o site Application Security da HP.

abraço,

Renato Guimarães, MS MVP Visual C#

[MVP] MVP Award em Visual C#: 2008-2009 (só alegria)

Tue, 01 Jul 2008 17:24:11 GMT

Amigos,

Mais uma vez tive a felicidade de receber o MVP Award em Visual C# (2008-2009). Há um ano, exatamente no dia 02 de Julho de 2007 eu publiquei um post ( manifestando minha felicidade por mais um ano. Impressionante que a felicidade foi tão grande quanto a primeira vez.

Só tenho a agradecer a todos da comunidade que de uma forma ou de outra me ajudaram com mais este título. A todos que confiaram em mim e me deram oportunidade de contribuir em eventos, palestras etc.

E vai meu agradecimento especial a Microsoft que a cada ano vem mostrando total seriedade e compromisso com a comunidade. É de impressionar! A dedicação deles é nossa motivação para contribuir cada vez mais e mais...

Ainda não consultei a lista de todos os que renovaram ou que receberam a titulação pela primeira vez, mas gostaria de dar meus parabéns a um grande brother: Rodrigo Kono. Kono, de coração, meus parabéns pelo seu título. Com certeza, você é uma pessoa que agrega muito valor a comunidade e mereceu demais este reconhecimento. Continue assim. Também fica meus parabéns a todos que também renovaram...

Abração,

Renato Guimarães (Feliz que só a p...), MS MVP Visual C#

[DOWNLOADS MICROSOFT]: Parallel Extensions to .NET Framework 3.5 June 2008 CTP

Sun, 08 Jun 2008 01:44:13 GMT

Olá amigos,

Há poucos dias a Microsoft liberou o CTP de Junho 2008 (já tem um CTP em Dezembro de 2007) do Parallel Extensions para o .NET Framework 3.5 2008, também conhecido com PLINQ (Parallel Language Integrated Query). Para fazer o download, clique aqui. Basicamente, o Parallel Extensions é um modelo de programação gerenciado para paralelismo de dados, tarefas e coordenação de trabalho paralelo executado por vários hardwares unificados por um agendador de trabalho. Como minha máquina tem dois núcleos, então vou mandar bala nos testes. Assim que eu der uma estudada publicarei minha experiência com ele.

Eu já tive a oportunidade de ver uma demonstração deste framework no MVP Summit de 2007. Sensacional! Naquela época ainda não tinha qualquer CTP disponível. Pelo que vi, ele torna muito mais fácil a tarefa de escrever programas que escalam para tirar proveito do harware paralelo garantindo performance a medida que o número de processadores e núcloes aumentam. O melhor de tudo é que toda complexidade de modelo de programação concorrente é abstraído pra você.

Como é um CTP, uma versão somente de testes, então vá com calma antes de pensar em adotá-lo em algum ambiente de produção, sabe-se que funcionalidades e características podem ser modificadas até a liberação da versão final.

Para estudar mais sobre o assunto, vou dar uma lida nestes dois artigos: MSDN Magazine Article: Parallel LINQ: Running Queries on Multi-Core Processors e MSDN Magazine Article: Parallel Performance: Optimize Managed Code for Multi-Core Machines. Além disso, também tem o Microsoft Parallel Computing Developer Center.

Abraço,

Renato Guimarães, MS MVP Visual C#

[EVENTO]: CIAB/FEBRABAN 2008: Tecnologia e Informação. HP SOA Governance, HP SOA Quality e HP SOA Management

Fri, 06 Jun 2008 23:55:25 GMT

Olá amigos,

Para quem for participar do evento CIAB/FEBRABAN 2008, além das várias atrações deste super evento, gostaria de convidá-los a visitar o stand INTEL/HP. Entre as várias soluções e produtos da HP, gostaria de destacar as soluções SOA que eu e mais dois colegas (Osvaldo Daibert e Erik Etsushi) iremos apresentar: Governança, qualidade e testes para ambiente SOA.

Começa na próxima quarta-feira, dia 11, o XIII Ciab Febraban, o maior congresso e exposição de Tecnologia da Informação (TI) do setor financeiro da América Latina. O evento já tem, confirmadas, as participações de 138 painelistas, que se apresentarão em 28 sessões, nos auditórios Febraban, Linha de Negócios e Eficiência Operacional. O tema central desta edição é “Tecnologia e Segurança”.
Os ministros do Desenvolvimento, Indústria e Comércio, Miguel Jorge, e da Justiça, Tarso Genro, já confirmaram participação. Além deles, deverão participar, também, os ex-ministros da Fazenda Antonio Palocci e Delfim Netto. Outros destaques do evento deverão ser o consultor da Peppers and Rogers, Don Peppers, o presidenta da Febraban, Fabio C. Barbosa, os presidentes da Oi, Luiz Eduardo Falco, e da CPM Braxis, Jair Ribeiro, o futurólogo brasileiro Jean Paul Jacob e a presidente da Caixa Econômica Federal, Maria Fernanda Ramos Coelho.
O evento terá início às 08h30 do próximo dia 11 (quarta-feira) e vai até o dia 13. Serão 138 painelistas, que se apresentarão em 28 sessões, nos auditórios Febraban, Linha de Negócios e Eficiência Operacional. O tema central desta edição é “Tecnologia e Segurança”.
Entre as personalidades presentes estão ministros de estado do Brasil, presidentes de bancos, diretores de tecnologia (CIOs), diretores de segurança (CSOs), presidentes de corporações de vários setores da economia e de tecnologia, jornalistas, consultores e conferencistas internacionais.

Vocês terão oportunidade de conhecer o Business Technology Optimization (BTO) para SOA. E o que é isso? Uma solução completa e integrada para preencher o gap entre a área de TI e de negócios ajudando a: acelerar a adoção SOA, reduzir os riscos de entrega do SOA, e suportar todos os desafios do Ciclo de Vida do Serviço.

Tecnologia da Informação - TI? Para HP não é só TI, e sim Business Technology - BT. Isso mesmo: Tecnologia do Negócio. TI é tão importante para o negócio que não deve ser chamado somente de Tecnologia da Informação. Como o negócio não vive sem TI, um banco por exemplo, então os resultados da área de TI são medidos com base nos resultados do negócio. Se TI não funciona, o banco (o negócio) não funciona. Resumindo, TI é tudo para o negócio.

A HP dispõe de um completo portfólio de produtos e serviços que podem ajudá-los a obter os benefícios (agilidade e baixo custo) prometidos pela adoção de uma arquitetura orientada a serviços. Por meio da governança, qualidade, testes e gerenciamento a HP ajuda na transformação do seu ambiente SOA. E por que HP? Só dar uma olhada no quadrante mágico do Gartner. Também pode verificar no SearchSOA.com, Products of the year 2007, veja quem foi o campeão :-):-):-):-) Why HP for SOA?

Em especial, você terá oportunidade de ouvir um pouco sobre os produtos da HP para governança, qualidade/testes de gerenciamento de ambiente SOA (Arquitetura Orientada a Serviços): HP SOA Governance, HP Quality e HP SOA Management. Quer mais informações, então assita este vídeo na internet:

Governança SOA

Governaça SOA? Sim. Pode-se dizer que é o conjunto de práticas e atividades que você utiliza para controlar os serviços de forma a garantir que tudo experado e com certo nível de qualidade.

SOA também traz riscos (complexidade), nem tudo é só agilidade, como é prometido. Quando se fala em SOA pensamos logo em uma modelo projetado para suportar mudanças, flexível, rápido time to market, e de baixo custo de implementação (considerando que teremos reuso etc). Por outro lado temos os riscos devido a complexidade (é amigo, não é fácil): duplicidade de código, falta de visibilidade dos serviços, pouco reuso, instabilidade, ninguém sabe onde tem serviços e o que fazem, serviços duplicados etc.

Em HP BTO definimos o ciclo de vida do serviço em Planejar, Entregar e Operar. Ou seja, com base nas necessidades do negócio você planeja o que será construído; depois você constrói para entregá-lo para uso; por final, opera o serviço para garantir que funcione conforme planejado e esperado pelos consumidores. E para controlar o ciclo de vida do serviço, a HP oferece as soluções ( e também serviços profissionais) necessárias para você controlar todo o ciclo de vida de forma integrada e transparente: HP SOA Governance, HP Quality e HP SOA Management.

O HP Governance garante visibilidade, controle e confiança dos serviços. O HP Systinet é uma solução completa para governança e gerenciamento do ciclo de vida do serviço:

Gerencia metadados, artefatos, dependências, relatório e análise de impacto;
Baseado em padrões de descoberta e interoperabilidade;
Gerenciamento de políticas em runtime e em construção, aplicação das políticas em execução;
Controle dos acordos de uso entre os produtores e consumidores;
Interopera com o ambiente SOA (Governance Interoperability Framework).

O HP SOA Quality controla o risco da entrega do serviço, bem como a qualidade e testes.

Gerencia a qualidade de serviços compostos e atômicos
Teste funcional e de regressão automatizados através do arquivo WSDL usando introspecção
Criação de teste e manutenção baseados em componente
Garantia de desempenhode serviços individuais ou de uma aplicação composta
Monitoração de serviços, isolamento de problema com rastreamento e análise de causa raiz

O HP SOA Management garante as operações de entrega dos resultados do negócio.

Monitoramento do desempenho e da disponibilidade, e do conteúdo de negócio
Mensuração e relatório dos SLAs para as aplicações SOA
Monitoramento do sistema SOA e da infra-estrutura
Descoberta automática e dinâmica SOA, mapeamento e impacto de mudança
Monitoramento da apilcação SOA, isolamento de problema com análise de causa raiz

abraço,

Renato Guimarães.

[EVENTO .NET]: Developers WebDays 2008: C# 3.0, LINQ, ASP.NET Web Services, WCF, Web Services Software Factory, ASP.NET MVC, Silverlight, Dynamic Data, entre outros

Fri, 06 Jun 2008 22:01:48 GMT

Olá amigos,

Já fez a sua inscrição para o evento Developers WebDays 2008? Então corra e faça hoje mesmo. Este é um grande evento realizado pela DevMedia, que edita a revista .NET Magazine, e está na sua segunda edição. Para fazer sua a inscrição clique aqui. Não esqueça: as vagas são limitadas. E olha que mamata: pagamento em até 6x no cartão de crédito.

Neste evento serão mostradas as principais novidades do .NET e, também, palestras de Boas Práticas e Arquitetura. Ao final do evento você receberá uma certificado pela participação e, o melhor de tudo, um DVD com o conteúdo do evento. Muito bom! Como não dá para participar de todas as palestras ao mesmo tempo, com o DVD você pode assistir as que não participou e rever as que participou. Ao todo são mais de 46h de conteúdo. O conteúdo está muito bom e recheado com todas as novidades do .NET: C# 3.0, LINQ, Silverlight, ASP.NET MVC, Dynamic Data, Windows Communication Foundation, ASP.NET, Web Services, entre outros. Não perca!

Sobre a minha participação, ministrarei 3 palestras, descritas abaixo. Conto com a presença de você pois vou fazer questão de dar o melhor de mim para este evento. Quero ir bem preparado e com muita coisa legal para mostrar.

Dos assuntos que irei apresentar, sinta-se a vontade para já mandar perguntas ou sugestões para o dia do evento.

Grande abraço e espero vocês,

Renato Guimarães, MS MVP Visual C#

[PAC.NET]: Muito mais fácil ter uma coleção com Iterators - O compilador faz o resto...

Wed, 04 Jun 2008 03:59:59 GMT

Olá amigos,

Hoje gostaria de falar sobre um assunto que, embora seja do C# 2.0, é de grande importância para execução das consultas em LINQ: Iterators. O que é isso? Lembra quando você necessitava de uma coleção customizada com suporte a instrução foreach: normalmente implementava IEnumerable e IEnumerator, por exemplo. Sei que com a chegada do recurso de Generics (outra maravilha) também facilitou nossa vida no que diz a criação de coleções.

Pois bem, o recurso de Iterators permite que você tenha um método, um get ou um operador que faça uma iteração customizada sobre uma coleção ou um array usando uma "palavrinha mágica" chamada yield (em português pode ser produzir, ceder, deferir ou render). Ou seja, é um bloco de código que produz uma sequência de valores do mesmo tipo. É bem fácil reconhecê-lo pois sempre estará acompanhado da instrução yield (que pode aparecer uma ou várias vezes).

No exemplo abaixo, temos a classe TesteIterator que usa o recurso de iterator e do yield, fazendo com que implemente IEnumerable (também poderia usar o IEnumerable<T>), retornando um IEnumerator. Com isso, esta classe pode ser usada numa instrução foreach, por exemplo. Perceba que não preciso me preocupar em criar uma coleção do tipo que está sendo retornado pois, implicitamente, o compilador já resolveu tudo para mim: internamente ele implementa a devida coleção. Eu também poderia implementar IEnumerable (ou IEnumerable<T>) explicitamente e, também, implementar qualquer outra.

using System;
using System.Collections;

namespace PostsMSN.Samples.ExemploSimplesIterator{

    class TesteIterator {
        //Uma instância da classe pode ser navegada com um foreach
        // porque o método é o GetEnumerator de IEnumerable.
        //Compilador gera uma classe interna que atende todos os requistos para 
        //implementar IEnumerable e IEnumerator (também com versão generic) e 
        //que funciona como uma máquina de estados. 
        public IEnumerator GetEnumerator(){
            for (int i = 1; i <= 10; i++){
                yield return i;
            }
        }

        //Para um método com nome específico, deve-se retornar IEnumerable
        //para que seja usado num foreach, por exemplo
        public IEnumerable GetOrdemDecrescente() {
            for (int i = 10; i >= 1; i--){
                yield return i;
            }        
        }
    }

    class Program{
        static void Main(string[] args){
            TesteIterator t = new TesteIterator();
            foreach (int i in t){
                Console.WriteLine(i);
            }

            Console.WriteLine();

            IEnumerable colecao = t.GetOrdemDecrescente();
            foreach (int i in colecao){
                Console.WriteLine(i);
            }

            Console.ReadLine();
        }
    }
}

Abaixo segue o código que é gerado pelo compilador. Para não ficar tão grande, só tem as classes sem o conteúdo de cada método:

internal class TesteIterator
{
    // Methods
    public TesteIterator();
    public IEnumerator GetEnumerator();
    public IEnumerable GetOrdemDecrescente();

    // Nested Types
    [CompilerGenerated]
    private sealed class <GetEnumerator>d__0 : 
            IEnumerator<object>, IEnumerator, IDisposable
    {
        // Fields
        private int <>1__state;
        private object <>2__current;
        public TesteIterator <>4__this;
        public int <i>5__1;

        // Methods
        [DebuggerHidden]
        public <GetEnumerator>d__0(int <>1__state);
        private bool MoveNext();
        [DebuggerHidden]
        void IEnumerator.Reset();
        void IDisposable.Dispose();

        // Properties
        object IEnumerator<object>.Current { [DebuggerHidden] get; }
        object IEnumerator.Current { [DebuggerHidden] get; }
    }

    [CompilerGenerated]
    private sealed class <GetOrdemDecrescente>d__3 : 
        IEnumerable<object>, IEnumerable, 
        IEnumerator<object>, IEnumerator, IDisposable
    {
        // Fields
        private int <>1__state;
        private object <>2__current;
        public TesteIterator <>4__this;
        private int <>l__initialThreadId;
        public int <i>5__4;

        // Methods
        [DebuggerHidden]
        public <GetOrdemDecrescente>d__3(int <>1__state);
        private bool MoveNext();
        [DebuggerHidden]
        IEnumerator<object> IEnumerable<object>.GetEnumerator();
        [DebuggerHidden]
        IEnumerator IEnumerable.GetEnumerator();
        [DebuggerHidden]
        void IEnumerator.Reset();
        void IDisposable.Dispose();

        // Properties
        object IEnumerator<object>.Current { [DebuggerHidden] get; }
        object IEnumerator.Current { [DebuggerHidden] get; }
    }
}

Quando um método de uma classe retorna uma IEnumerator usando um bloco de iterator, o fato de executar o método não que dizer que o código do bloco do iterator será executado automaticamente, somente um objeto enumerator é criado e retornado. Este objeto encapsula o código especificado no bloco do iterator, e a execução só acontecerá quando o método MoveNext() for executado. O objeto retornado tem as seguintes características: implementa IEnumerator e IEnumerator<T>, onde T é o tipo do bloco do iterator; implementa IDisposable; e é inicializado com uma cópia dos argumentos (se existir) e valores da instância passado para o método; e tem quatro estados básicos: antes (iniciado neste estado), executando, suspenso e depois. Por exemplo, na classe gerada pelo compilador, o conteúdo do método MoveNext():

private bool MoveNext()
{
    switch (this.<>1__state)
    {
        case 0:
            this.<>1__state = -1;
            this.<i>5__1 = 1;
            while (this.<i>5__1 <= 10)
            {
                this.<>2__current = this.<i>5__1;
                this.<>1__state = 1;
                return true;
            Label_004B:
                this.<>1__state = -1;
                this.<i>5__1++;
            }
            break;

        case 1:
            goto Label_004B;
    }
    return false;
}

Quando um método de um classe retorna um IEnumerable usando um bloco de iterator, o fator de executar o método não quer dizer que o código do bloco do iterator será executado automaticamente, somente um objeto enumerable é criado e retornado (mesmo caso do Enumerator). O método GetEnumerator() do objeto enumerable retorna um objeto enumerator que encapsula o código do bloco do iterator, e a execução ocorre quando o método MoveNext do enumerator é executado.

Abaixo segue um exemplo dando uma geral nas regras de uso da instrução yield:

delegate IEnumerable<String> TesteYield();

    class TesteIterator {
        public IEnumerator GetEnumerator(){
            try{
                yield return 1; // Funciona OK.
                yield break;    // Funciona OK.
            }finally{
                yield return 2; // Erro. Não pode usar no finally
                yield break;    // Erro. Não pode usar no finally
            }

            try{
                yield return 3; // Erro. Não pode usar try...catch
                yield break;    // Funciona OK.
            }catch{
                yield return 4; // Erro. Não pode usar try...catch
                yield break;    // Funciona OK.
            }
            // Erro. Não pode usar com Método Anônimo
            TesteYield del = delegate { yield return 5; };   
        }

        //Erro. int não é válido para um bloco iterator, lembra?
        //Somente IEnumerator, IEnumerator<T>, IEnumerable, IEnumerable<T>
        int Metodo() {
            yield return 100; 
        }
    }

Existem algumas restrições sobre os Iterators:

Quando usado num método com parâmetros, nenhum dos parâmetros pode ser declarado como ref ou out;
Não pode aparecer a instrução return, mas pode ter um yield return;
Não pode conter contextos unsafe, pois sempre define um contexto safe, mesmo quando a declaração é feita dentro de um contexto unsafe.

Para fecharmos, mais um exemplo com a implementação de uma pilha e usando o recurso de iterators (de quebra também usa Generics):

using System;
using System.Collections;
using System.Collections.Generic;


namespace PostsMSN.Samples.ExemploPilhaComIterator{

    public class PilhaIterator<T> {
        T[] itens;
        int contador;

        //Coloca item na pilha
        public void Push(T item) {
            //Inicializa caso seja null
            if (itens == null){
                itens = new T[10];
            //Se chegou em 10, cria novo array com o dobro da qtd
            }else if (itens.Length == contador){
                T[] novoArray = new T[contador * 2];
                Array.Copy(itens, 0, novoArray, 0, contador);
                itens = novoArray;
            }
            itens[contador++] = item;
        }

        //Remove item do topo da pilha
        public T Pop() {
            T retorno = itens[--contador];
            itens[contador] = default(T);
            return retorno;
        }

        public IEnumerator<T> GetEnumerator() {
            for (int i = contador - 1; i >= 0; i--){
                yield return itens[i];
            }
        }
    }

    class Program{
        static void Main(string[] args){
            PilhaIterator<int> pilha = new PilhaIterator<int>();
            pilha.Push(10);
            pilha.Push(9);
            pilha.Push(8);
            pilha.Push(7);
            pilha.Push(6);
            pilha.Push(5);
            pilha.Push(4);
            pilha.Push(3);
            pilha.Push(2);
            pilha.Push(1);

            foreach (int item in pilha){
                Console.WriteLine(item);
            }
            Console.WriteLine();

            int numero = pilha.Pop();
            Console.WriteLine("Pop: " + numero);
            
            numero = pilha.Pop();
            Console.WriteLine("Pop: " + numero);

            Console.ReadLine();
        }
    }
}

Como eu já comentei, os detalhes da geração das classes, bem como na execução num foreach, por exemplo, deixa tudo por conta do compilador e com o runtime. Você pode retornar um IEnumerator, implementando o GetEnumerator(); ou o IEnumerable, implementando um método qualquer. Como o compilador faz tudo, mantenha seu foco nas classes que você precisa retornar coleções e quais tipos estas devem retornar e pronto. Além disso, fique atento para as regras de uso dos blocos de iterators e também para instrução yield.

Abraço,

Renato Guimarães, MS MVP Visual C#

[PAC.NET]: Recuperando os HREFs de uma página HTML com Expressão Regular

Sun, 01 Jun 2008 07:34:52 GMT

Olá amigos,

Neste exemplo vou explicar com mais detalhes uma expressão regular que pode ser usada para capturar os valores dos HREFs de uma página HTML. Queremos capturar o conteúdo do atributo HREF que, por exemplo, pode aparecer no formato: href="http://www.devgoias.net". A expressão deve capturar o valor http://www.devgoias.net/. Abaixo segue a expressão que é um dos exemplos do Visual Studio .NET:

Antes de explicar cada detalhe da expressão, vamos entender os agrupadores, que permitem capturar sub-expressões de uma expressão. No caso da expressão acima temos três:

(?: e ) que está na cor azul, e diz que a substring não ser capturada pela sub-expressão, que está definido pelas duas partes separadas por |. A substring que não será capturada deve combinar com \"(?<1>[^\"]*)\" ou com (?<1>\\S+), logo abaixo mais explicações sobre este dois grupos.
(?<1> que estão em roxo e laranja que é um grupo numerado com o valor 1, ou seja, vamos acessá-lo pelo número.

Um detalhe. A \ é usada pra dizer que a aspa deve ser processada como o próprio caractere, a aspa. Onde tem \\ é para indicar que o C# não deve processar como um caractere de escape. Se fosse VB, por exemplo, não precisaria de \\, e no lugar do \" usaria um "".

Agora vamos entender a expressão que diz que a string para ser capturada deve:

• href\\s* -> começar por href e seguido, ou não, por um ou mais espaços em branco; e

• =\\s* -> um sinal de igual seguido, ou não, por um ou mais espaços em branco; e

• Uma substring que não será capturada pelo grupo (?:, mas um será capturada pelo grupo <1>. Aí queremos dizer que quando o valor do href vier entre aspas, a substring não será capturada. Só que o texto que estiver entre as aspas será capturado pelo grupo (?<1>.

O código abaixo acessa uma página HTML e lista todos os valores dos HREFs. No código abaixo não estou levando em consideração aspectos de segurança e tratamento de erro, pois o foco está na execução da expressão.

using System;
using System.Text.RegularExpressions;
using System.Net;
using System.IO;

namespace PostsMSN.Samples.ListarUrls{
    class Program{
        static void Main(string[] args){
            // Cria a URL para o site 
            WebRequest request = 
                WebRequest.Create("http://www.devgoias.net");

            // Obtém o response
            HttpWebResponse response = 
                (HttpWebResponse)request.GetResponse();

            // Obtém o stream com a resposta do servidor.
            Stream dataStream = response.GetResponseStream();

            // Abre o stream para leitura
            StreamReader reader = new StreamReader(dataStream);
            string strHtml = reader.ReadToEnd();

            ListarHrefs(strHtml);

            reader.Close();
            dataStream.Close();

            Console.ReadLine();
        }

        /// <summary>
        /// Lista todos os Hrefs do HTML
        /// </summary>
        /// <param name="strHtml"></param>
        private static void ListarHrefs(string strHtml){
            Regex regex = 
                new Regex("href\\s*=\\s*(?:\"(?<1>[^\"]*)\"|(?<1>\\S+))",
                RegexOptions.IgnoreCase | RegexOptions.Compiled);

            for (Match m = regex.Match(strHtml); m.Success; m = m.NextMatch()){
                Console.WriteLine("URL: " + m.Groups[1]);
            }
        }
    }
}

abraço,

Renato Guimarães, MS MVP Visual C#

[PAC.NET]: Como saber quais dlls foram carregadas como executável?

Fri, 30 May 2008 22:02:33 GMT

Olá amigos,

Um exemplo bem rápido de como saber quais as dlls foram carregads como executável. Perceba que estou considerando somente os assemblies carregados no AppDomain corrente. Deve existir outras formas de verificar esta informação... Acredito que uma delas está no código abaixo, onde verifico se o assembly tem um EntryPoint. Se tiver, quer dizer que é um executável.

using System;
using System.Reflection;
using System.IO;

namespace PostsMSN.Samples.LoadedAssemblies{
    class Program{
        static void Main(string[] args){
            //obtém todos os módulos carregados no appdomain corrente
            Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();

            foreach (Assembly assembly in loadedAssemblies){
                Console.Write("Assembly: " + Path.GetFileName(assembly.CodeBase));
                Console.WriteLine("   É Executável? " + 
                    ((assembly.EntryPoint != null) ? "Sim" : "Não"));
            }

            Console.ReadLine();
        }
    }
}

Resultado:

Assembly: mscorlib.dll É Executável? Não
Assembly: LoadedAssemblies.exe É Executável? Sim

Por que este exemplo? Sei lá :-). Brincando. É porque vi no histórico de acesso do meu MSN Spaces que alguém estava procurando por esta informação. Como já fiz outro dia, então fiz este exemplo bem rapidinho. Fique a vontade para mandar outras sugestões...

Abraço,

Renato Guimarães, MS MVP Visual C#