Befehl erkennen

Anubis153 · 27. November 2012, 19:16

Hi Leute,

ich hab da mal ne Frage...
Und da ich keine Antwort finde, Stelle ich sie einfach mal hier

Ich arbeite an einem Programm, welches eine Fernsteuerung für meinen 2ten PC sein soll.
Also hab ich mir es ein wenig umständlich gemacht, und mir einen TCP Server umgeschrieben.
Ich hab also einen Server, ein Senderprogramm, und ein Empfängerprogramm.
Momentan funktioniert das Programm aber leider nur als einseitiger chat

Meine Frage ist nun:
Wie sage ich meinem Empfängerprogramm, dass er bei einer Nachricht, die Mit einem / anfängt erstmal guckt, welches wort nach dem / kommt und diese dann in einer MSGBox ausgibt?

Ich habs schon mit einer Kombination aus If Abfrage und

VB.NET-Quellcode

Dim 1 As Char = empfangener Text(1)

versucht, aber das ist ziemlich umständlich da ich dann ja jeden Buchstaben einzelnd überprüfen muss.

Gibt es da irgentwie eine bessere möglichkeit?

Niko Ortner · 27. November 2012, 19:28

Da gibt's viele Möglichkeiten. Das hängt von dem gesendeten Befehl ab.
Schreib uns mal ein paar Beispiele, damit wir sehen, wie die Befehle aussehen.

Anubis153 · 27. November 2012, 19:35

Ich hätte auf anhieb mal 2 beispiele:

1. "/shutdown" (soll den PC mit "Shell("shutdown -s -t 20")" herunterfahren
2. wenn möglich "/kill [Prozessname]" (soll den Prozess mit dem Namen [Prozessname] beenden)

Killerjo96 · 27. November 2012, 19:37

z.B. so:

VB.NET-Quellcode

Select Case True
Case Befehl.Contains("/kick")
'führe das kicken aus
Case Befehl.Contains("/close")
'führe den befehl close aus z.B. me.Close oder sowas
End Select

wenn du parameter wie bei deinem fall (im nächsten post hab ich übersehen) das mit dem prozessnamen dann z.B. so

VB.NET-Quellcode

Select Case True
Case Befehl.Contains("/kick")
Dim splitter() as string = befehl.split(" ")
/kill splitter(0) 'wäre in dem fall der erste parameter der durch ein leerzeichen (" ") getrennt wurde.
End Select
[Achtung Pseudocode]

Hoffe du verstehst es.

Anubis153 · 27. November 2012, 20:27

OK! Danke hat geklappt!

Niko Ortner · 27. November 2012, 22:35

Vielleicht möchtest Du Dir ein etwas handlicheres System zulegen, wenn Du kompliziertere Befehle hast.
Du könntest eine MustInherit Basisklasse namens Action verwenden, die eine MustOverride Funktion namens "Execute" parat hält.
Alle abgeleiteten Klassen wissen, ob sie mit dem Befehl gemeint sind und wissen, was bei einem Befehl zu tun ist.
Dann kannst Du das hier anwenden: [VB 2010] Statische Funktionen abgeleiteter Klassen aufrufen um Dir eine TryParse-Funktion zu schreiben.
Das wird die Sache auf Dauer vereinfachen.

~blaze~ · 28. November 2012, 05:26

Hi
folgendes wäre wahrscheinlich angemessener:

Spoiler anzeigen

VB.NET-Quellcode

Public Shared Sub Test()
Dim commandList As New CommandList(True)
commandList.Add(New Command("msgBox", New Action(Of String)(Sub(p) MessageBox.Show(p)), _
New Action(Of String, String)(Sub(x, y) MessageBox.Show(x + " " + y))))
InvokeCommand("\MsgBox HelloWorld \MsgBox test merge", commandList)
End Sub
Public Shared Sub InvokeCommand(ByVal commandString As String, ByVal commandList As CommandList)
For Each commandInstance As CommandCall In InterpretCommand(commandString, commandList)
commandInstance.Invoke()
Next
End Sub
Public Shared Function InterpretCommand(ByVal commandString As String, ByVal commandList As CommandList) As IEnumerable(Of CommandCall)
'momentaner String-Index
Dim ind As Integer = 0
'string-Laenge
Dim count As Integer = commandString.Length
'Liste der auszufuehrenden Aufrufe
Dim output As ICollection(Of CommandCall) = New LinkedList(Of CommandCall)()
Dim currentCommand As Command = Nothing
Dim args As New List(Of String)(256)
Dim temp As String 'Zwischenspeicher fuer Bezeichner
While ind < count
If Char.IsWhiteSpace(commandString(ind)) Then 'Leerzeichen entfernen
ind += 1
ElseIf commandString(ind) = "\"c Then 'ist der momentane Buchstabe ein "\"c, so ist das nachfolgende Wort ein Bezeichner (auch \\ ist gueltig, usw.)
If currentCommand IsNot Nothing Then 'Bestehenden Aufruf einreihen und Argumenten-Liste leeren
output.Add(New CommandCall(currentCommand, args.ToArray()))
args.Clear()
End If
ind += 1
temp = ReadWord(commandString, ind) 'Kommando-Bezeichner lesen
currentCommand = commandList.Item(temp) 'Kommando ermitteln
If currentCommand Is Nothing Then
Throw New InvalidOperationException("Command """ + temp + """ was not found.")
End If
ElseIf currentCommand IsNot Nothing Then
args.Add(ReadWord(commandString, ind)) 'andere Faelle als Argument einreihen
Else
Throw New ArgumentException("Command expected before arguments.")
End If
End While
If currentCommand IsNot Nothing Then 'letzten Aufruf einreihen
output.Add(New CommandCall(currentCommand, args.ToArray()))
End If
Return output 'Aufrufe zurueckgeben
End Function
Public Shared Function ReadWord(ByVal input As String, ByRef index As Integer) As String
'ab dem ersten Nicht-Leerzeichen alle Nicht-Leerzeichen lesen
Dim count As Integer = input.Length
While index < count AndAlso Char.IsWhiteSpace(input(index))
index += 1
End While
If index < count Then
Dim startIndex As Integer = index
While index < count AndAlso Not Char.IsWhiteSpace(input(index))
index += 1
End While
Return input.Substring(startIndex, index - startIndex)
Else
Return Nothing
End If
End Function
Public Class CommandCall
Private ReadOnly _command As Command
Private ReadOnly _parameters() As String
Private ReadOnly _overload As System.Reflection.MethodInfo
Public ReadOnly Property Command As Command
Get
Return _command
End Get
End Property
Public ReadOnly Property Parameters() As String()
Get
Return _parameters
End Get
End Property
Public Sub Invoke()
_overload.Invoke(Nothing, _parameters)
End Sub
Public Sub New(ByVal command As Command, ByVal parameters() As String)
_command = command
_parameters = parameters
_overload = command.GetOverload(parameters.Length)
If _overload Is Nothing Then
Throw New ArgumentException("No command found that matches the specified parameter count.")
End If
End Sub
End Class
Public Class Command
Private ReadOnly _overloads As IDictionary(Of Integer, System.Reflection.MethodInfo)
Private ReadOnly _name As String
Public Sub AddOverload(ByVal method As System.Reflection.MethodInfo) 'Ueberladung fuer Kommando hinzufuegen
Dim param() As System.Reflection.ParameterInfo = method.GetParameters()
For i As Integer = 0 To param.Length - 1
If param(i).ParameterType <> GetType(String) Then
'oder Typ-Konversion zu String ueber TypeConverter oder dergleichen
Throw New ArgumentException("All method parameters have to derive from string.")
End If
Next
_overloads.Add(param.Length, method)
End Sub
Public Sub AddOverload(ByVal methodDelegate As [Delegate])
If methodDelegate.Target Is Nothing Then
AddOverload(methodDelegate.Method)
Else
'Delegaten mit Ziel-Instanz kann man ja noch unterstuetzen
Throw New ArgumentException("Cannot add targeted delegates.")
End If
End Sub
Public Function GetOverload(ByVal parameterCount As Integer) As System.Reflection.MethodInfo
GetOverload = Nothing
If Not _overloads.TryGetValue(parameterCount, GetOverload) Then
Return Nothing
End If
End Function
Public ReadOnly Property Name As String
Get
Return _name
End Get
End Property
Public Sub New(ByVal name As String)
If String.IsNullOrEmpty(name) OrElse ContainsWhitespaces(name) Then
Throw New ArgumentException("Name mustnot be null, empty or contain any whitespaces.")
End If
_overloads = New Dictionary(Of Integer, System.Reflection.MethodInfo)()
_name = name
End Sub
Public Sub New(ByVal name As String, ByVal ParamArray defaultOverloadMethods() As System.Reflection.MethodInfo)
Me.New(name)
For Each overload As System.Reflection.MethodInfo In defaultOverloadMethods
AddOverload(overload)
Next
End Sub
Public Sub New(ByVal name As String, ByVal ParamArray defaultOverloads() As [Delegate])
Me.New(name)
For Each overload As [Delegate] In defaultOverloads
AddOverload(overload)
Next
End Sub
Private Shared Function ContainsWhitespaces(ByVal value As String) As Boolean
For Each c As Char In value
If Char.IsWhiteSpace(c) Then
Return True
End If
Next
Return False
End Function
End Class
Public Class CommandList
Inherits System.Collections.ObjectModel.KeyedCollection(Of String, Command)
Protected Overrides Function GetKeyForItem(ByVal item As Command) As String
Return item.Name
End Function
Public Sub New()
MyBase.New(StringComparer.InvariantCulture)
End Sub
Public Sub New(ByVal ignoreCase As Boolean)
MyBase.New(If(ignoreCase, StringComparer.InvariantCultureIgnoreCase, StringComparer.InvariantCulture))
End Sub
End Class

Damit fällt die Vererbung weg und man hat auch sowas, wie einfache Überladungen der Aufrufe. Man könnte auch noch eine einfache Regel einführen, nach der Arrays gesondert behandelt werden oder wenn man es komplex machen will, könnte man die einzelnen Kommandos auch noch ineinander verschachteln, speziellere Ausdrücke einführen usw. Da kann man dann aber auch gleich was anständiges schreiben.

Übrigens: Contains überprüft, ob eine Zeichenkette eine andere Zeichenkette enthält. Folgende Aussagen sind somit alle gültig:

VB.NET-Quellcode

Debug.Assert("Hello World".Contains("Hello World"))
Debug.Assert(Not "Hello World".Contains("Hello World!"))
Debug.Assert("Hello World".Contains("llo Wor"))
Debug.Assert("\kick".Contains("\kick"))
Debug.Assert("böses \kick".Contains("\kick"))
Debug.Assert("\kicknochböser".Contains("\kick"))
Debug.Assert(Not "\KiCk".Contains("\kick"))

Gruß
~blaze~

Befehl erkennen

Befehl erkennen

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

VB.NET-Quellcode

Tags

Ähnliche Themen

4 Benutzer haben hier geschrieben