C # wie man enum mit switch benutzt

Ich kann nicht herausfinden, wie Schalter in Kombination mit einer Aufzählung verwendet werden. Könnten Sie mir bitte sagen, was ich falsch mache und wie ich es beheben kann? Ich muss eine Aufzählung verwenden, um einen Basisrechner zu erstellen.

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

Das Endergebnis sollte ungefähr so ​​aussehen:

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

Könnt ihr mir bitte sagen, wie ich es vermassle?

Sie müssen es nicht konvertieren

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

Verwenden Sie übrigens Klammern

Seit C # 8.0 einen neuen Schalterausdruck für Aufzählungen eingeführt hat, können Sie dies noch eleganter tun:

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
        }

Ref. https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8

Die richtige Antwort ist bereits gegeben, dennoch ist hier der bessere Weg (als Schalter):

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

einfach nicht auf int werfen

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

Sie sollten nicht in eine Ganzzahl umwandeln. Und für die Division müssen Sie zuerst nach links werfen, um zu verdoppeln, wenn nicht, werden Sie eine ganzzahlige Division durchführen.

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

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

Wenn Sie die return-Anweisung nicht für jeden Fall verwenden möchten, versuchen Sie Folgendes:

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

   return result;
}

Alle anderen Antworten sind korrekt, aber Sie müssen Ihre Methode auch korrekt aufrufen:

Calculate(5, 5, Operator.PLUS))

Und da Sie intfür leftund verwenden right, ist das Ergebnis intauch ( 3/2 will result in 1). Sie können doublevor der Berechnung des Ergebnisses eine Umwandlung vornehmen oder Ihre Parameter so ändern, dass sie akzeptiert werdendouble

Keine Notwendigkeit zu konvertieren. Sie können Bedingungen für Enums innerhalb eines Switches anwenden. Wie so,

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

Dann nenne es so:

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

Zwei Dinge. Zunächst müssen Sie die Enum-Referenz in Ihrem Test qualifizieren - anstelle von "PLUS" sollte es "Operator.PLUS" sein. Zweitens wäre dieser Code viel besser lesbar, wenn Sie die Namen der Enum-Mitglieder anstelle ihrer Integralwerte in der switch-Anweisung verwenden würden. Ich habe Ihren Code aktualisiert:

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

Nennen Sie dies mit:

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

Ihr Code ist in Ordnung. Wenn Sie sich nicht sicher sind, wie Sie die Berechnungsfunktion verwenden sollen, versuchen Sie es

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

Standard-Enum-Werte beginnen bei 0 und erhöhen sich für folgende Elemente um eins, bis Sie andere Werte zuweisen. Sie können auch:

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