My Socket Wrapper With Multi Threading and Events Similar to Classic Winsock

Imports System.Net.Sockets
Imports System.Net
Imports System.Text
Imports System.Threading
Public Class mysocket
    Private _listener As Socket
    Private listenThread As Thread

    Private client As Socket
    Private readThread As Thread
    Private connectThread As Thread
    Private sendThread As Thread

    Private _localport As Integer
    Private _remoteport As Integer
    Private _remoteIP As String


    Private data() As Byte
    Private Const ByteSize As Integer = 1024
    Private _Status As Integer
    Public ReadOnly Property Status()
        Get
            Return _Status
        End Get
    End Property
    Public Event OnConnectionRequest(ByVal client As Socket)
    Public Event OnDisconnection()
    Public Event OnConnect()
    Public Event OnDataArrival(ByVal bytesize As Integer)
    Public Event OnSendComplete(ByVal bytessent As Integer)
    Public Event OnError(ByVal errmsg As String)


    Public Sub New()
        ReDim data(ByteSize - 1)
        _Status = 0
    End Sub
    Public Property LocalPort() As Integer
        Get
            Return Me._localport
        End Get
        Set(ByVal value As Integer)
            Me._localport = value
        End Set
    End Property
    Public Property RemotePort() As Integer
        Get
            Return Me._remoteport
        End Get
        Set(ByVal value As Integer)
            Me._remoteport = value
        End Set
    End Property
    Public Property RemoteIP() As String
        Get
            Return Me._remoteIP
        End Get
        Set(ByVal value As String)
            Me._remoteIP = value
        End Set
    End Property


    Public Sub Listen()
        Try
            _listener = New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
            Dim IEP As IPEndPoint = New IPEndPoint(IPAddress.Any, Me._localport)
            _listener.Bind(IEP)
            _listener.Listen(100)
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
        _listener.BeginAccept(New AsyncCallback(AddressOf WaitConnections), _listener)

        listenThread = New Thread(AddressOf WaitConnections)
        listenThread.IsBackground = True
        listenThread.Start()

    End Sub
    Private Sub WaitConnections(ByVal iar As IAsyncResult)
        Try
            Dim tmpsoc As Socket = DirectCast(iar.AsyncState, Socket)
            Dim mclient As Socket = tmpsoc.EndAccept(iar)
            RaiseEvent OnConnectionRequest(mclient)
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
            Try
                Me._listener.BeginAccept(New AsyncCallback(AddressOf WaitConnections), _listener)
                Return
            Catch ex1 As Exception
                RaiseEvent OnError(ex1.ToString)
            End Try
        End Try
        Try
            Me._listener.BeginAccept(New AsyncCallback(AddressOf WaitConnections), _listener)
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub

    Public Sub Accept(ByVal newclient As Socket)
        Try
            Me.client = newclient
            Me.client.BeginReceive(data, 0, ByteSize, SocketFlags.None, New AsyncCallback(AddressOf ReceiveData), Me.client)
            readThread = New Thread(AddressOf ReceiveData)
            readThread.IsBackground = True
            readThread.Start()
            _Status = 1   ' Connected
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub

    Private Sub ReceiveData(ByVal iar As IAsyncResult)
        Try
            Try
                Me.client = DirectCast(iar.AsyncState, Socket)
                Dim SE As SocketError = New SocketError
                If Me.client.Connected Then
                    Dim datalen As Integer = Me.client.EndReceive(iar, SE)
                    If SE = SocketError.Success And datalen <> 0 Then
                        RaiseEvent OnDataArrival(datalen)
                        Me.client.BeginReceive(data, 0, ByteSize, SocketFlags.None, New AsyncCallback(AddressOf ReceiveData), Me.client)
                    Else
                        _Status = 0  ' Disconnected
                        RaiseEvent OnDisconnection()
                    End If
                Else
                    _Status = 0  ' Disconnected
                    RaiseEvent OnDisconnection()
                End If
            Catch ex As Exception
                RaiseEvent OnError(ex.ToString)
            End Try
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub
    Public Sub GetData(ByRef buffer() As Byte, ByVal bytestotal As Integer)
        ReDim buffer(bytestotal - 1)
        System.Buffer.BlockCopy(Me.data, 0, buffer, 0, bytestotal)
    End Sub

    '' Client
    Public Sub Connect()
        Me.client = New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
        Dim iep As New IPEndPoint(IPAddress.Parse(Me._remoteIP), Me._remoteport)
        client.BeginConnect(iep, New AsyncCallback(AddressOf Connected), client)

        connectThread = New Thread(AddressOf Connected)
        connectThread.IsBackground = True
        connectThread.Start()

    End Sub

    Private Sub Connected(ByVal iar As IAsyncResult)
        Try
            Me.client = DirectCast(iar.AsyncState, Socket)
            Me.client.EndConnect(iar)
            client.BeginReceive(data, 0, ByteSize, SocketFlags.None, New AsyncCallback(AddressOf ReceiveData), client)

            _Status = 1  ' Connected

            RaiseEvent OnConnect()
            readThread = New Thread(AddressOf ReceiveData)
            readThread.IsBackground = True
            readThread.Start()

        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub

    Public Sub SendData(ByVal buffer() As Byte)
        Try
            If client.Connected Then
                Me.client.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, New AsyncCallback(AddressOf SendComplete), Me.client)
                sendThread = New Thread(AddressOf SendComplete)
                sendThread.IsBackground = True
                sendThread.Start()
            Else
            End If
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub
    Private Sub SendComplete(ByVal iar As IAsyncResult)
        Dim sent As Integer = 0
        Try
            Dim remote As Socket = DirectCast(iar.AsyncState, Socket)
            sent = remote.EndSend(iar)
            RaiseEvent OnSendComplete(sent)
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub
    Public Sub Close()
        Try
            Me.client.Close()
            RaiseEvent OnDisconnection()
            _Status = 0  ' Disconnected
            Try
                listenThread.Abort()
                readThread.Abort()
                connectThread.Abort()
                sendThread.Abort()

            Catch ex As Exception
                RaiseEvent OnError(ex.ToString)
            End Try
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub
    Public Sub StopListen()
        Try
            Me._listener.Close()
            RaiseEvent OnDisconnection()
            _Status = 0  ' Disconnected
            Try
                listenThread.Abort()
            Catch ex As Exception
                RaiseEvent OnError(ex.ToString)
            End Try
        Catch ex As Exception
            RaiseEvent OnError(ex.ToString)
        End Try
    End Sub
End Class

Imports System.Text
Public Class Form1
    Private WithEvents myserver As mysocket = New mysocket
    Private WithEvents myclient As mysocket = New mysocket
    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        myserver.LocalPort = 43001
        myserver.Listen()
    End Sub

    Private Sub OnConnectionRequest(ByVal client As System.Net.Sockets.Socket) Handles myserver.OnConnectionRequest
        myclient.Accept(client)
    End Sub


    Private Sub OnDataArrival(ByVal bytesize As Integer) Handles myclient.OnDataArrival
        Dim buffer() As Byte = {}
        myclient.GetData(buffer, bytesize)
        MsgBox("From client=>" & Encoding.ASCII.GetString(buffer))
    End Sub
    Private Sub OnDisconnect() Handles myclient.OnDisconnection
        MsgBox("client was disconnected !!!")
    End Sub

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
        If myclient.Status = 1 Then
            myclient.SendData(Encoding.ASCII.GetBytes(Me.TextBox1.Text))
        End If
    End Sub

    Private Sub SendCompete(ByVal bytessent As Integer) Handles myclient.OnSendComplete
        MsgBox("Send complete from server=> " & bytessent)
    End Sub

    Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
        myclient.Close()
    End Sub

    Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click
        myserver.StopListen()
    End Sub
End Class

using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Net.Sockets;
using System.Net;
using System.Text;
using System.Threading;
public class mysocket
{
	private Socket _listener;

	private Thread listenThread;
	private Socket client;
	private Thread readThread;
	private Thread connectThread;

	private Thread sendThread;
	private int _localport;
	private int _remoteport;

	private string _remoteIP;

	private byte[] data;
	private const int ByteSize = 1024;
	private int _Status;
	public object Status {
		get { return _Status; }
	}
	public event OnConnectionRequestEventHandler OnConnectionRequest;
	public delegate void OnConnectionRequestEventHandler(Socket client);
	public event OnDisconnectionEventHandler OnDisconnection;
	public delegate void OnDisconnectionEventHandler();
	public event OnConnectEventHandler OnConnect;
	public delegate void OnConnectEventHandler();
	public event OnDataArrivalEventHandler OnDataArrival;
	public delegate void OnDataArrivalEventHandler(int bytesize);
	public event OnSendCompleteEventHandler OnSendComplete;
	public delegate void OnSendCompleteEventHandler(int bytessent);
	public event OnErrorEventHandler OnError;
	public delegate void OnErrorEventHandler(string errmsg);


	public mysocket()
	{
		data = new byte[ByteSize];
		_Status = 0;
	}
	public int LocalPort {
		get { return this._localport; }
		set { this._localport = value; }
	}
	public int RemotePort {
		get { return this._remoteport; }
		set { this._remoteport = value; }
	}
	public string RemoteIP {
		get { return this._remoteIP; }
		set { this._remoteIP = value; }
	}


	public void Listen()
	{
		try {
			_listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			IPEndPoint IEP = new IPEndPoint(IPAddress.Any, this._localport);
			_listener.Bind(IEP);
			_listener.Listen(100);
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
		_listener.BeginAccept(new AsyncCallback(WaitConnections), _listener);

		listenThread = new Thread(WaitConnections);
		listenThread.IsBackground = true;
		listenThread.Start();

	}
	private void WaitConnections(IAsyncResult iar)
	{
		try {
			Socket tmpsoc = (Socket)iar.AsyncState;
			Socket mclient = tmpsoc.EndAccept(iar);
			if (OnConnectionRequest != null) {
				OnConnectionRequest(mclient);
			}
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
			try {
				this._listener.BeginAccept(new AsyncCallback(WaitConnections), _listener);
				return;
			} catch (Exception ex1) {
				if (OnError != null) {
					OnError(ex1.ToString());
				}
			}
		}
		try {
			this._listener.BeginAccept(new AsyncCallback(WaitConnections), _listener);
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}

	public void Accept(Socket newclient)
	{
		try {
			this.client = newclient;
			this.client.BeginReceive(data, 0, ByteSize, SocketFlags.None, new AsyncCallback(ReceiveData), this.client);
			readThread = new Thread(ReceiveData);
			readThread.IsBackground = true;
			readThread.Start();
			_Status = 1;
			// Connected
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}

	private void ReceiveData(IAsyncResult iar)
	{
		try {
			try {
				this.client = (Socket)iar.AsyncState;
				SocketError SE = new SocketError();
				if (this.client.Connected) {
					int datalen = this.client.EndReceive(iar, out SE);
					if (SE == SocketError.Success & datalen != 0) {
						if (OnDataArrival != null) {
							OnDataArrival(datalen);
						}
						this.client.BeginReceive(data, 0, ByteSize, SocketFlags.None, new AsyncCallback(ReceiveData), this.client);
					} else {
						_Status = 0;
						// Disconnected
						if (OnDisconnection != null) {
							OnDisconnection();
						}
					}
				} else {
					_Status = 0;
					// Disconnected
					if (OnDisconnection != null) {
						OnDisconnection();
					}
				}
			} catch (Exception ex) {
				if (OnError != null) {
					OnError(ex.ToString());
				}
			}
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}
	public void GetData(ref byte[] buffer, int bytestotal)
	{
		buffer = new byte[bytestotal];
		System.Buffer.BlockCopy(this.data, 0, buffer, 0, bytestotal);
	}

	//' Client
	public void Connect()
	{
		this.client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
		IPEndPoint iep = new IPEndPoint(IPAddress.Parse(this._remoteIP), this._remoteport);
		client.BeginConnect(iep, new AsyncCallback(Connected), client);

		connectThread = new Thread(Connected);
		connectThread.IsBackground = true;
		connectThread.Start();

	}

	private void Connected(IAsyncResult iar)
	{
		try {
			this.client = (Socket)iar.AsyncState;
			this.client.EndConnect(iar);
			client.BeginReceive(data, 0, ByteSize, SocketFlags.None, new AsyncCallback(ReceiveData), client);

			_Status = 1;
			// Connected

			if (OnConnect != null) {
				OnConnect();
			}
			readThread = new Thread(ReceiveData);
			readThread.IsBackground = true;
			readThread.Start();

		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}

	public void SendData(byte[] buffer)
	{
		try {
			if (client.Connected) {
				this.client.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendComplete), this.client);
				sendThread = new Thread(SendComplete);
				sendThread.IsBackground = true;
				sendThread.Start();
			} else {
			}
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}
	private void SendComplete(IAsyncResult iar)
	{
		int sent = 0;
		try {
			Socket remote = (Socket)iar.AsyncState;
			sent = remote.EndSend(iar);
			if (OnSendComplete != null) {
				OnSendComplete(sent);
			}
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}
	public void Close()
	{
		try {
			this.client.Close();
			if (OnDisconnection != null) {
				OnDisconnection();
			}
			_Status = 0;
			// Disconnected
			try {
				listenThread.Abort();
				readThread.Abort();
				connectThread.Abort();
				sendThread.Abort();

			} catch (Exception ex) {
				if (OnError != null) {
					OnError(ex.ToString());
				}
			}
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}
	public void StopListen()
	{
		try {
			this._listener.Close();
			if (OnDisconnection != null) {
				OnDisconnection();
			}
			_Status = 0;
			// Disconnected
			try {
				listenThread.Abort();
			} catch (Exception ex) {
				if (OnError != null) {
					OnError(ex.ToString());
				}
			}
		} catch (Exception ex) {
			if (OnError != null) {
				OnError(ex.ToString());
			}
		}
	}
}

using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Text;
public class Form1
{
	private mysocket withEventsField_myserver = new mysocket();
	private mysocket myserver {
		get { return withEventsField_myserver; }
		set {
			if (withEventsField_myserver != null) {
				withEventsField_myserver.OnConnectionRequest -= OnConnectionRequest;
			}
			withEventsField_myserver = value;
			if (withEventsField_myserver != null) {
				withEventsField_myserver.OnConnectionRequest += OnConnectionRequest;
			}
		}
	}
	private mysocket withEventsField_myclient = new mysocket();
	private mysocket myclient {
		get { return withEventsField_myclient; }
		set {
			if (withEventsField_myclient != null) {
				withEventsField_myclient.OnDataArrival -= OnDataArrival;
				withEventsField_myclient.OnDisconnection -= OnDisconnect;
				withEventsField_myclient.OnSendComplete -= SendCompete;
			}
			withEventsField_myclient = value;
			if (withEventsField_myclient != null) {
				withEventsField_myclient.OnDataArrival += OnDataArrival;
				withEventsField_myclient.OnDisconnection += OnDisconnect;
				withEventsField_myclient.OnSendComplete += SendCompete;
			}
		}
	}
	private void Button1_Click(System.Object sender, System.EventArgs e)
	{
		myserver.LocalPort = 43001;
		myserver.Listen();
	}

	private void OnConnectionRequest(System.Net.Sockets.Socket client)
	{
		myclient.Accept(client);
	}


	private void OnDataArrival(int bytesize)
	{
		byte[] buffer = {
			
		};
		myclient.GetData(buffer, bytesize);
		Interaction.MsgBox("From client=>" + Encoding.ASCII.GetString(buffer));
	}
	private void OnDisconnect()
	{
		Interaction.MsgBox("client was disconnected !!!");
	}

	private void Button2_Click(System.Object sender, System.EventArgs e)
	{
		if (myclient.Status == 1) {
			myclient.SendData(Encoding.ASCII.GetBytes(this.TextBox1.Text));
		}
	}

	private void SendCompete(int bytessent)
	{
		Interaction.MsgBox("Send complete from server=> " + bytessent);
	}

	private void Button3_Click(System.Object sender, System.EventArgs e)
	{
		myclient.Close();
	}

	private void Button4_Click(System.Object sender, System.EventArgs e)
	{
		myserver.StopListen();
	}
}

Imports System.Text
Imports System.Array
Imports System.Net.Sockets


Module modTCP
    Public ListeningPort As Integer                     ' The port where proxy will listen the incoming connection from client(Conquer)
    Public LoginServerIP As String                      ' The login server IP

    Dim WithEvents ListenerSoc As As mysocket = New mysocket
    Dim Clients As List(Of ClientConnection)

    Public Sub StartListen()
        ListenerSoc.LocalPort = ListeningPort
        ListenerSoc.Listen()
        LogEvents("Waiting for connection at port " & ListeningPort)
    End Sub

    Private Sub OnConnectionReq(ByVal _tcpclient As Socket) Handles ListenerSoc.OnConnectionRequest

	LogEvents("Client => " & _tcpclient.ToString & " is requesting for connection", Now.ToString)
        Dim fromClientSoc As mysocket = New mysocket
        Dim connClient As New ClientConnection(fromClientSoc, _tcpclient)
        AddHandler connClient.AuthenticationConnClose, AddressOf OnAuthenticationClose
        ' You can add more event here for client connection class

        Clients.Add(connClient)
    End Sub

    Private Sub OnAuthenticationClose(ByVal cclient As clsAuthConnection)
        LogEvents("Class Container for authentication connection " & cclient.SocConnection.ToString & " has been removed", Now.ToString)
        Clients.Remove(cclient)
    End Sub

    Public Sub LogEvents(ByVal msg As String, ByVal _time As String)
        frmMain.mLogEvents(msg, _time)
    End Sub
End Module

Class ClientConnection
    Public listofLogs As New List(Of log)
    Public WithEvents ClientProxySoc As As mysocket = New mysocket
    Public Event AuthenticationConnClose(ByVal cclient As clsAuthConnection)

    Public Sub New(ByVal client As mysocket, ByVal _tcpclient As Socket)
        ClientProxySoc = client
        ClientProxySoc.Accept(_tcpclient)

        ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        ' For conquer proxy you can initialize here the authentication encryption
        ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''   

       
        ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
        ' For conquer proxy you can add here the socket that will connect to the game server
        ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''   
    End Sub
    
    Private Sub OnClose_ClientProxySoc() Handles ClientProxySoc.OnDisconnection
        LogEvents("Connection close")
	RaiseEvent AuthenticationConnClose(Me)
    End Sub
    Private Sub ClientProxySoc_OnDataArrival(ByVal bytestotal As Integer) Handles ClientProxySoc.OnDataArrival
        Dim buffer() As Byte = {}
        ReDim buffer(bytestotal)

        ClientProxySoc.GetData(buffer, bytestotal)
        
	'AutCrypthCP.Encrypt(buffer)
        
	LogEvents("Client Packet: " & Encoding.ASCII.GetString(buffer))
        
	'CPacket = New packet.myPacket(buffer)
        'If packet.LoginInformation.IsThisType(CPacket) Then
        '    Dim logInfo As packet.LoginInformation = New packet.LoginInformation(CPacket)
        '    Me.ServerName = logInfo.ServerName
        '    Me.LoginAccountID = logInfo.LoginID
        'End If
        'AutCrypthCP.Decrypt(buffer)
        'Try
        '    Me.ProxyServerLoginSoc.SendData(buffer)
        'Catch ex As Exception
        '    Me.ProxyServerLoginSoc.Close()
        '    RaiseEvent AuthenticationConnClose(Me)
        'End Try

    End Sub

    Private Sub LogEvents(ByVal mevents As String)
        Dim mlog As log = New log
        mlog.msg = mevents
        Me.listofLogs.Add(mlog)
        mlog = Nothing
    End Sub

End Class

' Miscelaneous for logging purposes
Public Class log
    Private _msg As String
    Private _timecreated As String
    Public Property msg() As String
        Get
            Return _msg
        End Get
        Set(ByVal value As String)
            _timecreated = Now().ToString
            _msg = value
        End Set
    End Property
    Public ReadOnly Property TimeCreated() As String
        Get
            Return _timecreated
        End Get
    End Property
End Class