Уникальные способы использования оператора объединения null

Is ?? necessary, or should you just use the ternary operator (that most are familiar with)

Вы должны использовать то, что лучше всего выражает ваши намерения. Поскольку является является нулевым оператором объединения, используй это.

С другой стороны, поскольку он настолько специализирован, я не думаю, что он может найти другое применение. Я бы предпочел соответствующую перегрузку оператора ||, как это делают другие языки. Это было бы более экономно в языковом дизайне. Но хорошо …

Во-первых, это намного проще, чем стандартный тернарный оператор:

string anybody = parm1 ?? localDefault ?? globalDefault;

против.

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

Это также хорошо работает, если объект с нулевым значением не является переменной:

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

против.

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

Я использовал его как однострочник с отложенной загрузкой:

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

Удобочитаемый? Решайте сами.

Здорово! Считайте меня человеком, который не знал об операторе объединения с нулевым значением - это довольно изящная штука.

Я считаю, что это намного легче читать, чем тернарный оператор.

Первое, что приходит на ум, где я мог бы его использовать, - это хранить все мои параметры по умолчанию в одном месте.

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
}

Я нашел его полезным двумя "немного странными" способами:

• В качестве альтернативы параметру out при написании подпрограмм TryParse (т.е. возвращать нулевое значение в случае сбоя синтаксического анализа)
• Как представление "не знаю" для сравнения

Последнему нужно немного больше информации. Обычно, когда вы создаете сравнение с несколькими элементами, вам нужно увидеть, дает ли первая часть сравнения (например, возраст) окончательный ответ, а затем следующая часть (например, имя), только если первая часть не помогла. Использование оператора объединения с нулевым значением означает, что вы можете писать довольно простые сравнения (для упорядочивания или равенства). Например, используя пару вспомогательных классов в 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;
}

По общему признанию, теперь у меня есть ProjectionComparer в MiscUtil вместе с некоторыми расширениями, которые делают такие вещи еще проще - но все равно аккуратно.

То же самое можно сделать для проверки ссылочного равенства (или недействительности) в начале реализации Equals.

Я использовал ?? в своей реализации IDataErrorInfo:

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

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

Если какое-либо отдельное свойство находится в состоянии «ошибки», я получаю эту ошибку, а в противном случае - null. Это действительно хорошо работает.

Еще одно преимущество состоит в том, что тернарному оператору требуется двойная оценка или временная переменная.

Рассмотрим это, например:

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

в то время как с тернарным оператором у вас остается либо:

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

который дважды вызывает MyMethod, или:

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

В любом случае, оператор объединения с нулевым значением чище и, я думаю, более эффективен.

Единственная проблема заключается в том, что оператор объединения с нулевым значением не обнаруживает пустые строки.

Т.е.

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

string result2 = null ?? "coalesced!";

Выход

result1 = ""

result2 = coalesced!

В настоящее время я пытаюсь переопределить ?? оператор, чтобы обойти это. Конечно, было бы удобно, если бы это было встроено в фреймворк.

Is ?? necessary, or should you just use the ternary operator (that most are familiar with)

На самом деле, мой опыт показывает, что слишком мало людей знакомы с тернарным оператором (или, точнее, с оператором условный; ?: является «троичным» в том же смысле, что || является двоичным или + либо унарным, либо двоичным; однако это случается. быть единственным тернарным оператором на многих языках), поэтому, по крайней мере, в этом ограниченном примере ваша инструкция не работает прямо здесь.

Кроме того, как упоминалось ранее, существует одна серьезная ситуация, когда оператор объединения с нулевым значением очень полезен, и это когда вычисляемое выражение вообще имеет какие-либо побочные эффекты. В этом случае вы не могу используете условный оператор без (а) введения временной переменной или (б) изменения фактической логики приложения. (b) явно не подходит ни при каких обстоятельствах, и, хотя это личное предпочтение, я не люблю загромождать область объявления множеством посторонних, даже если кратковременных, переменных, поэтому (a) тоже отсутствует в этом конкретный сценарий.

Конечно, если вам нужно выполнить несколько проверок результата, условный оператор или набор блоков if, вероятно, являются инструментом для работы. Но для простого «если это null, используйте это, иначе используйте это», оператор объединения с нулевым значением ?? идеально подходит.

Самым большим преимуществом, которое я нахожу для оператора ??, является то, что вы можете легко преобразовать типы значений, допускающие значение NULL, в типы, не допускающие значения NULL:

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

Я часто использую это в запросах 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?

Вы можете использовать нулевой оператор объединения, чтобы немного упростить обработку случая, когда необязательный параметр не установлен:

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

Мне нравится использовать нулевой оператор объединения для ленивой загрузки определенных свойств.

Очень простой (и надуманный) пример, чтобы проиллюстрировать мою точку зрения:

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

Еще одна вещь, которую следует учитывать, заключается в том, что оператор coalesce не вызывает метод get свойства дважды, как это делает троичный.

Итак, есть сценарии, в которых вы не должны использовать тернарный оператор, например:

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

Если вы используете:

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

геттер будет вызываться дважды, и переменная count будет равна 2, и если вы используете:

var b = a.Prop ?? 0

переменная count будет равна 1, как и должно быть.

Одна вещь, которую я много делал в последнее время, - это использование нулевого объединения для резервных копий на as. Например:

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

Console.WriteLine(i); // Prints 4

Это также полезно для резервного копирования длинных цепочек ?., каждая из которых может выйти из строя.

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

Это немного странный вариант использования, но у меня был метод, в котором объект IDisposable потенциально передается в качестве аргумента (и, следовательно, удаляется родителем), но он также может быть нулевым (и поэтому должен быть создан и удален в местный метод)

Чтобы использовать его, код выглядел как

Channel channel;
Authentication authentication;

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

Но с нулевым слиянием это становится намного аккуратнее:

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

Я использовал это так:

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