Мога ли да принудя собственото си късо съединение в извикване на метод?

Е, това е грозно, но...

static bool NoNulls(params Func<object>[] funcs) {
    for (int i = 0; i < funcs.Length; i++)
        if (funcs[i]() == null) return false;

    return true;
}

След това го извикайте с:

if (NoNulls(() => obj,
            () => obj.Parameters,
            () => obj.Parameters.UserSettings)) {
    // do something
}

По принцип вие предоставяте делегати да оценяват лениво стойностите, а не самите стойности (тъй като оценяването на тези стойности е това, което причинява изключение).

Не казвам, че е хубаво, но го има като опция...

РЕДАКТИРАНЕ: Това всъщност (и случайно) стига до сърцето на това, което преследваше Дан, мисля. Всички аргументи на метода се оценяват преди самият метод да бъде изпълнен. Ефективното използване на делегати ви позволява да забавите тази оценка, докато методът трябва да извика делегата, за да извлече стойността.

Можете да напишете функция, която приема дърво на изрази и трансформира това дърво във формуляр, който ще проверява за нули и ще върне Func<bool>, което може безопасно да бъде оценено, за да се определи дали има нула.

Подозирам, че докато полученият код може да е готин, той би бил объркващ и много по-малко ефективен от простото писане на куп a != null && a.b != null... проверки на късо. Всъщност вероятно би било по-малко ефективно от просто проверка на всички стойности и улавяне на NullReferenceException (не че препоръчвам обработката на изключения като механизъм за контрол на потока).

Сигнатурата за такава функция би била нещо като:

public static Func<bool> NoNulls( Expression<Func<object>> expr )

и използването му ще изглежда нещо като:

NoNulls( () => new { a = obj, 
                     b = obj.Parameters, 
                     c = obj.Parameters.UserSettings } )();

Ако имам малко свободно време, ще напиша функция, която прави точно такава трансформация на изразно дърво и ще актуализирам публикацията си. Сигурен съм обаче, че Джон Скийт или Марк Гравел биха могли да напишат такава функция с едно затворено око и една ръка зад гърба си.

Също така бих искал да видя C# да прилага оператора .?, за който споменава Ерик. Както може да каже един различен Ерик (Картман), това би "сритало задника".

Бихте могли да използвате отражения, ако нямате нищо против да загубите безопасността на статичния тип. Имам нещо против, така че просто използвам първата ви конструкция за късо съединение. Функция като споменатата от Ерик би била добре дошла :)

Мислил съм за този проблем няколко пъти. Lisp има макроси, които решават проблема по начина, който споменахте, тъй като ви позволяват да персонализирате оценката си.

Също така се опитах да използвам методи за разширение, за да разреша този проблем, но нищо не е по-малко грозно от оригиналния код.

Редактиране: (Отговорите не ми позволяват да вмъквам кодови блокове, така че редактирам публикацията си)

Упс, не продължих с това. Съжалявам за това :)

Можете да използвате отражения, за да търсите и оценявате член или свойство чрез низ. Клас, който един от моите приятели написа, приема синтаксис като:

new ReflectionHelper(obj)["Parameters"]["UserSettings"]

Работеше чрез верига на методите, връщайки ReflectionHelper на всяко ниво. Знам, че NullReferenceException е проблем в този пример. Просто исках да демонстрирам как оценката може да бъде отложена до време на изпълнение.

Пример, малко по-близък до това да бъде полезен:

public class Something
{
  public static object ResultOrDefault(object baseObject, params string[] chainedFields)
  {
    // ...
  }
}

Отново, този синтаксис смърди. Но това демонстрира използването на низове + отражения за отлагане на оценката до време на изпълнение.