C# - Conceitos : Operador Condicional (Ternário ?: ) e operador ?? (Null-Coalescente)

 Neste artigo eu vou apresentar os conceitos básicos da linguagem C# para usar o operador condicional ou ternário ( ? : ) e o operador ?? (null-coalescente).

O operador ternário  ( ? : ) é utilizado para validar uma condição.

Recursos usados :

Conceitos Básicos - Operador Ternário ( ? : )

O operador ternário ( ? : ) funciona assim:

Você tem uma condição que deve ser validada como verdadeira ou falsa.

Se a condição for verdadeira o operador retorna uma expressão e se for falsa retorna outra expressão.

Sintaxe:

	condição ? expressão1_se_true : expressão2_se_false

Argumentos :

condição
Qualquer expressão booleana.
Expressão1_se_true
Uma expressão retornada se a condição for verdadeira (true). Pode ser uma expressão de vírgula.
Expressão2_se_false
Uma expressão retornada se a condição for falsa (false). Pode ser uma expressão de vírgula.

O operador ? : pode ser usado como um atalho para uma instrução if...else.

Este operador é normalmente usado como parte de uma expressão maior onde uma instrução if...else seria inconveniente.

Vejamos um exemplo usando a instrução if...else :

using System;
namespace OperadorTenario
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime agora = DateTime.Now;
            Console.WriteLine("Agora: {0}", agora.ToLongDateString());
            string saudacao = "";            
            if (agora.Hour > 12)
                saudacao += "Boa Tarde.";
            else
                saudacao += "Bom Dia.";
            Console.WriteLine("São {0}  horas", agora.Hour);
            Console.WriteLine(saudacao);
            Console.ReadKey();
        }
    }
}

Vamos substituir a instrução if..else pelo operador ternário ( ? : ) :

using System;
namespace OperadorTenario
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime agora = DateTime.Now;
            Console.WriteLine("Agora: {0}", agora.ToLongDateString());
            string saudacao;       

            saudacao = agora.Hour > 12 ? "Boa Tarde" : "Bom dia";
            Console.WriteLine("São {0}  horas", agora.Hour);
            Console.WriteLine(saudacao);
            Console.ReadKey();
        }
    }
}

Podemos aplicar este recurso em qualquer local como por exemplo na definição de um delegate:

1- Usando else...if

 Func<Aluno, string> verificaNome = aluno =>
 {
                if (aluno.Nome.StartsWith("J"))
                    return aluno.Nome;
                else
                    return "O Aluno não atende o critério.";
 };

2- Usando o operador ternário


  Func<Aluno, string> verificaNome = aluno => aluno.Nome.StartsWith("J") ? aluno.Nome : "Não atende o critério";

 

Outro uso que podemos ter é usar o operador ternário como parâmetro  de um método.

Exemplo:  

using System;
namespace Ternario_Parametro_Metrodo
{
    class Program
    {
        static void Main(string[] args)
        {
            string nome1 = "Macoratti";
            string nome2 = "José Carlos";
            ExibirNome(nome1.Length > 5 ? nome1 : nome2);
            Console.ReadKey();
        }
        public static void ExibirNome(string texto)
        {
            Console.WriteLine(texto);
        }
    }
}

No código acima o resultado do operador ternário será usado como parâmetro no método ExibirNome.

Conceitos Básicos - Operador ?? (Null-Coalescente)

Outro uso que você pode ter é verificar se uma variável possui um valor Null.

Abaixo temos um exemplo que verifica se uma variável é null usando a instrução if...else, o operador ternário e  o operador ??  Null Coalescing:

Nota: O significado de Coalescente em português é :  Que de liga de modo intenso; que adere com facilidade; aderente ou aglutinante.

namespace Ternario_Null
{
    class Program
    {
        static void Main(string[] args)
        {
            // usando if ...else -----------------------
            object a = null;
            object b = new object();
            object c;
            if (a != null)
                c = a;
            else
                c = b; 
            //------usando operador ternário-----------
            object x = null;
            object y = new object();
            object z = (x != null) ? x : y; 
            
            //--------usando o operador ?? -------------
            object i = null;
            object j = new object();
            object k = i ?? j;
        }
    }
}

Para verificar valores null o operador mais indicado é o operador ?? ( null-coalescente).

O operador  ??  é chamado operador null-coalescente. Ele simplifica a verificação de valores nulos. (null)

Ele pode ser usado tanto com tipos anuláveis ( tipo? )  como com tipos de referência.(strings)

Sua representação é: x ?? y

Ele retorna o operando à esquerda se o operando não é nulo; caso contrário, retorna o operando do lado direito.

ou seja se x não é nulo, será retornado x, caso contrári será retornado y.

Na sintaxe: x ?? y

x é o primeiro operando que é do tipo nullable
y é o segundo operando que tem um valor non-nullable do mesmo tipo

Durante a execução de código, se x for avaliado como null, y é retornado como o valor.

Lembre-se que o operador ?? é avaliado da direita para a esquerda.

Então se você tem uma expressão da forma x?? y?? z

Esta expressão é avaliada como x ?? (y ?? z)

Exemplo:

class Program
    {
        static string _nome;

        static string Nome
        {
            get
            {
                return _nome ?? "Default";
            }
            set
            {
                _nome = value;
            }
        }

        static void Main(string[] args)
        {
            Console.WriteLine(Nome);
            Nome = "Macoratti";
            Console.WriteLine(Nome);
            Nome = null;
            Console.WriteLine(Nome);
        }
    }

Exemplo usando o operador ?? :

using System;
namespace Operador_Coalescente
{
    class Program
    {
        static void Main(string[] args)
        {
            int? x = null;
            //se x for null então retorna -1
            //se x Não for null entao null
            int y = x ?? -1;
            Console.WriteLine(y);  //retorna  -1
            Console.ReadKey();
        }
    }
}

O resultado de um operador ??  não é considerado como sendo uma constante, mesmo que ambos os seus argumentos sejam constantes.

Pegue o exemplo do projeto aqui:  OperadorTenario.zip

João 5:24 Na verdade, na verdade vos digo que quem ouve a minha palavra, e crê naquele que me enviou, tem a vida eterna, e não entrará em condenação, mas passou da morte para a vida.

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 ?


             Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter
 

Referências:

José Carlos Macoratti