How-to: короткозамкнутый инвертированный тернарный оператор, реализованный в, например, С#? Это имеет значение?

Ответ 1

лично я бы избегал короткого замыкания от операторов и просто позволял методам его цепью:

public static int CompareChain<T>(this int previous, T a, T b)
{
    if (previous != 0)
        return previous;
    return Comparer<T>.Default.Compare(a,b);
}

используйте так:

int a = 0, b = 2;
string x = "foo", y = "bar";
return a.Compare(b).CompareChain(x,y);

может быть встроен в JIT, поэтому он может выполнять так же хорошо, как и короткое замыкание, встроенное в язык, без лишних сложностей.

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

public static T ElseIf<T>(
    this T previous, 
    Func<T,bool> isOK
    Func<T> candidate)
{
    if (previous != null && isOK(previous))
        return previous;
    return candidate();
}

то используйте так:

Connection bestConnection = server1.GetConnection()
    .ElseIf(IsOk, server2.GetConnection)
    .ElseIf(IsOk, server3.GetConnection)
    .ElseIf(IsOk, () => null);

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

public static T ElseIf<T>(        
    Func<T,bool> isOK
    IEnumerable<Func<T>[] candidates)
{
   foreach (var candidate in candidates)
   { 
        var t = candidate();
        if (isOK(t))
            return t;
   }
   throw new ArgumentException("none were acceptable");
}

Вы можете сделать это с помощью linq, но этот способ дает хорошее сообщение об ошибке и позволяет это

public static T ElseIf<T>(        
    Func<T,bool> isOK
    params Func<T>[] candidates)
{
    return ElseIf<T>(isOK, (IEnumerable<Func<T>>)candidates);
}

что приводит к хорошему считываемому коду:

var bestConnection = ElseIf(IsOk,
    server1.GetConnection,
    server2.GetConnection,
    server3.GetConnection);

Если вы хотите разрешить значение по умолчанию, то:

public static T ElseIfOrDefault<T>(        
    Func<T,bool> isOK
    IEnumerable<Func<T>>[] candidates)
{
   foreach (var candidate in candidates)
   { 
        var t = candidate();
        if (isOK(t))
            return t;
   }
   return default(T);
}

Очевидно, что все вышеизложенное может быть легко написано с использованием lambdas, поэтому ваш конкретный пример:

var bestConnection = ElseIfOrDefault(
    c => c != null && !(c.IsBusy || c.IsFull),
    server1.GetConnection,
    server2.GetConnection,
    server3.GetConnection);

Ответ 2

Чтобы помещать одну предложенную реализацию в сторону из очень подробного вопроса, пусть работает с ключевым словом unless.

(выражение A) unless (boolean B) < magical ", в этом случае" operator > (выражение C)

... было бы все, что есть.

Логическое выражение B будет иметь доступ к оценке выражения A через ключевое слово value. Выражение C может иметь ключевое слово unless в своем выражении, что позволяет простое, линейное объединение.

Кандидаты на "магический", в этом случае "оператор":

• :
• |
• ?:
• otherwise ключевое слово

Ответ 3

Использование любых символов, как правило, уменьшает читаемость для среднего разработчика. Даже оператор ?? не используется широко. Я сам предпочитаю разрабатывать подробный код, но я могу легко читать через год.

Итак, кандидат для вашего:

выражение A, если только boolean B, в этом случае выражение C.

будет

выражение A, если только boolean B sothen выражение C.

Хотя многие люди вроде меня все равно будут использовать:

if (B) {expression C;}
else {expression A;}

Это происходит, когда вы разрабатываете программное обеспечение с большой командой, с разным фоном, каждый из которых находится в команде мастера одного языка и просто пользователь других.

Ответ 4

Подробнее @ShuggyCoUk: Ах, я вижу, что это может работать не только для сравнения? Я не использовал С# 3 и методы расширения, но я полагаю, что вы можете объявить для моего предыдущего примера ниже

public delegate bool Validation<T>( T toTest );
public static T Validate<T>( this T leftside, Validation<T> validator )
{
    return validator(leftside) ? leftside : null;
}

Далее: за Скит:

Validation<Connection> v = ( Connection c ) => ( c != null && !( c.IsBusy || c. IsFull ) );
Connection bestConnection =
    server1.GetConnection().Validate( v ) ??
    server2.GetConnection().Validate( v ) ??
    server3.GetConnection().Validate( v ) ?? null;

Как это работает на С#? Комментарии оценены. Спасибо.

В ответ на ShuggyCoUk:

Итак, это метод расширения в С# 3, то? Кроме того, результатом здесь является int, а не произвольное выражение. Полезно для перегрузки еще одного метода сравнения. Предположим, мне нужно выражение для выбора наилучшего соединения. В идеале я хочу что-то упростить:

Connection temp;
Connection bestConnection =
    ( temp = server1.GetConnection() ) != null && !(temp.IsBusy || temp.IsFull) ? temp
    :   ( temp = server2.GetConnection() ) != null && !(temp.IsBusy || temp.IsFull ) ? temp
        :   ( temp = server3.GetConnection() ) != null && !(temp.IsBusy || temp.IsFull ) ? temp
            : null;

Хорошо, поэтому можно было бы иметь метод

bool IsOk( Connection c )
{
    return ( c != null && !(c.IsBusy || c.IsFull) );
}

Что создаст:

Connection temp;
Connection bestConnection =
    ( temp = server1.GetConnection() ) && IsOk( temp ) ? temp
    :   ( temp = server2.GetConnection() ) && IsOk( temp ) ? temp
        :   ( temp = server3.GetConnection() ) && IsOk( temp ) ? temp
            : null;

Но как будет работать цепочка методов для сравнения? Я размышляю над тем, что выглядит следующим образом:

Connection bestConnection =
    server1.GetConnection() unless !IsOk(value) otherwise
    server2.GetConnection() unless !IsOk(value) otherwise
    server3.GetConnection() unless !IsOk(value) otherwise null;

Я думаю, что есть до сих пор, обручи, чтобы проскочить, если я хочу, чтобы результат условного выражения был выражением или результатом метода, который был в исходном условном выражении.

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