Unikalne sposoby korzystania z operatora Null Coalescing [zamknięte]

Wiem, że standardowym sposobem używania operatora koalescencji Null w C # jest ustawienie wartości domyślnych.

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

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

Ale do czego jeszcze można ??wykorzystać? Nie wydaje się tak użyteczny jak operator trójskładnikowy, poza tym, że jest bardziej zwięzły i łatwiejszy do odczytania niż:

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

Więc biorąc pod uwagę, że mniej nawet wie o zerowym operatorze koalescencji ...

• Czy używałeś ??czegoś innego?

• Jest to ??konieczne lub po prostu użyj operatora trójskładnikowego (który większość zna)

Po pierwsze, łańcuch jest znacznie łatwiejszy niż standardowy trójskładnik:

string anybody = parm1 ?? localDefault ?? globalDefault;

vs.

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

Działa również dobrze, jeśli obiekt z możliwością zerowania nie jest zmienną:

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

vs.

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

Użyłem go jako linijki z leniwym ładowaniem:

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

Czytelny? Zdecyduj sam.

Uważam, że jest przydatny na dwa „nieco dziwne” sposoby:

• Jako alternatywa dla posiadania outparametru podczas pisania TryParseprocedur (tj. Zwraca wartość null, jeśli parsowanie nie powiedzie się)
• Jako reprezentacja „nie wiem” dla porównań

Ten ostatni potrzebuje trochę więcej informacji. Zwykle, gdy tworzysz porównanie z wieloma elementami, musisz sprawdzić, czy pierwsza część porównania (np. Wiek) daje ostateczną odpowiedź, a następnie następna (np. Imię) tylko wtedy, gdy pierwsza część nie pomogła. Używanie operatora łączenia wartości null oznacza, że ​​możesz pisać całkiem proste porównania (czy to w celu uporządkowania, czy równości). Na przykład, używając kilku klas pomocniczych w 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;
}

Wprawdzie mam teraz ProjectionComparer w MiscUtil, wraz z kilkoma rozszerzeniami, które sprawiają, że tego rodzaju rzeczy są jeszcze łatwiejsze - ale nadal jest fajne.

To samo można zrobić, aby sprawdzić równość odwołań (lub nieważność) na początku implementowania Equals.

Kolejną zaletą jest to, że operator trójskładnikowy wymaga podwójnej oceny lub zmiennej tymczasowej.

Rozważmy to na przykład:

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

podczas gdy z operatorem trójskładnikowym pozostaje:

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

która dwukrotnie wywołuje MyMethod lub:

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

Tak czy inaczej, operator koalescencji zerowej jest czystszy i, jak sądzę, bardziej wydajny.

Inną rzeczą do rozważenia jest to, że operator koalescencji nie wywołuje metody get właściwości dwukrotnie, jak robi to trójskładnik.

Są więc scenariusze, w których nie powinieneś używać trójskładnika, na przykład:

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

Jeśli użyjesz:

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

getter zostanie wywołany dwukrotnie, a countzmienna będzie równa 2, a jeśli użyjesz:

var b = a.Prop ?? 0

countzmienna będzie równa 1, jak powinno.

Największą zaletą, jaką widzę dla ??operatora, jest to, że można łatwo przekonwertować typy wartości dopuszczające wartość null na typy nieprzekraczające wartości null:

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

Często używam tego w zapytaniach 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?

Użyłem ?? w mojej implementacji IDataErrorInfo:

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

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

Jeśli jakaś właściwość jest w stanie „błędu”, otrzymuję ten błąd, w przeciwnym razie otrzymuję wartość null. Działa naprawdę dobrze.

Możesz użyć operatora koalescencji null, aby uczynić go nieco czystszym w obsłudze przypadku, w którym opcjonalny parametr nie jest ustawiony:

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

Lubię używać operatora koalescencji zerowej do leniwego ładowania niektórych właściwości.

Bardzo prosty (i wymyślony) przykład, aby zilustrować mój punkt widzenia:

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

Jest ?? konieczne lub po prostu użyj operatora trójskładnikowego (który większość zna)

Właściwie, z mojego doświadczenia wynika, że ​​zbyt mało osób zna operator trójskładnikowy (a dokładniej operator warunkowy ; ?:jest „trójskładnikowy” w tym samym sensie, co ||binarny lub +jednoargumentowy lub binarny; jednak zdarza się, że jest to tylko operator trójskładnikowy w wielu językach), więc przynajmniej w tej ograniczonej próbce twoja instrukcja zawodzi.

Ponadto, jak wspomniano wcześniej, istnieje jedna poważna sytuacja, w której operator koalescencji zerowej jest bardzo przydatny, a jest to ilekroć oceniane wyrażenie ma jakiekolwiek skutki uboczne. W takim przypadku nie można użyć operatora warunkowego bez (a) wprowadzenia zmiennej tymczasowej lub (b) zmiany rzeczywistej logiki aplikacji. (b) jest wyraźnie nieodpowiednie w żadnych okolicznościach i chociaż jest to osobiste preferencje, nie lubię zaśmiecać zakresu deklaracji wieloma zewnętrznymi, nawet krótkotrwałymi, zmiennymi, więc (a) też jest w tym szczególny scenariusz.

Oczywiście, jeśli musisz przeprowadzić wielokrotne sprawdzenie wyniku, ifprawdopodobnie narzędziem do tego zadania jest operator warunkowy lub zestaw bloków. Ale dla prostego „jeśli to jest null, użyj tego, w przeciwnym razie użyj tego”, operator koalescencji zerowej ??jest doskonały.

Jedną z rzeczy, które ostatnio często robiłem, jest koalescencja zerowa do tworzenia kopii zapasowych as. Na przykład:

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

Console.WriteLine(i); // Prints 4

Jest to również przydatne do tworzenia kopii zapasowych długich łańcuchów, z ?.których każdy może zawieść

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

Jedynym problemem jest to, że operator łączenia zerowego nie wykrywa pustych ciągów.

to znaczy

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

string result2 = null ?? "coalesced!";

WYNIK:

result1 = ""

result2 = coalesced!

Obecnie pracuję nad zastąpieniem ?? operator, aby obejść ten problem. Z pewnością przydałoby się mieć to wbudowane w Framework.

Myśli?

Jest ?? konieczne lub po prostu użyj operatora trójskładnikowego (który większość zna)

Powinieneś używać tego, co najlepiej wyraża twoje zamiary. Ponieważ nie jest operatorem COALESCE null, używać go .

Z drugiej strony, ponieważ jest tak wyspecjalizowany, nie sądzę, aby miał inne zastosowania. Wolałbym odpowiednie przeciążenie ||operatora, tak jak robią to inne języki. Byłoby to bardziej oszczędne w projekcie języka. Ale cóż…

Chłodny! Policz mnie jako kogoś, kto nie wiedział o zerowym operatorze koalescencji - to całkiem fajna rzecz.

Uważam, że jest dużo łatwiejszy do odczytania niż operator trójskładnikowy.

Pierwszym miejscem, które przychodzi mi na myśl, gdzie mógłbym go użyć, jest przechowywanie wszystkich moich domyślnych parametrów w jednym miejscu.

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
}

Trochę dziwny przypadek użycia, ale miałem metodę, w której IDisposableobiekt jest potencjalnie przekazywany jako argument (i dlatego usuwany przez rodzica), ale może być również pusty (i dlatego powinien zostać utworzony i usunięty w metodzie lokalnej)

Aby go użyć, kod wyglądał jak

Channel channel;
Authentication authentication;

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

Ale z zerowym połączeniem staje się znacznie schludniejszy

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

Użyłem w ten sposób:

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; 
            }