C# - Usando Generics na prática - II

  Hoje veremos como usar Generics na prática em um projeto para criar uma calculadora Genérica.

Continuando a primeira parte deste artigo veremos uma abordagem mais robusta para implementar uma calculadora genérica usando Generics.

Nesta abordagem vamos usar uma classe abstrata Calculadora<T> que será especializada para cada tipo primitivo, e, o tipo genérico poderá então usar uma instância da calculadora apropriada para realizar as operações.

Em um projeto do tipo Console criado no VS 2017 Community vamos criar uma classe abstrata chamada Calculadora<T> com 4 métodos abstratos conforme abaixo:

A seguir vamos especializar o tipo para o qual desejamos criar a calculadora criando uma classe chamada CalculadoraInteiros que herda da classe Calculadora<T>, define o tipo como int e sobrescreve os métodos abstratos implementando as operações :

A seguir vamos criar uma classe que usa a implementação da CalculadoraInteiros e realiza as operações.

Vamos criar a classe CalcularOperacoes() que implementa as operações para uma lista de números com o código abaixo:

  1. using System.Collections.Generic;
  3. public class CalcularOperacoes<T> where T : new()
  4. {
  5.      Calculadora<T> calculadora;
  7.      public CalcularOperacoes(Calculadora<T> _calculadora)
  8.      {
  9.         this.calculadora = _calculadora;
  10.      } 
  12.      public T Somar(List<T> items)
  13.      {
  14.         T soma = new T();
  15.         for (int i = 0; i < items.Count; i++)
  16.         {
  17.             soma = calculadora.Adicionar(soma, items[i]);
  18.         }
  19.         return soma;
  20.      }
  21.  
  22.      public T Subtrair(List<T> items)
  23.      {
  24.         dynamic subtrair = new T();
  25.         for (int i = 0; i < items.Count; i++)
  26.         {
  27.             if(i==0)
  28.             {
  29.                 subtrair = calculadora.Subtrair(subtrair, items[i]);
  30.                 subtrair = subtrair * -1;
  31.              }
  32.              else
  33.              {
  34.                 subtrair = calculadora.Subtrair(subtrair, items[i]);
  35.              }
  36.         }
  37.         return subtrair;
  38.      }
  40.      public T Multiplicar(List<T> items)
  41.      {
  42.         dynamic multiplicar= 1;
  43.         for (int i = 0; i < items.Count; i++)
  44.         {
  45.             multiplicar= calculadora.Multiplicar(multiplicar, items[i]);
  46.         }
  47.         return multiplicar;
  48.      }
  50.      public T Dividir(List<T> items)
  51.      {
  52.         dynamic dividir= 1;
  53.         for (int i = 0; i < items.Count; i++)
  54.         {
  55.             if(dividir==1)
  56.             {
  57.                dividir= calculadora.Dividir(items[i], dividir);
  58.             }
  59.             else
  60.             {
  61.                dividir= calculadora.Dividir(dividir, items[i]);
  62.             } 
  63.         }
  64.         return dividir;
  65.      }
  66. }  
     

Neste código, continuamos a usar o tipo dynamic para as operações de subtração, multiplicação e divisão.

A seguir temos o código no método Main() que mostra a utilização da nossa implementação.

O resultado obtido para os números 9,3 e -1 exibido abaixo:

Nossa calculadora Genérica, na implementação para inteiros, esta funcionando, mas podemos melhorar ainda mais o código, pois continuamos a usar dynamics o que afeta o desempenho da aplicação.

Vou deixar um link para uma implementação que não usa nenhuma invocação de método virtual : https://goo.gl/rZt91p

Pegue o projeto aqui :  CalcGenerica.zip

"E (Jesus) dizia: Por isso eu vos disse que ninguém pode vir a mim, se por meu Pai não lhe for concedido."
João 6:65

Referências:

José Carlos Macoratti