public class PacketStream : IDisposable
    {
        public bool Connected { get; private set; } = true;
        public IAvailabilityStream Stream { get { return _stream; } }
        private readonly PacketStreamReader _reader;
        private readonly PacketStreamWriter _writer;
        private readonly IAvailabilityStream _stream;
        private readonly Dictionary<int, Func<PacketStreamReader, PacketBase>> _readerStrategies = new Dictionary<int, Func<PacketStreamReader, PacketBase>>();
        private readonly Dictionary<int, Action<PacketStreamWriter, PacketBase>> _writerStrategies = new Dictionary<int, Action<PacketStreamWriter, PacketBase>>();

        private readonly PacketBase _emptyPacket = new EmptyPacket();

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

        public void Write(PacketBase packet)
        {
            if (!_writerStrategies.ContainsKey(packet.PacketTypeId))
            {
                throw new InvalidOperationException($"Packet with ID {packet.PacketTypeId} was not found in WriterStrategies.");
            }
            try
            {
                _writer.Write(packet.PacketTypeId);
                _writerStrategies[packet.PacketTypeId](_writer, packet);
            }
            catch (Exception e)
            {
                Connected = false;
            }
        }

        public async Task WriteAsyc(PacketBase packet)
        {
            if (!_writerStrategies.ContainsKey(packet.PacketTypeId))
            {
                throw new InvalidOperationException($"Packet with ID {packet.PacketTypeId} was not found in WriterStrategies.");
            }
            await _writer.WriteAsync(packet.PacketTypeId);
            _writerStrategies[packet.PacketTypeId](_writer, packet);
        }

        public PacketBase Read()
        {
            if (!_stream.DataAvailable)
                return _emptyPacket;

            var packetTypeId = _reader.ReadInt32();

            if (!_readerStrategies.ContainsKey(packetTypeId))
            {
                throw new InvalidOperationException($"Packet with ID {packetTypeId} was not found in ReaderStrategies.");
            }
            return _readerStrategies[packetTypeId](_reader);
        }

        public async Task<PacketBase> ReadAsync()
        {
            if (!_stream.DataAvailable)
                return _emptyPacket;

            var packetTypeId = await _reader.ReadInt32Async();

            if (!_readerStrategies.ContainsKey(packetTypeId))
            {
                throw new InvalidOperationException($"Packet with ID {packetTypeId} was not found in ReaderStrategies.");
            }
            return _readerStrategies[packetTypeId](_reader);
        }

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

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

public class PacketStreamFactory
    {
        public static PacketStream CreateLoginServerPacketStream(IAvailabilityStream stream)
        {
            var packetStream = new PacketStream(stream);
            packetStream.Register<HeartbeatPacket>((int)PacketType.HEARTBEAT, Read, Write);
            packetStream.Register<LoginPacket>((int)PacketType.LOGIN, Read, Write);
            packetStream.Register<AuthSuccessPacket>((int)PacketType.AUTH_SUCCESS, Read, Write);
            packetStream.Register<AuthFailurePacket>((int)PacketType.AUTH_FAILURE, Read, Write);
            return packetStream;
        }

        public static PacketStream CreateLobbyPacketStream(IAvailabilityStream stream)
        {
            var packetStream = new PacketStream(stream);
            packetStream.Register<HeartbeatPacket>((int)PacketType.HEARTBEAT, Read, Write);
            packetStream.Register<ChatMessagePacket>((int)PacketType.CHAT_MESSAGE, Read, Write);
            packetStream.Register<CreateRoomPacket>((int)PacketType.CREATE_ROOM, Read, Write);
            packetStream.Register<CreateRoomResponsePacket>((int)PacketType.CREATE_ROOM_RESPONSE, Read, Write);
            packetStream.Register<RoomPresencePacket>((int)PacketType.ROOM_PRESENCE, Read, Write);
            packetStream.Register<RosterItemPacket>((int)PacketType.ROSTER_ITEM, Read, Write);
            packetStream.Register<PresencePacket>((int)PacketType.PRESENCE, Read, Write);
            packetStream.Register<StatusPacket>((int)PacketType.STATUS, Read, Write);
            return packetStream;
        }

        #region LOGIN
        private static void Write(PacketStreamWriter binaryWriter, LoginPacket loginPacket)
        {
            binaryWriter.Write(loginPacket.Username);
            binaryWriter.Write(loginPacket.Password);
        }

        private static LoginPacket Read(PacketStreamReader binaryReader, LoginPacket loginPacket)
        {
            loginPacket.Username = binaryReader.ReadString();
            loginPacket.Password = binaryReader.ReadString();
            return loginPacket;
        }
        #endregion
    }

Dictionary<int, object> _readerStrategies;
_readerStrategies.Add((int)PacketType.HEARTBEAT, new object());
_readerStrategies[packet.PacketTypeId];

Dictionary<PacketType, object> _readerStrategies;
_readerStrategies.Add(PacketType.HEARTBEAT, new object());
_readerStrategies[(PacketType)packet.PacketTypeId];