Client udp service

mROA/Implementation/Attributes/UntrustedAttribute.cs

@@ -0,0 +1,8 @@
+using System;
+
+namespace mROA.Implementation.Attributes
+{
+    public class UntrustedAttribute : Attribute
+    {
+    }
+}

mROA/Implementation/RemoteObjectBase.cs

@@ -137,6 +137,15 @@ namespace mROA.Implementation
             }
         }
 
+        protected async Task CallUntrustedAsync(int methodId, object?[]? parameters = null)
+        {
+            var request = new DefaultCallRequest
+            {
+                CommandId = methodId, ObjectId = _identifier, Parameters = parameters
+            };
+            await _representationModule.PostCallMessageUntrustedAsync(request.Id, EMessageType.CallRequest, request);
+        }
+
         public override string ToString()
         {
             return _identifier.ToString();

mROA/Implementation/RepresentationModule.cs

@@ -37,7 +37,7 @@ namespace mROA.Implementation
             var writer = _interaction.ReceiveChanel.Writer;
             var reader = _interaction.ReceiveChanel.Reader;
 
-            
+
             await foreach (var message in reader.ReadAllAsync(token))
             {
                 if (!rule(message))
@@ -95,6 +95,13 @@ namespace mROA.Implementation
             PostCallMessageAsync(id, eMessageType, payload).GetAwaiter().GetResult();
         }
 
+        public async Task PostCallMessageUntrustedAsync<T>(Guid id, EMessageType eMessageType, T payload) where T : notnull
+        {
+            var serialized = _serialization.Serialize(payload, typeof(T));
+            await _interaction.PostMessageUntrustedAsync(new NetworkMessageHeader
+                { Id = id, MessageType = eMessageType, Data = serialized });
+        }
+
         public void PostCallMessage(Guid id, EMessageType eMessageType, object payload, Type payloadType)
         {
             PostCallMessageAsync(id, eMessageType, payload, payloadType).GetAwaiter().GetResult();

mROA/Implementation/UdpUntrustedInteraction.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+using mROA.Abstract;
+
+namespace mROA.Implementation
+{
+    public class UdpUntrustedInteraction : IUntrustedInteractionModule
+    {
+        private ISerializationToolkit _serializationToolkit;
+        private IChannelInteractionModule _channelInteractionModule;
+        private CancellationTokenSource _tokenSource = new CancellationTokenSource();
+        public void Dispose()
+        {
+            _tokenSource.Cancel();
+        }
+
+        public Task Start(IPEndPoint endpoint)
+        {
+            return Task.Run(() =>
+            {
+                var client = new UdpClient();
+                client.Connect(endpoint);
+                Listening(client, _tokenSource.Token);
+                Posting(client, _tokenSource.Token);
+            }, _tokenSource.Token);
+        }
+
+        private async Task Listening(UdpClient udpClient, CancellationToken token)
+        {
+            var writer = _channelInteractionModule.ReceiveChanel.Writer;
+            while (token.IsCancellationRequested == false)
+            {
+                var message = new Memory<byte>((await udpClient.ReceiveAsync()).Buffer);
+                var parsed = _serializationToolkit.Deserialize<NetworkMessageHeader>(message.Span)!;
+                await writer.WriteAsync(parsed, token);
+            }
+        }
+
+        private async Task Posting(UdpClient udpClient, CancellationToken token)
+        {
+            await foreach (var post in _channelInteractionModule.UntrustedPostChanel.ReadAllAsync(token))
+            {
+                var serialized = _serializationToolkit.Serialize(post);
+                await udpClient.SendAsync(serialized, serialized.Length);
+            }
+        }
+        
+        public void Inject<T>(T dependency)
+        {
+            switch (dependency)
+            {
+                case IChannelInteractionModule channelModule:
+                    _channelInteractionModule = channelModule;
+                    break;
+                case ISerializationToolkit serializationToolkit:
+                    _serializationToolkit = serializationToolkit;
+                    break;
+            }
+        }
+    }
+}