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();
}
}
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();
}
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 Main()
{
try
{
InitializeComponent();
ProcessFile();
WriteFile();
MessageBox.Show("Done!");
return;
_mMouseHookManager = new MouseHookListener(new GlobalHooker()) {Enabled = true};
_mMouseHookManager.MouseUp += mMouseHookManager_MouseUp;
ReadKeyFile(Properties.Settings.Default.KeyPath);
IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
_mySender = aSenderFactory.CreateDuplexTypedMessageSender<AppQA, MyResponse>();
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel =
aMessaging.CreateDuplexOutputChannel("tcp://" + Properties.Settings.Default.IpAddress + ":8060/");
// Attach the input channel and start to listen to messages.
_mySender.AttachDuplexOutputChannel(anOutputChannel);
}
catch (Exception exception)
{
WriteAnswer(Properties.Settings.Default.AnswerPath, exception.Message);
}
}
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 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();
}
}
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)
{
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();
}
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;
}
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
}
public void Setup()
{
//EneterTrace.DetailLevel = EneterTrace.EDetailLevel.Debug;
IMessagingSystemFactory aMessaging = new SynchronousMessagingSystemFactory();
InputChannel = aMessaging.CreateDuplexInputChannel("MyChannelId");
OutputChannel = aMessaging.CreateDuplexOutputChannel("MyChannelId");
DuplexTypedMessagesFactory = new DuplexTypedMessagesFactory();
}
public void Setup()
{
string aPort = RandomPortGenerator.Generate();
string anAddress = "tcp://127.0.0.1:" + aPort + "/";
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
InputChannel = aMessaging.CreateDuplexInputChannel(anAddress);
OutputChannel = aMessaging.CreateDuplexOutputChannel(anAddress);
DuplexTypedMessagesFactory = new DuplexTypedMessagesFactory();
}
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 ChannelWrapper()
{
IMessagingSystemFactory anInternalMessaging = new SynchronousMessagingSystemFactory();
// The service receives messages via one channel (i.e. it listens on one address).
// The incoming messages are unwrapped on the server side.
// Therefore the client must use wrapper to send messages via one channel.
IChannelWrapperFactory aChannelWrapperFactory = new ChannelWrapperFactory();
myDuplexChannelWrapper = aChannelWrapperFactory.CreateDuplexChannelWrapper();
// To connect message senders and the wrapper with duplex channels we can use the following helper class.
IConnectionProviderFactory aConnectionProviderFactory = new ConnectionProviderFactory();
IConnectionProvider aConnectionProvider = aConnectionProviderFactory.CreateConnectionProvider(anInternalMessaging);
// Factory to create message senders.
// Sent messages will be serialized in Xml.
IDuplexTypedMessagesFactory aCommandsFactory = new DuplexTypedMessagesFactory();
plusSender = aCommandsFactory.CreateDuplexTypedMessageSender <TestOutput, TestInput>();
plusSender.ResponseReceived += (s, e) => {
Console.WriteLine("CW.V+: " + e.ResponseMessage.Value);
};
// attach method handling the request
aConnectionProvider.Connect(myDuplexChannelWrapper, plusSender, "plus"); // attach the input channel to get messages from unwrapper
minusSender = aCommandsFactory.CreateDuplexTypedMessageSender <TestOutput, TestInput>();
minusSender.ResponseReceived += (s, e) => {
Console.WriteLine("CW.V-: " + e.ResponseMessage.Value);
};
// attach method handling the request
aConnectionProvider.Connect(myDuplexChannelWrapper, minusSender, "minus"); // attach the input channel to get messages from unwrapper
dotSender = aCommandsFactory.CreateDuplexTypedMessageSender <TestOutput, TestInput>();
dotSender.ResponseReceived += (s, e) => {
Console.WriteLine("CW.V.: " + e.ResponseMessage.Value);
};
// attach method handling the request
aConnectionProvider.Connect(myDuplexChannelWrapper, dotSender, "dot"); // attach the input channel to get messages from unwrapper
IMessagingSystemFactory aTcpMessagingSystem = new TcpMessagingSystemFactory();
// Create output channel to send requests to the service.
IDuplexOutputChannel anOutputChannel = aTcpMessagingSystem.CreateDuplexOutputChannel("tcp://127.0.0.1:8091/");
// Attach the output channel to the wrapper - so that we are able to send messages
// and receive response messages.
// Note: The service has the coresponding unwrapper.
myDuplexChannelWrapper.AttachDuplexOutputChannel(anOutputChannel);
}
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 void Openconnection()
{
// Create message sender sending request messages of type Person and receiving responses of type string.
IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
myMessageSender = aTypedMessagesFactory.CreateDuplexTypedMessageSender <string, Person>();
myMessageSender.ResponseReceived += OnResponseReceived;
// Create messaging based on TCP.
IMessagingSystemFactory aMessagingSystemFactory = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel = aMessagingSystemFactory.CreateDuplexOutputChannel("tcp://127.0.0.1:8094/");
// Attach output channel and be able to send messages and receive response messages.
myMessageSender.AttachDuplexOutputChannel(anOutputChannel);
}
public Form1()
{
InitializeComponent();
// Create message sender.
IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
mySender = aSenderFactory.CreateDuplexTypedMessageSender <string, string>();
// Subscribe to handle when a message is received or if the client
// is disconnected.
mySender.ConnectionClosed += OnConnectionClosed;
mySender.ResponseReceived += OnResponseReceived;
}
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 void OpenConnection()
{
// Establish connection with load scheduling module
IMessagingSystemFactory myMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel = myMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8060/");
IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
mySender = aSenderFactory.CreateDuplexTypedMessageSender <double, Range>();
// Event handler on receipt of response
mySender.ResponseReceived += OnResponseReceived;
// Attach the output channel to send messages and receive responses
mySender.AttachDuplexOutputChannel(anOutputChannel);
}
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;
}
// The method is called when the button to send message is clicked.
private void SendMessage_Click(object sender, RoutedEventArgs e)
{
// Create message sender sending request messages of type Person and receiving responses of type string.
IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
myMessageSender = aTypedMessagesFactory.CreateDuplexTypedMessageSender <byte[], byte[]>();
myMessageSender.ResponseReceived += ResponseReceived;
// Create messaging based on TCP.
IMessagingSystemFactory aMessagingSystemFactory = new TcpMessagingSystemFactory();
IDuplexOutputChannel aDuplexOutputChannel = aMessagingSystemFactory.CreateDuplexOutputChannel("tcp://127.0.0.1:4502/");
// Attach output channel and be able to send messages and receive response messages.
myMessageSender.AttachDuplexOutputChannel(aDuplexOutputChannel);
myMessageSender.SendRequestMessage(GetBytes(textBox1.Text));
}
public void OpenConnection()
{
// Create TCP messaging for the communication.
// Note: Requests are sent to the balancer that will forward them
// to available services.
IMessagingSystemFactory myMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel = myMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8060/");
// Create sender to send requests.
IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
mySender = aSenderFactory.CreateDuplexTypedMessageSender <double, Range>();
// Subscribe to receive response messages.
mySender.ResponseReceived += OnResponseReceived;
// Attach the output channel and be able to send messages and receive responses.
mySender.AttachDuplexOutputChannel(anOutputChannel);
}
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();
}
}
private void OpenConnection()
{
// Create Protocol Buffers serializer.
ISerializer aSerializer = new ProtoBufSerializer();
// Create the synchronous message sender.
// It will wait max 5 seconds for the response.
// To wait infinite time use TimeSpan.FromMiliseconds(-1) or
// default constructor new DuplexTypedMessagesFactory()
IDuplexTypedMessagesFactory aSenderFactory =
new DuplexTypedMessagesFactory(TimeSpan.FromSeconds(5), aSerializer);
mySender = aSenderFactory.CreateSyncDuplexTypedMessageSender<ResponseMessage, RequestMessage>();
// Use TCP for the communication.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel =
aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:4502/");
// Attach the output channel and be able to send messages
// and receive response messages.
mySender.AttachDuplexOutputChannel(anOutputChannel);
}
public MainWindow()
{
InitializeComponent();
IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
mySender = aTypedMessagesFactory.CreateDuplexTypedMessageSender <MyResponse, MyRequest>();
mySender.ResponseReceived += OnResponseReceived;
// Create messaging based on TCP.
IMessagingSystemFactory aMessagingSystemFactory = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel = aMessagingSystemFactory.CreateDuplexOutputChannel("tcp://192.168.2.9:8060/");
// Attach output channel and be able to send messages and receive response messages.
mySender.AttachDuplexOutputChannel(anOutputChannel);
MyRequest test = new MyRequest {
side = "L", strength = 10
};
mySender.SendRequestMessage(test);
MyRequest reset = new MyRequest {
side = "L", strength = 0
};
mySender.SendRequestMessage(reset);
try
{
USBInterface usb = new USBInterface("vid_044f", "pid_b108");
usb.Connect();
usb.enableUsbBufferEvent(new System.EventHandler(myEventCacher));
usb.startRead();
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void CalculatePi()
{
//EneterTrace.DetailLevel = EneterTrace.EDetailLevel.Debug;
//EneterTrace.TraceLog = new StreamWriter("d:/tracefile.txt");
IMessagingSystemFactory aThreadMessaging = new ThreadMessagingSystemFactory();
List <CalculatorService> aServices = new List <CalculatorService>();
ILoadBalancer aDistributor = null;
IDuplexTypedMessageSender <double, Interval> aSender = null;
// Create 50 calculating services.
try
{
for (int i = 0; i < 50; ++i)
{
aServices.Add(new CalculatorService("a" + i.ToString(), aThreadMessaging));
}
// Create Distributor
ILoadBalancerFactory aDistributorFactory = new RoundRobinBalancerFactory(aThreadMessaging);
aDistributor = aDistributorFactory.CreateLoadBalancer();
// Attach available services to the distributor.
for (int i = 0; i < aServices.Count; ++i)
{
aDistributor.AddDuplexOutputChannel("a" + i.ToString());
}
// Attach input channel to the distributor.
IDuplexInputChannel anInputChannel = aThreadMessaging.CreateDuplexInputChannel("DistributorAddress");
aDistributor.AttachDuplexInputChannel(anInputChannel);
// Create client that needs to calculate PI.
IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
aSender = aTypedMessagesFactory.CreateDuplexTypedMessageSender <double, Interval>();
AutoResetEvent aCalculationCompletedEvent = new AutoResetEvent(false);
int aCount = 0;
double aPi = 0.0;
aSender.ResponseReceived += (x, y) =>
{
++aCount;
EneterTrace.Debug("Completed interval: " + aCount.ToString());
aPi += y.ResponseMessage;
if (aCount == 400)
{
aCalculationCompletedEvent.Set();
}
};
IDuplexOutputChannel anOutputChannel = aThreadMessaging.CreateDuplexOutputChannel("DistributorAddress");
aSender.AttachDuplexOutputChannel(anOutputChannel);
// Sender sends several parallel requests to calculate specified intervals.
// 2 / 0.005 = 400 intervals.
for (double i = -1.0; i <= 1.0; i += 0.005)
{
Interval anInterval = new Interval(i, i + 0.005);
aSender.SendRequestMessage(anInterval);
}
// Wait until all requests are calculated.
EneterTrace.Debug("Test waits until completion.");
aCalculationCompletedEvent.WaitOne();
EneterTrace.Info("Calculated PI = " + aPi.ToString());
}
catch (Exception err)
{
EneterTrace.Error("Test failed", err);
throw;
}
finally
{
aSender.DetachDuplexOutputChannel();
aDistributor.DetachDuplexInputChannel();
aServices.ForEach(x => x.Dispose());
}
}
// The method is called when the button to send message is clicked.
private void SendMessage_Click(object sender, RoutedEventArgs e)
{
// Create message sender sending request messages of type Person and receiving responses of type string.
IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
myMessageSender = aTypedMessagesFactory.CreateDuplexTypedMessageSender<byte[], byte[]>();
myMessageSender.ResponseReceived += ResponseReceived;
// Create messaging based on TCP.
IMessagingSystemFactory aMessagingSystemFactory = new TcpMessagingSystemFactory();
IDuplexOutputChannel aDuplexOutputChannel = aMessagingSystemFactory.CreateDuplexOutputChannel("tcp://127.0.0.1:4502/");
// Attach output channel and be able to send messages and receive response messages.
myMessageSender.AttachDuplexOutputChannel(aDuplexOutputChannel);
myMessageSender.SendRequestMessage(GetBytes(textBox1.Text));
}
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);
}
