Die einfachste Variante: arbeite mit String.Split, mit dem Rechenzeichen als Delimiter. Du erhältst 2 Texte: Zahl1 als Text und Zahl2 als Text. Die kannst Du mit Decimal.Parse u.ä. in Zahlen umwandeln (so, wie Du es schon im Code verwendest) und dann diese entsprechend dem Rechenoperator miteinander verrechnen, also wenn Du * als Rechenoperator im text stehen hast, dann nimm * als String.Split-Delimiter und multipliziere die sich ergebenden 2 Zahlen miteinander. Bei anderen Rechenoperatoren verrechnest Du die Zahlen eben anders, also addieren, subtrahieren, ...

Wenn's gut werden soll, bist Du bei EdRs FormelParser und ExpressionTree aufgehoben.

@VaporiZed @ErfinderDesRades Ich finde es merkwürdig, dass Ihr vielen Zeilen Code ohne Beantwortung von Fragen sowie Beratungsresistenz so viel Aufmerksamkeit widmet.

@Moritzgs1 Dann solltest Du präzise das fragen, was Du nicht verstehst.
In mehreren Posts praktisch denselben Code posten hilft nicht!

@Moritzgs1 In Post #8 habe ich Dir präzise geschrieben, was Du tun musst.
Du postest Deinen Code und erwartest von uns, dass wir ihn debuggen. Das musst Du selbst tun.
Ich will mal nicht annehmen, dass Du der Meinung bist, dass der Code, den Du geschrieben hast, einfach nur deshalb läuft, weil er compiliert.

Genügend Stichwörter sind gegeben, hier noch zum Abschluss ein Test, den Du dringend ausprobieren solltest - v.a. in Kombination mit RfGs Post#8!

Nun hast Du alles, was Du brauchst. Ich werde mich wieder äußern, wenn sich deutliche Erkenntnissprünge zeigen.

@Moritzgs1 Vielleicht solltest Du Deine Herangehensweise ändern.
Mische nicht alle Tasten, bis Enter kommt, sondern sammle komplette Zahlen ein und die Operatoren separat, also wenn ein Operator kommt, ist eine Zahl fertig eingegeben.

Hi.

Vielleicht kann das konzeptionelle herangehen an deine Problemstellung etwas "aufgedröselt" werden.

Eingaben in .NET:
Da eine "Oberfläche/UI" genutzt wird, ist die Ereignisbasierte eingabe mittels Eventargs die Vorgabe.
In Eingabeelementen (Controls) werden diese dann "gefeuert/getriggert".
Diese sind wiederum spezielle Ereignistypen.
z.B.: Mouse- , Keyboard-, Touchpad-, etc. Eingaben.

Mit den "Methoden" werden dann die Eingaben "behandelt".


"object sender" bedeutet das dieser Parameter sich auf das aufrufende/auslösende Steuerelement/Control bezieht.
Also das "WER?"
"EventArgs e" bedeutet das, dies der Ereignisparameter ist und hier das Ereignis vom "SENDER" gesendet wurde.
Dann empfiehlt es sich die "e" Variable/Parameterwert auf das gewollte Ereignis zu prüfen.

"button9_Click" ist der Name der Methode die ein Control haben kann.

Es könnte auch "Multipliziere" heißen, und dann sollte das im Control (UI) auch genauso als Event angegeben werden.

Es ist zum Beispiel auch möglich alle Buttons die eine mathematische Operation ausführen sollen, die selbe Methode aufrufen zu lassen.
Dann muss nur noch mittels sender ermittelt werden welcher denn nun gedückt wurde, und dann die entsprechen Operation ausführen.
Tipp: Die Controls (Buttons) sollten in dem Fall, zur Unterscheidbarkeit, benannt werden. (z.B.: ZifferEinsButton, ZifferZweiButton, MultplizierenButton, usw.)

Kleiner Tipp: Wenn im UI-Designer ein Button ausgewählt ist, dann im Eigenschaftenfenster einmal auf das kleine "Blitz" Symbol klicken,
und schon sind nur die Ereignisse die das Control haben kann aufgelistet.
Dort ist dann der Methodenname (z.B. : button9_Click) zu finden. (Scrollen nicht vergessen, ist manchmal nicht sofort zu sehen.)

Mit dem Schraubenschlüßel-Symbol im Eigenschaftenfenster, werden dann wieder die Eigenschaftenwerte angezeigt.

Möchte der gehobene Programmierer des neuen Jahrtausends, dann Tastatureingaben behandeln,
sollten es dann die KeyUp und/oder KeyDown oder ähnliche Ereignismethoden sein.

Jetzt ist nur noch zu klären wer dann der "sender" wird.
Das kann zum Beispiel das ganze Programmfenster sein, oder nur ein Teilelement der UI.
Der Windows eigene Taschenrechner macht das genauso.
Wenn irgendwo im Programm der Focus liegt, fängt das "Window" es vorher ab, und "behandelt" das Ereignis.
Mittels "e.Handeled = True" bestimmt der moderne Programmierer, das es hiermit getan ist und das Ereignis geht ins Nirvana, wenn gewünscht.

Ist schon fortgeschrittene Technik, aber die muss nun eimal sein.
Wird das Konzept einmal verstanden, ist das Weltweit und Universell bei allen UI/Eingaben gleich ob Mac, AMIGA oder Android.

Eine Idee zum Taschenrechner:
Sollen mathematische Formeln als Text eingegen werden, dann sind diese zu interpretieren.

Dazu muss der Text in sein Bestandteile zerlegt werden.
Das wird allgemeingültig als Splitten bezeichnet.
Daraufhin muss dann jedes Zeichen im Text "interpretiert" werden.
Zahlen, Operatoren (+,-,*,/, etc. ), und Klammern und was es nicht alles an Formelsymbolen gibt...

Daher kann ich nur Raten, nicht diesen Weg zu gehen, sondern einfach jeweils Buttons, wie im Vorbild des Windowstascherechners, nachzubilden.

Und das wo die Eingaben, bzw. das (zwischen-) Ergebnis(e) stehen soll einfach als Textbox, wo nichts eingeben wird, sondern nur die "gepufferte" Eingabe steht.

Mal etwas einfacher erklärt:
Willste 100 + 20 rechnen?
Eins, Null, Null eintippen und in der TextBox als 100 darstellen. ("Puffervariable benutzen", vieleicht mit dem zauberhaften Namen "PuffPiffPaff")
Wenn dann einmal der Button "+" (Addieren) gedrückt wird, den Wert des Puffers in einen weiteren Puffer ablegen (name "Zwischenwert").
Jetzt den PuffPiffPaff leeren, und Zwei, Null eintippen und in der TextBox als 20 darstellen.
Nun die "Enter" Taste oder den "=" Button drücken.
Dann mit hilfe von PuffPiffPaff, dem "operanden" und dem Zwischenwert berechen, das Ergebnis dann in der TextBox darstellen.
PuffPiffPaff ist jetzt zu leeren und Zwischenwert wird dann 120, also das Ergebnis.

Beachte das eigentlich Zwischenwert dann Operand dann PuffPiffPaff... und Punkt vor Strich und Klammern zuerst...
"Ich vemisse meinen Mathelehrer. WAS REDE ICH denn da? "

Ungefähr so kann das umgesetzt werden.

Es sollten (eigentlich) jeweils zwei Ereignisse pro Button vorhanden sein.
Einer für die Maus und einer für die Tastatur.
Und der aufgeweckte Programmierer von morgen, macht das mittels "private void BlaBlup()"
Das er aus der Ereignismethode entsprechend aufruft.
z.B. : Enter-Taste und "=" Button rufen dann "private void BerecheErgebnis()" auf.

CE und C Buttons:

CE würde dann alle PufferVariablen löschen (PuffPiffPaff und Zwischenergebnis)
C löscht nur PuffPiffPaff...

Der Rest kommt beim Probieren.

Ich hoffe es konnte ein wenig aufhellen...

Hmmm bei mir is dunkel grad, wird wohl Regen geben...

c.u. Joshi

Memo an Mich: Wenn Du was erklärst, dann pass gefälligst auf, ob Addieren und Multiplizieren nicht vertausch sind.
Jetzt weiss ich auch, warum ich bei TexasInstruments als Azubi abgelehnt wurde.