Argumentenliste beim Starten des Programmes übereben...

[dracoulars]

Hallo, Ich bin dabei zu übungszwecken einen 'Taschenrechner' zu Programieren mit den grundrechenarten (*,/,-,+). das Programm soll wie folgt gestartet weren:
C\> programmname 100 (rechenzeichen) 2
die argumente sollen gleich nach dem Programnamen mit aufgeführt werden.
Bei mir im Code sieht das so aus:

Imports System.Console
Imports Microsoft.visualBasic

Module abc

Sub Main( Argumente() as String )
Dim opt1 as Single
Dim opt2 as Single
Dim ergebnis as Single

opt1 = Argumente(0)
opt2 = Argumente(2)

Writeline("Anzahl der Argumente: {0}", argumente.length)
If Argumente.length > 3 then
Writeline ("zuviele Argumente")
Exit sub
Elseif Argumente.length < 3 then
Writeline ("Zuwenig Argumente")
Exit Sub
end if


Writeline("{0}{1}{2}=", _
Argumente(0), Argumente(1), Argumente(2), ergebnis, _
cInt(Argumente(0)), (Argumente(1)), Argumente(2), (ergebnis))
end sub
end module

das problem ich weiss nicht genau wie ich die rechnung im programm ausführe, damit ich ein ergebniss erhalte, denn bis jetzt steht nur ein leeres "feld" da. kann mir jemand helfen.
danke

[Yazu]

hallo zusammen...ich hab mich auch mal an dem Programm versucht aber bin irgendwie gescheitert. hat vielleicht jmd eine lösung? Mein Versuch sieht bisher so aus: (Allerdings ohne die möglichkeit rechenzeichen zu setzen)

Imports System.Console
Imports Microsoft.VisualBasic

Module abc

Sub Main(op() as String)

If op.length > 2 Then
WriteLine ("Zuviele Argumente")
Exit Sub
Elseif op.length < 2 Then
WriteLine ("Zuwenig Argumente")
Exit Sub
End if

WriteLine(" {0} + {1} = {2}", op(0), op(1), cInt(op(0)) + op(1))

End Sub

End Module

[M.Dietz]

Kurzer Tipp:

Versuchs mal mit
Dim Argumente as String()=System.Environment.GetCommandLineArgs()

musst dann allerdings aufpassen: Argumente(0) ist der name der EXE

Gruß
Martin

[Yazu]

hmm...das sagt mir gar nichts!? wüsste jetzt auch nicht wie ich es nutzen soll!?

[M.Dietz]

System.Environment.GetCommandLineArgs() gibt eine StringList zurück (sieh Dir zur genaueren Verwendung die OH an

Angenommen der Aufruf von HelloWorld ist "Hello Martin Dietz", und Du deklarierst

Dim Argumente as String()=System.Environment.GetCommandLineArgs()

dann hast Du hinterher

Argumente(0)="Hello.exe"
Argumente(1)="Martin"
Argumente(2)="Dietz"

[Yazu]

ok...soweit klar. aber wie unterscheidet das programm nachher die rechenoperatoren und einfach nur die anzahl der argumente?

[M.Dietz]

Anzahl der Argumente: Argumente.Count -1 (1 abziehen wegen Dateiname in Position 0)
Unterscheidung Zahl/Rechenzeichen: gar nicht, dass muss Dein Programm machen.

Dem System ist es völlig egal ob Du "rechne 2 / 3" angibst oder "rechne Herbert + Bier" oder "rechne 17 4 *" für das System sind es es einfach 4 Strings die in diese Liste gesteckt werden, und zwar in genau der Reihenfolge, wie sie in der Kommandozeile angegeben wurden, ob die Argumente einer Schnittstellenkonvention entsprechen, ob sie sinnvoll sind, und wie sie zu interpretieren sind ist Wissen, das das System nicht hat, darum muss sich Dein Programm kümmern.

Entweder Du sagst grundsätzlich "das Rechenzeichen ist Argumente(2)" und gibst einen Fehler zurück, wenn jemand so etwas wie "rechne Fakultaet 2" angibt, oder Du überprüfst jedes Argument einzeln, ob es das Rechenzeichen ist, dann kriegst Du aber Probleme nicht-kommutative Ausdrücke auszuwerten.

Ansonsten kannst Du natürlich auch den kompletten Kommandozeilenaufruf mit System.Environment.CommandLine auslesen, dann musst Du aber selbst zusammensuchen, wo ein Argument beginnt und wo es aufhört.

Hoffe das hilft, und ist ausführlich genug
Martin

[Yazu]

das hilft danke für deine mühe... hat mir ein ganzes stück weitergeholfen

grüsse sven

[gfoidl]

Hallo,

dir Argumentliste kann direkt über "args" ermittelt werden - der Umweg über Environment.GetCommandLineArgs() ist nicht nötig. Für das Ausführen der Operationen kann ein Delegat verwendet werden der auf die auszuführende Operation verweist.

Beispielanwendung:

# Imports System
# Imports System.Collections.Generic
# Imports System.Linq
# Imports System.Text
#
# Namespace Taschrenrechner
#     Class Program
#         ' Delegat (Funktionszeiger) für die Durchführung der Operation:
#         Public Delegate Function Operation(ByVal operand1 As Single, ByVal operand2 As Single) As Single
#         '---------------------------------------------------------------------
#         Private Shared Sub Main(ByVal args As String())
#             Dim operand1 As Single
#             Dim operand2 As Single
#             Dim operation As String
#            
#             ' Prüfen der länge der Befehlszeile:
#             If args.Length = 3 Then
#                 ' Befehlszeilenargumente könnnen über args abgerufen werden.
#                 ' Die exe ist nicht enthalten -> an 1. Indexposition ist
#                 ' also der 1. Parameter.
#                 operand1 = Single.Parse(args(0))
#                 operand2 = Single.Parse(args(2))
#                 operation = args(1)
#             Else
#                 ' Benutzereingabe für die Werte:
#                 Console.Write("Operand 1:" & Chr(9) & "" & Chr(9) & "" & Chr(9) & "")
#                 operand1 = Single.Parse(Console.ReadLine())
#                
#                 Console.Write("Operation (+, - , *, /):" & Chr(9) & "")
#                 operation = Console.ReadLine()
#                
#                 Console.Write("Operand 2:" & Chr(9) & "" & Chr(9) & "" & Chr(9) & "")
#                 operand2 = Single.Parse(Console.ReadLine())
#             End If
#            
#             ' Delegat:
#             Dim operationsZeiger As Operation
#            
#             ' Zuweisen der Operation an den Delegaten:
#             If operation = "+" Then
#                 operationsZeiger = New Operation(Addition)
#              ElseIf operation = "-" Then
#                 operationsZeiger = New Operation(Subtraktion)
#              ElseIf operation = "*" Then
#                 operationsZeiger = New Operation(Multiplikation)
#              ElseIf operation = "/" Then
#                 operationsZeiger = New Operation(Divison)
#             Else
#                 Throw New NotSupportedException()
#             End If
#            
#             ' Ausführen der Operation:
#             Dim ergebnis As Single = operationsZeiger(operand1, operand2)
#            
#             ' Ausgabe:
#             Console.WriteLine(New String("-"C, 20))
#             Console.WriteLine("Ergebnis: {0:f}", ergebnis)
#             Console.ReadKey()
#         End Sub
#        
#         #Region "Operationen"
#         Private Shared Function Addition(ByVal summand1 As Single, ByVal summand2 As Single) As Single
#             Return summand1 + summand2
#         End Function
#         '---------------------------------------------------------------------
#         Private Shared Function Subtraktion(ByVal minuend As Single, ByVal subtrahend As Single) As Single
#             Return minuend - subtrahend
#         End Function
#         '---------------------------------------------------------------------
#         Private Shared Function Multiplikation(ByVal faktor1 As Single, ByVal faktor2 As Single) As Single
#             Return faktor1 * faktor2
#         End Function
#         '---------------------------------------------------------------------
#         Private Shared Function Divison(ByVal dividend As Single, ByVal divisor As Single) As Single
#             Return dividend / divisor
#         End Function
#         #End Region
#     End Class
# End Namespace

mfG Gü

[Yazu]

super...vielen dank

[M.Dietz]

Ich weiß es nicht mehr genau unter welchen, aber unter bestimmten Umständen gibt es keine main-Funktion, die die Angabe von Argumenten erlaubt oder das aufrufende Famework gibt die nicht weiter oder so etwas. Irgendwas war da, deshalb ist der "Umweg" über System.Environment.GetCommandLineArgs() der sicherere. Außerdem sind System.Environment.CommandLine und .GetCommandLineArgs() von überall aus aufrufbar, auch wenn man z.B. von einer Startroutine zu einem Startfenster wechselt...

Aber noch was anderes: Yazu hatte offensichtlich sogar Probleme damit den eingelesenen String in Integers zu verwandeln, bevor er + aufruft, und Du glaubst er ist reif für Delegates (Nichts für ungut Sven, aber durch Deine Fragen hast Du dich eh schon als Anfänger geoutet)

[Yazu]

das bin ich auch aber genau das soll sich ja ändern

[gfoidl]

Ob er reif ist Delegates zu verstehen oder nicht - am Besten lernt man Programmiersprachen durch das Lesen von Codes (anderer). Genau in diesem Punkt will ich ihm helfen. So schwierig zu verstehen ist der Code nun auch wieder nicht.

mfG Gü