コード例 #1
0
        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();
            }
        }
コード例 #2
0
        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();
        }
コード例 #3
0
        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();
        }
コード例 #4
0
        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);
            }
        }
コード例 #5
0
ファイル: Program.cs プロジェクト: tvinod81/Load_Balancer
        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();
        }
コード例 #6
0
        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();
            }
        }
コード例 #7
0
        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();
        }
コード例 #8
0
        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();
        }
コード例 #9
0
        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);
                }
            }
        }
コード例 #10
0
        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;
        }
コード例 #11
0
ファイル: ChannelWrapper.cs プロジェクト: neemesis/EneterTest
        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
        }
コード例 #12
0
        public void Setup()
        {
            //EneterTrace.DetailLevel = EneterTrace.EDetailLevel.Debug;

            IMessagingSystemFactory aMessaging = new SynchronousMessagingSystemFactory();

            InputChannel  = aMessaging.CreateDuplexInputChannel("MyChannelId");
            OutputChannel = aMessaging.CreateDuplexOutputChannel("MyChannelId");

            DuplexTypedMessagesFactory = new DuplexTypedMessagesFactory();
        }
コード例 #13
0
        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();
        }
コード例 #14
0
        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>();
        }
コード例 #15
0
ファイル: ChannelWrapper.cs プロジェクト: neemesis/EneterTest
        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);
        }
コード例 #16
0
            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);
                }
            }
コード例 #17
0
        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);
        }
コード例 #18
0
        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;
        }
コード例 #19
0
        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;
        }
コード例 #20
0
ファイル: MasterUI.cs プロジェクト: ngrj93/Project-Morpheus
        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);
        }
コード例 #21
0
        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;
        }
コード例 #22
0
        // 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));
        }
コード例 #23
0
        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);
        }
コード例 #24
0
        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();
            }
        }
コード例 #25
0
        // 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;
        }
コード例 #26
0
        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();
            }
        }
コード例 #27
0
        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);
        }
コード例 #28
0
        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);
            }
        }
コード例 #29
0
        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());
            }
        }
コード例 #30
0
        // 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));
        }
コード例 #31
0
        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);
        }