web-dev-qa-db-fra.com

C # comment utiliser enum avec switch

Je n'arrive pas à comprendre comment utiliser des commutateurs en combinaison avec un enum. Pourriez-vous s'il vous plaît me dire ce que je fais mal, et comment y remédier? Je dois utiliser une énumération 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 ressembler à 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 me dire comment je me trompe?

c#enumsswitch-statement
54
ohyeah

Vous n'avez pas besoin de le convertir

switch(op)
{
     case Operator.PLUS:
     {

     }
}

Au fait, utilisez des crochets

86
J.Starkl

La bonne réponse est déjà donnée, mais voici le meilleur moyen (que de changer):

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;
}
8
JustAndrei

tout simplement ne pas jeter à int

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

Vous ne devriez pas lancer en entier. Et pour la division, vous devez lancer à gauche pour doubler d’abord, sinon vous ferez une division entière.

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;
}
2
Jeow Li Huan

Toutes les autres réponses sont correctes, mais vous devez également appeler votre méthode correctement:

Calculate(5, 5, Operator.PLUS))

Et puisque vous utilisez int pour left et right, le résultat sera également int (3/2 will result in 1). vous pouvez utiliser double avant de calculer le résultat ou modifier vos paramètres pour accepter double

1
Stephan Bauer

Si 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;
}
1
Martin
 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);
            }
        }
    }
1
omer schleifer

Deux choses. Tout d’abord, vous devez qualifier la référence enum dans votre test - plutôt que "PLUS", ce devrait être "Opérateur.PLUS". Deuxièmement, ce code serait beaucoup plus lisible si vous utilisiez les noms de membres enum plutôt que leurs valeurs intégrales 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;
    }
}

Appelez ceci avec:

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

Votre code est bon. Si vous ne savez pas comment utiliser la fonction Calculer, essayez 

Calculate(5,5,(Operator)0); //this will add 5,5
Calculate(5,5,Operator.PLUS);// alternate

Les valeurs d'énumération par défaut commencent à 0 et augmentent d'une unité pour les éléments suivants, jusqu'à ce que vous affectiez des valeurs différentes. Aussi, vous pouvez faire:

public enum Operator{PLUS=21,MINUS=345,MULTIPLY=98,DIVIDE=100};
0
novic3

Pas besoin de convertir. Vous pouvez appliquer des conditions sur Enums à l'intérieur d'un commutateur. Ainsi,

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 ça:

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