public override void Process(Entity entity, Army army, GeoEntity geoEntity) { ArmyChangeEvent armyChangeEvent = new ArmyChangeEvent(army, geoEntity); WsMessage wsMessage = WsMessageBuilder.CreateWsMessage("public", armyChangeEvent); _jEventBus.Post(wsMessage); }
public virtual WsMessage HelloWCF(WsMessage request) { // Build request object HelloWCFDataContractSerializer reqDcs; reqDcs = new HelloWCFDataContractSerializer("HelloWCF", "http://localhost/ServiceHelloWCF"); HelloWCF req; req = ((HelloWCF)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Create response object // Call service operation to process request and return response. HelloWCFResponse resp; resp = m_service.HelloWCF(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://localhost/ServiceHelloWCF/IServiceHelloWCF/HelloWCFResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer HelloWCFResponseDataContractSerializer respDcs; respDcs = new HelloWCFResponseDataContractSerializer("HelloWCFResponse", "http://localhost/ServiceHelloWCF"); response.Serializer = respDcs; return(response); }
public virtual WsMessage CreateMeasurement(WsMessage request) { // Build request object CreateMeasurementDataContractSerializer reqDcs; reqDcs = new CreateMeasurementDataContractSerializer("CreateMeasurement", "http://tempuri.org/"); CreateMeasurement req; req = ((CreateMeasurement)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Create response object // Call service operation to process request and return response. CreateMeasurementResponse resp; resp = m_service.CreateMeasurement(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://tempuri.org/ISmartService/CreateMeasurementResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer CreateMeasurementResponseDataContractSerializer respDcs; respDcs = new CreateMeasurementResponseDataContractSerializer("CreateMeasurementResponse", "http://tempuri.org/"); response.Serializer = respDcs; return(response); }
/// <summary> /// Implements the IWsServiceEndpoint.ProcessRequest method. /// Gets a service operation based on the action property sent in the soap header and calls /// invoke on the service method. /// </summary> /// <param name="header">A WsWsaHeader containing the header proerties of a request.</param> /// <param name="envelope">A WsXmlDocument containing the entire envelope of the message in a node tree.</param> /// <returns>A byte array containing a soap response to the request.</returns> WsMessage ProcessRequest(WsMessage request) { WsWsaHeader header = request.Header; String action = header.Action; // Display the action name. System.Ext.Console.Write("Action: " + action); // Look for a valid service Action WsServiceOperation operation = m_serviceOperations[action]; if (operation != null) { System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(operation.MethodName); if (methodInfo == null) { System.Ext.Console.Write(""); System.Ext.Console.Write("Operation method for action " + header.Action + " was not found"); System.Ext.Console.Write(""); throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable); } return((WsMessage)methodInfo.Invoke(this, new object[] { request })); } // If a valid Action is not found, fault throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable, "To: " + header.To + " Action: " + action); }
public virtual WsMessage SetData(WsMessage request) { // Build request object SetDataDataContractSerializer reqDcs; reqDcs = new SetDataDataContractSerializer("SetData", "http://tempuri.org/"); reqDcs.BodyParts = request.BodyParts; SetData req; req = ((SetData)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Create response object // Call service operation to process request and return response. SetDataResponse resp; resp = m_service.SetData(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://tempuri.org/IDataAccessService/SetDataResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer SetDataResponseDataContractSerializer respDcs; respDcs = new SetDataResponseDataContractSerializer("SetDataResponse", "http://tempuri.org/"); response.Serializer = respDcs; // Indicate that message is Mtom encoded response.BodyParts = new WsMtomBodyParts(); return(response); }
public virtual WsMessage TwoWayAttachment(WsMessage request) { // Build request object TwoWayAttachmentRequestDataContractSerializer reqDcs; reqDcs = new TwoWayAttachmentRequestDataContractSerializer("TwoWayAttachmentRequest", "http://schemas.example.org/AttachmentService"); reqDcs.BodyParts = request.BodyParts; TwoWayAttachmentRequest req; req = ((TwoWayAttachmentRequest)(reqDcs.ReadObject(request.Reader))); // Create response object // Call service operation to process request and return response. TwoWayAttachmentResponse resp; resp = m_service.TwoWayAttachment(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://schemas.example.org/AttachmentService/TwoWayAttachmentResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer TwoWayAttachmentResponseDataContractSerializer respDcs; respDcs = new TwoWayAttachmentResponseDataContractSerializer("TwoWayAttachmentResponse", "http://schemas.example.org/AttachmentService"); response.Serializer = respDcs; // Indicate that message is Mtom encoded response.BodyParts = new WsMtomBodyParts(); return(response); }
private void BroadCastGame(GameDTO gameDTO) { WsMessage wsMessage = new WsMessage(); wsMessage.Action = "UpdateGame"; wsMessage.Content = gameDTO; gameDTO.connectedPlayers[0].hero.mana = gameDTO.connectedPlayers[0].hero.maxMana; gameDTO.connectedPlayers[1].hero.mana = gameDTO.connectedPlayers[1].hero.maxMana; foreach (SocketClient client in Program.socketClients) { if (gameDTO.connectedPlayers[0] != null) { if (client.userDTO.username == gameDTO.connectedPlayers[0].username) { Program.socketServer.SendClientMessage(client.socket, JsonConvert.SerializeObject(gameDTO)); } } if (gameDTO.connectedPlayers[1] != null) { if (client.userDTO.username == gameDTO.connectedPlayers[1].username) { wsMessage.Content = SwapPlayers(gameDTO); Program.socketServer.SendClientMessage(client.socket, JsonConvert.SerializeObject(gameDTO)); } } } }
private void OnMessageReceived(WebSocketSession session, string value) { WsMessage message = Newtonsoft.Json.JsonConvert.DeserializeObject <WsMessage>(value); // TO DO CRACIUN: live updating charts if (message.type != "Alert") { if (cartesianChart1.InvokeRequired) { UpdateChartCb d = new UpdateChartCb(SetCartesianChart); this.Invoke(d, new object[] { message }); } else { SetCartesianChart(message); } } else { MessageBox.Show("Don't panic!!!", "Earthquake", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } // TO DO: HANDLE ALERTS // if(message.type == Alert) }
public async Task Excute(WebSocketConnection connection, string requestString) { var message = new WsMessage(); try { var request = requestString.DeserializeJson <WsRequest>(); message.MsgType = WsMessageType.Result; message.Id = request.Id; message.Method = request.Method; var session = _provider.GetService <WebSocketSession>(); session.Connection = connection; session.Request = request; var executor = _provider.GetService <WebSocketExecutor>(); var result = await executor.Excute(request); if (result is WsError error) { message.MsgType = WsMessageType.Error; message.Error = error; } else { message.Result = result; } } catch (ArgumentException ex) { message.MsgType = WsMessageType.Error; message.Error = new WsError() { Code = (int)ErrorCode.InvalidPara, Message = ex.Message, }; } catch (WsException wsEx) { message.MsgType = WsMessageType.Error; message.Error = new WsError() { Code = wsEx.Code, Message = wsEx.Message, }; } catch (Exception e) { message.MsgType = WsMessageType.Error; message.Error = new WsError() { Code = -1, Message = e.ToString(), }; } finally { connection.PushMessage(message); } }
internal WsMessage ReceiveMessage(BindingContext ctx) { WsMessage msg = new WsMessage(new WsWsaHeader(), null, WsPrefix.None); while (true) { try { if (!m_binding.Elements.ProcessInputMessage(ref msg, ctx)) { msg = null; } // only need to loop if we received a bad request break; } catch (Faults.WsFaultException ex) { WsMessage faultResp = Faults.WsFault.GenerateFaultResponse(ex, ctx.Version); if (faultResp != null) { SendMessage(faultResp, ctx); } } } return(msg); }
private async Task WaitForConnect(HttpContext context, WebSocket webSocket) { var buffer = new byte[1024 * 4]; WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); Contract.Assert(!result.CloseStatus.HasValue); try { string json = Encoding.UTF8.GetString(buffer, 0, result.Count); WsMessage message = CatanProxy.Deserialize <WsMessage>(json); if (message.MessageType != CatanWsMessageType.RegisterForGameNotifications) { throw new Exception($"Invalid Message sent: {message} - DataTypeName=CatanWsMessageType"); } await GameController.Games.RegisterWebSocket(context, webSocket); // runs until the end } catch (Exception e) { await webSocket.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(e.ToString()), 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None); } await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); }
internal void SendMessage(WsMessage message, BindingContext ctx) { // Reset the binding properties as they were likely changed by the receive ctx.BindingProperties = (ArrayList)m_context.BindingProperties.Clone(); m_binding.Elements.ProcessOutputMessage(ref message, ctx); }
/// <summary> /// Method used to send a soap request over http to a service endpoint. /// </summary> /// <param name="soapMessage">A byte array contining a soap request message.</param> /// <param name="endpointAddress">A string containing the endpoint address of a service that will receive /// the request. This must be a transport address in the format http://ip_address:port/service_address.</param> /// <param name="isOneway">True = don't wait for response, false means wait for a response.</param> /// <param name="isChuncked">If true true the message will be chunk encoded.</param> /// <returns> /// A DpwSoapResponse object containing a WsWsaHeader and a XmlReader or null if no response is received /// or parsing fails. /// </returns> public DpwsSoapResponse SendRequest(byte[] soapMessage, string endpointAddress, bool isOneway, bool isChuncked) { System.Ext.Console.Write(new string(System.Text.UTF8Encoding.UTF8.GetChars(soapMessage))); WsMessage response = SendRequest(soapMessage, endpointAddress, isOneway, isChuncked, null); if (isOneway) { return(null); } XmlReader reader; WsWsaHeader header; try { reader = WsSoapMessageParser.ParseSoapMessage(response.Message, out header); } catch { System.Ext.Console.Write("ParseSoapMessage failed."); return(null); } return(new DpwsSoapResponse(header, reader)); }
public virtual WsMessage AnyCheck(WsMessage request) { // Build request object AnyCheckRequestDataContractSerializer reqDcs; reqDcs = new AnyCheckRequestDataContractSerializer("AnyCheckRequest", "http://schemas.example.org/SimpleService"); AnyCheckRequest req; req = ((AnyCheckRequest)(reqDcs.ReadObject(request.Reader))); // Create response object // Call service operation to process request and return response. AnyCheckResponse resp; resp = m_service.AnyCheck(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://schemas.example.org/SimpleService/AnyCheckResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer AnyCheckResponseDataContractSerializer respDcs; respDcs = new AnyCheckResponseDataContractSerializer("AnyCheckResponse", "http://schemas.example.org/SimpleService"); response.Serializer = respDcs; return(response); }
// TwoWayRequest: Accept two integer values, return their sum public WsMessage TwoWayRequest(WsMessage request) { WsWsaHeader header = request.Header; XmlReader reader = request.Reader; try { // Find beginning of request reader.ReadStartElement("TwoWayRequest", SimpleServiceNamespaceUri); // Find the values to be added int X = Convert.ToInt32(reader.ReadElementString("X", SimpleServiceNamespaceUri)); int Y = Convert.ToInt32(reader.ReadElementString("Y", SimpleServiceNamespaceUri)); //Log.Comment(""); //Log.Comment("X = " + X.ToString() + " Y = " + Y.ToString()); //Log.Comment(X.ToString() + " + " + Y.ToString() + " = " + ((int)(X + Y)).ToString()); //Log.Comment(""); // Return the response return(TwoWayResponse(header, X + Y)); } catch (Exception e) { // Something went wrong throw new WsFaultException(header, WsFaultType.XmlException, e.ToString()); } }
public async Task Excute(WebSocketConnection connection, string requestString) { var message = new WsMessage(); try { var request = requestString.DeserializeJson <WsRequest>(); message.Type = WsMessageType.Result; message.Id = request.Id; message.Method = request.Method; var session = _provider.GetService <WebSocketSession>(); session.Connection = connection; session.Request = request; var executor = _provider.GetService <WebSocketExecutor>(); var result = await executor.Excute(request); message.Result = result; } catch (InvokerException invokerException) { message.Result = invokerException.Message; } catch (Exception e) { message.Type = WsMessageType.Error; message.Result = e.ToString(); } finally { connection.PushMessage(message); } }
/// <summary> /// A wrapper method that implements the ProcessRequest interface used to control blocking of request. /// The BlockingCall property is used by the stack to control single instance execution. Hello and Bye /// are not blocked. Event messages from a device are blocked. This means it is up to a client developer /// to insure long thread safety. /// </summary> /// <param name="header">A WsWsaHeader containing the header proerties of a request.</param> /// <param name="envelope">A WsXmlDocument containing the entire envelope of the message in a node tree.</param> /// <returns>A byte array containing a soap response to the request.</returns> WsMessage IWsServiceEndpoint.ProcessRequest(WsMessage request) { //We always block WsWsaHeader header = request.Header; if (header.MessageID != null && m_messageCheck.IsDuplicate(header.MessageID, header.From != null ? header.From.Address.AbsoluteUri : "")) { return(null); } if (header.Action.IndexOf(m_version.DiscoveryNamespace) == 0) { String action = header.Action.Substring(m_version.DiscoveryNamespace.Length + 1); switch (action) { case "Hello": return(Hello(request.Header, request.Reader)); case "Bye": return(Bye(request.Header, request.Reader)); } } System.Ext.Console.Write("Client discovery callback method for action " + header.Action + " was not found"); return(null); }
private void HandleWorldJson(int planetId, string planetDisplayName, WsMessage message) { JObject payload; try { payload = JObject.Parse(Encoding.UTF8.GetString(message.Buffer)); payload["world_id"] = planetId; } catch (Exception ex) { Log.Error(ex, "Error decoding World JSON message"); return; } var jsonString = payload.ToString(Formatting.Indented); if (ProxyManagerConfig.Instance.SaveWorldJson) { var filename = $"{planetDisplayName}.json"; WriteExportFile(filename, jsonString); } if (ProxyManagerConfig.Instance.UploadWorldJson) { UploadJson(jsonString, "/ingest-ws-data/", planetDisplayName, "World"); } }
// Implements the IWsServiceEndpoint.ProcessRequest method. // Gets a service callback method based on the action property sent in a soap header and calls // invoke on the callback method. private WsMessage ProcessRequest(WsMessage request) { WsServiceOperation callback; WsWsaHeader header = request.Header; // Look for a client event sink callback action if ((callback = m_eventCallbacks[header.Action]) != null) { System.Reflection.MethodInfo methodInfo = this.GetType().GetMethod(callback.MethodName); if (methodInfo == null) { System.Ext.Console.Write(""); System.Ext.Console.Write("Client event callback method for action " + header.Action + " was not found"); System.Ext.Console.Write(""); // If a valid Action is not found, fault throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable, "To: " + header.To + " Action: " + header.Action); } return((WsMessage)methodInfo.Invoke(this, new object[] { request })); } // If a valid Action is not found, fault throw new WsFaultException(header, WsFaultType.WsaDestinationUnreachable, "To: " + header.To + " Action: " + header.Action); }
/// <summary> /// Method used to send an http Bye message to specified endpoint. Use for managed discovery. /// </summary> /// <param name="endpointAddress">A string containing the endpoint address of a listening client.</param> public void DirectedBye(string endpointAddress, DpwsDiscoGreeting greeting, ProtocolVersion version) { WsMessage greetingsMessage = greeting.BuildByeMessage(endpointAddress, null, null); Ws.Services.Transport.HTTP.WsHttpClient httpClient = new Ws.Services.Transport.HTTP.WsHttpClient(version); httpClient.SendRequestOneWay(greetingsMessage, new Uri(endpointAddress)); }
public void SendGame(GameDTO game, string action) { WsMessage gameState = new WsMessage(); gameState.Content = game; gameState.Action = action; string data = JsonConvert.SerializeObject(gameState); foreach (SocketClient client in Program.socketClients) { if (game.connectedPlayers[0] != null) { if (client.userDTO.username == game.connectedPlayers[0].username) { Program.socketServer.SendClientMessage(client.socket, data); } } if (game.connectedPlayers[1] != null) { if (client.userDTO.username == game.connectedPlayers[1].username) { gameState.Content = SwapPlayers(game); Program.socketServer.SendClientMessage(client.socket, data); } } } }
// Build ws-discovery bye message internal WsMessage BuildByeMessage(string endpointAddress, WsWsaHeader header, XmlReader reader) { using (XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create()) { WsWsaHeader byeHeader = new WsWsaHeader( m_version.DiscoveryNamespace + "/Bye", // Action null, // RelatesTo endpointAddress, // To null, null, null); // ReplyTo, From, Any WsMessage msg = new WsMessage(byeHeader, null, WsPrefix.Wsd, null, new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version); smw.WriteSoapMessageStart(xmlWriter, msg); // write body xmlWriter.WriteStartElement(WsNamespacePrefix.Wsd, "Bye", null); xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "EndpointReference", null); xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "Address", null); xmlWriter.WriteString(Device.EndpointAddress); xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); smw.WriteSoapMessageEnd(xmlWriter); msg.Body = xmlWriter.ToArray(); // Return stream buffer return(msg); } }
private WsMessage GetStatusResponse(WsWsaHeader header, long newDuration) { using (XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create()) { WsWsaHeader responseHeader = new WsWsaHeader( WsWellKnownUri.WseNamespaceUri + "/RenewResponse", // Action header.MessageID, // RelatesTo header.ReplyTo.Address.AbsoluteUri, // To null, null, null); // ReplyTo, From, Any WsMessage msg = new WsMessage(responseHeader, null, WsPrefix.Wse, null, new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); // AppSequence // write body xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Expires", null); xmlWriter.WriteString(new WsDuration(newDuration).DurationString); xmlWriter.WriteEndElement(); // End Expires WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version); smw.WriteSoapMessageEnd(xmlWriter); msg.Body = xmlWriter.ToArray(); return(msg); } }
public virtual TypeCheckResponse TypeCheck(TypeCheckRequest req) { // Create request header String action; action = "http://schemas.example.org/SimpleService/TypeCheck"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer TypeCheckRequestDataContractSerializer reqDcs; reqDcs = new TypeCheckRequestDataContractSerializer("TypeCheckRequest", "http://schemas.example.org/SimpleService"); request.Serializer = reqDcs; request.Method = "TypeCheck"; // Send service request m_requestChannel.Open(); WsMessage response = m_requestChannel.Request(request); m_requestChannel.Close(); // Process response TypeCheckResponseDataContractSerializer respDcs; respDcs = new TypeCheckResponseDataContractSerializer("TypeCheckResponse", "http://schemas.example.org/SimpleService"); TypeCheckResponse resp; resp = ((TypeCheckResponse)(respDcs.ReadObject(response.Reader))); return(resp); }
/// <summary> /// send message (json format) to connection in queue /// </summary> /// <param name="message"></param> public void PushMessage(WsMessage message) { if (message != null) { _pushMessagesQueue.Add(message); } }
public virtual void OneWayAttachment(OneWayAttachmentRequest req) { // Create request header String action; action = "http://schemas.example.org/AttachmentService/OneWayAttachment"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer OneWayAttachmentRequestDataContractSerializer reqDcs; reqDcs = new OneWayAttachmentRequestDataContractSerializer("OneWayAttachmentRequest", "http://schemas.example.org/AttachmentService"); request.Serializer = reqDcs; request.Method = "OneWayAttachment"; // Indicate that this message will use Mtom encoding request.BodyParts = new WsMtomBodyParts(); // Send service request m_requestChannel.Open(); m_requestChannel.RequestOneWay(request); m_requestChannel.Close(); }
public void SendMessage(WsMessage wsMessage) { wsMessage.From = "Server"; var send = JsonConvert.SerializeObject(wsMessage); Server.MulticastText(send); }
// OneWay: Accept an integer value public WsMessage OneWay(WsMessage request) { try { WsWsaHeader header = request.Header; XmlReader reader = request.Reader; // Find beginning of request reader.ReadStartElement("OneWay", SimpleServiceNamespaceUri); // Find the integer value int number = Convert.ToInt32(reader.ReadElementString("Param", SimpleServiceNamespaceUri)); //Log.Comment(""); //Log.Comment("Integer = " + number.ToString()); //Log.Comment(""); return(null); // Empty response } catch (Exception e) { // Something went wrong throw new WsFaultException(request.Header, WsFaultType.XmlException, e.ToString()); } }
public virtual WsMessage keepAlive(WsMessage request) { // Build request object keepAliveDataContractSerializer reqDcs; reqDcs = new keepAliveDataContractSerializer("keepAlive", "http://tempuri.org/"); keepAlive req; req = ((keepAlive)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Create response object // Call service operation to process request and return response. keepAliveResponse resp; resp = m_service.keepAlive(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://tempuri.org/IService1/keepAliveResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer keepAliveResponseDataContractSerializer respDcs; respDcs = new keepAliveResponseDataContractSerializer("keepAliveResponse", "http://tempuri.org/"); response.Serializer = respDcs; return(response); }
public virtual HelloWCFResponse HelloWCF(HelloWCF req) { // Create request header String action; action = "http://localhost/ServiceHelloWCF/IServiceHelloWCF/HelloWCF"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer HelloWCFDataContractSerializer reqDcs; reqDcs = new HelloWCFDataContractSerializer("HelloWCF", "http://localhost/ServiceHelloWCF"); request.Serializer = reqDcs; request.Method = "HelloWCF"; // Send service request m_requestChannel.Open(); WsMessage response = m_requestChannel.Request(request); m_requestChannel.Close(); // Process response HelloWCFResponseDataContractSerializer respDcs; respDcs = new HelloWCFResponseDataContractSerializer("HelloWCFResponse", "http://localhost/ServiceHelloWCF"); HelloWCFResponse resp; resp = ((HelloWCFResponse)(respDcs.ReadObject(response.Reader))); return(resp); }