Вызов метода с использованием тернарного оператора

Тернарный оператор используется для возврата значений, и эти значения должны быть присвоены. Предполагая, что методы doThis() и doThat() возвращают значения, простое присваивание решит вашу проблему.

Если вы хотите делать то, что пытаетесь, это возможно, но решение не очень красивое.

int a = 5;
int b = 10;
(a == b ? (Action)doThis : doThat)();

Это возвращает делегат Action, который затем вызывается скобками. Это не типичный способ достижения этого.

Тернарный оператор должен что-то возвращать. Типичное использование выглядит так:

int x = (a > b) ? a : b;

Если вы попробуете что-то вроде

a + b;

Компилятор будет жаловаться.

(a > b) ? a - b : b - a;

в основном является сокращением для «a - b» или «b - a», которые сами по себе не являются законными утверждениями.

Если вы действительно хотите вызывать методы void в условном операторе, вы можете использовать делегаты:

(something ? new Action(DoThis) : DoThat)();

Если методы принимают параметры, это усложнится.
Вы можете либо поместить лямбда-выражения в условное выражение, либо использовать Action<T>.

Однако это очень глупый поступок.

Вы должны быть в состоянии сделать это, хотя:

        int a = 5;
        int b = 10;

        var func = a == b ? (Action)doThis : (Action)doThat; // decide which method

        func(); // call it

Хотя не то, чтобы это было так уж полезно.

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

Поиграв еще немного, я понял, что вы МОЖЕТЕ использовать этот оператор для выполнения вышеуказанного оператора, но это приводит к плохому коду.

Если бы я изменил приведенное выше утверждение на;

int a = 5;
int b = 10;
int result = a == b ? doThis() : doThat(); 

private int doThis()
{
    MessageBox.Show("Did this");
    return 0;
}
private int doThat()
{
    MessageBox.Show("Did that");
    return 1;
}

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

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

int result = a == b ? doThis() : doThat();

if (result == 0)
   MessageBox.Show("You called doThis()!");

Теперь этот код абсолютно бессмыслен и может быть легко выполнен с помощью If Else, но я просто хотел знать, можно ли это сделать, и что вам нужно сделать, чтобы заставить его работать.

Теперь, когда я знаю, что вы можете эффективно возвращать любой тип в этих методах, это может стать немного более полезным. Это может считаться «Плохой практикой кодирования», но может оказаться очень полезным в ситуациях, для которых это никогда не ПРЕДНАЗНАЧАЛОСЬ.

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

UserPrivileges result = user.Group == Group.Admin ? GiveAdminPrivileges() : GiveUserPrivileges();

private UserPrivileges GiveAdminPrivileges()
{
      //Enter code here
      return var;
}
private UserPrivileges GiveUserPrivileges()
{
      //Enter code here
      return var;
}

Конечно, это можно сделать с помощью оператора If, но я думаю, что использование тернарного оператора для других целей делает программирование увлекательным. Теперь это может быть не так эффективно, как оператор If Else, и в этом случае я бы никогда не использовал его.

Условный оператор — это выражение, возвращающее значение.
Его нельзя использовать с функциями, возвращающими void.

Вместо этого вы должны использовать обычный if.

.NET не (легко) поддерживает (читабельную версию) это по какой-то причине. Это очень дергано и делает ваш код трудночитаемым. Логические деревья должны быть относительно легкими для обхода. Если бы я пришел на работу и весь код, который они использовали для присваивания значений, вызова методов и т. д., я бы просто ушел.

Способ 1. Использование действия

Action Action = true is true ? new Action(() => A()) : new Action(() => B());
Action.Invoke();

Способ 2. Использование расширений

Button Button = new Button(){
    IsEnabled = false
};
Button.Switch((x) => x.IsEnabled).Invoke(() => A(), () => B())

Переключатель расширения:

public static R Switch<T, R>(this T sender, Func<T, R> method){
    return method.Invoke(sender);
}

Вызов расширения:

public static void Invoke(this bool condition, Action @true, Action @false){
    Action Action = condition ? @true : @false;
    Action.Invoke();
}

Способ 3. Использование расширений и условного оператора NULL в C# 6.0

Button.Case((x) => 0 > 1)?.With(() => A());
Button.Case((x) => 0 < 1)?.With(() => B());

Расширение с:

public static T With<T>(this T sender, Action method){
    method.Invoke();
    return sender;
}

Случай расширения:

public static object Case<T>(this T sender, Func<T, bool> method){
    return method.Invoke(sender) ? Convert.ChangeType(sender, typeof(T)) : null;
}