public void ProtobufSerializeChatPacket() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- ProtoBufSerializer serializer = new ProtoBufSerializer(); ChatMessagePacket packet = new ChatMessagePacket("This is a test", "Tester"); byte[] data; byte[] expectedData = { 162, 6, 16, 26, 14, 84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 115, 116, 8, 2, 18, 6, 84, 101, 115, 116, 101, 114 }; //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- data = serializer.Serialize(packet); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- Assert.IsNotNull(data); Assert.AreEqual(expectedData, data); }
static void Main(string[] args) { // Instantiate Protocol Buffer based serializer. ISerializer aSerializer = new ProtoBufSerializer(); // Create message receiver receiving 'MyRequest' and receiving 'MyResponse'. // The receiver will use Protocol Buffers to serialize/deserialize messages. IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory(aSerializer); myReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver<MyResponse, MyRequest>(); // Subscribe to handle messages. myReceiver.MessageReceived += OnMessageReceived; // Create TCP messaging. IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory(); IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:8060/"); // Attach the input channel and start to listen to messages. myReceiver.AttachDuplexInputChannel(anInputChannel); Console.WriteLine("The service is running. To stop press enter."); Console.ReadLine(); // Detach the input channel and stop listening. // It releases the thread listening to messages. myReceiver.DetachDuplexInputChannel(); }
public RpcTcpMessage <RpcResponse> GetResponse() { var h = ProtoBufSerializer.FromByteArray <RpcResponseHeader>(_headerBuffer); int offset = IdentityLength + HeaderLength; RpcResponse response = new RpcResponse() { ErrorCode = (RpcErrorCode)h.ResponseCode, Options = (RpcMessageOptions)h.Option, }; int len = h.BodyLength - 1; if (len > 0) { response.BodyBuffer = new RpcBodyBuffer(_bodyBuffer); response.BodyBuffer.TextError = true; offset += len; } else if (len == 0) { response.BodyBuffer = RpcBodyBuffer.EmptyBody; } else { response.BodyBuffer = null; } var message = new RpcTcpMessage <RpcResponse>() { Sequence = h.Sequence, Message = response, }; return(message); }
private void SaveItems(object param) { Directory.Delete(ItemsPath, true); Directory.CreateDirectory(ItemsPath); // directory creation might take some time -> wait until it is definitively created while (!Directory.Exists(ItemsPath)) { Thread.Sleep(100); Directory.CreateDirectory(ItemsPath); } int i = 0; T[] items = GetStorableItems(itemListViewItemMapping.Keys); foreach (T item in items) { try { i++; SetEnabledStateOfContentViews(item, false); var ser = new ProtoBufSerializer(); ser.Serialize(item, ItemsPath + Path.DirectorySeparatorChar + i.ToString("00000000") + ".hl"); OnItemSaved(item, progressBar.Maximum / listView.Items.Count); } catch (Exception) { } finally { SetEnabledStateOfContentViews(item, true); } } OnAllItemsSaved(); }
public void ProtobufDeserializeChatPacket() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- ProtoBufSerializer serializer = new ProtoBufSerializer(); ChatMessagePacket Expectedpacket = new ChatMessagePacket("This is a test", "Tester"); List <Packet> packet = new List <Packet>(); byte[] data = { 162, 6, 16, 26, 14, 84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 115, 116, 8, 2, 18, 6, 84, 101, 115, 116, 101, 114 }; //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- packet.Add(serializer.Deserialize(data)); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- ChatMessagePacket output = (ChatMessagePacket)packet[0]; //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- Assert.IsNotNull(data); Assert.AreEqual(Expectedpacket.message, output.message); Assert.AreEqual(Expectedpacket.sender, output.sender); Assert.AreEqual(Expectedpacket.type, output.type); }
private static ISerializer<Event<IUserCommand>> ConstructSerializer() { var protoBufModel = TypeModel.Create(); protoBufModel.Add(typeof(IUserCommand), true).AddSubType(1, typeof(UpdateName)); var serializer = new ProtoBufSerializer<Event<IUserCommand>>(protoBufModel); return serializer; }
public void SendResponse <T>(RpcResponseHeader header, T results) { HttpListenerResponse response = _httpContext.Response; response.StatusCode = 200; response.ContentType = "multipart/byteranges"; if (!header.HasBody) { response.Headers.Add("Null", "true"); response.ContentLength64 = 0; } else { byte[] buffer = ProtoBufSerializer.ToByteArray <T>(results); if (buffer.Length > 0) { response.ContentLength64 = buffer.Length; response.OutputStream.Write(buffer, 0, buffer.Length); response.OutputStream.Close(); } else { response.ContentLength64 = 0; } } response.Close(); }
public void ProtoBufSerializer_Deserialize_GivenNullInput_ShouldReturnNull() { var protoBufSerializer = new ProtoBufSerializer(); var result = protoBufSerializer.Deserialize<object>(null); Assert.IsNull(result); }
public static void WriteStream <T>(PipeStream stream, RpcPipeContext context, T data) { byte[] contextBuffer = ProtoBufSerializer.ToByteArray <RpcPipeContext>(context); byte[] bodyBuffer = null; if (typeof(T) != typeof(RpcNull)) { bodyBuffer = ProtoBufSerializer.ToByteArray <T>(data); } else { bodyBuffer = EmptyBuffer; } RpcPipeHeader header; header.Mark = RpcPipeHeader.MagicMark; header.ContextSize = contextBuffer.Length; header.BodySize = bodyBuffer.Length; byte[] headerBuffer = RpcPipeHeader.ToByteArray(header); stream.Write(headerBuffer, 0, headerBuffer.Length); stream.Write(contextBuffer, 0, contextBuffer.Length); if (header.BodySize > 0) { stream.Write(bodyBuffer, 0, bodyBuffer.Length); } stream.Flush(); }
public void ProtoBuf() { var serializer = new ProtoBufSerializer <LogIn>(); var bytes = BinaryProtocol.FromObject(_loginCmd, "LogIn", serializer); var receivedPacket = new BinaryProtocol(bytes.GetDataToSend()); var obj = serializer.Deserialize(receivedPacket.Data); }
public static void WriteStreamEx(PipeStream stream, RpcPipeContext context, Exception ex) { byte[] contextBuffer = ProtoBufSerializer.ToByteArray <RpcPipeContext>(context); byte[] bodyBuffer = null; if (ex != null) { bodyBuffer = BinarySerializer.ToByteArray(ex); } else { bodyBuffer = EmptyBuffer; } RpcPipeHeader header; header.Mark = RpcPipeHeader.MagicMark; header.ContextSize = contextBuffer.Length; header.BodySize = bodyBuffer.Length; byte[] headerBuffer = RpcPipeHeader.ToByteArray(header); stream.Write(headerBuffer, 0, headerBuffer.Length); stream.Write(contextBuffer, 0, contextBuffer.Length); if (header.BodySize > 0) { stream.Write(bodyBuffer, 0, bodyBuffer.Length); } stream.Flush(); }
public void TestLoadingRunAndStoreSamples() { CreateAllSamples(); var path = SamplesUtils.SamplesDirectory; var serializer = new ProtoBufSerializer(); foreach (var fileName in Directory.EnumerateFiles(path, "*.hl")) { var original = serializer.Deserialize(fileName); var exec = original as IExecutable; if (exec != null) { exec.Paused += (sender, e) => { serializer.Serialize(exec, fileName + "_paused.proto"); Console.WriteLine("Serialized paused file: " + fileName); File.Delete(fileName + "_paused.proto"); }; exec.Stopped += (sender, e) => { serializer.Serialize(exec, fileName + "_stopped.proto"); Console.WriteLine("Serialized stopped file: " + fileName); File.Delete(fileName + "_stopped.proto"); }; var t = exec.StartAsync(); System.Threading.Thread.Sleep(20000); // wait 20 secs if (exec.ExecutionState == ExecutionState.Started) // only if not already stopped { exec.Pause(); } } } }
public bool DeserializeMessage(StreamBuffer streamBuffer, int start, int len, ref int msgLen, ref HjSendMsgDef msgObj) { msgObj = default(HjSendMsgDef); msgLen = 0; if (len < sizeof(int)) { return(false); } byte[] data = streamBuffer.GetBuffer(); int _len = BitConverter.ToInt32(data, start); if (len < _len + sizeof(int)) { return(false); } msgLen = _len + sizeof(int); start += sizeof(int); MemoryStream ms = streamBuffer.memStream; BinaryReader br = streamBuffer.binaryReader; ms.Seek(start, SeekOrigin.Begin); uint requestSeq = br.ReadUInt32(); msgObj.requestSeq = requestSeq; msgObj.msgProto = ProtoBufSerializer.Deserialize(ms, typeof(ntf_battle_frame_data), _len - sizeof(int)); return(true); }
private bool IsSerializable(KeyValuePair <string, object> variable) { Type type = null; bool serializable = false; if (variable.Value != null) { type = variable.Value.GetType(); if (serializableLookup.TryGetValue(type, out serializable)) { return(serializable); } if (StorableTypeAttribute.IsStorableType(type)) { return(serializableLookup[type] = true); } } var ser = new ProtoBufSerializer(); try { using (var memStream = new MemoryStream()) { ser.Serialize(variable.Value, memStream); // try to serialize to memory stream serializable = true; } } catch (PersistenceException) { serializable = false; } if (type != null) { serializableLookup[type] = serializable; } return(serializable); }
public void TestProtoBufSerializerSerialize() { // Arrange ProtoBufSerializerTestEntity entity = new ProtoBufSerializerTestEntity { PartitionKey = "KE", RowKey = "Hello", Name = "Kevin", Number = 5 }; ProtoBufSerializer serializer = new ProtoBufSerializer(); // Act byte[] b = serializer.Serialize(entity); // Assert Assert.AreEqual(9, b.Length); Assert.AreEqual(10, b[0]); Assert.AreEqual(5, b[1]); Assert.AreEqual(75, b[2]); Assert.AreEqual(101, b[3]); Assert.AreEqual(118, b[4]); Assert.AreEqual(105, b[5]); Assert.AreEqual(110, b[6]); Assert.AreEqual(16, b[7]); Assert.AreEqual(5, b[8]); }
public void OnAfterDeserialize() { if (bytes != null) { logs = ProtoBufSerializer.DeserializeFromBytes <LogCollection>(bytes); } }
static void Main(string[] args) { // Create ProtoBuf serializer. ISerializer aSerializer = new ProtoBufSerializer(); // Create message receiver. IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory(aSerializer); IDuplexTypedMessageReceiver<ResponseMessage, RequestMessage> aReceiver = aReceiverFactory.CreateDuplexTypedMessageReceiver<ResponseMessage, RequestMessage>(); // Subscribe to process request messages. aReceiver.MessageReceived += OnMessageReceived; // Use TCP for the communication. IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory(); IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:4502/"); // Attach the input channel to the receiver and start listening. aReceiver.AttachDuplexInputChannel(anInputChannel); Console.WriteLine("The calculator service is running. Press ENTER to stop."); Console.ReadLine(); // Detach the input channel to stop listening. aReceiver.DetachDuplexInputChannel(); }
public void ProtoBufSerializer_Deserialize_GivenNullInput_ShouldReturnNull() { var protoBufSerializer = new ProtoBufSerializer(); var result = protoBufSerializer.Deserialize <object>(null); Assert.IsNull(result); }
protected override IStorableContent LoadContent(string filename, out Info info) { bool useOldPersistence = XmlParser.CanOpen(filename); IStorableContent content = null; if (useOldPersistence) { var sw = new Stopwatch(); sw.Start(); content = XmlParser.Deserialize <IStorableContent>(filename); sw.Stop(); info = new Info(filename, sw.Elapsed); } else { var ser = new ProtoBufSerializer(); content = (IStorableContent)ser.Deserialize(filename, out SerializationInfo serInfo); info = new Info(filename, serInfo); } if (content == null) { throw new PersistenceException($"Cannot deserialize root element of {filename}"); } return(content); }
private static IServiceProxyManager Init(string host, int port, string localHost, int?localPort) { var proxyName = "XNodeDemoService"; LoggerManager.ClientLoggerFactory.AddConsole(LogLevel.Information); var serializer = new ProtoBufSerializer(LoggerManager.ClientLoggerFactory); //new MsgPackSerializer(LoggerManager.ClientLoggerFactory); var nodeClientParametersList = new List <NodeClientParameters>() { new NodeClientParameters() { Host = host, Port = port, LocalHost = localHost, LocalPort = localPort, Serializer = serializer, Communication = new DotNettyClient(host, port), LoginHandler = new DefaultLoginHandler(new DefaultLoginHandlerConfig() { AccountName = "Test01", AccountKey = "123456" }, serializer) } }; var nodeClientContainer = new DefaultNodeClientContainer(); foreach (var c in nodeClientParametersList) { nodeClientContainer.Add(new DefaultNodeClient(c)); } var serviceProxy = new ServiceProxy(proxyName, null, null, nodeClientContainer) .AddService <ICustomerService>() .AddService <OrderService>() .EnableAll(); var serviceProxyManager = new ServiceProxyManager(); serviceProxyManager.Regist(serviceProxy); serviceProxyManager.ConnectAsync().Wait(); var builder = new ContainerBuilder(); builder.Register(c => new ServiceProxyInterceptor(serviceProxyManager)); builder.RegisterType <CustomerService>() .As <ICustomerService>() .EnableInterfaceInterceptors() //接口拦截 .InterceptedBy(typeof(ServiceProxyInterceptor)) .SingleInstance(); builder.RegisterType <OrderService>() //.As<IOrderService>() .EnableClassInterceptors() //类拦截 .InterceptedBy(typeof(ServiceProxyInterceptor)) .SingleInstance(); container = builder.Build(); return(serviceProxyManager); }
public void Deserialize() { var serializer = new ProtoBufSerializer(); using (var memStream = new MemoryStream(buffer)) { var obj = serializer.Deserialize(memStream); } }
private void LoadSample(string name, Assembly assembly, ListViewGroup group, int count) { using (var stream = assembly.GetManifestResourceStream(name)) { var serializer = new ProtoBufSerializer(); var item = (NamedItem)serializer.Deserialize(stream, false); OnSampleLoaded(item, group, 1.0 / count); } }
public static byte[] Serialize(object obj, out IEnumerable <Type> types) { var ser = new ProtoBufSerializer(); var bytes = ser.Serialize(obj, out SerializationInfo info); types = info.SerializedTypes; return(bytes); }
public void ProtoBufSerializer_Serialize_GivenValidReferenceTypeInput_ShouldReturnBytes() { var protoBufSerializer = new ProtoBufSerializer(); var input = "test"; var result = protoBufSerializer.Serialize(input); Assert.IsNotNull(result); Assert.IsTrue(result.Length > 0); }
private static IServiceProxyManager InitWithConfig() { string path = Path.Combine(Directory.GetCurrentDirectory(), "config_simple.json"); var configRoot = new ConfigurationBuilder() .AddJsonFile(path) .Build(); var globalConfig = configRoot.GetGlobalConfig(); GlobalSettings.Apply(globalConfig); var clientConfig = configRoot.GetClientConfig(); LoggerManager.ClientLoggerFactory.AddConsole(LogLevel.Error); //var serializer = new MsgPackSerializer(LoggerManager.ClientLoggerFactory); var serializer = new ProtoBufSerializer(LoggerManager.ClientLoggerFactory); var serviceCaller = new ServiceCallerBuilder() .UseDefault() .Build(); var serviceProxyManager = new ServiceProxyManager(); foreach (var serviceProxyConfig in clientConfig.ServiceProxies) { var serviceProxy = new ServiceProxy( serviceProxyConfig.ProxyName, serviceProxyConfig?.Services, serviceCaller) .AddServices(serviceProxyConfig.ProxyTypes) .AddClients( new NodeClientBuilder() .ConfigConnections(serviceProxyConfig.Connections) .ConfigSerializer(serializer) .ConfigLoginHandler(new DefaultLoginHandler(configRoot.GetDefaultLoginHandlerConfig(serviceProxyConfig.ProxyName), serializer)) .UseDotNetty() .Build() ); serviceProxyManager.Regist(serviceProxy); } serviceProxyManager.ConnectAsync().Wait(); var builder = new ContainerBuilder(); builder.Register(c => new ServiceProxyInterceptor(serviceProxyManager)); builder.RegisterType <SimpleService>() .As <ISimpleService>() .EnableInterfaceInterceptors() //接口拦截 .InterceptedBy(typeof(ServiceProxyInterceptor)) .SingleInstance(); container = builder.Build(); return(serviceProxyManager); }
void IRpcClientTransaction.SendRequest <T>(RpcRequestHeader request, T args, Action <RpcResponseHeader> callback, int timeout) { _callback = callback; _serviceUrl = string.Format("{0}/{1}.{2}", request.ServerUri, request.Service, request.Method); _webRequest = HttpWebRequest.Create(_serviceUrl); _webRequest.Method = "POST"; _webRequest.Proxy = null; _webRequest.ContentType = "multipart/byteranges"; _webRequest.Headers.Add(HttpRequestHeader.From, request.ServiceAtComputer); _webRequest.Headers.Add(HttpRequestHeader.Pragma, _serviceUrl); _webRequest.Headers.Add(HttpRequestHeader.Cookie, "to=" + ObjectHelper.ToString(request.ToUri)); byte[] buffer = null; if (!request.HasBody) { _webRequest.Headers.Add("Null", "true"); _webRequest.ContentLength = 0; } else { buffer = ProtoBufSerializer.ToByteArray <T>(args); _webRequest.ContentLength = buffer.Length; } timeout = timeout > 0 ? timeout : _channel.Timeout; if (timeout > 0) { _waitHandle = new ManualResetEvent(false); ThreadPool.RegisterWaitForSingleObject(_waitHandle, new WaitOrTimerCallback(TimeoutCallback), this, timeout, true); } if (_webRequest.ContentLength == 0) { _webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this); } else { _webRequest.BeginGetRequestStream( delegate(IAsyncResult asyncResult) { try { Stream stream = _webRequest.EndGetRequestStream(asyncResult); stream.Write(buffer, 0, buffer.Length); stream.Close(); _webRequest.BeginGetResponse(new AsyncCallback(ResponseCallback), this); } catch (Exception ex) { var resp = RpcResponseHeader.CreateError(RpcErrorCode.SendFailed, ex); _callback(resp); } }, this ); } }
public T ReceiveResponse <T>() { if (_context.HasBody) { return(ProtoBufSerializer.FromByteArray <T>(_bodyBuffer)); } else { return(default(T)); } }
public void ProtoBufSerializer_Deserialize_GivenValidValueType_ShouldReturnValueType() { var protoBufSerializer = new ProtoBufSerializer(); var input = 123; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize<int>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual(123, deserialized); }
public void ProtoBufSerializer_Deserialize_GivenValidReferenceType_ShouldReturnReferenceType() { var protoBufSerializer = new ProtoBufSerializer(); var input = "test"; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize <string>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual("test", deserialized); }
public void ProtoBufSerializer_Deserialize_GivenValidValueType_ShouldReturnValueType() { var protoBufSerializer = new ProtoBufSerializer(); var input = 123; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize <int>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual(123, deserialized); }
public void ProtoBufSerializer_Deserialize_GivenValidReferenceType_ShouldReturnReferenceType() { var protoBufSerializer = new ProtoBufSerializer(); var input = "test"; var serialized = protoBufSerializer.Serialize(input); var deserialized = protoBufSerializer.Deserialize<string>(serialized); Assert.IsNotNull(deserialized); Assert.AreEqual("test", deserialized); }
protected T CloneByPersistence <T>(T value) { using (var serializerStream = new MemoryStream()) { var serializer = new ProtoBufSerializer(); serializer.Serialize(value, serializerStream, disposeStream: false); var bytes = serializerStream.GetBuffer(); using (var deserializerStream = new MemoryStream(bytes)) { return((T)serializer.Deserialize(deserializerStream)); } } }
public void ProtoBufSerializer_Primitives <T>(T value) { // arrange var serializer = new ProtoBufSerializer(); // act var data = serializer.Serialize(value); var result = serializer.Deserialize(data, typeof(T)); result.Should().Be(value); }
public T ReceiceRequest <T>() { if (_context.HasBody) { return(ProtoBufSerializer.FromByteArray <T>(_buffer)); } else { return(default(T)); } }
public T ReceiceRequest <T>() { if (_httpContext.Request.ContentLength64 == 0) { return(ProtoBufSerializer.Deserialize <T>(RpcNull.EmptyStream)); } else { return(ProtoBufSerializer.Deserialize <T>(_httpContext.Request.InputStream)); } }
public void TestSerialize() { var serializer = new ProtoBufSerializer(); var t = serializer.Serialize(new VPb { A = 10, B = 20, }); Assert.AreNotEqual(t, null); }
public void ProtoBufSerializer_Pocco() { // arrange var serializer = new ProtoBufSerializer(); var item = SerializerPoccoSerializable.Create(); // act var data = serializer.Serialize(item); var result = serializer.Deserialize(data, item.GetType()); result.ShouldBeEquivalentTo(item); }
public void TestProtoBufSerializerDeserialize() { // Arrange byte[] b = { 10, 5, 75, 101, 118, 105, 110, 16, 5 }; ProtoBufSerializer serializer = new ProtoBufSerializer(); // Act ProtoBufSerializerTestEntity entity = serializer.Deserialize<ProtoBufSerializerTestEntity>(b); // Assert Assert.AreEqual("Kevin", entity.Name); Assert.AreEqual(5, entity.Number); }
public Cache CreateCache() { ISerializer serializer = null; switch (this._serializerType) { case SerializerType.ProtoBufNet: serializer = new ProtoBufSerializer(); break; case SerializerType.Json: break; default: throw new ArgumentOutOfRangeException(); } ILocalCacheAdapter firstLevelCache = null; switch (this._firstLevelCacheType) { case FirstLevelCacheType.None: break; case FirstLevelCacheType.ConcurrentDictionary: firstLevelCache = new DictionaryCacheAdapter(); break; default: throw new ArgumentOutOfRangeException(); } IDistributedCacheAdapter secondLevelCache = null; IMessenger messenger = null; switch (this._secondLevelCacheType) { case SecondLevelCacheType.None: break; case SecondLevelCacheType.Redis: if (this._redisInstances == null || !this._redisInstances.Any()) throw new ArgumentNullException("Missing redis instances configurations"); var redis = new RedisCacheAdapter(this._redisInstances, this._redisDatabase, serializer); secondLevelCache = redis; messenger = redis; break; default: throw new ArgumentOutOfRangeException(); } return new Cache(firstLevelCache, secondLevelCache, messenger); }
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); }
static void Main(string[] args) { // Create ProtoBuf serializer. ISerializer aSerializer = new ProtoBufSerializer(); // Create the broker. IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(aSerializer); IDuplexBroker aBroker = aBrokerFactory.CreateBroker(); // Create the Input channel receiving messages via Tcp. // Note: You can also choose NamedPipes or Http. // (if you choose http, do not forget to execute it with sufficient user rights) IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory(); IDuplexInputChannel aBrokerInputChannel = aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:7091/"); aBroker.AttachDuplexInputChannel(aBrokerInputChannel); // Attach the input channel to the broker and start listening. Console.WriteLine("The broker application is running. Press ENTER to stop."); Console.ReadLine(); aBroker.DetachDuplexInputChannel(); }
private IDuplexTypedMessagesFactory CreateReceiverFactory() { ISerializer protoBufSerializer = new ProtoBufSerializer(); // ISerializer wrappingSerializer = _proxyGenerator.CreateInterfaceProxyWithTarget<ISerializer>(jsonSerializer, this); return new DuplexTypedMessagesFactory(protoBufSerializer); }