public ChannelWrapper()
{
// Internal messaging used for messaging between channel unwrapper
// and typed message receivers.
// We want that requests do not block each other. So every request will be processed in its own thread.
IMessagingSystemFactory anInternalMessaging = new ThreadPoolMessagingSystemFactory();
// All messages are received via one channel. So we must provide "unwrapper" forwarding incoming messages
// to correct receivers.
IChannelWrapperFactory aChannelWrapperFactory = new ChannelWrapperFactory();
myDuplexChannelUnwrapper = aChannelWrapperFactory.CreateDuplexChannelUnwrapper(anInternalMessaging);
// To connect receivers and the unwrapper with duplex channels we can use the following helper class.
IConnectionProviderFactory aConnectionProviderFactory = new ConnectionProviderFactory();
IConnectionProvider aConnectionProvider = aConnectionProviderFactory.CreateConnectionProvider(anInternalMessaging);
// Factory to create message receivers.
IDuplexTypedMessagesFactory aMessageReceiverFactory = new DuplexTypedMessagesFactory();
// Create receiver to sum two numbers.
plusReceiver = aMessageReceiverFactory.CreateDuplexTypedMessageReceiver <TestOutput, TestInput>();
plusReceiver.MessageReceived += (s, e) => {
Console.WriteLine("PLUS: " + e.RequestMessage.Name + " | " + e.RequestMessage.Value);
plusReceiver.SendResponseMessage(e.ResponseReceiverId, new TestOutput {
Value = e.RequestMessage.Name + "+" + e.RequestMessage.Value
});
};
// attach method handling the request
aConnectionProvider.Attach(plusReceiver, "plus"); // attach the input channel to get messages from unwrapper
// Create receiver to sum two numbers.
minusReceiver = aMessageReceiverFactory.CreateDuplexTypedMessageReceiver <TestOutput, TestInput>();
minusReceiver.MessageReceived += (s, e) => {
Console.WriteLine("MINUS: " + e.RequestMessage.Name + " | " + e.RequestMessage.Value);
minusReceiver.SendResponseMessage(e.ResponseReceiverId, new TestOutput {
Value = e.RequestMessage.Name + "-" + e.RequestMessage.Value
});
};
// attach method handling the request
aConnectionProvider.Attach(minusReceiver, "minus"); // attach the input channel to get messages from unwrapper
// Create receiver to sum two numbers.
dotReceiver = aMessageReceiverFactory.CreateDuplexTypedMessageReceiver <TestOutput, TestInput>();
dotReceiver.MessageReceived += (s, e) => {
Console.WriteLine("DOT: " + e.RequestMessage.Name + " | " + e.RequestMessage.Value);
dotReceiver.SendResponseMessage(e.ResponseReceiverId, new TestOutput {
Value = e.RequestMessage.Name + "." + e.RequestMessage.Value
});
};
// attach method handling the request
aConnectionProvider.Attach(dotReceiver, "dot"); // attach the input channel to get messages from unwrapper
}
static void Main(string[] args)
{
// Create ProtoBuf serializer.
ISerializer aSerializer = new ProtoBufSerializer();
// Create message receiver.
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory(aSerializer);
IDuplexTypedMessageReceiver<ResponseMessage, RequestMessage> aReceiver =
aReceiverFactory.CreateDuplexTypedMessageReceiver<ResponseMessage, RequestMessage>();
// Subscribe to process request messages.
aReceiver.MessageReceived += OnMessageReceived;
// Use TCP for the communication.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexInputChannel anInputChannel =
aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:4502/");
// Attach the input channel to the receiver and start listening.
aReceiver.AttachDuplexInputChannel(anInputChannel);
Console.WriteLine("The calculator service is running. Press ENTER to stop.");
Console.ReadLine();
// Detach the input channel to stop listening.
aReceiver.DetachDuplexInputChannel();
}
public void SyncRequestResponse()
{
IDuplexTypedMessageReceiver <string, int> aReceiver = DuplexTypedMessagesFactory.CreateDuplexTypedMessageReceiver <string, int>();
aReceiver.MessageReceived += (x, y) =>
{
aReceiver.SendResponseMessage(y.ResponseReceiverId, (y.RequestMessage * 10).ToString());
};
ISyncDuplexTypedMessageSender <string, int> aSender = DuplexTypedMessagesFactory.CreateSyncDuplexTypedMessageSender <string, int>();
try
{
aReceiver.AttachDuplexInputChannel(InputChannel);
aSender.AttachDuplexOutputChannel(OutputChannel);
string aResult = aSender.SendRequestMessage(100);
Assert.AreEqual("1000", aResult);
}
finally
{
aSender.DetachDuplexOutputChannel();
aReceiver.DetachDuplexInputChannel();
}
}
public static void run()
{
// Create message receiver receiving 'MyRequest' and receiving 'MyResponse'.
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
myReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver <MyResponse, MyRequest>();
// Subscribe to handle messages.
myReceiver.MessageReceived += OnMessageReceived;
// Create TCP messaging.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexInputChannel anInputChannel
= aMessaging.CreateDuplexInputChannel("tcp://192.168.43.167:8067/");
//= aMessaging.CreateDuplexInputChannel("tcp://192.168.173.1:8060/");
// Attach the input channel and start to listen to messages.
myReceiver.AttachDuplexInputChannel(anInputChannel);
Console.WriteLine("The service is running. To stop press enter.");
Console.ReadLine();
// Detach the input channel and stop listening.
// It releases the thread listening to messages.
myReceiver.DetachDuplexInputChannel();
}
static void Main(string[] args)
{
// Instantiate Protocol Buffer based serializer.
ISerializer aSerializer = new ProtoBufSerializer();
// Create message receiver receiving 'MyRequest' and receiving 'MyResponse'.
// The receiver will use Protocol Buffers to serialize/deserialize messages.
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory(aSerializer);
myReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver<MyResponse, MyRequest>();
// Subscribe to handle messages.
myReceiver.MessageReceived += OnMessageReceived;
// Create TCP messaging.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexInputChannel anInputChannel
= aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:8060/");
// Attach the input channel and start to listen to messages.
myReceiver.AttachDuplexInputChannel(anInputChannel);
Console.WriteLine("The service is running. To stop press enter.");
Console.ReadLine();
// Detach the input channel and stop listening.
// It releases the thread listening to messages.
myReceiver.DetachDuplexInputChannel();
}
public void ConnectionClosedDuringWaitingForResponse()
{
IDuplexTypedMessageReceiver <int, int> aReceiver = DuplexTypedMessagesFactory.CreateDuplexTypedMessageReceiver <int, int>();
aReceiver.MessageReceived += (x, y) =>
{
// Disconnect the cient.
aReceiver.AttachedDuplexInputChannel.DisconnectResponseReceiver(y.ResponseReceiverId);
};
ISyncDuplexTypedMessageSender <int, int> aSender = DuplexTypedMessagesFactory.CreateSyncDuplexTypedMessageSender <int, int>();
try
{
aReceiver.AttachDuplexInputChannel(InputChannel);
aSender.AttachDuplexOutputChannel(OutputChannel);
Assert.Throws <InvalidOperationException>(() => aSender.SendRequestMessage(100));
}
finally
{
aSender.DetachDuplexOutputChannel();
aReceiver.DetachDuplexInputChannel();
}
}
static void Main(string[] args)
{
string aServiceAddress = GetMyAddress();
if (aServiceAddress == "")
{
Console.WriteLine("The service could not start because all possible ports are occupied");
return;
}
// TCP message protocol for receiving requests
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel(aServiceAddress);
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
IDuplexTypedMessageReceiver <double, Range> aReceiver
= aReceiverFactory.CreateDuplexTypedMessageReceiver <double, Range>();
aReceiver.MessageReceived += OnMessageReceived;
aReceiver.AttachDuplexInputChannel(anInputChannel);
Console.WriteLine("Root Square Calculator listening to " + aServiceAddress +
" is running.\r\n Press ENTER to stop.");
Console.ReadLine();
aReceiver.DetachDuplexInputChannel();
}
static void Main(string[] args)
{
string aServiceAddress = GetMyAddress();
if (aServiceAddress == "")
{
Console.WriteLine("The service could not start because all possible ports are occupied.");
return;
}
// Create TCP messaging for receiving requests.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel(aServiceAddress);
// Create typed message receiver to receive requests.
// It receives request messages of type Range and sends back
// response messages of type double.
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
IDuplexTypedMessageReceiver <double, Range> aReceiver
= aReceiverFactory.CreateDuplexTypedMessageReceiver <double, Range>();
// Subscribre to messages.
aReceiver.MessageReceived += OnMessageReceived;
// Attach the input channel and start listening.
aReceiver.AttachDuplexInputChannel(anInputChannel);
Console.WriteLine("Root Square Calculator listening to " + aServiceAddress +
" is running.\r\n Press ENTER to stop.");
Console.ReadLine();
// Detach the input channel and stop listening.
aReceiver.DetachDuplexInputChannel();
}
public void ThreadDispatching()
{
IDuplexTypedMessageReceiver <string, int> aReceiver = DuplexTypedMessagesFactory.CreateDuplexTypedMessageReceiver <string, int>();
aReceiver.MessageReceived += (x, y) =>
{
aReceiver.SendResponseMessage(y.ResponseReceiverId, (y.RequestMessage * 10).ToString());
};
// Set windows working thread dispatcher.
Dispatcher aWindowsDispatcher = WindowsDispatching.StartNewWindowsDispatcher();
WindowsDispatching aThreadDispatching = new WindowsDispatching(aWindowsDispatcher);
((DuplexTypedMessagesFactory)DuplexTypedMessagesFactory).SyncDuplexTypedSenderThreadMode = aThreadDispatching;
ISyncDuplexTypedMessageSender <string, int> aSender = DuplexTypedMessagesFactory.CreateSyncDuplexTypedMessageSender <string, int>();
int aOpenConnectionThreadId = 0;
aSender.ConnectionOpened += (x, y) =>
{
aOpenConnectionThreadId = Thread.CurrentThread.ManagedThreadId;
};
ManualResetEvent aConnectionClosedEvent = new ManualResetEvent(false);
int aCloseConnectionThreadId = 0;
aSender.ConnectionClosed += (x, y) =>
{
aCloseConnectionThreadId = Thread.CurrentThread.ManagedThreadId;
aConnectionClosedEvent.Set();
};
try
{
aReceiver.AttachDuplexInputChannel(InputChannel);
aSender.AttachDuplexOutputChannel(OutputChannel);
string aResult = aSender.SendRequestMessage(100);
aReceiver.AttachedDuplexInputChannel.DisconnectResponseReceiver(aSender.AttachedDuplexOutputChannel.ResponseReceiverId);
aConnectionClosedEvent.WaitOne();
Assert.AreEqual("1000", aResult);
Assert.AreEqual(aWindowsDispatcher.Thread.ManagedThreadId, aOpenConnectionThreadId);
Assert.AreEqual(aWindowsDispatcher.Thread.ManagedThreadId, aCloseConnectionThreadId);
}
finally
{
aSender.DetachDuplexOutputChannel();
aReceiver.DetachDuplexInputChannel();
if (aWindowsDispatcher != null)
{
WindowsDispatching.StopWindowsDispatcher(aWindowsDispatcher);
}
}
}
public void OpenConnect()
{
// Create duplex typed message receiver.
// It receives request messages of type Person and responses string.
IDuplexTypedMessagesFactory aDuplexTypedMessagesFactory = new DuplexTypedMessagesFactory();
myMessageReceiver = aDuplexTypedMessagesFactory.CreateDuplexTypedMessageReceiver <string, Person>();
myMessageReceiver.MessageReceived += OnMessageReceived;
}
protected void Setup(IMessagingSystemFactory messagingSystemFactory, string channelId, ISerializer serializer)
{
MessagingSystemFactory = messagingSystemFactory;
DuplexOutputChannel = MessagingSystemFactory.CreateDuplexOutputChannel(channelId);
DuplexInputChannel = MessagingSystemFactory.CreateDuplexInputChannel(channelId);
IDuplexTypedMessagesFactory aMessageFactory = new DuplexTypedMessagesFactory(serializer);
Requester = aMessageFactory.CreateDuplexTypedMessageSender <int, int>();
Responser = aMessageFactory.CreateDuplexTypedMessageReceiver <int, int>();
}
public CalculatorService(string address, IMessagingSystemFactory messaging)
{
using (EneterTrace.Entering())
{
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
myRequestReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver <double, Interval>();
myRequestReceiver.MessageReceived += OnMessageReceived;
IDuplexInputChannel anInputChannel = messaging.CreateDuplexInputChannel(address);
myRequestReceiver.AttachDuplexInputChannel(anInputChannel);
}
}
public Server()
{
sampleMutex = new object();
dataReceiveds = new List <DataReceived>();
// Create message receiver.
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
myReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver <MyResponse, MyRequest>();
clients = new List <Client>();
myReceiver.ResponseReceiverConnected += OnClientConnected;
myReceiver.ResponseReceiverDisconnected += OnClientDisconnected;
myReceiver.MessageReceived += OnMessageReceived;
}
public Form1()
{
InitializeComponent();
// Create message receiver.
// Note: it receives string and sends back string.
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
myReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver <MyResponse, MyRequest>();
// Subscribe to get notified when a client connects, disconnects
// or sends a message.
myReceiver.ResponseReceiverConnected += OnClientConnected;
myReceiver.ResponseReceiverDisconnected += OnClientDisconnected;
myReceiver.MessageReceived += OnMessageReceived;
}
public void DetachOutputChannelDuringWaitingForResponse()
{
IDuplexTypedMessageReceiver <int, int> aReceiver = DuplexTypedMessagesFactory.CreateDuplexTypedMessageReceiver <int, int>();
ISyncDuplexTypedMessageSender <int, int> aSender = DuplexTypedMessagesFactory.CreateSyncDuplexTypedMessageSender <int, int>();
try
{
aReceiver.AttachDuplexInputChannel(InputChannel);
aSender.AttachDuplexOutputChannel(OutputChannel);
// Send the request from a different thread.
AutoResetEvent aWaitingInterrupted = new AutoResetEvent(false);
Exception aCaughtException = null;
ThreadPool.QueueUserWorkItem(x =>
{
try
{
aSender.SendRequestMessage(100);
}
catch (Exception err)
{
aCaughtException = err;
}
aWaitingInterrupted.Set();
});
Thread.Sleep(100);
// Detach the output channel while other thread waits for the response.
aSender.DetachDuplexOutputChannel();
Assert.IsTrue(aWaitingInterrupted.WaitOne(50000));
Assert.IsTrue(aCaughtException != null && aCaughtException is InvalidOperationException);
}
finally
{
aSender.DetachDuplexOutputChannel();
aReceiver.DetachDuplexInputChannel();
}
}
// Connect
public void Connect(string channelID)
{
// Create message receiver receiving 'MyRequest' and receiving 'MyResponse'.
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
myReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver <MyResponse, MyRequest>();
// Subscribe to handle messages.
myReceiver.MessageReceived += OnMessageReceived;
// Create TCP messaging.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexInputChannel anInputChannel =
aMessaging.CreateDuplexInputChannel(channelID);
// Attach the input channel and start to listen to messages.
myReceiver.AttachDuplexInputChannel(anInputChannel);
isConnected = true;
}
public void WaitingForResponseTimeouted()
{
IDuplexTypedMessageReceiver <int, int> aReceiver = DuplexTypedMessagesFactory.CreateDuplexTypedMessageReceiver <int, int>();
// Create sender expecting the response within 500 ms.
IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory(TimeSpan.FromMilliseconds(500));
ISyncDuplexTypedMessageSender <int, int> aSender = aSenderFactory.CreateSyncDuplexTypedMessageSender <int, int>();
try
{
aReceiver.AttachDuplexInputChannel(InputChannel);
aSender.AttachDuplexOutputChannel(OutputChannel);
Assert.Throws <InvalidOperationException>(() => aSender.SendRequestMessage(100));
}
finally
{
aSender.DetachDuplexOutputChannel();
aReceiver.DetachDuplexInputChannel();
}
}
public void SendReceive_1Message_PerClientSerializer()
{
string aClient1Id = null;
IDuplexTypedMessagesFactory aSender1Factory = new DuplexTypedMessagesFactory(new XmlStringSerializer());
IDuplexTypedMessagesFactory aSender2Factory = new DuplexTypedMessagesFactory(new BinarySerializer());
IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory()
{
SerializerProvider = x => (x == aClient1Id) ? (ISerializer) new XmlStringSerializer() : (ISerializer) new BinarySerializer()
};
IDuplexTypedMessageSender <int, int> aSender1 = aSender1Factory.CreateDuplexTypedMessageSender <int, int>();
IDuplexTypedMessageSender <int, int> aSender2 = aSender2Factory.CreateDuplexTypedMessageSender <int, int>();
IDuplexTypedMessageReceiver <int, int> aReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver <int, int>();
aReceiver.ResponseReceiverConnected += (x, y) => aClient1Id = aClient1Id ?? y.ResponseReceiverId;
int aReceivedMessage = 0;
aReceiver.MessageReceived += (x, y) =>
{
aReceivedMessage = y.RequestMessage;
// Send the response
aReceiver.SendResponseMessage(y.ResponseReceiverId, 1000);
};
AutoResetEvent aSender1MessageReceivedEvent = new AutoResetEvent(false);
int aSender1ReceivedResponse = 0;
aSender1.ResponseReceived += (x, y) =>
{
aSender1ReceivedResponse = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aSender1MessageReceivedEvent.Set();
};
AutoResetEvent aSender2MessageReceivedEvent = new AutoResetEvent(false);
int aSender2ReceivedResponse = 0;
aSender2.ResponseReceived += (x, y) =>
{
aSender2ReceivedResponse = y.ResponseMessage;
// Signal that the response message was received -> the loop is closed.
aSender2MessageReceivedEvent.Set();
};
try
{
aReceiver.AttachDuplexInputChannel(DuplexInputChannel);
aSender1.AttachDuplexOutputChannel(MessagingSystemFactory.CreateDuplexOutputChannel(DuplexInputChannel.ChannelId));
aSender2.AttachDuplexOutputChannel(MessagingSystemFactory.CreateDuplexOutputChannel(DuplexInputChannel.ChannelId));
aSender1.SendRequestMessage(2000);
aSender2.SendRequestMessage(2000);
// Wait for the signal that the message is received.
aSender1MessageReceivedEvent.WaitIfNotDebugging(2000);
aSender2MessageReceivedEvent.WaitIfNotDebugging(2000);
//Assert.IsTrue(aMessageReceivedEvent.WaitOne(2000));
}
finally
{
aSender1.DetachDuplexOutputChannel();
aSender2.DetachDuplexOutputChannel();
aReceiver.DetachDuplexInputChannel();
// Give some time to complete tracing.
Thread.Sleep(300);
}
// Check received values
Assert.AreEqual(2000, aReceivedMessage);
Assert.AreEqual(1000, aSender1ReceivedResponse);
Assert.AreEqual(1000, aSender2ReceivedResponse);
}