public void OnDataReceive1()
{
// Example receiving for the server
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer();
server.Start(port);
const string message = "Hello server!";
int receiveCount = 0;
server.OnDataReceive += (s, receivedMessage) =>
{
//Async lambda, so thread safe increase integer
if (message.Equals(receivedMessage.ToString()))
{
Interlocked.Increment(ref receiveCount);
}
Console.WriteLine($"[{receiveCount}]Received message: {receivedMessage.ToString()}");
};
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
client.Send(message);
client.Send(message);
TestHelper.WaitWhileTrue(() => receiveCount < 2);
Assert.AreEqual(2, receiveCount);
}
public void SendString()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
string data = "Data";
client.Send(data);
client.Send(data, Encoding.UTF32); //Send with different encoding
}
public void Stream2() //Client -> Server -(Stream)> Client (Client requests stream from server)
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer();
server.Start(port);
string testData = "123", data = null;
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
server.OnDataReceive += (sender, message) => //Send stream if client requests
{
using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
message.Client.Send("Stream");
message.Client.SendStream(dataStream);
};
client.OnDataReceive += (sender, message) => //Receive stream from server
{
using var stream = new MemoryStream();
message.ReceiveStream(stream);
data = Encoding.UTF8.GetString(stream.ToArray());
};
client.Send("GetStream"); //Request stream
TestHelper.WaitWhileTrue(() => data == null);
Assert.AreEqual(testData, data);
}
public void Stream()
{
var certificate = new X509Certificate2("certificate.pfx", "password");
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().UseSsl(certificate).Start(port);
using var client = new EasyTcpClient().UseSsl("localhost", true);
Assert.IsTrue(client.Connect(IPAddress.Any, port));
string testData = "123", data = null;
server.OnDataReceiveAsync += async(sender, message) => //Receive stream from client
{
await using var stream = new MemoryStream();
message.ReceiveStream(stream);
data = Encoding.UTF8.GetString(stream.ToArray());
};
//Send stream to server
using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
client.Send("Stream");
client.SendStream(dataStream);
TestHelper.WaitWhileTrue(() => data == null);
Assert.AreEqual(testData, data);
}
/// <summary>
/// Send data (byte[][]) to the remote host. Then wait for a reply from the server.
/// </summary>
/// <param name="client"></param>
/// <param name="data">data to send to server</param>
/// <param name="timeout">maximum time to wait for a reply, if time expired: return null</param>
/// <returns>received data or null</returns>
public static async Task <Message> SendAndGetReplyAsync(this EasyTcpClient client, TimeSpan?timeout = null,
params byte[][] data)
{
Message reply = null;
using var signal = new SemaphoreSlim(0, 1); // Use SemaphoreSlim as async ManualResetEventSlim
client.DataReceiveHandler = message =>
{
reply = message;
client.ResetDataReceiveHandler();
// Function is no longer used when signal is disposed, therefore ignore this warning
// ReSharper disable once AccessToDisposedClosure
signal.Release();
};
client.Send(data);
await signal.WaitAsync(timeout ?? TimeSpan.FromMilliseconds(DefaultTimeout));
if (reply == null)
{
client.ResetDataReceiveHandler();
}
return(reply);
}
public static void Connect()
{
var client = new EasyTcpClient();
if (!client.Connect(IPAddress.Loopback, Port))
{
return;
}
var list = new PacketList <Message>
{
EasyTcpPacket.To <Message>("Message1"),
EasyTcpPacket.To <Message>("Message2"),
EasyTcpPacket.To <Message>("Message3")
};
client.Send(list); // Send list
// Message also implements IEasyTcpPacket
// So we can use all functions on message as example
// This is how we create a new message with as content a string
// The EasyTcpPacket.To can be used on all packets, but not all packets support being created from a string
// Our list for example wouldn't work when created from a string
var message = EasyTcpPacket.To <Message>("S_T_R_I_N_G");
message.Compress(); // Compress message
}
public void TestLargeArray()
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
server.OnDataReceive += async(sender, message) =>
{
var array = await message.ReceiveLargeArrayAsync();
message.Client.Send(array.Length);
await message.Client.SendLargeArrayAsync(array);
};
byte[] receivedArray = null;
using var client = new EasyTcpClient();
client.OnDataReceive += (sender, message) => receivedArray = message.ReceiveLargeArray();
Assert.IsTrue(client.Connect(IPAddress.Loopback, port));
client.Send("first message");
byte[] largeMessage = new byte[ushort.MaxValue * 10];
for (int i = 0; i < largeMessage.Length; i++)
{
largeMessage[i] = 11;
}
client.SendLargeArray(largeMessage);
TestHelper.WaitWhileTrue(() => receivedArray == null);
Assert.IsTrue(receivedArray.SequenceEqual(largeMessage));
}
public void Stream1() //Client -> -(Stream)> Server (Client sends message to server)
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
string testData = "123", data = null;
server.OnDataReceive += (sender, message) => //Receive stream from client
{
using var stream = new MemoryStream();
message.ReceiveStream(stream, compression: true);
data = Encoding.UTF8.GetString(stream.ToArray());
};
//Send stream to server
using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
client.Send("Stream");
client.SendStream(dataStream, compression: true);
TestHelper.WaitWhileTrue(() => data == null);
Assert.AreEqual(testData, data);
}
public static void Run()
{
// Create server with logging enabled
// Write log to console
using var server = new EasyTcpServer().UseServerLogging(Console.WriteLine).Start(Port);
server.OnDataReceive += (s, message) => message.Client.Send("Hello client test!");
// Create client with logging enabled
using var client = new EasyTcpClient().UseClientLogging(Console.WriteLine);
if (!client.Connect("127.0.0.1", Port))
{
return;
}
client.Send("Hello server!");
Console.ReadLine();
/* Custom logging,
* only log connect/disconnect events
*/
using var server2 = new EasyTcpServer().UseCustomServerLogging(logMessage =>
{
if (logMessage.Type == LoggingType.ClientConnected)
{
Console.WriteLine(logMessage);
}
else if (logMessage.Type == LoggingType.ClientDisconnected)
{
Console.WriteLine(logMessage);
}
});
}
public async Task Stream1() //Client -> -(Stream)> Server (Client sends message to server)
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer();
server.Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, port));
string testData = "123", data = "";
server.OnDataReceiveAsync += async(sender, message) => //Receive stream from client
{
await using var stream = new MemoryStream();
await message.ReceiveStreamAsync(stream);
data = Encoding.UTF8.GetString(stream.ToArray());
};
//Send stream to server
await using var dataStream = new MemoryStream(Encoding.UTF8.GetBytes(testData));
client.Send("Stream");
await client.SendStreamAsync(dataStream);
TestHelper.WaitWhileTrue(() => data == "");
Assert.AreEqual(testData, data);
}
static void Main(string[] args)
{
EasyTcpClient client = new EasyTcpClient(System.Reflection.Assembly.GetExecutingAssembly());
client.OnConnected += (sender, tcp) =>
{
Console.WriteLine("Client successfuly connected!");
client.Send(new Packet(BytesTransformation.TransformIt("Test String", "Test String2", 1337, true, 412.214, 4124u), "Some packet"));
};
client.OnDisconnect += (sender, tcp) =>
{
Console.WriteLine("Client disconnected!");
};
client.OnError += (sender, error) =>
{
Console.WriteLine($"{error.Message}\n{error.StackTrace}");
};
client.DataReceived += (sender, msg) =>
{
Console.WriteLine($"PacketType: {msg.GetPacket.PacketType}");
client.PacketHandler(msg, false);
};
if (!client.Connect("127.0.0.1", 6124, TimeSpan.FromSeconds(15)))
{
Console.WriteLine("Connection aborted. Timeout!");
}
Console.ReadLine();
Task.Delay(-1).Wait();
}
/// <summary>
/// Send action to remote host
/// </summary>
/// <param name="client"></param>
/// <param name="action">action code</param>
/// <param name="data">data to send to remote host</param>
/// <param name="compression">compress data using deflate if set to true</param>
public static void SendAction(this EasyTcpClient client, int action, byte[] data = null, bool compression = false)
{
if (compression && data != null)
{
data = CompressionUtil.Compress(data);
}
client.Send(BitConverter.GetBytes(action), data);
}
/// <summary>
/// Send data (byte[][]) to remote host. Then wait and return the reply
/// </summary>
/// <param name="client"></param>
/// <param name="data">data to send to remote host</param>
/// <param name="timeout">maximum time to wait for a reply, if time expired this function returns null</param>
/// <returns>received reply</returns>
public static async Task <Message> SendAndGetReplyAsync(this EasyTcpClient client, TimeSpan?timeout = null,
params byte[][] data)
{
var receive = client.ReceiveAsync(timeout ?? TimeSpan.FromMilliseconds(DefaultTimeout));
client.Send(data);
return(await receive);
}
public void SendArray()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
byte[] data = new byte[100];
client.Send(data);
}
public void SendBool()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
bool data = true;
client.Send(data);
}
public void SendLong()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
long data = 123;
client.Send(data);
}
public void SendDouble()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
double data = 123.0;
client.Send(data);
}
public void OnSendClient()
{
ushort port = TestHelper.GetPort();
using var server = new EasyTcpServer().Start(port);
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Loopback, port));
int x = 0;
client.OnDataSend += (_, message) => Interlocked.Increment(ref x);
client.Send("Test");
client.Send("Test");
TestHelper.WaitWhileFalse(() => x == 2);
Assert.AreEqual(2, x);
}
public static void Connect()
{
// Create new client with .net core 3 json serialization
using var client = new EasyTcpClient
{
Serialize = o => JsonSerializer.SerializeToUtf8Bytes(o),
Deserialize = (bytes, type) => JsonSerializer.SerializeToUtf8Bytes(bytes, type)
};
if (!client.Connect("127.0.0.1", Port))
{
return;
}
// Serialize and send array
client.Send(new[] { "testdata", "testdata", "testdata" });
// Compress message before sending
client.Send(new[] { "testdata", "testdata", "testdata" }, true);
}
public static void Connect()
{
var client = new EasyTcpClient();
//Print received data
client.OnDataReceive += (sender, message) =>
Console.WriteLine($"HelloClient: Received \"{message.ToString()}\" from the server");
//Connect to server, return if failed
if (!client.Connect(IPAddress.Any, Port))
{
return;
}
client.Send("Hello");
}
public static void Run()
{
const ushort PORT = 100;
using var encrypter = new EasyEncrypt("Password", "SALT1415312");
using var server = new EasyTcpServer().Start(PORT);
server.OnDataReceive += (sender, message) =>
Console.WriteLine($"Received: {message.Decrypt(encrypter).ToString()}");
using var client = new EasyTcpClient();
if (!client.Connect(IPAddress.Loopback, PORT))
{
return;
}
client.Send(EasyTcpPacket.To <Message>("Hello Server!").Encrypt(encrypter));
}
public static void Connect()
{
/* Create new client with ssl
* "localhost" is the servername. This should be the domain name of the server (same as in certificate)
* Second parameter determines whether the client accepts invalid certificates.
* This is set to true because our test certificate is invalid.
*/
using var client = new EasyTcpClient().UseSsl("localhost", true);
if (!client.Connect("127.0.0.1", Port))
{
return;
}
// All data is now encrypted before sending
client.Send("Data");
}
public static void Connect()
{
var client = new EasyTcpClient();
if (!client.Connect(IPAddress.Loopback, Port))
{
return;
}
using var encrypter = new EasyEncrypt("Key", Salt);
// Send encrypted message
// .Encrypt works on all EasyTcpPackets
client.Send(EasyTcpPacket.To <Message>("TestMessage").Encrypt(encrypter)
.Compress()); // Compression also works on all EasyTcpPackets
}
public static void Connect()
{
var client = new EasyTcpClient();
/* OnConnect event,
* triggered when client connects to the server
*/
client.OnConnect += (sender, c) => Console.WriteLine("Client: Connected to server");
/* OnDisconnect event,
* triggered when client disconnects from server
*/
client.OnDisconnect += (sender, c) => { Console.WriteLine("Client: Disconnected from server"); };
/* OnDataReceive event,
* triggered when client receives any data from the server
*/
client.OnDataReceive += (sender, message) =>
{
Console.WriteLine($"Client: Received data, received: {message.ToString()}");
};
/* OnError get triggered when an error occurs in the server code,
* This includes errors in the events because these are triggered by the server
*/
client.OnError += (sender, exception) =>
Console.WriteLine($"Server: Error occured, message: {exception.Message}");
/* Connect to server on ip 127.0.0.1 and port 5_000 (Our BasicServer.cs)
* See ConnectUtil.cs and ConnectAsyncUtil.cs for the connect functions
*/
bool connected = client.Connect("127.0.0.1", Port);
if (connected)
{
client.Send("Hello everyone!");
}
else
{
Console.WriteLine("Client: Could not connect to server");
}
// Send a message and get the reply
Message reply = client.SendAndGetReply("Hello server!");
}
public static void Connect()
{
// Create new easyTcpClient
using var client = new EasyTcpClient();
// Connect client
if (!client.Connect("127.0.0.1", Port))
{
return;
}
else
{
Console.WriteLine("Connected to server!");
}
// Send hello world to server
client.Send("Hello world!");
} // End of function, dispose/disconnect client because of using statement
public void SendAndGetReplyInsideOnDataReceive()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
bool triggered = false;
client.OnDataReceive += async(sender, message) =>
{
var reply = await message.Client.SendAndGetReplyAsync("ECHO");
triggered = reply.ToString() == "ECHO";
};
client.Send("test");
TestHelper.WaitWhileFalse(() => triggered);
Assert.IsTrue(triggered);
}
public static void Connect()
{
/* Create new instance of EasyEncrypt with a password and (hardcoded) salt
* Default algorithm is Aes
*/
_encrypter = new EasyEncrypt("Password", "Salt2135321");
// Create new client with encryption
var client = new EasyTcpClient().UseClientEncryption(_encrypter);
client.Connect("127.0.0.1", Port);
// All data is now encrypted before sending
client.Send("Data");
// Encrypter gets disposed with client + protocol
client.Dispose();
}
public static void Run()
{
const ushort PORT = 100;
using var server = new EasyTcpServer().Start(PORT);
server.OnConnect += (sender, client) => Console.WriteLine($"Client connected [ip: {client.GetIp()}]");
server.OnDisconnect += (sender, client) => Console.WriteLine($"Client disconnected [ip: {client.GetIp()}]");
server.OnDataReceive += (sender, message) => Console.WriteLine($"Received: {message.ToString()}");
using var client = new EasyTcpClient();
client.OnConnect += (sender, client) => Console.WriteLine("Client connected!");
client.OnDisconnect += (sender, client) => Console.WriteLine("Client disconnected!");
client.OnDataReceive += (sender, message) => Console.WriteLine($"Received: {message.ToString()}");
if (!client.Connect(IPAddress.Loopback, PORT))
{
return;
}
client.Send("Hello server");
}
public void ReceiveShort()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
short data = 123;
int receiveCount = 0;
client.OnDataReceive += (sender, receivedMessage) =>
{
//Async lambda, so thread safe increase integer
if (receivedMessage.IsValidShort() && data.Equals(receivedMessage.ToShort()))
{
Interlocked.Increment(ref receiveCount);
}
};
client.Send(data);
TestHelper.WaitWhileTrue(() => receiveCount == 0);
Assert.AreEqual(1, receiveCount);
}
public void ReceiveArray()
{
using var client = new EasyTcpClient();
Assert.IsTrue(client.Connect(IPAddress.Any, _port));
byte[] data = new byte[100];
int receiveCount = 0;
client.OnDataReceive += (sender, receivedMessage) =>
{
//Async lambda, so thread safe increase integer
if (data.SequenceEqual(receivedMessage.Data))
{
Interlocked.Increment(ref receiveCount);
}
};
client.Send(data);
TestHelper.WaitWhileTrue(() => receiveCount == 0);
Assert.AreEqual(1, receiveCount);
}
