Desenvolvimento - C#

Resolva seus problemas do dia-a-dia com Elevate

Este artigo é uma introdução ao Elevate, uma biblioteca Open Source para C# contendo dezenas de funcionalidades para auxiliar o desenvolvimento de quaisquer tipos de aplicações.

por Marcio Paulo Mello Martins


Descrição

Este artigo é uma introdução ao Elevate, uma biblioteca Open Source para C# contendo dezenas de funcionalidades para auxiliar o desenvolvimento de quaisquer tipos de aplicações.

Tecnologias relacionadas

.NET 3.5, C# 3.0, Visual Studio 2008

Introdução

Vamos ser sinceros: nenhuma biblioteca possui tudo o que precisamos. Vira e mexe, lá estamos nós escrevendo novamente aquele método de utilidade (os famosos namespaces "Util") para uma outra aplicação ou um outro projeto. Mesmo sabendo que não é uma boa prática, vivemos reinventando a roda a todo momento para coisas relativamente simples. Ou então você é um cara mais esperto e vive carregando seu arquivo "Utilidades.cs" de um projeto para outro. Ainda assim, lá no seu inconsciente, você sabe que um dia isto tem que mudar.

Para quem conhece C++, esta lacuna é preenchida pelo Boost, uma biblioteca que traz diversas funcionalidades que, por um motivo maior, não são nativos da linguagem. É uma biblioteca fantástica para quem desenvolve em C++ ... mas e nós, pobres mortais do C#?

É aí que entra uma turminha muito legal que resolveu dar uma mãozinha: começaram a desenvolver uma biblioteca para ser o Boost.NET: Elevate.

O Elevate nada mais é do que uma biblioteca "Boost-like", com diversas facilidades que ajudarão a resolver problemas comuns ao dia-a-dia do desenvolvedor C#, além de economizar tempo e, consequentemente, dinheiro dos patrocinadores do seu projeto.

Iniciando a utilização

Para utilizar o Elevate, basta baixar o projeto através da página do projeto no CodePlex, compilar o projeto e adicionar uma referência à DLL gerada.

Para os exemplos abaixo você deve declarar os seguintes namespaces na seção de usings:

using SRTSolutions.Elevate;

using SRTSolutions.Elevate.PatternMatching;

Analisando o Elevate

A equipe de desenvolvedores do Elevate quis trazer alguns conceitos de linguagens funcionais para o C#. Para isto, tomaram alguns métodos e classes mais úteis de linguagens como F#, Ruby e Haskell e adicionaram à sua propria coleção de utilidades para C#. Apresento aqui alguns destaques que, com certeza, vão ajudar muito.

Construindo sequências

Sequências para o Elevate são conjuntos de valores seqüenciais ou não, constituídos numa estrutura parecida com uma lista genérica (List<T>).

Imagine a seguinte situação: você precisa criar listas que precisam ser adicionadas a outras listas, e a outras, e a mais outras.

Veja como o elevate pode nos ajudar em dois casos:

· Sequências de strings: Utilizaremos uma classe chamada "Seq", e seu método "Build" para construir uma sequência. Veja o código abaixo:

Caixa de texto: static void Misturar() { // Se você quer construir uma sequência de valores, // utilize o método Seq.Build var s1 = Seq.Build("alpha", "beta"); var s2 = Seq.Build("delta", "epsilon"); // Você pode combinar sequências com outros valores // para criar novas sequências var resultado = Seq.Build(s1, "gama", s2, "zeta"); foreach (string s in resultado) { Console.WriteLine(s); } }

Ao executarmos o código acima, teremos a seguinte saída:

alpha

beta

gama

delta

epsilon

zeta

    Então, ao executarmos o código acima, a saída será:

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

      Ao executar o código acima, teremos como saída:

      Sequência inicial: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

      Pedaço: 1 2 3 4 5

      Pedaço: 6 7 8 9 10

      Pedaço: 11 12 13 14 15

      Pedaço: 16 17 18 19 20

      Utilizando com LINQ

      Ao utilizar o Elevate como extensor do LINQ, podemos abrir um leque de novas possibilidades.

        A saída do código acima é:

        Valores iniciais: 10 20 30 40 50

        Valores calculados: 10 10 10 10 10

          A saída da execução deste código é a seguinte:

          Sequência 1: 0 1 2 3 4 5

          Sequência 2: 2 4 6 8 10 12

          Sequência calculada: 0 4 12 24 40 60

          Comparação de padrões

          O Elevate possui um namespace chamado “PatternMatching” que possui classes, métodos e extensões muito úteis para quem precisa fazer comparações entre padrões de strings de vez em quando, ou seja, todo mundo! Vejamos alguns exemplos interessantes.

            O código acima, quando executado, exibirá a seguinte saída:

            Comparação em "alpha": Contém "a"!

              Na saída, teremos:

              Comparando o tuple<"Pernetas", 2>: 2

              Tipos Option

              Um tipo Option<T> é um opcional, como o nome já diz. Você pode criar uma variável Option e atribuir (ou não) um valor para ela. O Tipo Option<T> é útil quando precisamos de uma variável que tem a opção por conter ou não um valor. É semelhante ao tipo Nullable<T>, nosso já bem conhecido.

              Caixa de texto: static void TiposOptionPodemConterValores() { // Dado um valor int value = 10; //Podemos encapsulá-lo em um tipo Option, assim: Option<int> option = Option.Some(value); // Desta forma, podemos verificar se existe valor no objeto: Console.WriteLine("Possui valor? R: " + option.IsSome); Console.WriteLine("É nada? R: " + option.IsNone); Console.WriteLine("Qual o valor? R: " + option.Value); }

              A saída do código acima é a seguinte:

              Possui valor? R: True

              É nada? R: False

              Qual o valor? R: 10

              Mais um exemplo, desta vez utilizando o resultado de funções lambda:

              Caixa de texto: static void MultiplasOperacoesComOption() { // Digamos que temos algumas funções que retornam (ou não) um valor: Func<int, Option<int>> divideSePar = value => ((value % 2) == 0) ? Option.Some(value / 2) : Option<int>.None; Func<int, Option<int>> subtraiSeDivisivelPorTres = value => ((value % 3) == 0) ? Option.Some(value - 3) : Option<int>.None; Func<int, Option<int>> multiplicaSeImpar = value => ((value % 2) != 0) ? Option.Some(value * 2) : Option<int>.None; // Vamos encadear os resultados destas operações, assim: Option<int> resultado = divideSePar(36) .Select(subtraiSeDivisivelPorTres) .Select(multiplicaSeImpar); // Podemos então verificar se existe valor no objeto: Console.WriteLine("Possui valor? R: " + resultado.IsSome); Console.WriteLine("É nada? R: " + resultado.IsNone); // O valor é o resultado de: {[(36 / 2) - 3] * 2} = 30 Console.WriteLine("Qual o valor? R: " + resultado.Value); }

              Ao executarmos, teremos:

              Possui valor? R: True

              É nada? R: False

              Qual o valor? R: 30

              Conclusão

              O Elevate, apesar de estar começando a andar nestes últimos meses, promete. Resolvendo pequenos "probleminhas" que o desenvolvedor C# encontra, a economia de tempo que se pode obter utilizando esta biblioteca é considerável. Claro que ainda falta muita coisa para que o Elevate torne-se um Boost para .NET, mas os primeiros passos foram dados. Convido a todos os interessados para acompanharem o progresso deste projeto, além de colaborar com a comunidade para que possamos ajudar a criar uma ferramenta digna de reverência, assim como o Boost o é em relação ao C++.

              Três vivas para o Elevate! Viva! Viva! Viva!

              Referências

                http://srtsolutions.com/blogs/chrismarinos/archive/2009/08/19/introducing-elevate.aspx
Marcio Paulo Mello Martins

Marcio Paulo Mello Martins - Bacharel em Ciência da Computação pela FASP; MCP, MCAD, MCSD, MCTS, MCPD e MCT. Atua há mais de 10 anos com desenvolvimento de software e treinamento em tecnologias Microsoft, trabalhando hoje como Analista Desenvolvedor na F|Camara (http://www.fcamara.com.br), além de ser proprietário da Logical Docs (http://www.logicaldocs.com.br), empresa do ramo de gerenciamento eletrônico de documentos. Quando sobra um tempinho, é pianista e toca em uma banda de Jazz.