TCP texte senden

[lordfinal]

Hi,

ich habe zwar schon einiges beim suchen gefunden, aber da war bisher nichts dabei, was wenigstens im Ansatz funktionierte. Daher hab ich einen Code etwas umgeschrieben und er funktioniert fast, nur dass ich nur ein Wort schicken kann und danach nichts mehr. vlt kann mir jmd helfen.

Danke



Imports System.Net
Imports System.Net.Sockets
Imports System.Threading
Imports System.Text


Public Class Form1


Dim conn As TcpClient
Dim nstrm As System.IO.Stream
Dim sr As System.IO.StreamReader
Dim netBuff(1000 - 1) As Byte
Dim enc As New System.Text.UTF8Encoding
Dim dec As System.Text.Decoder
Dim listener As New TcpListener(Net.IPAddress.Any, 1738)





Sub New()

' Dieser Aufruf ist für den Windows Form-Designer erforderlich.
InitializeComponent()

' Fügen Sie Initialisierungen nach dem InitializeComponent()-Aufruf hinzu.
Dim mythread As Thread = New Thread(New ThreadStart(AddressOf Me.getData))
mythread.IsBackground = True
mythread.Priority = ThreadPriority.BelowNormal
mythread.Start()

End Sub




Public Sub getData()

If IsNothing(conn) Then
listener.Start()
conn = listener.AcceptTcpClient
nstrm = conn.GetStream()
dec = enc.GetDecoder
nstrm.BeginRead(netBuff, 0, 1000, AddressOf cbr, Nothing)
Else
MsgBox("Server running")
End If
End Sub


Private Delegate Sub setTextHandler(ByVal data As String)



Public Sub cbr(ByVal ar As IAsyncResult)

Dim cnt As Integer
Dim data As String
Dim chars() As Char
Dim carryOn As Boolean = True
Try

cnt = conn.GetStream.EndRead(ar)
Debug.WriteLine("Server Bytes read: " + cnt.ToString())
If cnt = 0 Then
carryOn = False
Else
ReDim chars(dec.GetCharCount(netBuff, 0, cnt) - 1)
dec.GetChars(netBuff, 0, cnt, chars, 0)
data = New String(chars, 0, chars.Length)
Debug.WriteLine("Data received: " + data.Length.ToString() + " chars: " + data)
txtresponse.Invoke(CType(AddressOf setText, setTextHandler), New String() {data})
Debug.WriteLine("Restart read request")
nstrm.BeginRead(netBuff, 0, 1000, AddressOf cbr, Nothing)
End If
Catch ex As System.Exception
Debug.WriteLine("Error: " + ex.Message)
carryOn = False
End Try
If Not carryOn Then
nstrm.Close()
conn.Close()
listener.Stop()
nstrm = Nothing
conn = Nothing
End If
End Sub

Private Sub setText(ByVal data As String)
txtresponse.AppendText(data)
Application.DoEvents()
End Sub


Private Sub start_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles start.Click
Dim data As [Byte]() = Encoding.ASCII.GetBytes(send.text)
conn = New TcpClient("localhost", 1738)
nstrm = conn.GetStream
nstrm.Write(data, 0, data.Length)

End Sub
End Class

[lordfinal]

So, da hier einige immer mal reingeschaut , aber nichts gepostet haben, interesiert es vlt den einen oder anderen.
Also ich habe jetzt statt einer Applikation zwei draus gemacht, aber das kann man nach belieben wieder rueckgaengig machen. Zum einen ist die Serverapplikation, die nichts weiter macht als einen Port auf und dann auf diesem zu lausche, ob sich jemand darauf befindet. Doch es ist nicht nur ein Thread der das bewerkstelligt, sondern ich benutze zwei. Der eine ist fuer die Darstellung verantworlich und der andere fuer das Polling auf der Tcpschnittstelle. Mehr mach der Server nicht.
Die Clientapplikation meldet sich sozusagen auf dem Server an und schreibt dann ueber den offenen Port immer wieder auf den Server. Aber auch hier gibt es zwei Threads, da der eine zum Schreiben auf die Tcp schnittstelle gebraucht wird und der andere wieder zur Darstellung.


Code vom Server : Imports System.Net.Sockets
Imports System.Text
Imports System.Threading


Public Class Form1
Delegate Sub AddTBTextTSActuallyDelegate(ByVal tb As TextBox, ByVal txt As String)
Private Sub listen()
Const portNumber As Integer = 8000
Dim tcpClient As TcpClient
Dim first As Boolean = True

Dim tcpListener As New TcpListener(portNumber)

tcpListener.Start()
'ausgabe.Text = "Warte..."
SyncLock Me
'Text in die TextBox des Threads ausgeben
AddTBTextTS(ausgabe, Thread.CurrentThread.Name + "Warte... " + vbNewLine)
End SyncLock
Try


tcpClient = tcpListener.AcceptTcpClient()
While True
If first Then

SyncLock Me
'Text in die TextBox des Threads ausgeben
AddTBTextTS(ausgabe, Thread.CurrentThread.Name + "Verbindung aufgebaut " + vbNewLine)
End SyncLock
End If

'ausgabe.Text = "Verbindung aufgebaut"

Dim networkStream As NetworkStream = tcpClient.GetStream
Dim bytes(tcpClient.ReceiveBufferSize) As Byte

networkStream.Read(bytes, 0, CInt(tcpClient.ReceiveBufferSize))

'Test ob etwas geschickt wurde
If bytes.Length <> 0 Then

Dim clientdata As String = Encoding.ASCII.GetString(bytes)

'ausgabe.Text = "Empfangen : " + clientdata
SyncLock Me
'Text in die TextBox des Threads ausgeben
AddTBTextTS(ausgabe, Thread.CurrentThread.Name + "Empfang: " + clientdata + vbNewLine)
End SyncLock
End If

If first Then

Dim response As String = "Verbunden mit Server"

Dim send As Byte() = Encoding.ASCII.GetBytes(response)
networkStream.Write(send, 0, send.Length)

'ausgabe.Text = "Gesendet : " + response
SyncLock Me
'Text in die TextBox des Threads ausgeben
AddTBTextTS(ausgabe, Thread.CurrentThread.Name + "Gesendet: " + response + vbNewLine)
End SyncLock
first = False
End If

Thread.Sleep(300)
End While
tcpClient.Close()
tcpListener.Stop()
'ausgabe.Text = "Alles zu "
SyncLock Me
'Text in die TextBox des Threads ausgeben
AddTBTextTS(ausgabe, Thread.CurrentThread.Name + "Alles zu " + vbNewLine)
End SyncLock
Catch ex As Exception
MessageBox.Show(ex.Message)

End Try
End Sub
Sub New()

' Dieser Aufruf ist für den Windows Form-Designer erforderlich.
InitializeComponent()

' Fügen Sie Initialisierungen nach dem InitializeComponent()-Aufruf hinzu.


End Sub

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

'Me.listen()


End Sub
'Dient zum Setzen einer Eigenschaft auf einer TextBox indirekt über Invoke
Private Sub AddTBTextTS(ByVal tb As TextBox, ByVal txt As String)
Dim locDel As New AddTBTextTSActuallyDelegate(AddressOf AddTBTextTSActually)

If Me.IsHandleCreated Then
Me.Invoke(locDel, New Object() {tb, txt})
End If

End Sub
Private Sub AddTBTextTSActually(ByVal tb As TextBox, ByVal txt As String)
tb.Text += txt
tb.SelectionStart = tb.Text.Length - 1
tb.ScrollToCaret()
End Sub

Private Sub b_start_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles b_start.Click
Dim mythread As Thread = New Thread(New ThreadStart(AddressOf Me.listen))
'mythread.IsBackground = True
mythread.Priority = ThreadPriority.BelowNormal
mythread.Start()
End Sub
End Class





Code vom Client




Imports System.Net.Sockets
Imports System.Text
Imports System.Threading

Public Class Form1
Private tcpclient As New TcpClient
Private netstream As NetworkStream

Delegate Sub SetTextCallback(ByVal [text] As String)
Private Sub netwrite()
Try



'While True
If netstream.CanRead And netstream.CanWrite Then
Dim send As Byte() = Encoding.ASCII.GetBytes(eingabe.text + vbNewLine)
netstream.Write(send, 0, send.Length)
Dim bytes(tcpclient.ReceiveBufferSize) As Byte
netstream.Read(bytes, 0, CInt(tcpclient.ReceiveBufferSize))
Dim returned As String = Encoding.ASCII.GetString(bytes)
Me.settext(returned)
Else
If Not netstream.CanWrite Then
Me.settext("kann nicht schreiben ")
tcpclient.Close()

End If
If Not netstream.CanRead Then
' Thread sicheres Schreiben die ThreadID wird vorher geprueft und bei bedarf Delegiert
Me.settext("kann nicht lesen")
tcpclient.Close()


End If
End If
'End While
Catch ex As Exception
MessageBox.Show(" Client sagt : " + ex.Message)
End Try

End Sub
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

tcpclient.Connect("localhost", 8000)
netstream = tcpclient.GetStream

End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
'Me.netwrite()
Dim mythread As Thread = New Thread(New ThreadStart(AddressOf Me.netwrite))
'mythread.IsBackground = True
mythread.Priority = ThreadPriority.BelowNormal
mythread.Start()


End Sub
Private Sub settext(ByVal [text] As String)
If Me.ausgabe.InvokeRequired Then
Dim d As New SetTextCallback(AddressOf settext)
Me.Invoke(d, New Object() {[text]})
Else
Me.ausgabe.Text = [text]
End If
End Sub
End Class



Im falle es gibt noch Fragen immer her damit ^^ viel Spass damit

[Tonkey]

Hallo, Ich habe keine Zeit, mich da im Detail reinzulesen.

Für den Fall es bringt was, stelle ich meine TCP-Routinen ein. Sie sind so konzipiert, daß sie Texte senden und empfangen. Sie sind halbwegs ausreichend kommentiert. Man kann sie zumindest als Beispiel nutzen.
Erst mal nur der Server, wegen der Zeichenbegrenzung im Forum auf 10000 Zeichen.



'String-Kommunikation über TCP-IP
'Modul Enthält Server-Klasse und Client-Klasse
'optimiert für Modbus-artige Kommunikation mit Funktionscodes

Imports system
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
Imports System.Net.NetworkInformation
Imports System.Threading
Imports System.Runtime.CompilerServices


'Funktionsweise des Servers:
'1. mit Init Server starten
'2. mit VerbindungPollen auf client warten (regelmäßig aufrufen)
'3. mit DatenVorhanden auf Daten prüfen (regelmäßig aufrufen)
'4. wenn Daten vorhanden mit Empfangen String einlesen
'5. mit Senden String senden
'6. mit VerbindungSchließen Verbindung zum Client kappen

'alle Funktionen sind nicht-blockierend, brauchen keine Zeit

'im Fehlerfall werden Werte < 0 oder Leerstrings zurückgegeben

Public Class IPStringKommuServer

Const MAX_TELEGRAMM_LEN As Integer = 10000

Public Const STX As Char = Chr(2)
Public Const ETX As Char = Chr(3)

Const ERR_NICHT_GESTARTET As Integer = -1
Const ERR_NICHT_VERBUNDEN As Integer = -2
Const ERR_SENDEN As Integer = -3
Const ERR_BEIM_VERBINDEN_MIT_CLIENT As Integer = -4
Const ERR_DATEN_LESEN As Integer = -5
Const ERR_SCHON_GESTARTET As Integer = -6
Const ERR_INIT As Integer = -7
Const ERR_SCHON_VERBUNDEN As Integer = -8


'Initialisiert den Server mit dem angegebenen Kanal und der optional angegebenen Adresse
'Ohne Angabe der Adresse wird eine Adresse gefunden und genommen.
'Vorsicht bei PCs mit mehreren Netzwerkkarten
<MethodImpl(MethodImplOptions.Synchronized)> _
Function Init(ByVal IPKanal As Integer, Optional ByVal IPAdresse As String = "") As Integer

If Not IsNothing(server) Then Return ERR_SCHON_GESTARTET

Try
If IPAdresse = "" Then
lokaleIP = HoleErstbesteLokaleIPAdresse()
Else
lokaleIP = IPAddress.Parse(IPAdresse)
End If
Kanal = IPKanal
server = New TcpListener(lokaleIP, IPKanal)
server.Start()

Catch 'Bei Fehler ist Verbindung nicht gestartet
server = Nothing
Return ERR_INIT

End Try

Return 0
End Function

'liefert, ob die Initialisierung des Objekts geglückt ist
Function gestartet() As Boolean
Return Not IsNothing(server)
End Function

'Liefert die lokale IP-Adresse, die der Server glaubt zu haben
'im Fehlerfall wird ein Leerstring zurückgeliefert
'Server muß initialisiert, aber nicht unbedingt verbunden sein
Function HoleIPAdresse() As String
If IsNothing(server) Then Return "" ' nicht initialisiert

If IsNothing(lokaleIP) Then
Return ""
Else
Try
Return lokaleIP.ToString()
Catch
Return ""
End Try
End If
End Function

'Wartet auf Verbindungsversuche durch einen Client.
'Return <0: Fehler; Return = 0: wartet; Return = 1: verbunden
<MethodImpl(MethodImplOptions.Synchronized)> _
Function VerbindungPollen() As Integer

'Test: Server nicht gestartet
If IsNothing(server) Then Return ERR_NICHT_GESTARTET

'Test: Server schon verbunden
If Not IsNothing(ip_client) AndAlso ip_client.Connected() Then Return ERR_SCHON_VERBUNDEN

'Test: keine Verbindungsanfrage vorhanden
If Not server.Pending() Then Return 0

'Jetzt ist Verbindungsanfrage vom Client da! Also verbinden.
Try
'TCPClient akzepieren (verbinden)
ip_client = server.AcceptTcpClient()
ip_stream = ip_client.GetStream()

Catch
ip_client = Nothing 'Verbindungsobjekte löschen
ip_stream = Nothing
Return ERR_BEIM_VERBINDEN_MIT_CLIENT

End Try

Return 1
End Function

'Abfrage Verbindung mit Client hergestellt
Function verbunden() As Boolean
If IsNothing(server) Then Return False
If IsNothing(ip_client) Then Return False
Return ip_client.Connected()
End Function

'Sendet Telegramm ab. Ohne Verbindung gibt es einen Fehlerwert
<MethodImpl(MethodImplOptions.Synchronized)> _
Function Senden(ByVal Telegramm As String) As Integer

If IsNothing(server) Then Return ERR_NICHT_GESTARTET

If Not verbunden() Then Return ERR_NICHT_VERBUNDEN

'Telegramm in ein Byte-Array konvertieren
Dim msg As Byte() = Encoding.ASCII.GetBytes(STX & Telegramm & ETX)

Try
ip_stream.Write(msg, 0, msg.Length) 'Byte-Array abschicken
Catch
Return ERR_SENDEN
End Try

Return 0
End Function

'Liefert, ob der Client Daten gesendet hat
<MethodImpl(MethodImplOptions.Synchronized)> _
Function DatenVorhanden() As Boolean

'ohne Initialisierung oder Verbindung raus
If IsNothing(server) OrElse Not verbunden() Then Return False

Try
Return ip_stream.DataAvailable()
Catch
Return False
End Try

End Function

'Liest Daten ein. Ohne Daten oder bei Fehler wird ein Leerstring zurückgegeben
<MethodImpl(MethodImplOptions.Synchronized)> _
Function Empfangen() As String

'ohne Initialisierung oder Verbindung raus
If IsNothing(server) OrElse Not verbunden() Then Return ""

Dim len As Int32 = 0
Dim InString As String
Dim arrString() As String 'String-Feld zur Aufnahme des gesplitteten Strings
Dim str As String 'Laufvariable

'Wenn Daten anstehen, diese einlesen
Try
If ip_stream.DataAvailable() Then
len = ip_stream.Read(tel_bytes, 0, tel_bytes.Length)
End If
Catch
len = 0
End Try

'nichts da, also raus
If len <= 0 Then Return ""

InString = Encoding.ASCII.GetString(tel_bytes, 0, len)

'String in Telegramme aufteilen mit STXund ETX als Trennzeichen
arrString = InString.Split(STXundETX, StringSplitOptions.RemoveEmptyEntries)
For Each str In arrString
Telegramme.Add(str) 'In die Liste der empfangenen Telegramme einfügen
Next

'wenn ein Telegramm empfangen wurde, dieses zurückgeben
If Telegramme.Count > 0 Then
Empfangen = Telegramme(0) 'Telegramm zurückgeben
Telegramme.RemoveAt(0) 'dann aus der Liste löschen
Exit Function 'dann Funktion verlassen
End If

'ohne verwertbares Telegramm "" zurückgeben
Return ""

End Function


'Kappt die Verbindung zum Client, aber der Server bleibt bestehen (wird per GarbageCollector entfernt)
<MethodImpl(MethodImplOptions.Synchronized)> _
Sub VerbindungSchließen()
Try
If Not IsNothing(ip_stream) Then ip_stream.Close()
If Not IsNothing(ip_client) Then ip_client.Close()
Catch
'Exception unterdrücken
End Try
End Sub


'private--------------------------------------------------------------------------------------

Private server As TcpListener = Nothing
Private lokaleIP As IPAddress = Nothing
Private Kanal As Integer
Private ip_client As TcpClient = Nothing
Private ip_stream As NetworkStream = Nothing
' Private InData As String

Private tel_bytes(MAX_TELEGRAMM_LEN) As Byte

'Holt, wie der Name schon sagt, die erstbeste IP-Adresse des lokalen PCs (es gibt auch PCs mit mehreren Karten, WLAN etc.)
'Im Fehlerfall wird 'localhost' also 127.0.0.1 zurückgegeben.
Private Function HoleErstbesteLokaleIPAdresse() As IPAddress
Try
Dim adapter As NetworkInterface = NetworkInterface.GetAllNetworkInterfaces()(0)
Dim adapterProperties As IPInterfaceProperties = adapter.GetIPProperties()
Dim uniCast As UnicastIPAddressInformation = adapterProperties.UnicastAddresses(0)
Return uniCast.Address
Catch
Return IPAddress.Parse("127.0.0.1")
End Try
End Function

Dim Telegramme As New List(Of String) 'Puffer für Strings
Dim STXundETX() As Char = {STX, ETX} 'Telegramm-Trenner

End Class

[Tonkey]

Und nun noch der Client:
Der Client steht im selben Modul wie der Server.


'Funktionsweise des Clients:
'1. mit Init() Verbindungsdaten Adresse und Kanal holen
'2. mit Verbinden() Verbindung zum Server herstellen
'3. mit Senden(() String senden
'4. mit DatenVorhanden auf Daten prüfen (regelmäßig aufrufen)
'5. mit Empfangen() String empfangen
'6. mit VerbindungSchließen() Verbindung beenden

'alle Funktionen sind nicht-blockierend, brauchen keine Zeit
'im Fehlerfall werden Werte < 0 oder Leerstrings zurückgegeben

Public Class IPStringKommuClient

Const MAX_TELEGRAMM_LEN As Integer = 10000

Public Const STX As Char = Chr(2)
Public Const ETX As Char = Chr(3)

Const ERR_UNGÜLTIGE_IPADRESSE As Integer = -1
Const ERR_VERBINDEN As Integer = -2
Const ERR_NICHT_VERBUNDEN As Integer = -3
Const ERR_DATEN_EMPFANGEN As Integer = -4

'Initialisiert den Client mit Port und Adresse des Servers
<MethodImpl(MethodImplOptions.Synchronized)> _
Function Init(ByVal Kanal As Integer, ByVal ServerIP As String) As Integer
Kanal1 = Kanal
Server_IP = ServerIP

'Teste IPAdresse
Try
IPAddress.Parse(ServerIP)
Return 1
Catch ex As Exception
Return ERR_UNGÜLTIGE_IPADRESSE
End Try
End Function

'Mit Server nach erfolgter Initialisierung verbinden
<MethodImpl(MethodImplOptions.Synchronized)> _
Function Verbinden() As Integer
Try
If Not verbunden() Then
ip_client = New TcpClient(Server_IP, Kanal1)
End If

If ip_client.Connected() Then
ip_stream = ip_client.GetStream()
Return 0 '0=kein Fehler beim Verbindungsaufbau
Else
Return ERR_VERBINDEN
End If

Catch
ip_client = Nothing
ip_stream = Nothing
Return ERR_VERBINDEN

End Try
End Function

'Liefert, ob der Client mit dem Server verbunden ist
Function verbunden() As Boolean
If IsNothing(ip_client) Then Return False
Return ip_client.Connected()
End Function

'Sendet einen Telegramm-String ab
'Liefert 1=ok, <0 Fehler
<MethodImpl(MethodImplOptions.Synchronized)> _
Function Senden(ByVal Telegramm As String) As Integer
Dim OutData(MAX_TELEGRAMM_LEN) As Byte

OutData = Encoding.ASCII.GetBytes(STX & Telegramm & ETX)

If verbunden() Then
Try
ip_stream.Write(OutData, 0, OutData.Length())
Return 1
Catch
Try
ip_stream.Close() 'vorbereiten für Neu-Aufbau
ip_client.Close()
Catch 'Exception ingnorieren
End Try
End Try
End If

'ggf. automatischer Verbindungsaufbau und erneuter Sendeversuch
If Not verbunden() Then
If Verbinden() < 0 Then
Return ERR_NICHT_VERBUNDEN
Else
Try
ip_stream.Write(OutData, 0, OutData.Length())
Return 1
Catch
Try
ip_stream.Close()
ip_client.Close()
Catch
End Try
Return ERR_NICHT_VERBUNDEN
End Try
End If
End If

End Function

'Test ob Empfangstelegramm vorhanden
<MethodImpl(MethodImplOptions.Synchronized)> _
Function DatenVorhanden() As Boolean
If Not verbunden() Then Return False
Try
Return ip_stream.DataAvailable()
Catch
Return False
End Try
End Function

'Empfangen eines evtl. vorhandenen Telegramms
<MethodImpl(MethodImplOptions.Synchronized)> _
Function Empfangen() As String

If Not verbunden() Then
Telegramme.Clear() 'Bei Verbindungsunterbrechung auch den Telegrammpuffer löschen
Return ""
End If

'Wenn noch ein altes Telegramm drinsteckt, dieses zurückgeben
If Telegramme.Count > 0 Then
Empfangen = Telegramme(0)
Telegramme.RemoveAt(0)
Exit Function
End If


Dim len As Int32
Dim InData(MAX_TELEGRAMM_LEN) As Byte
Dim InString As String
Dim arrString() As String 'String-Feld zur Aufnahme des gesplitteten Strings
Dim str As String 'Laufvariable

'Wenn Daten anstehen, diese einlesen
Try
If ip_stream.DataAvailable() Then
len = ip_stream.Read(InData, 0, InData.Length())
Else
Return ""
End If
Catch
Return ""
End Try

'Bytes nach String konvertieren
InString = System.Text.Encoding.ASCII.GetString(InData, 0, len)

'String in Telegramme aufteilen, mit ETX und STX den String aufsplitten
arrString = InString.Split(STXundETX, StringSplitOptions.RemoveEmptyEntries)
For Each str In arrString
Telegramme.Add(str) 'In die Liste der empfangenen Telegramme einfügen
Next

'wenn ein Telegramm empfangen wurde, dieses zurückgeben
If Telegramme.Count > 0 Then
Empfangen = Telegramme(0)
Telegramme.RemoveAt(0)
Exit Function
End If

'ohne Telegramm "" zurückgeben
Return ""

End Function

'Schließen der Verbindung zum Server
<MethodImpl(MethodImplOptions.Synchronized)> _
Sub VerbindungSchließen()
Try
If Not IsNothing(ip_stream) Then ip_stream.Close()
If Not IsNothing(ip_client) Then ip_client.Close()
Catch
ip_stream = Nothing
ip_client = Nothing
End Try
End Sub

'private--------------------------------------------------------------------------------------
Private Server_IP As String
Private Kanal1 As Integer
Private ip_client As TcpClient = Nothing
Private ip_stream As NetworkStream = Nothing

Dim Telegramme As New List(Of String) 'Puffer für Strings
Dim STXundETX() As Char = {STX, ETX} 'Telegramm-Trenner

End Class