Czy te dwie linie są takie same ”? … :' vs '??'?

Czy jest różnica między tymi dwiema liniami?

MyName = (s.MyName == null) ? string.Empty : s.MyName

lub

MyName = s.MyName ?? string.Empty

AKTUALIZACJA: Napisałem post na blogu, który bardziej szczegółowo omawia ten temat. http://www.codeducky.org/properties-fields-and-methods-oh-my/

Generalnie zwrócą ten sam wynik. Jest jednak kilka przypadków, w których zauważysz zauważalne różnice, gdy MyNamejest to właściwość, ponieważ MyNamemetoda pobierająca zostanie wykonana dwukrotnie w pierwszym przykładzie i tylko raz w drugim przykładzie.

Na przykład mogą wystąpić różnice w wydajności przy MyNamedwukrotnym wykonaniu :

string MyName
{
    get 
    {
        Thread.Sleep(10000);
        return "HELLO";
    }
}

Lub możesz uzyskać inne wyniki, wykonując MyNamedwa razy, jeśli MyNamejest stanowy:

private bool _MyNameHasBeenRead = false;

string MyName
{
    get 
    {
        if(_MyNameHasBeenRead)
                throw new Exception("Can't read MyName twice");
        _MyNameHasBeenRead = true;
        Thread.Sleep(10000);
        return "HELLO";
    }
}

Lub możesz uzyskać inne wyniki po MyNamedwukrotnym wykonaniu, jeśli MyNamemożna to zmienić w innym wątku:

void ChangeMyNameAsync()
{
    //MyName set to null in another thread which makes it 
    //possible for the first example to return null
    Task.Run(() => this.MyName = null);
}

string MyName { get; set; }  

Oto, jak kompilowany jest rzeczywisty kod. Najpierw utwór z potrójnym wyrażeniem:

IL_0007:  ldloc.0     // s
IL_0008:  callvirt    s.get_MyName       <-- first call
IL_000D:  brfalse.s   IL_0017
IL_000F:  ldloc.0     // s
IL_0010:  callvirt    s.get_MyName       <-- second call
IL_0015:  br.s        IL_001C
IL_0017:  ldsfld      System.String.Empty
IL_001C:  call        set_MyName

a oto fragment z operatorem koalescencji zerowej:

IL_0007:  ldloc.0     // s
IL_0008:  callvirt    s.get_MyName       <-- only call
IL_000D:  dup         
IL_000E:  brtrue.s    IL_0016
IL_0010:  pop         
IL_0011:  ldsfld      System.String.Empty
IL_0016:  call        s.set_MyName

Jak widać, skompilowany kod dla operatora trójskładnikowego wykona dwa wywołania w celu uzyskania wartości właściwości, podczas gdy operator łączący wartość null wykona tylko 1.

Jeśli właściwość jest czymś więcej niż prostym pobieraczem, możesz wykonywać funkcję dwukrotnie w przypadku niezerowym dla pierwszej.

Jeśli właściwość jest obiektem stanowym, drugie wywołanie właściwości może zwrócić inny wynik:

class MyClass
{
    private IEnumerator<string> _next = Next();

    public MyClass()
    {
        this._next.MoveNext();
    }

    public string MyName
    {
        get
        {
            var n = this._next.Current;
            this._next.MoveNext();
            return n;
        }
    }


    public static IEnumerator<string> Next()
    {
        yield return "foo";
        yield return "bar";
    }
}

Ponadto w przypadku nie będącym łańcuchem klasa może przeciążać ==, aby zrobić coś innego niż operator trójargumentowy. Nie wierzę, że operator trójskładnikowy może być przeciążony.

Jedyną różnicą jest to, czy oceniasz s.MyNamedwukrotnie czy raz. Pierwsza zrobi to dwukrotnie w przypadku, gdy s.MyNamenie jest zerowa, druga tylko raz oceni to.

W większości przypadków ta różnica nie ma znaczenia i wybrałbym drugą, ponieważ jest bardziej przejrzysta i zwięzła.

Tak, oba są takie same i jest to operator łączenia zerowego .

Zwraca operand po lewej stronie, jeśli operand nie jest null; w przeciwnym razie zwraca operand po prawej stronie.

Jeśli mówimy wtedy o wydajności

string MyName = (s.MyName == null) ? string.Empty : s.MyName;
string MyName2 = s.MyName ?? string.Empty;

Jeśli używam disemblera, to widzę, że pierwsza instrukcja wymaga 19 instrukcji do wykonania przez kompilator, podczas gdy druga wymaga tylko 12 instrukcji do wykonania.

Tak, robią to samo. ??jest skrótem do sprawdzania null.

Wykonują to samo zadanie.

Jedyną różnicą byłaby czytelność, czy Twoi współpracownicy lub ktokolwiek czyta kod, rozumie składnię.

EDYCJA: Dodatkowo pierwsza opcja może MyNamedwukrotnie ocenić właściwość .

Nie. Obaj robią to samo. Drugi jest skuteczny. Co zwraca rzeczywistą wartość, jeśli nie jest zerowa. W przeciwnym razie zostanie zwrócona wartość po prawej stronie.

Zapoznaj się z tym http://msdn.microsoft.com/en-us/library/ms173224.aspx

Mam nadzieję że to pomoże.