Use Operadores Implícitos 1#

Use Operador Implícito

Salve Dev, me chamo Jorel Magatti e sou Desenvolvedor c# .Net, aqui trago algumas implementações simples utilização de objetos do tipo Operador Implícito. Conforme a documentação o Operador implícito é uma operador de conversão, onde temos operadores implícitos usados naturalmente pela linguagem como temos operadores de conversão definidos pelo usuário, dentre estes operadores de conversão temos tanto os implícitos como o explícitos, neste artigo vou tratar somente do operador implícito e suas qualidades. Eu trabalho bastante com operadores implícitos em minhas entregas, principalmente como um mapping de dados, parecido ao usado no auto-mapper e similares, porem com código nativo do c#.

Operadores de conversão definidos pelo usuário - Referência de C#

Operador de Conversão Implícita?

Operador de Conversão Implícita são maneiras de mostrar ao compilador como resolver a conversão entre formatos diferentes de dados de forma implícita (ou não expresso formalmente), deixando o código enxuto e mais limpo. Um exemplo nativo de conversão implícita usado diariamente em conversões de dados do tipo (int) para (double):

exemplo simples Operador Implícito e Explícito nativo

Operador de Conversão Implícita Definida pelo Usuário?

O C# nos dá a possibilidade de criar operadores implícitos para serem usados em conversões entre objetos compostos, para mostrar um exemplo de utilização do operador implícito definido pelo usuário, vou usar como exemplo uma conversão entre dois objetos onde na conversão entre eles, ele deve executar cálculos básico (soma, divisão …) retornando um outro tipo de objeto já com estes resultados em mãos, segue abaixo:

using System;

namespace ConsoleAppOperadoresImplicitos
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Operador Implícito Definido pelo Usua´rio!");
            ValoresSemCalculo valoresParaCalcular = new ValoresSemCalculo()
            {
                valorA = 2,
                valorB = 5,
            };

            ValoresCalculados calculado = valoresParaCalcular;

            Console.WriteLine($" Valor Soma => {calculado.ValorSoma}");
            Console.WriteLine($" Valor Subtração => {calculado.ValorSubtracao}");
            Console.WriteLine($" Valor Multiplicação => {calculado.ValorMultiplicado}");
            Console.WriteLine($" Valor Divisão => {calculado.ValorDivisao}");
            Console.ReadKey();
        } 
    }

    public class ValoresSemCalculo
    {
        public int valorA { get; set; }
        public int valorB { get; set; }

        public static implicit operator ValoresCalculados(ValoresSemCalculo dados)
        {
            return new ValoresCalculados() {
                valorA = dados.valorA,
                valorB = dados.valorB,
                ValorMultiplicado = dados.valorA * dados.valorB,
                ValorSoma = dados.valorA + dados.valorB,
                ValorDivisao = dados.valorA / dados.valorB,
                ValorSubtracao = dados.valorA - dados.valorB
            };
        }

    }

    public class ValoresCalculados
    {
        public int valorA { get; set; }
        public int valorB { get; set; }

        public decimal ValorMultiplicado { get; set; }
        public decimal ValorSoma { get; set; }
        public decimal ValorDivisao { get; set; }
        public decimal ValorSubtracao { get; set; }
    }
}

No exemplo acima note que fora da nossa classe Main() padrão dos Consoles Applications, temos a criação de duas classes de objeto ValoresSemCalculo() e ValoresCalculados() (lembrando que nunca é recomendado criar classes no mesmo arquivo, o mesmo foi feito somente para trazer todo o exemplo em um único arquivo). O objeto ValoresSemCalculo vai receber os valores dentro dos parametros A e B para serem calculados e logo abaixo temos a definição do operador implicito deste objeto, onde ele define que o retorno será para o objeto ValoresCalculados segue abaixo:

criação de Operador Implícito definido pelo usuário

Note que a criação de um operador implícito em um objeto deve ser sempre public e estática, ele é muito similar a criação de um construtor, porem ao invés de criá-lo para o objeto da sua própria classe (ValoresSemCalculo), você está criando para outra classe (ValoresCalculados) e como argumento recebe o seu próprio tipo de classe (ValoresCalculados(ValoresSemCalculo dados)):

Argumento Operador implicito Definido pelo usuário

E no corpo da definição do operador implícito, descrevemos onde cada valor de parâmetro da classe ValoresSemCalculo deve ser usado na classe ValoresCalculados, e aqui também definimos os cálculos aplicados para os campos ValorMultiplicado, ValorSoma, ValorDivisao e ValorSubtracao usando os dados dos campos valorA e valorB do objeto de entrada:

corpo da definição de Operador Implícito definido pele usuário

Operador Implícito, é muito útil e performático, ajuda a manter isolado regras de mapeamento entre a conversão dos objetos compostos nas classes usadas e com ele você utiliza código nativo, as ultimas versões do C# já trazem ele por padrão, evitando com isso a utilização de bibliotecas terceiras para estas necessidades, e claro deixando o código mais limpo e enxuto, em outros artigos vou trazer mais exemplos de utilização de operadores implícitos entre outros casos de uso.

Espero que goste da leitura e espero que este pequeno artigo tenha lhe ajudado em sua necessidade de entrega. Abraços Dev🚀🚀🚀

jorelmagatti - Overview