C# comment utiliser enum avec interrupteur

Je ne peux pas comprendre comment utiliser les commutateurs en combinaison avec un enum. Pourriez-vous s'il vous plaît dites-moi ce que je fais mal, et comment le résoudre? J'ai utiliser un enum pour faire une calculatrice de base.

public enum Operator
{
    PLUS, MINUS, MULTIPLY, DIVIDE
}

public double Calculate(int left, int right, Operator op)
{

    int i = (int) op;

    switch(i)
    {
        case 0:
        {
            return left + right;
        }

        case 1:
        {
            return left - right;
        }

        case 2:
        { 
            return left * right;
        }

        case 3:
        {
            return left / right;
        }

        default:
        {
            return 0.0;
        }
    }
}

Le résultat final devrait être quelque chose comme ceci:

Console.WriteLine("The sum of 5 and 5 is " + Calculate(5, 5, PLUS))
Output: The sum of 5 and 5 is 10

Pourriez-vous les gars s'il vous plaît dites-moi comment je suis gâcher?

InformationsquelleAutor yesman | 2013-02-28

c#enums switch-expression switch-statement

101

Vous n'avez pas besoin de convertir
```
switch(op)
{
     case Operator.PLUS:
     {
        //your code 
        //for plus operator
        break;
     }
     case Operator.MULTIPLY:
     {
        //your code 
        //for MULTIPLY operator
        break;
     }
     default: break;
}
```
Par le chemin, utilisez des crochets
- Pourquoi utiliser des crochets ici?
- Pas nécessaire, mais rend le code plus lisible
- Merci, cela a fonctionné. Je vais aussi ajouter des crochets.
- Eh bien, c'est une question d'opinion, je pense 🙂
- Oui, il est 🙂
- Plus d'un tiret homme, moi-même =) Curieusement, c'est la seule chose que je ne mets pas les accolades. Allez comprendre!
- Si jamais vous introduire une nouvelle variable pour une utilisation dans un seul cas, vous n'avez bien sûr besoin d'utiliser des crochets. Et à ce moment là mon TOC coups de pied dans, et j'ai besoin de faire tous les cas le même aspect en ajoutant des parenthèses pour eux. (En toute sincérité, j'ai utiliser des crochets dans les instructions switch car je les utilise pour les blocs partout ailleurs.)
- Super! Merci pour la mention de ce point avec des variabloes pour un seul cas - jamais pensé à ça 🙂
- C# peut avoir plusieurs lignes de blocs sans parenthèses puisque tout doit se terminer par un retour ou une rupture, goto ou n'ont pas de code du tout. Fall-through n'est pas permis en dehors de ces options: stackoverflow.com/questions/174155/...
- Oui, mais si vous les utiliser partout -pas de pièges -conforme au code de lisibilité améliorée -plus simple maintenance/extension-les meilleures pratiques (faire)
- à propos de la lisibilité - je trouver python et haskell code plus facile à lire que c# ou java
- Notez que les parenthèses n'est pas relié au switch/case: Vous pouvez ajouter des parenthèses partout où vous voulez séparer les variables.
- Commutateur cas, vous permet de réutiliser le même bloc de code pour plusieurs cas. Si vous n' - assurez-vous de ne pas utiliser de crochets.
InformationsquelleAutor J.Starkl
9

La bonne réponse est déjà donné, néanmoins, ici, c'est le meilleur moyen (de passer):
```
private Dictionary<Operator, Func<int, int, double>> operators =
    new Dictionary<Operator, Func<int, int, double>>
    {
        { Operator.PLUS, ( a, b ) => a + b },
        { Operator.MINUS, ( a, b ) => a - b },
        { Operator.MULTIPLY, ( a, b ) => a * b },
        { Operator.DIVIDE ( a, b ) => (double)a / b },
    };

public double Calculate( int left, int right, Operator op )
{
    return operators.ContainsKey( op ) ? operators[ op ]( left, right ) : 0.0;
}
```
- Je pense que c'est un exemple de cas où l'utilisation de var pour déclarer la variable serait approprié!
- Var ne peuvent pas être utilisés à l'extérieur du corps de la méthode.
- Oh oui, j'en ai oublié que c'était déclarée en dehors de la méthode.
- Vous pouvez utiliser using OperatorsDict = Dictionary<Operator, Func<int, int, double>> et ensuite utiliser OperatorsDict au lieu
- sais que c'est un vieux post) Pourquoi cette méthode est meilleure que l'interrupteur est-il plus rapide ? ou est-il une préférence ? Je voudrais savoir, pas pour l'amour du arguments, mais mieux codage - j'ai toujours utilisé le switch mais n'a jamais pensé à utiliser un dictionnaire de la fonction. Ne devrait certainement pas être dans un objet sérialisable.. et bien sûr, Adassko commentaire de rend mes réflexions sur un problème de mémoire en aller.
- il existe de nombreuses raisons:
- 1. La séparation de la configuration et de la logique: votre code est trop court et facile à lire. Votre configuration se lit comme un tableau, ce qui est facile. 2. À la différence de l'interrupteur, Dictionnaire en interne utilise une table de hachage pour la recherche rapide, ce qui devient important quand il y a de nombreux cas. Parfois, les programmeurs de mettre la plus utilisée élément à la fin de l'interrupteur et ont des problèmes avec la performance. 3. Une fois que la configuration est extrait à partir du code, maintenant, vous pouvez faire beaucoup de bonnes choses:
- A. le Déplacer à partir du code d'une source externe, par exemple de fichier de configuration ou de la base de données. B. modifier Dynamiquement la configuration en fonction de vos besoins, droite, tandis que l'exécution du programme. C. Créer un système de plugin, de sorte que votre configuration est prolongée par des modules. D. Bien que le Dictionnaire aide déjà à la recherche de la clé plus rapide, vous pouvez encore faire mieux en personnaliser la façon dont vous la recherche de l'opération. Une fois que j'ai mis en place un tel remplacement du commutateur, qui se sont accumulés au cas des statistiques d'utilisation pendant l'exécution du programme, et périodiquement ré-arrangé la liste de cas de sorte que le plus populaire est devenu le premier.
- J'aimerais voir un fiable la preuve que le Dictionnaire look-up est plus rapide que l'Interrupteur avec les Énumérations.
InformationsquelleAutor JustAndrei

n'ont tout simplement pas de cast en int

 switch(operator)
    {
       case Operator.Plus:
       //todo

InformationsquelleAutor burning_LEGION

Depuis C# 8.0 a introduit un nouveau commutateur d'expression pour les énumérations, vous pouvez le faire encore plus élégant:

public double Calculate(int left, int right, Operator op) =>
            op switch 
        {
            Operator.PLUS => left + right,
            Operator.MINUS => left - right,
            Operator.MULTIPLY => left * right,
            Operator.DIVIDE => left / right,
            _    =>  0
        }

Réf. https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8

InformationsquelleAutor Przemek Struciński

Vous ne devraient pas jeter un entier. Et pour la division, vous avez besoin de jeter gauche pour doubler tout d'abord, si non vous allez faire une division d'entier.

public enum Operator
{
    PLUS, MINUS, MULTIPLY, DIVIDE
}

public double Calculate(int left, int right, Operator op)
{
    double sum = 0.0;

    switch(op)
    {
       case Operator.PLUS:
       sum = left + right;
       return sum;

       case Operator.MINUS:
       sum = left - right;
       return sum;

       case Operator.MULTIPLY:
       sum = left * right;
       return sum;

       case Operator.DIVIDE:
       sum = (double)left / right;
       return sum;

       default:
       return sum;
   }

   return sum;
}

InformationsquelleAutor Jeow Li Huan

 public enum Operator
    {
        PLUS, MINUS, MULTIPLY, DIVIDE
    }

    public class Calc
    {
        public void Calculate(int left, int right, Operator op)
        {

            switch (op)
            {
                case Operator.DIVIDE:
                    //Divide
                    break;
                case Operator.MINUS:
                    //Minus
                    break;
                case Operator.MULTIPLY:
                    //...
                    break;
                case Operator.PLUS:
                    //;;
                    break;
                default:
                    throw new InvalidOperationException("Couldn't process operation: " + op);
            }
        }
    }

InformationsquelleAutor omer schleifer

Dans le cas où vous ne voulez pas utiliser l'instruction return pour chaque cas, essayez ceci:

Calculate(int left, int right, Operator op)
{
   int result = 0;
   switch(op)
   {
        case Operator.PLUS:
        {
            result = left + right;;  
        }
        break;
        ....
   }

   return result;
}

InformationsquelleAutor Martin

1

Toutes les autres réponses sont correctes, mais vous avez également besoin d'appeler votre méthode correctement:
```
Calculate(5, 5, Operator.PLUS))
```
Et puisque vous utilisez int pour left et right, le résultat sera int ainsi (3/2 will result in 1). vous pourriez lancer à double avant le calcul du résultat ou de modifier vos paramètres pour accepter double
- Ce se révèle être un trouver le bug question...
- Eh bien .. oui, type de... 😀
InformationsquelleAutor Stephan Bauer

Deux choses. Tout d'abord, vous devez qualifier l'enum de référence dans votre test - plutôt que de "PLUS", il faut "de l'Opérateur.PLUS". Deuxièmement, ce code serait beaucoup plus lisible si vous avez utilisé l'énumération des noms de membres plutôt que de leur intégrante des valeurs dans l'instruction switch. J'ai mis à jour votre code:

public enum Operator
{
    PLUS, MINUS, MULTIPLY, DIVIDE
}

public static double Calculate(int left, int right, Operator op)
{
    switch (op)
    {
        default:
        case Operator.PLUS:
            return left + right;

        case Operator.MINUS:
            return left - right;

        case Operator.MULTIPLY:
            return left * right;

        case Operator.DIVIDE:
            return left / right;
    }
}

Appeler ce avec:

Console.WriteLine("The sum of 5 and 5 is " + Calculate(5, 5, Operator.PLUS));

InformationsquelleAutor Mike

0

Votre code est bien. Dans le cas où vous ne savez pas comment l'utiliser Calculer la fonction, essayez de
```
Calculate(5,5,(Operator)0); //this will add 5,5
Calculate(5,5,Operator.PLUS);//alternate
```
Par défaut les valeurs de l'enum commencer à 0 et augmente d'un pour les éléments suivants, jusqu'à ce que vous attribuer des valeurs différentes. Vous pouvez aussi le faire :
```
public enum Operator{PLUS=21,MINUS=345,MULTIPLY=98,DIVIDE=100};
```
InformationsquelleAutor novic3

Pas besoin de se convertir. Vous pouvez appliquer des conditions sur les Énumérations à l'intérieur d'un commutateur. Comme si,

public enum Operator
{ 
    PLUS,
    MINUS,
    MULTIPLY,
    DIVIDE
}

public double Calculate(int left, int right, Operator op)
{
    switch (op)
    {
        case Operator.PLUS: return left + right; 
        case Operator.MINUS: return left - right; 
        case Operator.MULTIPLY: return left * right;
        case Operator.DIVIDE: return left / right;
        default: return 0.0; 
    }
}

Ensuite, appelez ça comme ceci:

Console.WriteLine("The sum of 5 and 5 is " + Calculate(5, 5, Operator.PLUS));

InformationsquelleAutor Kent Aguilar

Vous devez vous connecter pour publier un commentaire.