Rechenterm in string ausrechenen

xparet0209 · 23. Oktober 2009, 14:51

ich habe ein kleines problem
und zwar liegt mir ein string vor, der einfache grundrechenarten beinhaltet
z.b.:
(1+-2)*(3+4/2)*(5+6*(7+8*9)+10)-(-3+5-8*(-5+2)/(3-5))

nun versuche ich diesen string zu analysieren also vorher zu splitten und auszurechnen
allerdings scheitere ich bei verschachtelten klammern
und bei der punkt vor strich regel
außerdem weiß ich noch nicht wie ich mit den vorzeichen umgehen soll

könnte mir jmd ein paar tipps geben?
mfg xparet0209

Zerd · 23. Oktober 2009, 15:40

Ich habe mal in Java einen Parser geschrieben, der Arithmetische Ausdrücke nach der Methode des Rekursiven Abstiegs analysiert und automatisch berechnet.

Lies dir dazu mal den Artikel durch: Parser ? Wikipedia

Prinzipiell wird der Ausdruck in atomare Elemente +,-, nummer, (, ), expression, Konstante, und Funktionen aufgeteilt. Rekursiv werden diese Symbole angeschaut und je nach match die entsprechende Berechnung durchgeführt.

wasawasa · 23. Oktober 2009, 17:22

Man kann es sich (aus meiner Sicht) einfacher machen, wenn man über UPN (umgekehrte polnische Notation) dran geht. Da lösen sich solche Klammern sehr elegant auf (kenne ich von meinem HP-Taschenrechner). Ein nettes Beispiel findet sich hierActiveVB - Die Umgekehrte Polnische Notation

Nomotu · 23. Oktober 2009, 19:26

Tja, wäre ganz praktisch gewesen wenn du die Sprache erwähnt hättest. In .NET ganz du das ganze zur Laufzeit kompilieren und ausführen. Google mal nach 'c# runtime compile'.

xparet0209 · 23. Oktober 2009, 19:41

also UPN hab ich erst letzte woche ein kleinen taschenrechner geschrieben^^
aber wie "konvertiere" ich den string in UPN schreibweise?
denn die eingabe soll halt ganz normal wie beim schreiben sein (prog ist für andere, die UPN wahrscheinlich nciht kennen)

Zerd · 23. Oktober 2009, 20:55

UPN ist letztendlich kein Unterschied zu meinem Vorschlag, auch da brauchst du einen Parser der dir den String in seine Einzelteile zerlegt.

UPN beschreibt doch nur wie der Baum letztendlich traversiert (nämlich postfix) wird oder erinner ich mich da falsch??

xparet0209 · 23. Oktober 2009, 23:50

also bei einem upn rechner gibt man statt
(1+2)*(3+4) ein
1 2 + 3 4 + *
dort kann ich super mit einem stack arbeiten und die operationen abarbeiten^^
allerdings hab ihc das ja schon bzw. mein programm soll leichter verständlich sein
und daher macht sich diese postfixnotation eher schlecht
außer es gäbe ein möglichkeit die vom nutzer eingegebenen normale rechenterme
in die postfix notation umzuwandel...

nile · 24. Oktober 2009, 00:11

UPN beschreibt doch nur wie der Baum letztendlich traversiert (nämlich postfix) wird oder erinner ich mich da falsch??

Nein, passt genau.

außer es gäbe ein möglichkeit die vom nutzer eingegebenen normale rechenterme
in die postfix notation umzuwandel...

Genau das versuchen dir Zerd und wasawasa ja gerade vorzuschlagen, wenn ich das jetzt richtig herauslese.

Tja, wäre ganz praktisch gewesen wenn du die Sprache erwähnt hättest.

C#, steht doch im Threadtitel...

wasawasa · 24. Oktober 2009, 08:40

Dem kann ich nur zustimmen.
Das kleine Tutorial hinter meinem Link sollte auch die esten Schritte ermöglichen.
Zudem sind es jetzt genug Informationen um sich den Rest zusammenzusuchen.
Ein Frage bei Google mit "upn postfix parser c# t-60420.html" liefert ein Link.
Dort finden sich sogar fertige Codebeispiele in Java und C#.
Um nicht wieder Punkte unter meinem Namen zu haben, verlinke ich nicht direkt.

xparet0209 · 24. Oktober 2009, 14:58

also der parser an sich ist nicht das problem aber der string an isch liegt in normaler notation dar
das heißt die rechenzeichen sind zwischen den zahlen und klammern
wie wandle ich das denn um in postfix notation?

meiner meinung nach müsste das ungefähr so gehen:
1)
operator zwischen speichern
zahl2* -> stack
operator verarbeiten

* wenn zahl x ein klammer abschnitt ist, ermittle klammertiefe
zähle schließende klammern bis klammertiefe
das ist dann der komplette klammer term
rechne den aus wie 1)

dabei muss ich das glaub ich rekursiv aufrufen
jetzt hab ich das problem mit der punkt vor stich regel...
wie kann ich das lösen?

nile · 24. Oktober 2009, 16:03

also der parser an sich ist nicht das problem aber der string an isch liegt in normaler notation dar das heißt die rechenzeichen sind zwischen den zahlen und klammern
wie wandle ich das denn um in postfix notation?

Das ist ja gerade die Aufgabe des Parsers. Er liefert dir aus dem in Standardnotation eingegebenen Term einen relativ einfach verarbeitbaren Term in UPN Notation.

wie kann ich das lösen?

Durch lesen

wasawasa schrieb:

Ein Frage bei Google mit "upn postfix parser c# t-60420.html" liefert ein Link.
Dort finden sich sogar fertige Codebeispiele in Java und C#.

Wobei dir das eigentlich die Sache schon zu einfach macht, eigentlich reicht sollte dir dieser Ansatz reichen bzw. das "Wie" beantworten:

Zerd schrieb:

Prinzipiell wird der Ausdruck in atomare Elemente +,-, nummer, (, ), expression, Konstante, und Funktionen aufgeteilt. Rekursiv werden diese Symbole angeschaut und je nach match die entsprechende Berechnung durchgeführt.

Zerd · 24. Oktober 2009, 19:59

Richtig, der Parser dient dazu den string so vorzubereiten wie du ihn brauchst (ob es jetzt UPN oder eine andere lösungsart ist).

Die Tipps die wir dir gegeben haben müssten eigentlich reichen... wenn nicht schreib ich dir vielleicht morgen mal ein wenig pseudocode, aber dafür hab ich heute keine Zeit

Viel Spaß!!

xparet0209 · 24. Oktober 2009, 21:13

achso
ich dachte die parser rechnen das nur aus
(CodeProject: Parsing Mathematical Expressions with muParser. Free source code and programming help)

denn die parser liefern double werte zurück

Zerd · 24. Oktober 2009, 21:21

Naja, das Projekt macht vermutlich genau das was du vorhast...
-> Den eingelesenen string parsen und den entstandenen Baum traversieren und die funktion berechnen...

übrigens: to parse = dict.cc | parse | Deutsch-Wrterbuch

xparet0209 · 30. Oktober 2009, 17:39

mir war langweilig also hab ich einfach mal einen parser für einfache rechnungen geschrieben
er kann mit klammern und +,-,*,/ umgehen
kommas sind ganz normal wie um deutschen mit "," einzugeben

die methode RechneString() aus liefert einen double wert zurück
zuvor muss der eingegebene string nach "=" geslpittet werden

allerdings ist der code eher schlecht kommentiert, was ich evt. noch verbessern werde
das auffangen von exceptions habe ich mit eingebaut allerdings gibt das programm ncoh kein hinweis wenn ein fehler aufgetreten ist
war mir noch zu aufwendig die fehlermeldungen zu schreiben
achja da mir die standart split methoden nciht gefallen haben, hab ich meine split methoden selber geschrieben

Quellcode

//Ü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<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)
{
}
}
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

Alles anzeigen

also wenn mir jmd erklären kann wie ich eine dll in ein c# projekt einbinde wäre es nett xDD

wasawasa · 31. Oktober 2009, 09:23

also wenn mir jmd erklären kann wie ich eine dll in ein c# projekt einbinde wäre es nett xDD

Theorie:

Quellcode

// Externe dll-Funktion Importieren
[DllImport('Name.dll')]
protected static extern int dll_Funktionsname(Datentyp Parametername);
// Methode die es ermöglicht von C# aus auf die dll
// zuzugreifen
public int Funktionsname_in_C_sharp()
{
return dll_funktionsname(Übergabeparamter);
}

Praxis:

Quellcode

// using System.Runtime.InteropServices;
[DllImport('kernel32.dll')]
public static extern bool Beep(int Frequenz, int Dauer);
// gibt einen Alarmton aus
private void Alarm()
{
for (int i = 0; i < 3; i++)
{
Beep(500, 1000);
Beep(1000, 1000);
}
}
// gibt einen einfachen beep aus
private void Beep()
{
Beep(1000, 1000);
}

Alles anzeigen

superduper · 3. November 2009, 15:09

Hier ist auch noch ein kleiner netter und sehr schneller MathParser für C#:

lundin.info

Damit sollte das auch klappen. Er ist auch sehr einfach zu bedienen. Wenn Du keine Variablen hast, brauchst Du auch nicht die Hashtabelle zu füllen.

Quellcode

Quellcode

Quellcode

Teilen