/// <inheritdoc />
        public async Task RunAsync()
        {
            EndPoint defaultEndPoint = new IPEndPoint(IPAddress.Any, 0);

            Socket rawSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            rawSocket.Bind(Program.Constants.ClientEndPoint);
            rawSocket.Connect(Program.Constants.ServerEndPoint);

            using RawStreamNetworkWriter writer = new RawStreamNetworkWriter(ref rawSocket, defaultEndPoint, PacketSize);

            byte[] transmissionBuffer = new byte[PacketSize];

            EndPoint remoteEndPoint = Program.Constants.ServerEndPoint;

            try
            {
                while (true)
                {
                    Console.Write("Input to send to server: ");
                    string userInput = Console.ReadLine();

                    if (!Program.Constants.ServerEncoding.GetBytes(userInput).AsMemory().TryCopyTo(transmissionBuffer))
                    {
                        Console.WriteLine("Given input is too large. Please try again!");
                        continue;
                    }

                    int sent = await writer.WriteAsync(remoteEndPoint, transmissionBuffer);

                    lock (typeof(Console))
                    {
                        Console.WriteLine($"Sent {sent} bytes to {remoteEndPoint}!");
                    }

                    Array.Clear(transmissionBuffer, 0, transmissionBuffer.Length);

                    int received = await writer.ReadAsync(remoteEndPoint, transmissionBuffer);

                    lock (typeof(Console))
                    {
                        Console.WriteLine($"Received {received} bytes from {remoteEndPoint}!");
                        Console.WriteLine(Program.Constants.ServerEncoding.GetString(transmissionBuffer));
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            finally
            {
                rawSocket.Shutdown(SocketShutdown.Both);
                rawSocket.Disconnect(true);

                rawSocket.Close();
                rawSocket.Dispose();
            }
        }
Ejemplo n.º 2
0
        private static async Task ClientTask()
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            clientSocket.Bind(Program.Constants.ClientEndPoint);
            clientSocket.Connect(Program.Constants.ServerEndPoint);

            EndPoint defaultEndPoint = new IPEndPoint(IPAddress.Any, 0);

            using RawStreamNetworkWriter client = new RawStreamNetworkWriter(ref clientSocket, defaultEndPoint, ChatPacketSize);

            byte[] transmissionBuffer = new byte[ChatPacketSize];

            try
            {
                while (true)
                {
                    Console.Write("Enter string to send to the server: ");
                    string request = Console.ReadLine();
                    if (!Program.Constants.ServerEncoding.GetBytes(request).AsMemory().TryCopyTo(transmissionBuffer))
                    {
                        Console.WriteLine("Could not copy message to transmission buffer. Please try again!");
                        continue;
                    }

                    int sentBytes = await client.WriteAsync(Program.Constants.ServerEndPoint, transmissionBuffer);

                    Console.WriteLine($"[{clientSocket.LocalEndPoint}] Sent {sentBytes} bytes to server:");
                    Console.WriteLine($"\t{request}");

                    Array.Clear(transmissionBuffer, 0, transmissionBuffer.Length);

                    int receivedBytes = await client.ReadAsync(Program.Constants.ServerEndPoint, transmissionBuffer);

                    string response = Program.Constants.ServerEncoding.GetString(transmissionBuffer);

                    Console.WriteLine($"[{clientSocket.LocalEndPoint}] Received {receivedBytes} bytes from server!");
                    Console.WriteLine($"\t{response}");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            finally
            {
                clientSocket.Shutdown(SocketShutdown.Both);
                clientSocket.Disconnect(true);

                clientSocket.Close();
                clientSocket.Dispose();
            }
        }