initial commit

Quasar.Common/Networking/ISender.cs

@@ -0,0 +1,10 @@
+using Quasar.Common.Messages;
+
+namespace Quasar.Common.Networking
+{
+    public interface ISender
+    {
+        void Send<T>(T message) where T : IMessage;
+        void Disconnect();
+    }
+}

Quasar.Common/Networking/PayloadReader.cs

@@ -0,0 +1,75 @@
+using ProtoBuf;
+using Quasar.Common.Messages;
+using System;
+using System.IO;
+
+namespace Quasar.Common.Networking
+{
+    public class PayloadReader : MemoryStream
+    {
+        private readonly Stream _innerStream;
+        public bool LeaveInnerStreamOpen { get; }
+
+        public PayloadReader(byte[] payload, int length, bool leaveInnerStreamOpen)
+        {
+            _innerStream = new MemoryStream(payload, 0, length, false, true);
+            LeaveInnerStreamOpen = leaveInnerStreamOpen;
+        }
+
+        public PayloadReader(Stream stream, bool leaveInnerStreamOpen)
+        {
+            _innerStream = stream;
+            LeaveInnerStreamOpen = leaveInnerStreamOpen;
+        }
+
+        public int ReadInteger()
+        {
+            return BitConverter.ToInt32(ReadBytes(4), 0);
+        }
+
+        public byte[] ReadBytes(int length)
+        {
+            if (_innerStream.Position + length <= _innerStream.Length)
+            {
+                byte[] result = new byte[length];
+                _innerStream.Read(result, 0, result.Length);
+                return result;
+            }
+            throw new OverflowException($"Unable to read {length} bytes from stream");
+        }
+
+        /// <summary>
+        /// Reads the serialized message of the payload and deserializes it.
+        /// </summary>
+        /// <returns>The deserialized message of the payload.</returns>
+        public IMessage ReadMessage()
+        {
+            ReadInteger();
+            /* Length prefix is ignored here and already handled in Client class,
+             * it would cause to much trouble to check here for split or not fully
+             * received packets.
+             */
+            IMessage message = Serializer.Deserialize<IMessage>(_innerStream);
+            return message;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            try
+            {
+                if (LeaveInnerStreamOpen)
+                {
+                    _innerStream.Flush();
+                }
+                else
+                {
+                    _innerStream.Close();
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }
+    }
+}

Quasar.Common/Networking/PayloadWriter.cs

@@ -0,0 +1,65 @@
+using ProtoBuf;
+using Quasar.Common.Messages;
+using System;
+using System.IO;
+
+namespace Quasar.Common.Networking
+{
+    public class PayloadWriter : MemoryStream
+    {
+        private readonly Stream _innerStream;
+        public bool LeaveInnerStreamOpen { get; }
+
+        public PayloadWriter(Stream stream, bool leaveInnerStreamOpen)
+        {
+            _innerStream = stream;
+            LeaveInnerStreamOpen = leaveInnerStreamOpen;
+        }
+
+        public void WriteBytes(byte[] value)
+        {
+            _innerStream.Write(value, 0, value.Length);
+        }
+
+        public void WriteInteger(int value)
+        {
+            WriteBytes(BitConverter.GetBytes(value));
+        }
+
+        /// <summary>
+        /// Writes a serialized message as payload to the stream.
+        /// </summary>
+        /// <param name="message">The message to write.</param>
+        /// <returns>The amount of written bytes to the stream.</returns>
+        public int WriteMessage(IMessage message)
+        {
+            using (MemoryStream ms = new MemoryStream())
+            {
+                Serializer.Serialize(ms, message);
+                byte[] payload = ms.ToArray();
+                WriteInteger(payload.Length);
+                WriteBytes(payload);
+                return sizeof(int) + payload.Length;
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            try
+            {
+                if (LeaveInnerStreamOpen)
+                {
+                    _innerStream.Flush();
+                }
+                else
+                {
+                    _innerStream.Close();
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }
+    }
+}