Haute performance serveur TCP en C#

Il doit être asynchrone, il n'y a pas moyen de contourner cela. Hautes performances et évolutivité, ne pas mélanger avec un thread par socket. Vous pouvez jeter un oeil à ce StackExchange font eux-mêmes, voir async Redis attendent BookSleeve qui tire profit de la CTP fonctionnalités de la prochaine C# version (donc sur le bord et sujet à des changements, mais c'est cool). Pour encore plus avant-gardistes et les solutions évoluent autour de levier Classe SocketAsyncEventArgs qui prend les choses un peu plus loin en éliminant les allocations de fréquentes de async gestionnaires associés à "classiques" async C# traitement:

La classe SocketAsyncEventArgs est partie
d'un ensemble d'améliorations apportées à la
Système.Net.Les Sockets.Classe Socket
fournir une solution de rechange asynchrone
modèle qui peut être utilisé par
spécialisés de haute performance socket
des applications. Cette classe a été
spécialement conçu pour le réseau
serveur d'applications qui nécessitent une haute
les performances. Une application peut utiliser
le renforcement du modèle asynchrone
exclusivement ou seulement la cible de chaud
les domaines (par exemple, lors de la réception
de grandes quantités de données).

Longue histoire courte: apprendre async ou mourir en essayant...

BTW, si vous vous demandez pourquoi asynchrone, puis de lire les trois articles liés à partir de ce post: Les Fenêtres à haut Rendement des programmes. L'ultime réponse est: l'OS sous-jacent de la conception exige.

Vous pouvez faire cela avec le TcpClient classe, bien qu'à vrai dire je ne sais pas si vous pourriez avoir 10 mille ouvrir des sockets. C'est tout un lot. Mais j'utilise régulièrement TcpClient pour gérer des dizaines de connexions simultanées sockets. Et le modèle asynchrone est vraiment très agréable à utiliser.

Votre plus gros problème n'est pas de faire de la TcpClient travail. Avec 10 mille connexions simultanées, je suis en train de penser de la bande passante et l'évolutivité allez avoir des problèmes. Je ne sais même pas si une machine peut gérer tout ce trafic. Je suppose que cela dépend de la taille des paquets et comment souvent ils vont venir dans. Mais vous feriez mieux de faire plusieurs allers-de-la-estimation de l'enveloppe avant de vous engager à mettre en œuvre tout cela sur un seul ordinateur.

Vous pouvez utiliser mon TCP CSharpServer j'ai faite, C'est très simple à mettre en œuvre, mettre en Œuvre IClientRequest sur l'une de vos Classes.

using System;
using System.Collections.Generic;
using System.Linq;
namespace cSharpServer
{
public interface IClientRequest
{        
///<summary>
///this needs to be set, otherwise the server will not beable to handle the request.
///</summary>
byte IdType { get; set; } //This is used for Execution.
///<summary>
///handle the process by the client.
///</summary>
///<param name="data"></param>
///<param name="client"></param>
///<returns></returns>
byte[] Process(BinaryBuffer data, Client client);
}
}

BinaryBuffer vous permet de lire les données envoyées au serveur vraiment facile.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace cSharpServer
{
public class BinaryBuffer
{
private const string Str0001 = "You are at the End of File!";
private const string Str0002 = "You are Not Reading from the Buffer!";
private const string Str0003 = "You are Currenlty Writing to the Buffer!";
private const string Str0004 = "You are Currenlty Reading from the Buffer!";
private const string Str0005 = "You are Not Writing to the Buffer!";
private const string Str0006 = "You are trying to Reverse Seek, Unable to add a Negative value!";
private bool _inRead;
private bool _inWrite;
private List<byte> _newBytes;
private int _pointer;
public byte[] ByteBuffer;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return Helper.DefaultEncoding.GetString(ByteBuffer, 0, ByteBuffer.Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public BinaryBuffer(string data)
: this(Helper.DefaultEncoding.GetBytes(data))
{
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public BinaryBuffer()
{
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public BinaryBuffer(byte[] data)
: this(ref data)
{
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public BinaryBuffer(ref byte[] data)
{
ByteBuffer = data;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void IncrementPointer(int add)
{
if (add < 0)
{
throw new Exception(Str0006);
}
_pointer += add;
if (EofBuffer())
{
throw new Exception(Str0001);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int GetPointer()
{
return _pointer;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static string GetString(ref byte[] buffer)
{
return Helper.DefaultEncoding.GetString(buffer, 0, buffer.Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static string GetString(byte[] buffer)
{
return GetString(ref buffer);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void BeginWrite()
{
if (_inRead)
{
throw new Exception(Str0004);
}
_inWrite = true;
_newBytes = new List<byte>();
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(float value)
{
if (!_inWrite)
{
throw new Exception(Str0005);
}
_newBytes.AddRange(BitConverter.GetBytes(value));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(byte value)
{
if (!_inWrite)
{
throw new Exception(Str0005);
}
_newBytes.Add(value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(int value)
{
if (!_inWrite)
{
throw new Exception(Str0005);
}
_newBytes.AddRange(BitConverter.GetBytes(value));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(long value)
{
if (!_inWrite)
{
throw new Exception(Str0005);
}
byte[] byteArray = new byte[8];
unsafe
{
fixed (byte* bytePointer = byteArray)
{
*((long*)bytePointer) = value;
}
}
_newBytes.AddRange(byteArray);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int UncommitedLength()
{
return _newBytes == null ? 0 : _newBytes.Count;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteField(string value)
{
Write(value.Length);
Write(value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(string value)
{
if (!_inWrite)
{
throw new Exception(Str0005);
}
byte[] byteArray = Helper.DefaultEncoding.GetBytes(value);
_newBytes.AddRange(byteArray);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(decimal value)
{
if (!_inWrite)
{
throw new Exception(Str0005);
}
int[] intArray = decimal.GetBits(value);
Write(intArray[0]);
Write(intArray[1]);
Write(intArray[2]);
Write(intArray[3]);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetInt(int value, int pos)
{
byte[] byteInt = BitConverter.GetBytes(value);
for (int i = 0; i < byteInt.Length; i++)
{
_newBytes[pos + i] = byteInt[i];
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void SetLong(long value, int pos)
{
byte[] byteInt = BitConverter.GetBytes(value);
for (int i = 0; i < byteInt.Length; i++)
{
_newBytes[pos + i] = byteInt[i];
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(byte[] value)
{
Write(ref value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(ref byte[] value)
{
if (!_inWrite)
{
throw new Exception(Str0005);
}
_newBytes.AddRange(value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void EndWrite()
{
if (ByteBuffer != null)
{
_newBytes.InsertRange(0, ByteBuffer);
}
ByteBuffer = _newBytes.ToArray();
_newBytes = null;
_inWrite = false;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void EndRead()
{
_inRead = false;
_pointer = 0;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void BeginRead()
{
if (_inWrite)
{
throw new Exception(Str0003);
}
_inRead = true;
_pointer = 0;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public byte ReadByte()
{
if (!_inRead)
{
throw new Exception(Str0002);
}
if (EofBuffer())
{
throw new Exception(Str0001);
}
return ByteBuffer[_pointer++];
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int ReadInt()
{
if (!_inRead)
{
throw new Exception(Str0002);
}
if (EofBuffer(4))
{
throw new Exception(Str0001);
}
int startPointer = _pointer;
_pointer += 4;
return BitConverter.ToInt32(ByteBuffer, startPointer);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float[] ReadFloatArray()
{
float[] dataFloats = new float[ReadInt()];
for (int i = 0; i < dataFloats.Length; i++)
{
dataFloats[i] = ReadFloat();
}
return dataFloats;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float ReadFloat()
{
if (!_inRead)
{
throw new Exception(Str0002);
}
if (EofBuffer(sizeof(float)))
{
throw new Exception(Str0001);
}
int startPointer = _pointer;
_pointer += sizeof(float);
return BitConverter.ToSingle(ByteBuffer, startPointer);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public decimal ReadDecimal()
{
if (!_inRead)
{
throw new Exception(Str0002);
}
if (EofBuffer(16))
{
throw new Exception(Str0001);
}
return new decimal(new[] { ReadInt(),
ReadInt(),
ReadInt(),
ReadInt()
});
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public long ReadLong()
{
if (!_inRead)
{
throw new Exception(Str0002);
}
if (EofBuffer(8))
{
throw new Exception(Str0001);
}
int startPointer = _pointer;
_pointer += 8;
return BitConverter.ToInt64(ByteBuffer, startPointer);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadString(int size)
{
return Helper.DefaultEncoding.GetString(ReadByteArray(size), 0, size);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public byte[] ReadByteArray(int size)
{
if (!_inRead)
{
throw new Exception(Str0002);
}
if (EofBuffer(size))
{
throw new Exception(Str0001);
}
byte[] newBuffer = new byte[size];
Array.Copy(ByteBuffer, _pointer, newBuffer, 0, size);
_pointer += size;
return newBuffer;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool EofBuffer(int over = 1)
{
return ByteBuffer == null || ((_pointer + over) > ByteBuffer.Length);
}
}
}

L'ensemble de ce Projet est sur GitHub CSharpServer