//Überprüfen
#region
private void textBox_rechung_KeyDown(object sender, KeyEventArgs e)
{
textBox_rechung.BackColor = Color.Empty;
if (e.KeyCode == Keys.Enter)
{
char TA = '=' ;
char TB = '+';
string[] TeilA = textBox_rechung.Text.Split(TA);
if (RechneStringaus(TeilA[0], TB) == RechneStringaus(TeilA[1], TB))
//if (Convert.ToDouble(Rechne.Berechne(TeilA[0])) == Convert.ToDouble(TeilA[1]))
{
textBox_rechung.BackColor = Color.Green;
}
else
{
textBox_rechung.BackColor = Color.Red;
}
}
}
private double RechneStringaus(string Str, char T)
{
char TC1 = '*' ;
char TC2 = '/' ;
char TD1 = '+' ;
char TD2 = '-' ;
double ergebnis = 0;
try
{
ergebnis = Convert.ToDouble(Str);
}
catch (Exception)
{
//Klammern erkennen in term spalten
string[] strArraystrArrayT = SplitStringKlammern(Str);
//wenn die länge von strArrayT = 1 dann nach operatoren splitten, sonst für jedenterm RechneStringaus methode verwenden
if (strArraystrArrayT.Length == 1)
{
#region
try
{
switch (T)//nur so geschrieben
{
case '+':
string[] strArrayplus = SplitStringPlus(strArraystrArrayT[0]);
if (strArrayplus.Length != 1)
{
for (int a = 0; a < strArrayplus.Length; a++)
{
ergebnis += RechneStringaus(strArrayplus[a],TD1);
}
}
else
{
ergebnis = RechneStringaus(strArrayplus[0], TD2);
}
break;
case '-':
string[] strArrayminus = SplitStringMinus(strArraystrArrayT[0]);
if (strArrayminus.Length != 1)
{
for (int a = 0; a < strArrayminus.Length; a++)
{
if (a == 0)
{
ergebnis += RechneStringaus(strArrayminus[a], TD1);
}
else
{
ergebnis -= RechneStringaus(strArrayminus[a], TD1);
}
}
}
else
{
ergebnis = RechneStringaus(strArrayminus[0], TC1);
}
break;
case '*':
string[] strArraymal = SplitStringMal(strArraystrArrayT[0]);
if (strArraymal.Length != 1)
{
for (int a = 0; a < strArraymal.Length; a++)
{
if (a == 0)
{
ergebnis += RechneStringaus(strArraymal[a], TC1);
}
else
{
ergebnis *= RechneStringaus(strArraymal[a], TC1);
}
}
}
else
{
ergebnis = RechneStringaus(strArraymal[0], TC2);
}
break;
case '/':
string[] strArraygeteilt = SplitStringGeteilt(strArraystrArrayT[0]);
if (strArraygeteilt.Length != 1)
{
for (int a = 0; a < strArraygeteilt.Length; a++)
{
if (a == 0)
{
ergebnis += RechneStringaus(strArraygeteilt[a], TC2);
}
else
{
try
{
ergebnis *= 1 / RechneStringaus(strArraygeteilt[a], TC2);
}
catch (Exception ex)
{
Console.WriteLine("Fehler: "+ex);
}
}
}
}
else
{
ergebnis = RechneStringaus(strArraygeteilt[0], TC2);
}
break;
}
}
catch (Exception)
{
}
#endregion
}
else//tritt nur ein wenn operator vor/nach klammer
{
// erst alles nach / und dann nach * danach nach - und dann nach +
// am besten methode für rechenzeichen nach/vor klammern suchen
// prüft ob / vor klammer und dann ob / nach klammer
// prüft ob * vor klammer und dann ob * nach klammer usw...
#region
for (int a = 0; a < strArraystrArrayT.Length; a++)
{
char[] cArrayT = strArraystrArrayT[a].ToCharArray();
string temp;
if (OperatorVorKlammer(strArraystrArrayT[a], '/'))
{
if (OperatorNachKlammer(strArraystrArrayT[a], '/') && cArrayT.Length == 1)
{
// tritt ein wenn ...)/(...
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) / RechneStringaus(strArraystrArrayT[a + 1], TD1);
}
else
{
// .../(...
cArrayT[cArrayT.Length - 1] = ' ';// sonderfall denn / bindet an nächsten term
temp = new string(cArrayT);
ergebnis += RechneStringaus(temp, TD1) / RechneStringaus(strArraystrArrayT[a + 1], TD1);
a++;
}
}
if (OperatorNachKlammer(strArraystrArrayT[a], '/'))
{
//...)/...
temp = new string(cArrayT);
string[] tempArr = new string[1];
bool bindung, mal;
if (SplitStringPlus(temp).Length != 1)//ermittelt ob die mit dem rechneoperator verbundenen zahl noch eine stärkere bindung zu etwas anderem hat
{
tempArr = SplitStringPlus(temp);
bindung = true;
mal = false;
}
else
{
if (SplitStringMinus(temp).Length != 1)
{
tempArr = SplitStringMinus(temp);
bindung = true;
mal = false;
}
else
{
if (SplitStringMal(temp).Length != 1)
{
tempArr = SplitStringMal(temp);
bindung = true;
mal = true;
}
else
{
tempArr[0] = temp;
bindung = false;
mal = false;
}
}
}
cArrayT = tempArr[0].ToCharArray();//nur den teil des term der an die klammer gebunden ist wird in ein cahr array gewandelt
cArrayT[0] = ' ';
temp = new string(cArrayT);
strArraystrArrayT[a - 1] = (RechneStringaus(strArraystrArrayT[a - 1], TD1) / RechneStringaus(temp, TD1)).ToString();//die klammer und der bindene term ausgerechnet und auf speicherplatz von klammer gesetzt
char[] tempCharArr = strArraystrArrayT[a].ToCharArray(); ;
char[] cArrayT2;
if (bindung)
{
cArrayT2 = new char[tempCharArr.Length - cArrayT.Length - 1];
Array.Copy(tempCharArr, cArrayT.Length + 1, cArrayT2, 0, cArrayT2.Length);//kopiert den ehemaligen term in cArray und lässt dabei das bereits berrechnete weg
}
else
{
cArrayT2 = new char[tempCharArr.Length - cArrayT.Length];
Array.Copy(tempCharArr, cArrayT.Length, cArrayT2, 0, cArrayT2.Length);//löscht bindenden term hinter der klammer, da er nicht mehr gebunden wird
}
temp = new string(cArrayT2);
if (mal)
{
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) * RechneStringaus(temp, TD1);
}
else
{
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) + RechneStringaus(temp, TD1);
}
}
//------------------------------------------------------
if (OperatorVorKlammer(strArraystrArrayT[a], '*'))
{
if (OperatorNachKlammer(strArraystrArrayT[a], '*') && cArrayT.Length == 1)
{
// tritt ein wenn ...)*(...
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) * RechneStringaus(strArraystrArrayT[a + 1], TD1);
}
else
{
// ...*(...
cArrayT[cArrayT.Length - 1] = ' ';// sonderfall denn * bindet an nächsten term
temp = new string(cArrayT);
ergebnis += RechneStringaus(temp, TD1) * RechneStringaus(strArraystrArrayT[a + 1], TD1);
a++;
}
}
if (OperatorNachKlammer(strArraystrArrayT[a], '*'))
{
//...)*...
temp = new string(cArrayT);
string[] tempArr = new string[1];
bool bindung;
if (SplitStringPlus(temp).Length != 1)//ermittelt ob die mit dem rechneoperator verbundenen zahl noch eine stärkere bindung zu etwas anderem hat
{
tempArr = SplitStringPlus(temp);
bindung = true;
}
else
{
if (SplitStringMinus(temp).Length != 1)
{
tempArr = SplitStringMinus(temp);
bindung = true;
}
else
{
tempArr[0] = temp;
bindung = false;
}
}
cArrayT = tempArr[0].ToCharArray();//nur den teil des term der an die klammer gebunden ist wird in ein cahr array gewandelt
cArrayT[0] = ' ';// sonderfall denn * bindet an vorherigen term
temp = new string(cArrayT);
strArraystrArrayT[a - 1] = (RechneStringaus(strArraystrArrayT[a - 1], TD1) * RechneStringaus(temp, TD1)).ToString();//die klammer und der bindene term ausgerechnet und auf speicherplatz von klammer gesetzt
char[] tempCharArr = strArraystrArrayT[a].ToCharArray(); ;
char[] cArrayT2;
if (bindung)
{
cArrayT2 = new char[tempCharArr.Length - cArrayT.Length - 1];
Array.Copy(tempCharArr, cArrayT.Length + 1, cArrayT2, 0, cArrayT2.Length);//kopiert den ehemaligen term in cArray und lässt dabei das bereits berrechnete weg
}
else
{
cArrayT2 = new char[tempCharArr.Length - cArrayT.Length ];
Array.Copy(tempCharArr, cArrayT.Length, cArrayT2, 0, cArrayT2.Length);//löscht bindenden term hinter der klammer, da er nicht mehr gebunden wird
}
temp = new string(cArrayT2);
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) + RechneStringaus(temp, TD1);
}
//------------------------------------------------------
if (OperatorVorKlammer(strArraystrArrayT[a], '-'))
{
if (OperatorNachKlammer(strArraystrArrayT[a], '-') && cArrayT.Length == 1)
{
// tritt ein wenn ...)-(...
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) - RechneStringaus(strArraystrArrayT[a + 1], TD1);
}
else
{
// ...-(...
cArrayT[cArrayT.Length - 1] = ' ';
temp = new string(cArrayT);
ergebnis += RechneStringaus(temp, TD1) - RechneStringaus(strArraystrArrayT[a + 1], TD1);
a++;
}
}
if (OperatorNachKlammer(strArraystrArrayT[a], '-'))
{
//...)-...
cArrayT[0] = ' ';
temp = new string(cArrayT);
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) - RechneStringaus(temp, TD1);
}
//------------------------------------------------------
if (OperatorVorKlammer(strArraystrArrayT[a], '+'))
{
if (OperatorNachKlammer(strArraystrArrayT[a], '+')&& cArrayT.Length==1)
{
// tritt ein wenn ...)+(...
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) + RechneStringaus(strArraystrArrayT[a + 1], TD1);
}
else
{
// ...+(...
cArrayT[cArrayT.Length - 1] = ' ';
temp = new string(cArrayT);
ergebnis += RechneStringaus(temp, TD1) + RechneStringaus(strArraystrArrayT[a + 1], TD1);
a++;
}
}
if (OperatorNachKlammer(strArraystrArrayT[a], '+'))
{
//...)+...
cArrayT[0] = ' ';
temp = new string(cArrayT);
ergebnis += RechneStringaus(strArraystrArrayT[a - 1], TD1) + RechneStringaus(temp, TD1);
}
}
#endregion
}
}
return ergebnis;
}
private bool OperatorVorKlammer(string Str, char Operator)
{
char[] cArrayT = Str.ToCharArray();
if (cArrayT[cArrayT.Length-1] == Operator)
{
return true;
}
else
{
return false;
}
}
private bool OperatorNachKlammer(string Str,char Operator)
{
char[] cArrayT = Str.ToCharArray();
if (cArrayT[0] == Operator)
{
return true;
}
else
{
return false;
}
}
private string[] SplitStringKlammern(string Str)
{
string[] strArraystrArrayT = new string[1];
//Klammern erkennen in term spalten
#region
char[] cArray = Str.ToCharArray();
int Klammerauf = 0;
int Klammerzu = 0;
bool inKlammer = false;
int counterT = 1;
for (int a = 0; a < cArray.Length; a++)
{
if (cArray[a] == '(')
{
Klammerauf++;
if (!inKlammer)//erzeugt neuen termabschnitt nach öffnender klammer
{
inKlammer = true;
try
{
if (strArraystrArrayT[counterT - 1].Length != 0)//wenn das erste zeichen eine klammer ist wird kein neuer termabschnitt erzeugt
{
string[] temp = (string[])strArraystrArrayT.Clone();
strArraystrArrayT = new string[strArraystrArrayT.Length + 1];
temp.CopyTo(strArraystrArrayT, 0);
counterT++;
}
}
catch (Exception)
{
}
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArray[a].ToString();//aufgehende klammer innerhalb eines klammer abschnittes
}
}
else
{
if (cArray[a] == ')')
{
Klammerzu++;
if (Klammerauf == Klammerzu && Klammerauf != 0)//erzeugt neuen termabschnitt nach schließender klammer
{
if (a != cArray.Length - 1)//wenn die schließende klammer nicht das letzte zeichen ist
{
inKlammer = false;
Klammerauf = 0;
Klammerzu = 0;
string[] temp = (string[])strArraystrArrayT.Clone();//
strArraystrArrayT = new string[strArraystrArrayT.Length + 1];
temp.CopyTo(strArraystrArrayT, 0);
counterT++;
}
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArray[a].ToString();//schließende klammer innerhalb eines klammer abschnittes
}
}
else
{
if (cArray[a] != ' ')
{
if (!inKlammer)
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArray[a].ToString();//term außerhalb der klammer aufschreiben
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArray[a].ToString(); //term in klammer aufschreiben
}
}
}
}
}
#endregion
return strArraystrArrayT;
}
private string[] SplitStringPlus(string Str)
{
string[] strArraystrArrayT = new string[1];
int counterT = 1;
char[] cArrayT = Str.ToCharArray();
#region
for (int a = 0; a < cArrayT.Length; a++)
{
if (cArrayT[a] == '+')
{
try
{
if (strArraystrArrayT[counterT - 1].Length != 0)//wenn das erste zeichen eine klammer ist wird kein neuer termabschnitt erzeugt
{
string[] temp = (string[])strArraystrArrayT.Clone();
strArraystrArrayT = new string[strArraystrArrayT.Length + 1];
temp.CopyTo(strArraystrArrayT, 0);
counterT++;
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArrayT[a].ToString();
}
}
catch (Exception)
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArrayT[a].ToString();
}
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArrayT[a].ToString();
}
}
#endregion
return strArraystrArrayT;
}
private string[] SplitStringMinus(string Str)
{
string[] strArraystrArrayT = new string[1];
int counterT = 1;
char[] cArrayT = Str.ToCharArray();
#region
for(int a = 0; a {
if (cArrayT[a] == '-')
{
try
{
if (strArraystrArrayT[counterT - 1].Length != 0)//wenn das erste zeichen eine klammer ist wird kein neuer termabschnitt erzeugt
{
string[] temp = (string[])strArraystrArrayT.Clone();
strArraystrArrayT = new string[strArraystrArrayT.Length + 1];
temp.CopyTo(strArraystrArrayT, 0);
counterT++;
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArrayT[a].ToString();
}
}
catch (Exception)
{
}
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArrayT[a].ToString();
}
}
#endregion
return strArraystrArrayT;
}
private string[] SplitStringMal(string Str)
{
string[] strArraystrArrayT = new string[1];
int counterT = 1;
char[] cArrayT = Str.ToCharArray();
#region
for (int a = 0; a < cArrayT.Length; a++)
{
if (cArrayT[a] == '*')
{
string[] temp = (string[])strArraystrArrayT.Clone();
strArraystrArrayT = new string[strArraystrArrayT.Length + 1];
temp.CopyTo(strArraystrArrayT, 0);
counterT++;
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArrayT[a].ToString();
}
}
#endregion
return strArraystrArrayT;
}
private string[] SplitStringGeteilt(string Str)
{
string[] strArraystrArrayT = new string[1];
int counterT = 1;
char[] cArrayT = Str.ToCharArray();
#region
for (int a = 0; a < cArrayT.Length; a++)
{
if (cArrayT[a] == '/')
{
string[] temp = (string[])strArraystrArrayT.Clone();
strArraystrArrayT = new string[strArraystrArrayT.Length + 1];
temp.CopyTo(strArraystrArrayT, 0);
counterT++;
}
else
{
strArraystrArrayT[counterT - 1] = strArraystrArrayT[counterT - 1] + cArrayT[a].ToString();
}
}
#endregion
return strArraystrArrayT;
}
#endregion
