[HaBo]

/* 
 * User: System.I/O
 * Date: 20.09.2006
 * Time: 18:40 
 * Version: 1.0.0
 */
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Tcp {
	public enum AcceptTypes {Socket,TcpClient};
	
	//---------------------------------------- EventHanlder ----------------------------------------	
	public delegate void SocketAcceptedEventHandler(Socket socket);
	public delegate void TcpClientAcceptedEventHandler(TcpClient client);
	
	
	public class Server	{
		//---------------------------------------- Konstruktoren ----------------------------------------	
		public Server(IPAddress ip, int port)	{
			this.listener		= new TcpListener(ip ,port);
			this.isListening	= false;
			this.stopListening	= false;			
			this.acceptType		= AcceptTypes.TcpClient;
		}
		
		
		//---------------------------------------- Events ----------------------------------------		
		public event SocketAcceptedEventHandler SocketAcceptedEvent;
				
		private void OnSocketAcceptedEvent(Socket socket) {	    	
	        if (SocketAcceptedEvent != null) {
	    		SocketAcceptedEvent(socket);
	        }
	    }
		
		public event TcpClientAcceptedEventHandler TcpClientAcceptedEvent;
				
		private void OnTcpClientAcceptedEvent(TcpClient client) {	    	
	        if (TcpClientAcceptedEvent != null) {
	    		TcpClientAcceptedEvent(client);
	        }
	    }
		
		
		//---------------------------------------- Datenfelder ----------------------------------------					
		private bool 			isListening;				
		private bool 			stopListening;
		private AcceptTypes		acceptType;
		private TcpListener		listener;
		private Thread 			listeningThread;
		
		
		//---------------------------------------- Eigenschaften ----------------------------------------		
		public bool IsListening {
			get { return this.isListening; }
		}
		
		public AcceptTypes AcceptType {
			get { return this.acceptType; }
			set {this.acceptType = value; }
		}
		
		
		//---------------------------------------- Methoden ----------------------------------------		
		public void Start()	{		
			this.listeningThread = new Thread(ListenAsThread);			
			this.listeningThread.Start();
		}
				
		public void Stop() {		
			this.stopListening = true;
			while(this.isListening) {
				Thread.Sleep(100);
			}			
			this.stopListening = false;
		}
				
		private void ListenAsThread() {			
			this.listener.Start();
			this.isListening = true;
			while(!stopListening) {
				if(!this.listener.Pending()) {
					Thread.Sleep(100);
					continue;
				}
				try {
					if(this.acceptType == AcceptTypes.Socket)
						this.listener.BeginAcceptSocket(new AsyncCallback(AcceptSocketCallback), this.listener);
					else
						this.listener.BeginAcceptTcpClient(new AsyncCallback(AcceptTcpClientCallback), this.listener);
				}
				catch(SocketException) {}
				
			}	
			this.listener.Stop();
			this.isListening = false;
		}
		
		
		//---------------------------------------- Callbacks ----------------------------------------
		private void AcceptSocketCallback(IAsyncResult ar) {	
			try {
				TcpListener listener = (TcpListener) ar.AsyncState;
			    Socket socket = listener.EndAcceptSocket(ar);
			    OnSocketAcceptedEvent(socket);
			}
			catch(SocketException) {}
		}

		private void AcceptTcpClientCallback(IAsyncResult ar) {	
			try {
				TcpListener listener = (TcpListener) ar.AsyncState;
			    TcpClient client = listener.EndAcceptTcpClient(ar);
			    OnTcpClientAcceptedEvent(client);
			}
			catch(SocketException) {}
		}
		
	}
}

Imports System
Imports System.IO
Imports System.Net
Imports System.Net.Sockets
Imports System.Text
Imports Microsoft.VisualBasic


Class MyTcpListener

    Public Shared Sub Main()

	Dim server As TcpListener
	server=nothing
        Try
            ' Set the TcpListener on port 13000.
         Dim port As Int32 = 13000
         Dim localAddr As IPAddress = IPAddress.Parse("127.0.0.1")

         server = New TcpListener(localAddr, port)
         
         ' Start listening for client requests.
         server.Start()
         
         ' Buffer for reading data
            Dim bytes(1024) As Byte
            Dim data As String = Nothing
         
         ' Enter the listening loop.
         While True
            Console.Write("Waiting for a connection... ")
            
            ' Perform a blocking call to accept requests.
            ' You could also user server.AcceptSocket() here.
            Dim client As TcpClient = server.AcceptTcpClient()
            Console.WriteLine("Connected!")
            
            data = Nothing
            
            ' Get a stream object for reading and writing
            Dim stream As NetworkStream = client.GetStream()
            
            Dim i As Int32
            
            ' Loop to receive all the data sent by the client.
            i = stream.Read(bytes, 0, bytes.Length)
            While (i <> 0) 
               ' Translate data bytes to a ASCII string.
               data = System.Text.Encoding.ASCII.GetString(bytes, 0, i)
                    Console.WriteLine("Received: {0}", data)
               
               ' Process the data sent by the client.
               data = data.ToUpper()
                    Dim msg As Byte() = System.Text.Encoding.ASCII.GetBytes(data)
               
               ' Send back a response.
               stream.Write(msg, 0, msg.Length)
                    Console.WriteLine("Sent: {0}", data)
              
               i = stream.Read(bytes, 0, bytes.Length)

            End While
            
            ' Shutdown and end connection
            client.Close()
         End While
      Catch e As SocketException
         Console.WriteLine("SocketException: {0}", e)
      Finally
         server.Stop()
      End Try
      
      Console.WriteLine(ControlChars.Cr + "Hit enter to continue....")
      Console.Read()
   End Sub 'Main

End Class 'MyTcpListener

Public server As New System.Net.Sockets.TcpListener(System.Net.IPAddress.Any, 26000)    

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnStarten.Click
        server.Start()
        lblStatus.Text = "Server gestartet"
        While (true)
             If server.Pading() Then
                  Dim client As System.Net.Sockes.TcpClient = server.AcceptTcpClient()
                  Dim netStream As System.Net.Sockets.NetworkStream = client.GetStream()
                 
                  Dim readBuffer(1024) As Byte
                  Dim message As StringBuilder = New StringBuilder()
                  Dim bytesReaded As Integer = 0
   
                  ' Incoming message may be larger than the buffer size.
                  Do
                         bytesReaded = netStream.Read(readBuffer, 0, readBuffer.Length)
                         message.AppendFormat("{0}", Encoding.ASCII.GetString(readBuffer, 0, bytesReaded))
                  Loop While netStream.DataAvailable
   
                  ' Print out the received message to the console.
                  lblStatus.Text = "You received the following message : " + message.ToString() 
                  
                  Dim writeBuffer As Byte() = Encoding.ASCII.GetBytes("hier ist der server")
                  netStream.Write(writeBuffer, 0,writeBuffer.Length)
                  netStream.Close()
                  client.Close()
                  server.Stop()
                  break;
             Else
                  System.Threading.Thread.Sleep(10)                    
             End If     
        End While
    End Sub

Private Sub btnVerbinden_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnVerbinden.Click

        If txtIP.Text = "" Then
            MsgBox("Bitte eine IP eingeben")
            Exit Sub
        End If
        If txtPort.Text = "" Then
            MsgBox("Bitte einen Port eingeben")
            Exit Sub
        End If
        Try
            'Uses the IP address and port number to establish a socket connection.
            Dim tcpClient As New TcpClient
            Dim ipAddress As IPAddress = Dns.GetHostEntry(txtIP.Text).AddressList(0)
            tcpClient.Connect(ipAddress,  Convert.ToInt32(txtPort.Text))

            Dim netStream As NetworkStream = tcpClient.GetStream()
            Dim writeBuffer As Byte() = Encoding.ASCII.GetBytes("hallo, hier is der client")
            netStream.Write(writeBuffer, 0,writeBuffer.Length)
            
            Dim readBuffer(1024) As Byte
            Dim message As StringBuilder = New StringBuilder()
            Dim bytesReaded As Integer = 0
   
            ' Incoming message may be larger than the buffer size.
            Do
                  bytesReaded = netStream.Read(readBuffer, 0, readBuffer.Length)
                  message.AppendFormat("{0}", Encoding.ASCII.GetString(readBuffer, 0, bytesReaded))
            Loop While netStream.DataAvailable
   
            ' Print out the received message to the console.
            MsgBox("You received the following message : " + message.ToString()) 

            netStream.Close()
            tcpClient.Close()
        Catch ex As Exception
            MsgBox("Fehlermeldung")
        End Try

    End Sub