C# - Três Recursos desconhecidos ou pouco usados

Hoje veremos 5 recursos da linguagem C# que são raramente usados ou até mesmo desconhecidos por muitos desenvolvedores.

Já estamos caminhando para a versão 8.0 da linguagem C# e, é impressionante como a linguagem vem evoluindo e agregando novos recursos.

Em meio a tantos recursos existem alguns que são raramente usados ou mesmo desconhecidos pelos desenvolvedores.

Neste artigo vou apresentar 3 desses recursos.

Recursos usados:

1 - GOTO

Quem não lembra do famigerado Go To do Basic ?

Pois bem, ele existe também na linguagem C#...

Ele funciona assim: "Transfere o controle para uma label nomeada e pode ser usado para sair de laços, ifs, switchs, etc."

A sintaxe usada para nomear a label é : nome_da_label:

Vejamos dois exemplos básicos de uso do goto no C# : 

 private static int Recurso1_Goto()
        {
            int conta = 0;
            for (int a = 0; a < 10; a++)
            {
                for (int y = 0; y < 10; y++) 
                {
                    for (int x = 0; x < 10; x++)
                    {
                        if (x == 5 && y == 5)
                        {
                            goto Saida;
                        }
                    }
                    conta++;
                }
                Saida:
                continue;
            }
            return conta;
        }
 
  static void Main(string[] args)
  {
            string nome;
            Rotulo:            //cria uma label
            Console.WriteLine("Qual seu nome: ");
            nome = Console.ReadLine();
            Console.WriteLine("Bem-Vindo {0}", nome);
            Console.WriteLine("Pressione Ctrl + C para Sair\n");
            goto Rotulo;     //pula para label definida
   }
 

Basta criar uma label em qualquer parte do seu código e usar a instrução goto para desviar o controle para esta parte do código.

Assim, mesmo não sendo praticamente usado a instrução goto faz parte da linguagem C#.

2 - CHECKED/UNCHECKED

Este é outro recurso raramente usado.

Instruções C# podem ser executadas em contexto checked ou unchecked. Em um contexto checked, o estouro aritmético (overflow) gera uma exceção. Em um contexto unchecked, o estouro aritmético é ignorado e o resultado é truncado descartando-se quaisquer bits de alta ordem que não se encaixam no tipo de destino.

A instrução checked força o C# a gerar exceções sempre que ocorram exceções de aritmético ou de estouro de pilha devido a problemas aritméticos ou de conversão do tipo integral.  A instrução unchecked ignora a exceção de estouro de pilha e executa o programa de modo que o valor obtido pode estar incorreto.

Se nada for especificado o contexto padrão para expressões não constantes é definido pelo valor da opção -checked do compilador. Por padrão, o valor dessa opção não é definido e as operações aritméticas são executadas em um contexto unchecked.

Exemplos:

Dentro de um contexto checked, uma exceção será lançada e os erros erros podem ser evitados pegando o estouro antecipadamente. Isso leva a programas de maior qualidade.

Se você remover a instrução checked a exceção não será lançada e o valor da variável num apresentará um valor inconsistente.

3 - EXPLICIT / IMPLICIT

Outro recurso que raramente usamos...

Como a linguagem  C#  é estaticamente tipada em tempo de compilação, após uma variável ser declarada, ele não pode ser declarada novamente ou usada para armazenar valores de outro tipo, a menos que esse tipo seja convertível para o tipo da variável.

No entanto, às vezes você pode precisar copiar um valor em uma variável ou parâmetro de método de outro tipo; ou pode precisar atribuir uma variável de classe a uma variável de um tipo de interface. Esses tipos de operações são chamados conversões de tipo. Dentro os tipos de conversões tempos as conversões explicitas e sa implícitas.

A palavra-chave implicit é usada para declarar um operador de conversão implícita de tipo definido pelo usuário. Use-a para habilitar conversões implícitas entre um tipo definido pelo usuário e outro tipo, se houver garantia de que a conversão não causará perda de dados.

A palavra-chave explicit declara um operador de conversão de tipo definido pelo usuário que deve ser invocado com uma conversão. Ela é usada na sobrecarga de operador.

Exemplo de uso de explicit :

using System;
namespace CSharp_RecursosRaros
{
    class Apartmento
    {
        public string Nome { get; set; }
        public static explicit operator Casa(Apartmento a)
        {
            return new Casa() { Nome = a.Nome };
        }
    }
    class Casa
    {
        public string Nome { get; set; }
        public static explicit operator Apartmento(Casa c)
        {
            return new Apartmento() { Nome = c.Nome };
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Casa casa = new Casa();
            casa.Nome = "Minha Casa";
            // Converte uma Casa para um Apartamento
            Apartmento apartamento = (Apartmento)casa;
            // Apartamento foi convertido de Casa
            Console.WriteLine(apartamento.Nome);
        }     
    }
}
 Neste exemplo temos duas classes:

1 - Apartamento
2 - Casa

Cada uma fornece um operador público explicit

Esses operadores explícitos são implementados através da construção de uma nova instância do tipo de destino.

Eles definem a propriedade Nome.

Assim, o Apartamento ou Casa é agora do tipo oposto, mas tem o mesmo campo de dados.

Quando você usa um cast como (Apartamento) ou (Casa), este é um cast explícito.

Um cast implícito não usa essa sintaxe.

Exemplo de operador implicit :

namespace CSharp_RecursosRaros
{
    struct Digito
    {
        byte valor;
        public Digito(byte valor)  
        {
            if (valor > 9)
            {
                throw new System.ArgumentException();
            }
            this.valor = valor;
        }
        //operador de conversão implicita de Digito para byte
        public static implicit operator byte(Digito d)  
        {
            System.Console.WriteLine("Conversão realizada");
            return d.valor;  // conversão implicita
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Digito d = new Digito(3);
            byte b = d;  // conversão implicita -- não precisa fazer o cast
        }
    }
}

 

 Este exemplo demonstra um operador de conversão implícita definindo um operador de conversão que converte de uma classe de valor chamada Digito no tipo Byte.

Como qualquer dígito pode ser convertido em um Byte, não há necessidade de forçar os usuários a serem explícitos com relação à conversão.

Assim é possível usar o operador de conversão implicit, ou o operador explicit, que é indicado para alguém que lê o código que está convertendo em um tipo.

Vimos assim 3 recursos existentes na linguagem C# que são usados muito raramente.

Você sabia que estes recursos existiam ? Já usou alguns destes recursos ?

Existem mais recursos existentes no C# que são raramente usados e em outro artigo eu volto ao assunto...

Havendo Deus antigamente falado muitas vezes, e de muitas maneiras, aos pais, pelos profetas, a nós falou-nos nestes últimos dias pelo Filho; A quem constituiu herdeiro de tudo, por quem fez também o mundo.
 Hebreus 1:1,2

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:

José Carlos Macoratti