Maneiras exclusivas de usar o operador Null Coalescing [fechado]

Eu sei que a maneira padrão de usar o operador coalescente nulo em C # é definir valores padrão.

string nobody = null;
string somebody = "Bob Saget";
string anybody = "";

anybody = nobody   ?? "Mr. T"; // returns Mr. T
anybody = somebody ?? "Mr. T"; // returns "Bob Saget"

Mas o que mais pode ??ser usado? Não parece tão útil quanto o operador ternário, além de ser mais conciso e fácil de ler do que:

nobody = null;
anybody = nobody == null ? "Bob Saget" : nobody; // returns Bob Saget

Portanto, dado que menos sabem sobre o operador coalescente nulo ...

• Você já usou ??para outra coisa?

• É ??necessário ou você deve apenas usar o operador ternário (com o qual a maioria está familiarizada)

Bem, primeiro de tudo, é muito mais fácil encadear do que o ternário padrão:

string anybody = parm1 ?? localDefault ?? globalDefault;

vs.

string anyboby = (parm1 != null) ? parm1 
               : ((localDefault != null) ? localDefault 
               : globalDefault);

Também funciona bem se o objeto nulo possível não for uma variável:

string anybody = Parameters["Name"] 
              ?? Settings["Name"] 
              ?? GlobalSetting["Name"];

vs.

string anybody = (Parameters["Name"] != null ? Parameters["Name"] 
                 : (Settings["Name"] != null) ? Settings["Name"]
                 :  GlobalSetting["Name"];

Eu usei-o como uma linha de carga lenta:

public MyClass LazyProp
{
    get { return lazyField ?? (lazyField = new MyClass()); }
}

Legível? Decida por si mesmo.

Eu achei útil de duas maneiras "um pouco estranhas":

• Como alternativa para ter um outparâmetro ao escrever TryParserotinas (ou seja, retornar o valor nulo se a análise falhar)
• Como uma representação "não sei" para comparações

Este último precisa de um pouco mais de informação. Normalmente, quando você cria uma comparação com vários elementos, é necessário verificar se a primeira parte da comparação (por exemplo, idade) fornece uma resposta definitiva e a próxima parte (por exemplo, nome) apenas se a primeira parte não ajudar. Usar o operador coalescente nulo significa que você pode escrever comparações bastante simples (seja para pedidos ou igualdade). Por exemplo, usando algumas classes auxiliares no MiscUtil :

public int Compare(Person p1, Person p2)
{
    return PartialComparer.Compare(p1.Age, p2.Age)
        ?? PartialComparer.Compare(p1.Name, p2.Name)
        ?? PartialComparer.Compare(p1.Salary, p2.Salary)
        ?? 0;
}

É certo que agora tenho o ProjectionComparer no MiscUtil, junto com algumas extensões, que tornam esse tipo de coisa ainda mais fácil - mas ainda é legal.

O mesmo pode ser feito para verificar a igualdade de referência (ou a nulidade) no início da implementação de Equals.

Outra vantagem é que o operador ternário exige uma avaliação dupla ou uma variável temporária.

Considere isso, por exemplo:

string result = MyMethod() ?? "default value";

enquanto no operador ternário, você fica com:

string result = (MyMethod () != null ? MyMethod () : "default value");

que chama MyMethod duas vezes ou:

string methodResult = MyMethod ();
string result = (methodResult != null ? methodResult : "default value");

De qualquer maneira, o operador coalescente nulo é mais limpo e, acho, mais eficiente.

Outra coisa a considerar é que o operador de coalescência não chama o método get de uma propriedade duas vezes, como o ternário.

Portanto, existem cenários em que você não deve usar ternários, por exemplo:

public class A
{
    var count = 0;
    private int? _prop = null;
    public int? Prop
    {
        get 
        {
            ++count;
            return _prop
        }
        set
        {
            _prop = value;
        }
    }
}

Se você usar:

var a = new A();
var b = a.Prop == null ? 0 : a.Prop;

o getter será chamado duas vezes e a countvariável será igual a 2, e se você usar:

var b = a.Prop ?? 0

a countvariável será igual a 1, como deveria.

A maior vantagem que encontro para o ??operador é que você pode converter facilmente tipos de valor anuláveis ​​em tipos não anuláveis:

int? test = null;
var result = test ?? 0; // result is int, not int?

Eu freqüentemente uso isso em consultas Linq:

Dictionary<int, int?> PurchaseQuantities;
// PurchaseQuantities populated via ASP .NET MVC form.
var totalPurchased = PurchaseQuantities.Sum(kvp => kvp.Value ?? 0);
// totalPurchased is int, not int?

Eu usei ?? na minha implementação do IDataErrorInfo:

public string Error
{
    get
    {
        return this["Name"] ?? this["Address"] ?? this["Phone"];
    }
}

public string this[string columnName]
{
    get { ... }
}

Se alguma propriedade individual estiver no estado "erro", eu recebo esse erro, caso contrário, fico nulo. Funciona muito bem.

Você pode usar o operador coalescente nulo para torná-lo um pouco mais limpo para lidar com o caso em que um parâmetro opcional não está definido:

public void Method(Arg arg = null)
{
    arg = arg ?? Arg.Default;
    ...

Eu gosto de usar o operador de coalescência nula para carregar preguiçosamente determinadas propriedades.

Um exemplo muito simples (e artificial) apenas para ilustrar meu argumento:

public class StackOverflow
{
    private IEnumerable<string> _definitions;
    public IEnumerable<string> Definitions
    {
        get
        {
            return _definitions ?? (
                _definitions = new List<string>
                {
                    "definition 1",
                    "definition 2",
                    "definition 3"
                }
            );
        }
    } 
}

É ?? necessário, ou você deve apenas usar o operador ternário (com o qual a maioria está familiarizada)

Na verdade, minha experiência é que poucas pessoas estão familiarizadas com o operador ternário (ou mais corretamente, o operador condicional ; ?:é "ternário" no mesmo sentido que ||é binário ou +é unário ou binário; no entanto, é o único operador ternário em vários idiomas); portanto, pelo menos nessa amostra limitada, sua declaração falhará ali.

Além disso, como mencionado anteriormente, há uma situação importante em que o operador coalescente nulo é muito útil e é sempre que a expressão a ser avaliada tem algum efeito colateral. Nesse caso, você não pode usar o operador condicional sem (a) introduzir uma variável temporária ou (b) alterar a lógica real do aplicativo. (b) claramente não é apropriado em nenhuma circunstância e, embora seja uma preferência pessoal, não gosto de bagunçar o escopo da declaração com muitas variáveis ​​estranhas, mesmo que de curta duração; cenário particular.

Obviamente, se você precisar fazer várias verificações no resultado, o operador condicional ou um conjunto de ifblocos provavelmente será a ferramenta para o trabalho. Mas, para simples "se isso for nulo, use isso, caso contrário, use-o", o operador coalescente nulo ??é perfeito.

Uma coisa que venho fazendo muito ultimamente é usar coalescência nula para backups as. Por exemplo:

object boxed = 4;
int i = (boxed as int?) ?? 99;

Console.WriteLine(i); // Prints 4

Também é útil para fazer backup de longas cadeias ?.que podem falhar

int result = MyObj?.Prop?.Foo?.Val ?? 4;
string other = (MyObj?.Prop?.Foo?.Name as string)?.ToLower() ?? "not there";

O único problema é que o operador de coalescência nula não detecta cadeias vazias.

ie

string result1 = string.empty ?? "dead code!";

string result2 = null ?? "coalesced!";

RESULTADO:

result1 = ""

result2 = coalesced!

Atualmente, estou olhando para substituir o ?? operador para contornar isso. Seria útil que isso fosse incorporado ao Framework.

Pensamentos?

É ?? necessário, ou você deve apenas usar o operador ternário (com o qual a maioria está familiarizada)

Você deve usar o que melhor expressa sua intenção. Uma vez que não é um operador de coalesce nulo, usá-lo .

Por outro lado, como é tão especializado, não acho que tenha outros usos. Eu teria preferido uma sobrecarga apropriada do ||operador, como outros idiomas. Isso seria mais parcimonioso no design da linguagem. Mas, bem …

Legal! Conte-me como alguém que não sabia sobre o operador coalescente nulo - isso é uma coisa bem bacana.

Acho muito mais fácil ler do que o operador ternário.

O primeiro lugar que me vem à mente onde posso usá-lo é manter todos os meus parâmetros padrão em um único local.

public void someMethod( object parm2, ArrayList parm3 )
{ 
  someMethod( null, parm2, parm3 );
}
public void someMethod( string parm1, ArrayList parm3 )
{
  someMethod( parm1, null, parm3 );
}
public void someMethod( string parm1, object parm2, )
{
  someMethod( parm1, parm2, null );
}
public void someMethod( string parm1 )
{
  someMethod( parm1, null, null );
}
public void someMethod( object parm2 )
{
  someMethod( null, parm2, null );
}
public void someMethod( ArrayList parm3 )
{
  someMethod( null, null, parm3 );
}
public void someMethod( string parm1, object parm2, ArrayList parm3 )
{
  // Set your default parameters here rather than scattered through the above function overloads
  parm1 = parm1 ?? "Default User Name";
  parm2 = parm2 ?? GetCurrentUserObj();
  parm3 = parm3 ?? DefaultCustomerList;

  // Do the rest of the stuff here
}

Um caso de uso estranho, mas eu tinha um método em que um IDisposableobjeto é potencialmente passado como um arg (e, portanto, descartado pelo pai), mas também poderia ser nulo (e, portanto, deve ser criado e descartado no método local)

Para usá-lo, o código parecia

Channel channel;
Authentication authentication;

if (entities == null)
{
    using (entities = Entities.GetEntities())
    {
        channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
        [...]
    }
}
else
{
    channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
    [...]
}

Mas com uma coalescência nula torna-se muito mais limpo

using (entities ?? Entities.GetEntities())
{
    channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
    [...]
}

Eu usei assim:

for (int i = 0; i < result.Count; i++)
            {
                object[] atom = result[i];

                atom[3] = atom[3] ?? 0;
                atom[4] = atom[4] != null ? "Test" : string.Empty;
                atom[5] = atom[5] ?? "";
                atom[6] = atom[6] ?? "";
                atom[7] = atom[7] ?? "";
                atom[8] = atom[8] ?? "";
                atom[9] = atom[9] ?? "";
                atom[10] = atom[10] ?? "";
                atom[12] = atom[12] ?? false; 
            }