![[C#]Sockets (No packet splitting)](https://www.elitepvpers.com/forum/iconimages/co2-programming/c-sockets-no-packet-splitting_ltr.gif){kind=small}
Released some other sockets earlier, but these are far more improved.
Source:
Code:
public class SocketServer
{
private Socket serverSocket;
private int backlog;
public SocketServer(int backlog = 100)
{
this.backlog = backlog;
}
public void Start(string IP, int Port)
{
serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
serverSocket.Bind(new IPEndPoint(IPAddress.Parse(IP), Port));
serverSocket.Listen(backlog);
AcceptConnections();
}
private void AcceptConnections()
{
serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
private void AcceptCallback(IAsyncResult asyncResult)
{
try
{
SocketClient client = new SocketClient();
if (client.EndAccept(serverSocket, asyncResult))
{
if (SocketEvents.OnConnection != null)
SocketEvents.OnConnection.Invoke(client);
client.ReceiveData();
}
}
catch { }
AcceptConnections();
}
}
public class SocketClient
{
private Socket clientSocket;
private byte[] dataHolder;
private ushort requiredSize;
private ushort currentSize;
private byte[] sizePacket;
private bool inHeader = true;
private byte[] CombineData()
{
if (inHeader)
{
sizePacket = new byte[2];
System.Buffer.BlockCopy(dataHolder, 0, sizePacket, 0, 2);
return null;
}
else
{
byte[] cmbData = new byte[requiredSize];
System.Buffer.BlockCopy(sizePacket, 0, cmbData, 0, 2);
System.Buffer.BlockCopy(dataHolder, 0, cmbData, 2, (requiredSize - 2));
return cmbData;
}
}
public bool EndAccept(Socket serverSocket, IAsyncResult asyncResult)
{
try
{
clientSocket = serverSocket.EndAccept(asyncResult);
return true;
}
catch
{
return false;
}
}
public void ReceiveData()
{
ReceiveData(2);
}
private void ReceiveData(int size)
{
dataHolder = new byte[size];
clientSocket.BeginReceive(dataHolder, 0, size, SocketFlags.None, new AsyncCallback(ReceiveCallback), null);
}
private void ReceiveCallback(IAsyncResult asyncResult)
{
try
{
SocketError err;
int rSize = clientSocket.EndReceive(asyncResult, out err);
if (err == SocketError.Success)
{
if (rSize >= 2)
{
if (inHeader)
HandleHeader();
else
HandleBody(rSize);
}
else
Disconnect();
}
else
Disconnect();
}
catch
{
Disconnect();
}
}
private unsafe void HandleHeader()
{
currentSize = 2;
fixed (byte* bPtr = dataHolder)
{
requiredSize = (*(ushort*)(bPtr + 0));
}
CombineData();
inHeader = false;
ReceiveData(requiredSize);
}
private void HandleBody(int rSize)
{
currentSize += (ushort)rSize;
if (currentSize == requiredSize)
{
byte[] nData = CombineData();
if (currentSize == nData.Length)
{
if (SocketEvents.OnReceive != null)
SocketEvents.OnReceive.Invoke(this, nData);
inHeader = true;
ReceiveData();
}
else
Disconnect();
}
else if (currentSize > requiredSize)
Disconnect();
}
private bool alreadyDisconnected = false;
public void Disconnect()
{
if (alreadyDisconnected)
return;
alreadyDisconnected = true;
try
{
if (clientSocket.Connected)
clientSocket.Disconnect(false);
}
catch { }
if (SocketEvents.OnDisconnection != null)
SocketEvents.OnDisconnection.Invoke(this);
}
public void Send(byte[] data)
{
byte[] sendBuffer = new byte[data.Length];
System.Buffer.BlockCopy(data, 0, sendBuffer, 0, data.Length);
try
{
Monitor.Enter(this);
if (clientSocket.Connected)
{
clientSocket.BeginSend(sendBuffer, 0, sendBuffer.Length, SocketFlags.None, new AsyncCallback(Send_Callback), null);
}
}
finally
{
Monitor.Exit(this);
}
}
private void Send_Callback(IAsyncResult asyncResult)
{
try
{
int size = clientSocket.EndSend(asyncResult);
if (size < 4)
Disconnect();
}
catch
{
Disconnect();
}
}
public bool Connect(string IP, int Port)
{
clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int tries = 0;
while (tries < 3 && !clientSocket.Connected)
{
try
{
clientSocket.Connect(new IPEndPoint(IPAddress.Parse(IP), Port));
return true;
}
catch { }
tries++;
Thread.Sleep(2000);
}
return false;
}
}
public delegate void ConnectionEvent(SocketClient client);
public delegate void BufferEvent(SocketClient client, byte[] data);
public static class SocketEvents
{
public static ConnectionEvent OnConnection;
public static ConnectionEvent OnDisconnection;
public static BufferEvent OnReceive;
}
Code:
class Program
{
public static void Main(string[] args)
{
SocketEvents.OnConnection += new ConnectionEvent(SocketEvents_OnConnection);
SocketEvents.OnDisconnection += new ConnectionEvent(SocketEvents_OnDisconnection);
SocketEvents.OnReceive += new BufferEvent(SocketEvents_OnReceive);
SocketServer server = new SocketServer(); // or new SocketServer(500);
server.Start("127.0.0.1", 9959);
while (true)
Console.ReadLine();
}
static void SocketEvents_OnReceive(SocketClient client, byte[] data)
{
Console.WriteLine("received data.");
client.Send(data);
Console.WriteLine("send data.");
}
static void SocketEvents_OnDisconnection(SocketClient client)
{
Console.WriteLine("disconnected.");
}
static void SocketEvents_OnConnection(SocketClient client)
{
Console.WriteLine("connection.");
}
}
Code:
class Program
{
public static unsafe void Main(string[] args)
{
SocketEvents.OnDisconnection += new ConnectionEvent(SocketEvents_OnDisconnection);
SocketEvents.OnReceive += new BufferEvent(SocketEvents_OnReceive);
SocketClient client = new SocketClient();
client.Connect("127.0.0.1", 9959);
client.ReceiveData();
Console.WriteLine("connected.");
while (true)
{
Console.ReadLine();
byte[] sendData = new byte[8];
fixed (byte* b = sendData)
{
(*(ushort*)(b + 0)) = 8;
}
client.Send(sendData);
Console.WriteLine("send data.");
}
}
static void SocketEvents_OnReceive(SocketClient client, byte[] data)
{
Console.WriteLine("received data.");
}
static void SocketEvents_OnDisconnection(SocketClient client)
{
Console.WriteLine("disconnected.");
}
}
. 
