Add InterfacedMessageBuilder

core/Akka.Interfaced.Tests/Akka.Interfaced.Tests.csproj

@@ -85,6 +85,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="InterfacedActorRefCastTest.cs" />
+    <Compile Include="InterfacedMessageBuilderTest.cs" />
     <Compile Include="Interface\IBasic.cs" />
     <Compile Include="Interface\IDummy.cs" />
     <Compile Include="Interface\IOverloaded.cs" />

core/Akka.Interfaced.Tests/InterfacedMessageBuilderTest.cs

@@ -0,0 +1,25 @@
+using Xunit;
+
+namespace Akka.Interfaced
+{
+    public class InterfacedMessageBuilderTest
+    {
+        [Fact]
+        public void BuildRequestMessage()
+        {
+            var message = InterfacedMessageBuilder.Request<IBasic>(x => x.CallWithParameter(10));
+            var payload = message.InvokePayload as IBasic_PayloadTable.CallWithParameter_Invoke;
+            Assert.NotNull(payload);
+            Assert.Equal(10, payload.value);
+        }
+
+        [Fact]
+        public void BuildNotificationMessage()
+        {
+            var message = InterfacedMessageBuilder.Notification<ISubject2Observer>(x => x.Event("A"));
+            var payload = message.InvokePayload as ISubject2Observer_PayloadTable.Event_Invoke;
+            Assert.NotNull(payload);
+            Assert.Equal("A", payload.eventName);
+        }
+    }
+}

core/Akka.Interfaced/Akka.Interfaced.csproj

@@ -78,6 +78,7 @@
     <Compile Include="MessageDispatcher.cs" />
     <Compile Include="MessageHandlerBuilderInternalHelper.cs" />
     <Compile Include="MessageHandlerBuilder.cs" />
+    <Compile Include="InterfacedMessageBuilder.cs" />
     <Compile Include="MethodInfoComparer.cs" />
     <Compile Include="NotificationDispatcher.cs" />
     <Compile Include="NotificationHandler.cs" />

core/Akka.Interfaced/InterfacedMessageBuilder.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Akka.Interfaced
+{
+    public class InterfacedMessageBuilder
+    {
+        private class SinkRequestWaiter : IRequestWaiter
+        {
+            public RequestMessage Message { get; private set; }
+
+            void IRequestWaiter.SendRequest(IRequestTarget target, RequestMessage requestMessage)
+            {
+                Message = requestMessage;
+            }
+
+            Task IRequestWaiter.SendRequestAndWait(IRequestTarget target, RequestMessage requestMessage, TimeSpan? timeout)
+            {
+                Message = requestMessage;
+                return Task.FromResult(0);
+            }
+
+            Task<TReturn> IRequestWaiter.SendRequestAndReceive<TReturn>(IRequestTarget target, RequestMessage requestMessage, TimeSpan? timeout)
+            {
+                Message = requestMessage;
+                return Task.FromResult(default(TReturn));
+            }
+        }
+
+        public static RequestMessage Request<T>(Action<T> action)
+            where T : IInterfacedActor
+        {
+            var waiter = new SinkRequestWaiter();
+            var actorRef = InterfacedActorRef.Create(typeof(T));
+            InterfacedActorRefModifier.SetRequestWaiter(actorRef, waiter);
+            action((T)(object)actorRef);
+            return waiter.Message;
+        }
+
+        private class SinkNotificationChannel : INotificationChannel
+        {
+            public NotificationMessage Message { get; private set; }
+
+            void INotificationChannel.Notify(NotificationMessage notificationMessage)
+            {
+                Message = notificationMessage;
+            }
+        }
+
+        public static NotificationMessage Notification<T>(Action<T> action)
+            where T : IInterfacedObserver
+        {
+            var channel = new SinkNotificationChannel();
+            var observer = InterfacedObserver.Create(typeof(T));
+            observer.Channel = channel;
+            action((T)(object)observer);
+            return channel.Message;
+        }
+    }
+}