Ternaire opérateurs en C#

Avec l'opérateur ternaire, il est possible de faire quelque chose comme ce qui suit (en supposant que Func1() et Func2() retourne un int:

int x = (x == y) ? Func1() : Func2();

Cependant, est-il possible de faire la même chose, sans retour d'une valeur? Par exemple, quelque chose comme (en supposant que Func1() et Func2() return void):

(x == y) ? Func1() : Func2();

Je me rends compte de ce qui pourrait être accompli à l'aide d'une instruction if, je me demandais si il y avait un moyen de le faire comme cela.

Désolé de pinailler, mais le nom propre est l'opérateur conditionnel msdn.microsoft.com/en-us/library/aa691313(SV.71).aspx
Dans ce même article, "Il est parfois également appelé l'opérateur ternaire". Alors, vraiment, les deux sont utilisés.
dans la mode que la somme signe peut aussi être appelé un opérateur binaire, et que l'incrémentation de l'opérateur peut aussi être appelé opérateur unaire? Oui... mais c'est toujours pas une bonne façon de les nommer, malgré l'habitude d'être le seul opérateur ternaire. (Existe-t-il? Bonne question.)
Oui, ternaire (et ceux liés tels que unaires, binaires) sont plus généralisée des noms. Si l'opérateur conditionnel est un opérateur ternaire (ou "la" opérateur ternaire si la syntaxe de la langue ne fournit pas un autre), mais un opérateur ternaire n'est pas nécessairement un opérateur conditionnel. Je pense que dans le contexte des langages de programmation, les deux vont généralement être compris comme signifiant la même chose. Sauf si il y a plus, comme vous l'avez dit.
Recherche Google pour " C# "opérateur ternaire" " et " C# "opérateur conditionnel" " retourne un nombre similaire de résultats, il semble donc qu'ils sont tous deux utilisés avec à peu près la même fréquence.

OriginalL'auteur Paul Michaels | 2010-05-04

.net c#methods ternary-operator

Bizarre, mais vous pourriez le faire

class Program
{
    private delegate void F();

    static void Main(string[] args)
    {
        ((1 == 1) ? new F(f1) : new F(f2))();
    }

    static void f1()
    {
        Console.WriteLine("1");
    }

    static void f2()
    { 
        Console.WriteLine("2");
    }
}

C'est beaucoup de travail supplémentaire, pour éviter qu'à l'aide de "if" et "else". Nice extrait de si.
Oui. Nice extrait.

OriginalL'auteur Diego Pereyra

3

Je ne le pense pas. Aussi loin que je me souvienne, l'opérateur ternaire est utilisé dans un contexte d'expression et non pas comme une déclaration. Le compilateur a besoin de connaître le type de l'expression et void n'est pas vraiment un type de.

Vous pourriez essayer de définir une fonction pour ça:
```
void iif(bool condition, Action a, Action b)
{
    if (condition) a(); else b();
}
```
Et puis vous pouvez l'appeler comme ceci:
```
iif(x > y, Func1, Func2);
```
Mais ce n'est pas vraiment de rendre votre code plus clair...

OriginalL'auteur Daren Thomas
1

Si vous vous sentez en confiance, vous devez créer une méthode statique dont le seul but est d'absorber l'expression, et de "faire" une déclaration.
```
public static class Extension
{
    public static void Do(this Object x) { }
}
```
De cette façon, vous pouvez appeler l'opérateur ternaire et invoquer la méthode d'extension.
```
((x == y) ? Func1() : Func2()).Do(); 
```
Ou, dans un presque équivalent manière, l'écriture d'une méthode statique (si la classe lorsque vous souhaitez utiliser ce "raccourci" est limité).
```
private static void Do(object item){ }
```
... et de l'appeler de cette façon
```
Do((x == y) ? Func1() : Func2());
```
Cependant, je vous conseille fortement de ne pas utiliser ce "raccourci" pour les mêmes raisons déjà explicitées par les auteurs avant moi.

OriginalL'auteur Erik Burigo
0

Non, parce que l'opérateur ternaire est une expression, alors que les actions/void fonctions sont consolidés. Vous pourriez les faire revenir object, mais je pense qu'un if/else bloc l'intention beaucoup plus clair (c'est à dire les actions sont exécutées pour le compte de leurs effets secondaires à la place de leurs valeurs).

OriginalL'auteur Lee

Vous devez vous connecter pour publier un commentaire.