private void OpenConnectionBtn_Click(object sender, EventArgs e)
{
if (!mySender.IsDuplexOutputChannelAttached)
{
// The output channel is not attached yet.
// So attach the output channel and be able to send
// request messagas and receive response messages.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory()
{
// Set to receive messages in the main UI thread.
// Note: if this is not set then methods OnResponseReceived and
// OnConnectionClosed would not be called from main UI thread
// but from a listener thread.
OutputChannelThreading = new WinFormsDispatching(this)
};
IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8033/");
mySender.AttachDuplexOutputChannel(anOutputChannel);
ConnectionStatusLabel.Text = "Client Connected";
}
else if (!mySender.AttachedDuplexOutputChannel.IsConnected)
{
// The output channel is attached but the client got disconnected.
// So jut reopen the connection.
mySender.AttachedDuplexOutputChannel.OpenConnection();
ConnectionStatusLabel.Text = "Client Connected";
}
}
private bool Command_Initialize()
{
// Create duplex message sender.
// It can send messages and also receive messages.
IDuplexStringMessagesFactory aStringMessagesFactory = new DuplexStringMessagesFactory();
Command_MessageSender = aStringMessagesFactory.CreateDuplexStringMessageSender();
Command_MessageSender.ResponseReceived += Command_ResponseReceived;
// Create TCP based messaging.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel aDuplexOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + serverIP.Text + ":4502/");
// Attach the duplex output channel to the message sender
// and be able to send messages and receive messages.
try
{
Command_MessageSender.AttachDuplexOutputChannel(aDuplexOutputChannel);
}
catch (Exception e)
{
Log(e.Message);
}
if (Command_MessageSender.IsDuplexOutputChannelAttached)
{
Log("Initialized connection.");
return(true);
}
else
{
Log("Unable to initialize connection");
return(false);
}
}
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);
}
}
public Form1()
{
InitializeComponent();
// Create ProtoBuf serializer.
mySerializer = new ProtoBufSerializer();
// Create the broker client that will receive notification messages.
IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(mySerializer);
myBrokerClient = aBrokerFactory.CreateBrokerClient();
myBrokerClient.BrokerMessageReceived += OnNotificationMessageReceived;
// Create the Tcp messaging for the communication with the publisher.
// Note: For the interprocess communication you can use: Tcp, NamedPipes and Http.
IMessagingSystemFactory aMessagingFactory = new TcpMessagingSystemFactory();
// Create duplex output channel for the communication with the publisher.
// Note: The duplex output channel can send requests and receive responses.
// In our case, the broker client will send requests to subscribe/unsubscribe
// and receive notifications as response messages.
myOutputChannel = aMessagingFactory.CreateDuplexOutputChannel("tcp://127.0.0.1:7091/");
// Attach the output channel to the broker client
myBrokerClient.AttachDuplexOutputChannel(myOutputChannel);
}
public void ClientReceiveTimeout()
{
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory()
{
ReceiveTimeout = TimeSpan.FromMilliseconds(1000)
};
IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8046/");
IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:8046/");
try
{
ManualResetEvent aConnectionClosed = new ManualResetEvent(false);
anOutputChannel.ConnectionClosed += (x, y) =>
{
EneterTrace.Info("Connection closed.");
aConnectionClosed.Set();
};
anInputChannel.StartListening();
anOutputChannel.OpenConnection();
EneterTrace.Info("Connection opened.");
// According to set receive timeout the client should get disconnected within 1 second.
//aConnectionClosed.WaitOne();
Assert.IsTrue(aConnectionClosed.WaitOne(3000));
}
finally
{
anOutputChannel.CloseConnection();
anInputChannel.StopListening();
}
}
private bool InitializeWorkerConnection()
{
// Create TCP messaging
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
Worker4504OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:4504/");
// Subscribe to response messages.
Worker4504OutputChannel.ConnectionClosed += Worker4504OutputChannel_ConnectionClosed;
Worker4504OutputChannel.ConnectionOpened += Worker4504OutputChannel_ConnectionOpened;
Worker4504OutputChannel.ResponseMessageReceived += Worker4504OutputChannel_ResponseMessageReceived;
// Open connection and be able to send messages and receive response messages.
Worker4504OutputChannel.OpenConnection();
Log("Channel id : " + Worker4504OutputChannel.ChannelId);
// Send a message.
byte[] data = new byte[1048576]; // initialize 1MB data
//byte[] data = new byte[10]; // initialize 1MB data
Random random = new Random();
random.NextBytes(data);
Worker4504OutputChannel.SendMessage(data);
Log("Sent data length : " + data.Length);
// Close connection.
//Worker4504OutputChannel.CloseConnection();
return(true);
}
public void MaxAmountOfConnections()
{
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory()
{
MaxAmountOfConnections = 2
};
IDuplexOutputChannel anOutputChannel1 = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8049/");
IDuplexOutputChannel anOutputChannel2 = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8049/");
IDuplexOutputChannel anOutputChannel3 = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8049/");
IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:8049/");
try
{
ManualResetEvent aConnectionClosed = new ManualResetEvent(false);
anOutputChannel3.ConnectionClosed += (x, y) =>
{
EneterTrace.Info("Connection closed.");
aConnectionClosed.Set();
};
anInputChannel.StartListening();
anOutputChannel1.OpenConnection();
anOutputChannel2.OpenConnection();
anOutputChannel3.OpenConnection();
if (!aConnectionClosed.WaitOne(1000))
{
Assert.Fail("Third connection was not closed.");
}
Assert.IsTrue(anOutputChannel1.IsConnected);
Assert.IsTrue(anOutputChannel2.IsConnected);
Assert.IsFalse(anOutputChannel3.IsConnected);
}
finally
{
anOutputChannel1.CloseConnection();
anOutputChannel2.CloseConnection();
anOutputChannel3.CloseConnection();
anInputChannel.StopListening();
}
}
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();
}
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 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);
}
private void button2_Click(object sender, EventArgs e)
{
TcpMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + tbIP.Text + ":" + tbPorta.Text + "/");//ip local e porta do servidor
myRpcClient.AttachDuplexOutputChannel(anOutputChannel);
txtCliente.Enabled = true;
txtCod.Enabled = true;
txtValor.Enabled = true;
SumButton.Enabled = true;
button1.Enabled = true;
button2.Enabled = false;
tbPorta.Enabled = false;
tbIP.Enabled = false;
}
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 void init()
{
try
{
IRpcFactory rpcFactory = new RpcFactory();
RpcObj = rpcFactory.CreateClient<ILeiloeiro>();
TcpMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + IP + ":" + Porta + "/");//ip local e porta do servidor
RpcObj.AttachDuplexOutputChannel(anOutputChannel);
}
catch (Exception ex)
{
throw new Exception("Erro: É necessario iniciar o servidor - " + ex.Message);
}
}
public TalkFlow()
{
IRpcFactory factory = new RpcFactory();
var client = factory.CreateClient <ITalk>();
TcpMessagingSystemFactory messaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel anOutputChannel = messaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8045/");
client.AttachDuplexOutputChannel(anOutputChannel);
string sentence = "";
while ((sentence = Console.ReadLine()) != "stop")
{
client.Proxy.Talk("Client A", sentence);
}
}
// 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 MainPage()
{
InitializeComponent();
// Create duplex message sender.
// It can send messages and also receive messages.
IDuplexStringMessagesFactory aStringMessagesFactory = new DuplexStringMessagesFactory();
myMessageSender = aStringMessagesFactory.CreateDuplexStringMessageSender();
myMessageSender.ResponseReceived += MessageReceived;
// Create TCP based messaging.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel aDuplexOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:4502/");
// Attach the duplex output channel to the message sender
// and be able to send messages and receive messages.
myMessageSender.AttachDuplexOutputChannel(aDuplexOutputChannel);
}
public Form1()
{
InitializeComponent();
// Create ProtoBuf serializer.
mySerializer = new ProtoBufSerializer();
// Create broker client responsible for sending messages to the broker.
IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(mySerializer);
myBrokerClient = aBrokerFactory.CreateBrokerClient();
// Create output channel to send messages via Tcp.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
myOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:7091/");
// Attach the output channel to the broker client to be able to send messages.
myBrokerClient.AttachDuplexOutputChannel(myOutputChannel);
}
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 ConnectionTimeout()
{
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory()
{
ConnectTimeout = TimeSpan.FromMilliseconds(1000)
};
// Nobody is listening on this address.
IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://109.74.151.135:8045/");
ManualResetEvent aConnectionCompleted = new ManualResetEvent(false);
try
{
// Start opening in another thread to be able to measure
// if the timeout occured with the specified time.
Exception anException = null;
ThreadPool.QueueUserWorkItem(x =>
{
try
{
anOutputChannel.OpenConnection();
}
catch (Exception err)
{
anException = err;
}
aConnectionCompleted.Set();
});
if (aConnectionCompleted.WaitOne(1500))
{
}
Assert.AreEqual(typeof(TimeoutException), anException);
}
finally
{
anOutputChannel.CloseConnection();
}
}
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);
}
}
private bool Worker4504_Initialize()
{
// Create TCP messaging
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
Worker4504_OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + serverIP.Text + ":4504/");
// Subscribe to response messages.
Worker4504_OutputChannel.ConnectionClosed += Worker4504_ConnectionClosed;
Worker4504_OutputChannel.ConnectionOpened += Worker4504_ConnectionOpened;
Worker4504_OutputChannel.ResponseMessageReceived += Worker4504_ResponseMessageReceived;
// Open connection and be able to send messages and receive response messages.
Worker4504_OutputChannel.OpenConnection();
if (Worker4504_OutputChannel.IsConnected)
{
return(true);
}
else
{
return(false);
}
}
private bool Worker4504_Initialize()
{
// Create TCP messaging
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
Worker4504_OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + serverIP.Text + ":4504/");
// Subscribe to response messages.
Worker4504_OutputChannel.ConnectionClosed += Worker4504_ConnectionClosed;
Worker4504_OutputChannel.ConnectionOpened += Worker4504_ConnectionOpened;
Worker4504_OutputChannel.ResponseMessageReceived += Worker4504_ResponseMessageReceived;
// Open connection and be able to send messages and receive response messages.
Worker4504_OutputChannel.OpenConnection();
if (Worker4504_OutputChannel.IsConnected)
{
return true;
}
else
{
return false;
}
}
private bool Command_Initialize()
{
// Create duplex message sender.
// It can send messages and also receive messages.
IDuplexStringMessagesFactory aStringMessagesFactory = new DuplexStringMessagesFactory();
Command_MessageSender = aStringMessagesFactory.CreateDuplexStringMessageSender();
Command_MessageSender.ResponseReceived += Command_ResponseReceived;
// Create TCP based messaging.
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
IDuplexOutputChannel aDuplexOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://" + serverIP.Text + ":4502/");
// Attach the duplex output channel to the message sender
// and be able to send messages and receive messages.
try
{
Command_MessageSender.AttachDuplexOutputChannel(aDuplexOutputChannel);
}
catch (Exception e)
{
Log(e.Message);
}
if (Command_MessageSender.IsDuplexOutputChannelAttached)
{
Log("Initialized connection.");
return true;
}
else
{
Log("Unable to initialize connection");
return false;
}
}
private bool InitializeWorkerConnection()
{
// Create TCP messaging
IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
Worker4504OutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:4504/");
// Subscribe to response messages.
Worker4504OutputChannel.ConnectionClosed += Worker4504OutputChannel_ConnectionClosed;
Worker4504OutputChannel.ConnectionOpened += Worker4504OutputChannel_ConnectionOpened;
Worker4504OutputChannel.ResponseMessageReceived += Worker4504OutputChannel_ResponseMessageReceived;
// Open connection and be able to send messages and receive response messages.
Worker4504OutputChannel.OpenConnection();
Log("Channel id : " + Worker4504OutputChannel.ChannelId);
// Send a message.
byte[] data = new byte[1048576]; // initialize 1MB data
//byte[] data = new byte[10]; // initialize 1MB data
Random random = new Random();
random.NextBytes(data);
Worker4504OutputChannel.SendMessage(data);
Log("Sent data length : " + data.Length);
// Close connection.
//Worker4504OutputChannel.CloseConnection();
return true;
}
// 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));
}