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); }