Imports System
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
Imports Microsoft.VisualBasic
 
Public Class frmSynchronousSocketDemo
 
    Dim txtMsg As New TextBox With _
        {.Parent = Me, .Width = 200, .Height = 200, .Multiline = True}
 
    Dim WithEvents btnServer As New Button With _
        {.Parent = Me, .Text = "Start Server", .Top = 210, .Width = 100}
 
    Dim WithEvents btnClient As New Button With _
        {.Parent = Me, .Text = "Send Message", _
         .Top = 210, .Left = 110, .Width = 100}
 
    Dim WithEvents server As SynchronousSocketListenerServer
    Dim client As SynchronousSocketListenerClient
 
    Dim IsServerActive As Boolean
 
    Private Delegate Sub StringDelegate(ByVal str As String)
 
    Dim serverthread As Threading.Thread
    Dim ClientThread as Threading.Thread
 
    Private Sub btnServer_Click(sender As System.Object, _
            e As System.EventArgs) Handles btnServer.Click
 
        If IsServerActive Then
            MsgBox("Der Server ist bereits aktiv") : Exit Sub
        End If
 
        'Server-Instanz starten
        Me.Text = "Gestartet als Server"
        server = New SynchronousSocketListenerServer
        Dim threadstart As New Threading.ThreadStart(AddressOf server.Listen)
        serverthread = New Threading.Thread(threadstart)
        IsServerActive = True
        btnClient.Enabled = False
        serverthread.Start()
    End Sub
 
 
    Private Sub btnClient_Click(sender As System.Object, _
        e As System.EventArgs) Handles btnClient.Click
 
        Me.Text = "Gestartet als Client"
 
        'Text als Nachricht vom Client an den Server senden
        client = New SynchronousSocketListenerClient
        client.TextToSend = txtMsg.Text
        btnServer.Enabled = False
        Dim threadstart As New Threading.ThreadStart(AddressOf client.Send)
        clientthread = New Threading.Thread(threadstart)
        clientthread.Start()
    End Sub
 
 
    Private Sub server_Received(msg As String) Handles server.Received
        'Server hat eine Nachricht empfangen
        Me.Invoke(New StringDelegate(AddressOf ShowMessage), msg)
    End Sub
 
 
    Private Sub ShowMessage(ByVal msg As String)
        txtMsg.Text = "Empfangene Nachricht  " & vbcrlf & _
            Now.ToString & vbCrLf & msg
    End Sub
 
 
    Private Sub frmSynchronousSocketDemo_FormClosing(sender As Object, _
        e As System.Windows.Forms.FormClosingEventArgs) Handles Me.FormClosing
        If IsServerActive Then server.Dispose()
    End Sub
End Class

Imports System
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
 
Public Class SynchronousSocketListenerClient
 
    Public Property TextToSend As String
 
    Public Sub Send()
 
        Const endchars As String = _
             SynchronousSocketListenerServer.endchars
 
        Dim mml As Integer = _
             SynchronousSocketListenerServer.MaxMessageLength
 
        Dim bytes(mml) As Byte
 
        ' Connect to a remote device.
 
        ' Establish the remote endpoint for the socket.
        ' This example uses port 11000 on the local computer.
        Dim ipHostInfo As IPHostEntry = Dns.GetHostEntry(Dns.GetHostName())
        Dim ipAddress As IPAddress = ipHostInfo.AddressList(2)
        Dim remoteEP As New IPEndPoint(ipAddress, 11000)
 
 
        Dim msg() As Byte
        Dim text As String, tl As Integer = TextToSend.Length + 1
        Do
            tl -= 1
            text = TextToSend.Substring(0, tl)
            If String.IsNullOrEmpty(text) Then
                text = "Leere Botschaft"
            End If
 
            If Not text.EndsWith(endchars) Then
                text &= endchars
            End If
            msg = Encoding.ASCII.GetBytes(text)
        Loop While msg.Length > mml
 
 
        Dim sender As Socket = Nothing
        Dim bytesrec As Integer
        Try
            ' Create a TCP/IP socket.
            sender = New Socket(AddressFamily.InterNetwork, _
                SocketType.Stream, ProtocolType.Tcp)
 
            ' Connect the socket to the remote endpoint.
            sender.Connect(remoteEP)
 
            ' Send the data through the socket.
            Dim bytesSent As Integer = sender.Send(msg)
            ' Receive the response from the remote device.
            bytesrec = sender.Receive(bytes)
        Catch ex As Exception
            MessageBox.Show(ex.Message)
        End Try
 
        ' Release the socket.
        If sender IsNot Nothing Then
            If sender.Connected Then
                sender.Shutdown(SocketShutdown.Both)
            End If
            sender.Close()
        End If
    End Sub
End Class 'SynchronousSocketClient

Imports System
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
 
Class SynchronousSocketListenerServer
    Implements IDisposable
 
    Public Event Received(ByVal msg As String)
    Public Property data As String = Nothing
 
    Private handler As Socket
    Private Listener As Socket
    Private IsListening As Boolean
 
    Public Const endchars As String = "<EOF>"
    Public Const MaxMessageLength As Integer = 2048
 
 
    Public Sub Listen()
 
        ' Data buffer for incoming data.
        Dim bytes() As Byte
 
        ' Establish the local endpoint for the socket.
        Dim ipHostInfo As IPHostEntry = Dns.GetHostEntry(Dns.GetHostName())
        Dim ipAddress As IPAddress = ipHostInfo.AddressList(2)
        Dim localEndPoint As New IPEndPoint(ipAddress, 11000)
 
        Try
            ' Create a TCP/IP socket.
            Listener = New Socket(AddressFamily.InterNetwork, _
                SocketType.Stream, ProtocolType.Tcp)
 
            ' Bind the socket to the local endpoint and 
            ' listen for incoming connections.
            Listener.Bind(localEndPoint)
            Listener.Listen(10)
            IsListening = True
        Catch ex As Exception
            MessageBox.Show(ex.Message)
            Exit Sub
        End Try
 
        ' Start listening for connections.
        While IsListening
            ' Program is suspended while waiting for an incoming connection.
            Try
                handler = Listener.Accept
                data = Nothing
                ' An incoming connection needs to be processed.
                While True
                    bytes = New Byte(MaxMessageLength) {}
                    Dim bytesRec As Integer = handler.Receive(bytes)
                    data += Encoding.ASCII.GetString(bytes, 0, bytesRec)
                    If data.IndexOf(endchars) > -1 Then
                        Exit While
                    End If
                End While
 
                data = data.Substring(0, data.Length - endchars.Length)
                RaiseEvent Received(data)
 
                ' Echo the data back to the client.
                Dim msg As Byte() = Encoding.ASCII.GetBytes(data)
 
                handler.Send(msg)
                handler.Shutdown(SocketShutdown.Both)
                handler.Close()
            Catch
                'wegen Beendigung beim Dispose
            End Try
        End While
    End Sub
 
 
#Region "IDisposable Support"
    Private disposedValue As Boolean
 
    Protected Overridable Sub Dispose(disposing As Boolean)
        If Not Me.disposedValue Then
            If disposing Then
                IsListening = False
                If Listener IsNot Nothing Then
                    If Listener.Connected Then Listener.Disconnect(False)
                End If
                Listener.Dispose()
            End If
        End If
        Me.disposedValue = True
    End Sub
 
    Public Sub Dispose() Implements IDisposable.Dispose
        Dispose(True)
        GC.SuppressFinalize(Me)
    End Sub
#End Region
 
End Class