asfasfasfasf

using Game.NetLib.Events;
using Game.NetLib.Packets;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace Game.NetLib
{
    public class PacketStream : IDisposable
    {
        private readonly PacketStreamReader _reader;
        private readonly PacketStreamWriter _writer;
        private readonly Stream _stream;
        private readonly Dictionary<int, Func<PacketStreamReader, Task<PacketBase>>> _readerStrategies = new Dictionary<int, Func<PacketStreamReader, Task<PacketBase>>>();
        private readonly Dictionary<int, Action<PacketStreamWriter, Task<PacketBase>>> _writerStrategies = new Dictionary<int, Action<PacketStreamWriter, Task<PacketBase>>>();

        private readonly PacketBase _emptyPacket = new EmtpyPacket();

        public PacketStream(Stream stream)
        {
            _stream = stream;
            _reader = new PacketStreamReader(stream, Encoding.UTF8);
            _writer = new PacketStreamWriter(stream, Encoding.UTF8);
        }

        public async Task Write(PacketBase packet)
        {
            if (!_writerStrategies.ContainsKey(packet.PacketTypeId))
            {
                throw new InvalidOperationException();
            }
            await _writer.WriteAsync(packet.PacketTypeId);
            _writerStrategies[packet.PacketTypeId](_writer, packet);
        }

        public async Task<PacketBase> Read()
        {
            var packetTypeId = await _reader.ReadInt32Async();

            if (!_readerStrategies.ContainsKey(packetTypeId))
            {
                throw new InvalidOperationException();
            }
            return _readerStrategies[packetTypeId](_reader);
        }

        public void Register<T>(int identifier, Func<PacketStreamReader, T, Task<T>> reader, Action<PacketStreamWriter, T> writer) where T : PacketBase, new()
        {
            if (_readerStrategies.ContainsKey(identifier) || _writerStrategies.ContainsKey(identifier))
            {
                throw new InvalidOperationException();
            }
            _readerStrategies.Add(identifier, async (binaryReader) => await reader(_reader, new T()));
            _writerStrategies.Add(identifier, async (binaryReader, packetBase) => await writer(_writer, (T)packetBase));
        }

        public void Dispose()
        {
            _reader.Dispose();
            _writer.Dispose();
            _stream.Dispose();
        }
    }
}

using Game.NetLib.Packets;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

namespace Game.NetLib
{
    public class PacketStreamFactory
    {
        public static PacketStream CreateLoginServerPacketStream(NetworkStream stream)
        {
            var packetStream = new PacketStream(stream);
            packetStream.Register<Task<LoginPacket>>((int)PacketType.LOGIN, Read, Write);
            packetStream.Register<Task<StatusPacket>>((int)PacketType.STATUS, Read, Write);
            return packetStream;
        }

        public static PacketStream CreateLobbyPacketStream(NetworkStream stream)
        {
            var packetStream = new PacketStream(stream);
            packetStream.Register<ChatMessagePacket>((int)PacketType.CHAT_MESSAGE, Read, Write);
            packetStream.Register<CreateRoomPacket>((int)PacketType.CREATE_ROOM, Read, Write);
            packetStream.Register<StatusPacket>((int)PacketType.STATUS, Read, Write);
            return packetStream;
        }

        #region LOGIN
        private static async Task Write(PacketStreamWriter binaryWriter, LoginPacket loginPacket)
        {
            await binaryWriter.WriteAsync(loginPacket.Username);
            await binaryWriter.WriteAsync(loginPacket.Password);
        }

        private static async Task<LoginPacket> Read(PacketStreamReader binaryReader, LoginPacket loginPacket)
        {
            loginPacket.Username = await binaryReader.ReadStringAsync();
            loginPacket.Password = await binaryReader.ReadStringAsync();
            return loginPacket;
        }
        #endregion

        #region CHATMESSAGE
        private static async Task Write(PacketStreamWriter binaryWriter, ChatMessagePacket chatMessagePacket)
        {
            await binaryWriter.WriteAsync(chatMessagePacket.From);
            await binaryWriter.WriteAsync(chatMessagePacket.Body);
            await binaryWriter.WriteAsync(chatMessagePacket.To);
        }

        private static async Task<ChatMessagePacket> Read(PacketStreamReader binaryReader, ChatMessagePacket chatMessagePacket)
        {
            chatMessagePacket.From = await binaryReader.ReadInt32Async();
            chatMessagePacket.Body = await binaryReader.ReadStringAsync();
            chatMessagePacket.To = await binaryReader.ReadInt32Async();
            return chatMessagePacket;
        }
        #endregion

        #region CREATEROOM
        private static async Task Write(PacketStreamWriter binaryWriter, CreateRoomPacket createRoomPacket)
        {
            await binaryWriter.WriteAsync(createRoomPacket.Name);
            await binaryWriter.WriteAsync(createRoomPacket.Capacity);
            await binaryWriter.WriteAsync(createRoomPacket.Protected);
            await binaryWriter.WriteAsync(createRoomPacket.Password);
        }

        private static async Task<CreateRoomPacket> Read(PacketStreamReader binaryReader, CreateRoomPacket createRoomPacket)
        {
            createRoomPacket.Name = await binaryReader.ReadStringAsync();
            createRoomPacket.Capacity = await binaryReader.ReadInt32Async();
            createRoomPacket.Protected = await binaryReader.ReadBooleanAsync();
            createRoomPacket.Password = await binaryReader.ReadStringAsync();
            return createRoomPacket;
        }
        #endregion

        #region STATUS
        private static async Task Write(PacketStreamWriter binaryWriter, StatusPacket errorPacket)
        {
            await binaryWriter.WriteAsync((int)errorPacket.StatusCode);
            await binaryWriter.WriteAsync(errorPacket.Message);
        }

        private static async Task<StatusPacket> Read(PacketStreamReader binaryReader, StatusPacket errorPacket)
        {
            errorPacket.StatusCode = (Status)await binaryReader.ReadInt32Async();
            errorPacket.Message = await binaryReader.ReadStringAsync();
            return errorPacket;
        }
        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Game.NetLib
{
    public class PacketStreamWriter : IDisposable
    {
        private Stream _stream;
        private Encoding _encoding;

        public PacketStreamWriter(Stream stream) : this(stream, Encoding.UTF8) { }

        public PacketStreamWriter(Stream stream, Encoding encoding)
        {
            _stream = stream;
            _encoding = encoding;
        }

        public async Task WriteAsync(Int16 value)
        {
            var buffer = BitConverter.GetBytes(value);
            await WriteBytesAsync(buffer);
        }

        public async Task WriteAsync(Int32 value)
        {
            var buffer = BitConverter.GetBytes(value);
            await WriteBytesAsync(buffer);
        }

        public async Task WriteAsync(double value)
        {
            var buffer = BitConverter.GetBytes(value);
            await WriteBytesAsync(buffer);
        }

        public async Task WriteAsync(bool value)
        {
            var buffer = BitConverter.GetBytes(value);
            await WriteBytesAsync(buffer);
        }

        public async Task WriteAsync(string value)
        {
            var contentBuffer = _encoding.GetBytes(value);
            var lengthBuffer = BitConverter.GetBytes(contentBuffer.Length);
            await WriteBytesAsync(lengthBuffer);
            await WriteBytesAsync(contentBuffer);
        }

        private async Task WriteBytesAsync(byte[] buffer)
        {
            await _stream.WriteAsync(buffer, 0, buffer.Length);
        }

        public void Dispose()
        {
            _stream.Dispose();
        }
    }
}