C# : comment utiliser un enum avec un switch

Question

Je n'arrive pas à comprendre comment utiliser les commutateurs en combinaison avec un enum. Pourriez-vous me dire ce que je fais de travers et comment y remédier ? Je dois utiliser un enum pour créer 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 me dire comment je me trompe ?

Answer 1

Vous n'avez pas besoin de le convertir

switch(op)
{
     case Operator.PLUS:
     {
        // your code 
        // for plus operator
        break;
     }
     case Operator.MULTIPLY:
     {
        // your code 
        // for MULTIPLY operator
        break;
     }
     default: break;
}

Au fait, utilisez les parenthèses

Answer 2

Depuis que C# 8.0 a introduit une nouvelle expression de commutation pour les enums, vous pouvez le faire de manière encore plus élégante :

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

Answer 3

La réponse correcte est déjà donnée, néanmoins voici la meilleure façon (que le switch) :

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

Answer 4

Vous ne devez pas faire de cast en entier. Et pour la division, vous devez d'abord convertir la gauche en double, sinon vous ferez une division en 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;
}

Answer 5

Ne sont pas convertis en int

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