улучшен новый модуль взаимодействия и написан новый модуль репрезентации

mROA/Abstract/IInteractionModule.cs

@@ -2,25 +2,10 @@ using mROA.Implementation;
 
 namespace mROA.Abstract;
 
-public interface IInteractionModule : IInjectableModule
-{
-    void SendTo(int clientId, byte[] message);
-    void RegisterSource(Stream stream);
-    Stream GetSource(int clientId);
-    public interface IFrontendInteractionModule : IInjectableModule
-    {
-        int ClientId { get; }
-        public Task<byte[]> ReceiveMessage();
-        public void PostMessage(byte[] message);
-    }
-}
-
 public interface INextGenerationInteractionModule : IInjectableModule
 {
     int ConntectionId { get; }
     public Stream? BaseStream { get; set; }
     Task<NetworkMessage> GetNextMessageReceiving();
-    void PostMessage(NetworkMessage message);
-    NetworkMessage[] UnhandledMessages { get; }
-    void HandleMessage(NetworkMessage msg);
+    Task PostMessage(NetworkMessage message);
 }

mROA/Abstract/ISerialisationModule.cs

@@ -1,3 +1,4 @@
+using System.Windows.Input;
 using mROA.Implementation;
 
 namespace mROA.Abstract;
@@ -12,7 +13,14 @@ public interface ISerialisationModule : IInjectableModule
         int ClientId { get; }
         Task<T> GetNextCommandExecution<T>(Guid requestId) where T : ICommandExecution;
         Task<FinalCommandExecution<T>> GetFinalCommandExecution<T>(Guid requestId);
-        
         void PostCallRequest(ICallRequest callRequest);
     }
+}
+
+public interface IRepresentationModule : IInjectableModule
+{
+    int Id { get; }
+    Task<T> GetMessage<T>(Guid? requestId, MessageType? messageType);
+    Task PostCallMessage<T>(Guid id, MessageType messageType, T payload);
+    Task PostCallMessage(Guid id, MessageType messageType, object payload, Type payloadType);
 }

mROA/Implementation/AsyncNetworkInteractionModule.cs

@@ -1,33 +0,0 @@
-namespace mROA.Implementation;
-
-public class AsyncNetworkInteractionModule
-{
-    private ISerializationToolkit _iSerializationToolkit;
-    private const int BufferSize = ushort.MaxValue;
-    private Stream? _stream;
-    private List<NetworkMessage> _unhandledMessages = new(8);
-    private byte[] _buffer = new byte[BufferSize];
-    private Task? _currentReadTask;
-    
-    
-    public Task ReceiveNext()
-    {
-        _currentReadTask ??= StartReceiving();
-        return _currentReadTask;
-    }
-
-    private async Task StartReceiving()
-    {
-        await _stream.ReadExactlyAsync(_buffer, 0, 2);
-        var len = BitConverter.ToUInt16(_buffer, 0);
-        await _stream.ReadExactlyAsync(_buffer, 0, len);
-        
-    }
-    
-    public NetworkMessage GetLastMessage()
-    {
-        return _unhandledMessages.Last();
-    }
-    
-    
-}

mROA/Implementation/NetworkMessage.cs

@@ -1,4 +1,5 @@
-using mROA.Abstract;
+using System.Text.Json;
+using mROA.Abstract;
 
 namespace mROA.Implementation;
 

mROA/Implementation/NextGenerationInteractionModule.cs

@@ -1,17 +1,15 @@
 using mROA.Abstract;
-using mROA.Implementation;
 
-namespace mROA;
+namespace mROA.Implementation;
 
 public class NextGenerationInteractionModule : INextGenerationInteractionModule
 {
-    private ISerializationToolkit _serialization;
+    private ISerializationToolkit? _serialization;
     public int ConntectionId { get; set; }
-    public Stream BaseStream { get; set; }
+    public Stream? BaseStream { get; set; }
     private Task<NetworkMessage>? _currentReceiving;
     private const int BufferSize = ushort.MaxValue;
-    private byte[] _buffer = new byte[BufferSize];
-    private List<NetworkMessage> _unhandledMessages = new(8);
+    private readonly byte[] _buffer = new byte[BufferSize];
 
     public void Inject<T>(T dependency)
     {
@@ -29,22 +27,24 @@ public class NextGenerationInteractionModule : INextGenerationInteractionModule
         return _currentReceiving;
     }
 
-    public void PostMessage(NetworkMessage message)
+    public async Task PostMessage(NetworkMessage message)
     {
+        if (BaseStream == null)
+            throw new NullReferenceException("BaseStream is null");
+        
         var rawMessage = _serialization.Serialize(message);
-        BaseStream.Write(BitConverter.GetBytes((ushort)rawMessage.Length), 0, sizeof(ushort));
-        BaseStream.Write(rawMessage, 0, rawMessage.Length);
-    }
-
-    public NetworkMessage[] UnhandledMessages => _unhandledMessages.ToArray();
-
-    public void HandleMessage(NetworkMessage msg)
-    {
-        _unhandledMessages.Remove(msg);
+        await BaseStream.WriteAsync(BitConverter.GetBytes((ushort)rawMessage.Length).AsMemory(0, sizeof(ushort)));
+        await BaseStream.WriteAsync(rawMessage);
     }
 
     private async Task<NetworkMessage> GetNextMessage()
     {
+        if (BaseStream == null)
+            throw new NullReferenceException("BaseStream is null");
+
+        if (_serialization == null)
+            throw new NullReferenceException("Serialization toolkit is null");
+
         await BaseStream.ReadExactlyAsync(_buffer, 0, 2);
         var len = BitConverter.ToUInt16(_buffer, 0);
         await BaseStream.ReadExactlyAsync(_buffer, 0, len);

mROA/Implementation/RemoteContextRepository.cs

@@ -1,5 +1,4 @@
 using System.Collections.Frozen;
-using System.Collections.Immutable;
 using mROA.Abstract;
 
 namespace mROA.Implementation;

mROA/Implementation/RepresentationModule.cs

@@ -0,0 +1,44 @@
+using mROA.Abstract;
+
+namespace mROA.Implementation;
+
+public class RepresentationModule : IRepresentationModule
+{
+    private ISerializationToolkit _serialization;
+    private INextGenerationInteractionModule _interaction;
+
+    public void Inject<T>(T dependency)
+    {
+        switch (dependency)
+        {
+            case ISerializationToolkit toolkit:
+                _serialization = toolkit;
+                break;
+            case INextGenerationInteractionModule interactionModule:
+                _interaction = interactionModule;
+                break;
+        }
+    }
+
+    public int Id { get; set; }
+
+    public async Task<T> GetMessage<T>(Guid? requestId, MessageType? messageType)
+    {
+        while (true)
+        {
+            var message = await _interaction.GetNextMessageReceiving();
+            if ((requestId is null || message.Id == requestId) && (messageType is null || message.SchemaId == messageType))
+                return _serialization.Deserialize<T>(message.Data)!;
+        }
+    }
+
+    public async Task PostCallMessage<T>(Guid id, MessageType messageType, T payload)
+    {
+        await PostCallMessage(id, messageType, payload, typeof(T));
+    }
+
+    public async Task PostCallMessage(Guid id, MessageType messageType, object payload, Type payloadType)
+    {
+        await _interaction.PostMessage(new NetworkMessage {Id = id, SchemaId = messageType, Data = _serialization.Serialize(payload, payloadType)});
+    }
+}