Renato Guimarães

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#

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#

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.

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#

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#