public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { MessageBuffer requstBuffer = reply.CreateBufferedCopy(int.MaxValue); Message msg = requstBuffer.CreateMessage(); reply = requstBuffer.CreateMessage(); }
String MessageString(ref Message m) { // copy the message into a working buffer. MessageBuffer mb = m.CreateBufferedCopy(int.MaxValue); // re-create the original message, because "copy" changes its state. m = mb.CreateMessage(); Stream s = new MemoryStream(); XmlWriter xw = XmlWriter.Create(s); mb.CreateMessage().WriteMessage(xw); xw.Flush(); s.Position = 0; byte[] bXml = new byte[s.Length]; s.Read(bXml, 0, (int)s.Length); // sometimes bXML[] starts with a BOM if (bXml[0] != (byte)'<') { return(Encoding.UTF8.GetString(bXml, 3, bXml.Length - 3)); } return(Encoding.UTF8.GetString(bXml, 0, bXml.Length)); }
public string SelectOperation(ref System.ServiceModel.Channels.Message message) { MessageBuffer buffer = message.CreateBufferedCopy(Int32.MaxValue); message = buffer.CreateMessage(); var copy = buffer.CreateMessage(); XmlDictionaryReader bodyReader = copy.GetReaderAtBodyContents(); XmlQualifiedName lookupQName = new XmlQualifiedName(bodyReader.LocalName, bodyReader.NamespaceURI); if (dispatchDictionary.ContainsKey(lookupQName)) { // Mark Soap Headers action etc as understood //int actionHeaderIdx = message.Headers.FindHeader("Action", "http://www.w3.org/2005/08/addressing"); //int actionHeaderIdx2 = message.Headers.FindHeader("Action", "*"); //message.Headers.UnderstoodHeaders.Add((MessageHeaderInfo)message.Headers[actionHeaderIdx]); //message.Headers.UnderstoodHeaders.Add((MessageHeaderInfo)message.Headers.FindHeader(Headers[0]); return(dispatchDictionary[lookupQName]); } else { return(null); } }
/// <summary> /// BeforeSendReply /// </summary> /// <param name="reply"></param> /// <param name="correlationState"></param> public void BeforeSendReply(ref Message reply, object correlationState) { // create message copy MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); // fresh copy to extract response codee from Message msgCopy = buffer.CreateMessage(); // fresh unread copy to return Message msgReturn = buffer.CreateMessage(); // read body string msgBody = ReadMsgBody(msgCopy); // sanity check for empty bidy if (string.IsNullOrWhiteSpace(msgBody)) { return; } // extract response code if it exists, search for "HttpResponseCodeTagName" above var httpResponseCode = ExtractMessageResponseCode(msgBody); if (!string.IsNullOrWhiteSpace(httpResponseCode)) { // set response code in return msg SetStatusCode(httpResponseCode, msgReturn); } // set reply to copy reply = msgReturn; }
/// <summary> /// Throws an AdsException if the response was a SOAP fault. /// </summary> /// <param name="reply">The response Message</param> /// <param name="correlationState">The correlation state returned by BeforeSendRequest</param> public void AfterReceiveReply(ref Message reply, object correlationState) { if (reply.IsFault) { StringBuilder xmlStringBuilder = new StringBuilder(); using (XmlWriter xmlWriter = XmlWriter.Create(xmlStringBuilder, xmlWriterSettings)) using (MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue)) { // Message can only be read once, so replace it with a copy. reply = buffer.CreateMessage(); buffer.CreateMessage().WriteBody(xmlWriter); } // Try locating the ApiExceptionFault node and deserializing it. Make sure to ignore // the namespace and look only for the local name. XmlDocument xDoc = new XmlDocument(); xDoc.LoadXml(xmlStringBuilder.ToString()); XmlElement faultNode = (XmlElement)xDoc.SelectSingleNode(FAULT_ELEMENT_XPATH); if (faultNode != null) { // Deserialize the correct exception type and raise it. string faultNodeNamespaceUri = faultNode.NamespaceURI; string faultNodeContents = faultNode.OuterXml; object apiError = SerializationUtilities.DeserializeFromXmlTextCustomRootNs( faultNodeContents, ErrorType, faultNodeNamespaceUri, FAULT_ELEMENT_NAME); throw (TException)Activator.CreateInstance( typeof(TException), new object[] { apiError }); } } }
public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel, System.ServiceModel.InstanceContext instanceContext) { bool isVersionExist = false; for (int i = 0; i < request.Headers.Count; i++) { var headerInfo = request.Headers[i]; if (headerInfo.Name == "Version" && headerInfo.Namespace == "http://WcfPoc.wcfRouting.int/Increment1") { isVersionExist = true; break; } } //if (!isVersionExist) //{ // throw new Exception("SOAP Message don't have VERSION header!"); //} MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); request = buffer.CreateMessage(); Console.WriteLine("Message Received:\n{0}", buffer.CreateMessage().ToString()); return(null); }
public void AfterReceiveReply(ref Message reply, object correlationState) { LogManager.LogTrace(string.Format("SE.GOV.MM.Integration.DeliveryMailbox.DataLayer.FaultMessageInspector: incoming AfterReceiveReply ")); if (reply.IsFault) { MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); reply = buffer.CreateMessage(); Message m = buffer.CreateMessage(); var bodyContententsAsString = string.Empty; using (XmlDictionaryReader reader = m.GetReaderAtBodyContents()) { XmlDocument document = new XmlDocument(); document.Load(reader); using (var stringWriter = new StringWriter()) { using (var xmlTextWriter = XmlWriter.Create(stringWriter)) { document.WriteTo(xmlTextWriter); xmlTextWriter.Flush(); bodyContententsAsString = stringWriter.GetStringBuilder().ToString(); } } } LogManager.LogTrace(string.Format("SE.GOV.MM.Integration.DeliveryMailbox.DataLayer.FaultMessageInspector: ReplyMessage: {0}", bodyContententsAsString)); } LogManager.LogTrace(string.Format("SE.GOV.MM.Integration.DeliveryMailbox.DataLayer.FaultMessageInspector: leaving AfterReceiveReply")); }
String MessageString(ref Message m) { MessageBuffer mb = m.CreateBufferedCopy(int.MaxValue); m = mb.CreateMessage(); Stream s = new MemoryStream(); XmlWriter xw = XmlWriter.Create(s); mb.CreateMessage().WriteMessage(xw); xw.Flush(); s.Position = 0; byte[] bXML = new byte[s.Length]; s.Read(bXML, 0, (int)s.Length); if (bXML[0] != (byte)'<') { return(Encoding.UTF8.GetString(bXML, 3, bXML.Length - 3)); } else { return(Encoding.UTF8.GetString(bXML, 0, bXML.Length)); } }
public void AfterReceiveReply(ref Message reply, object correlationState) { if (!reply.IsFault || !_enabled) { return; } MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); Message copy = buffer.CreateMessage(); reply = buffer.CreateMessage(); ErrorServicioRespuesta exception = RecuperarFaultException(copy); if (exception == null) { return; } switch (exception.Tipo) { case TipoErrorServicio.ErrorValidacion: throw new ExcepcionValidacion(exception.Mensaje); case TipoErrorServicio.ErrorNegocio: throw new ExcepcionReglaNegocio(exception.Codigo, exception.Mensaje); default: throw new ExcepcionServicio( "La respuesta no pudo ser atendida por el servicio. Por favor intente más tarde."); } }
public Message CompressMessage(Message sourceMessage) { byte[] buffer; MessageBuffer messageBuffer = sourceMessage.CreateBufferedCopy(int.MaxValue); sourceMessage.Close(); sourceMessage = messageBuffer.CreateMessage(); using (XmlDictionaryReader reader1 = sourceMessage.GetReaderAtBodyContents()) { buffer = Encoding.UTF8.GetBytes(reader1.ReadOuterXml()); } if (buffer.Length < this.MinMessageSize) { sourceMessage.Close(); return(messageBuffer.CreateMessage()); } byte[] compressedData = DataCompressor.Compress(buffer); string copressedBody = CreateCompressedBody(compressedData); XmlTextReader reader = new XmlTextReader(new StringReader(copressedBody), new NameTable()); Message compressedMessage = Message.CreateMessage(sourceMessage.Version, null, (XmlReader)reader); compressedMessage.Headers.CopyHeadersFrom(sourceMessage); compressedMessage.Properties.CopyProperties(sourceMessage.Properties); compressedMessage.AddCompressionHeader(this.DataCompressor.Algorithm); sourceMessage.Close(); return(compressedMessage); }
public void BeforeSendReply(ref Message reply, object correlationState) { var correlationModel = (CorrelationModel)correlationState; if (reply != null) { //Correlation Guid for track var correlationGuid = MessageHeader.CreateHeader("Correlation-GUID", "http://tempuri.org", correlationModel.CorrelationGuid.ToString()); reply.Headers.Add(correlationGuid); XmlWriterSettings settings = new XmlWriterSettings { Encoding = System.Text.Encoding.UTF8 }; StringWriter sw = new StringWriter(); XmlWriter writer = XmlWriter.Create(sw, settings); MessageBuffer buffer = reply.CreateBufferedCopy(int.MaxValue); //Create a copy of the message in order to continue the handling of te SOAP reply = buffer.CreateMessage(); reply.WriteMessage(writer); //Recreate the message writer.Flush(); //Flush the contents of the writer so that the stream gets updated //you can log the str to the database var str = sw.ToString(); WriteToTxt.WriteToFile(str); reply = buffer.CreateMessage(); } else { WriteToTxt.WriteToFile("No response xml for this request"); } WriteToTxt.WriteToFile("Response time:" + new TimeSpan(DateTime.Now.Ticks - correlationModel.ResponseTicks)); }
public Message CopyMessage(Message message, MessageContainer container, MessageDirection direction) { MessageBuffer buffer = message.CreateBufferedCopy(Int32.MaxValue); if (direction == MessageDirection.Incoming) { container.RequestMessageText = buffer.CreateMessage().ToString(); container.RequestReceived = DateTime.Now; if (message.Properties.ContainsKey(RemoteEndpointMessageProperty.Name)) { RemoteEndpointMessageProperty property = (RemoteEndpointMessageProperty)message.Properties[RemoteEndpointMessageProperty.Name]; container.RemoteAddress = property.Address; } if (message.Headers.To != null) { container.ToAddress = message.Headers.To.ToString(); } container.RequestAction = message.Headers.Action; } else if (direction == MessageDirection.Outgoing) { container.ResponseMessageText = buffer.CreateMessage().ToString(); container.ResponseReceived = DateTime.Now; container.ResponseAction = message.Headers.Action; } return(buffer.CreateMessage()); }
public object AfterReceiveRequest( ref Message request, IClientChannel channel, InstanceContext instanceContext) { MessageBuffer buffer = request.CreateBufferedCopy(int.MaxValue); try { XmlReaderSettings settings = new XmlReaderSettings(); settings.Schemas.Add(schemas); settings.ValidationType = ValidationType.Schema; Message msgToValidate = buffer.CreateMessage(); XmlReader reader = XmlReader.Create( msgToValidate.GetReaderAtBodyContents().ReadSubtree(), settings); while (reader.Read()) { ; // do nothing, just validate } request = buffer.CreateMessage(); } catch (Exception e) { throw new FaultException(e.Message); } return(null); }
private Message TraceMessage(MessageBuffer buffer) { //Must use a buffer rather than the origonal message, because the Message's body can be processed only once. Message msg = buffer.CreateMessage(); //Setup StringWriter to use as input for our StreamWriter //This is needed in order to capture the body of the message, because the body is streamed. StringWriter stringWriter = new StringWriter(); XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter); //msg.WriteMessage(xmlTextWriter); xmlTextWriter.Flush(); xmlTextWriter.Close(); //Setup filename to write to if (!Directory.Exists(LogDir)) { Directory.CreateDirectory(LogDir); } DateTime now = DateTime.Now; string datePart = now.Year.ToString() + '-' + now.Month.ToString() + '-' + now.Day.ToString() + '-' + now.Hour + '-' + now.Minute + '-' + now.Second; string fileName = LogDir + "\\" + datePart + '-' + "SoapEnv.xml"; //Write to file using (StreamWriter sw = new StreamWriter(fileName)) sw.Write(stringWriter.ToString()); //Return copy of origonal message with unalterd State return(buffer.CreateMessage()); }
public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel, System.ServiceModel.InstanceContext instanceContext) { if (!_traceSoapMessages && !_traceSoapMessageHeaders) { return(null); } StringBuilder logMessage = new StringBuilder(); MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); request = buffer.CreateMessage(); Message originalMessage = buffer.CreateMessage(); logMessage.AppendLine("Received:"); logMessage.AppendLine(); if (_traceSoapMessageHeaders) { foreach (MessageHeader header in originalMessage.Headers) { string headerString = header.ToString(); logMessage.AppendLine(headerString); } } if (_traceSoapMessages) { logMessage.AppendLine(); string soapMessage = originalMessage.ToString(); logMessage.AppendLine(soapMessage); } string logMessageString = logMessage.ToString(); GOCWindows.Instance.Logger.LogMessage(new LogMessage(logMessageString, LogMessageType.Information, LoggingLevel.Maximum)); return(null); }
/// <summary>Called after an inbound message has been received but before the message is dispatched to the intended operation.</summary> /// <param name="request">The request message.</param> /// <param name="channel">The incoming channel.</param> /// <param name="instanceContext">The current service instance.</param> /// <returns>The object used to correlate state. This object is passed back in the BeforeSendReply(Message@,object) method.</returns> public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext) { if (request == null) { return(null); } /* Create a buffer in order to make it possible to work with copies of the message */ MessageBuffer buffer = request.CreateBufferedCopy(int.MaxValue); this.OnPreValidation(buffer.CreateMessage(), channel, instanceContext); /* Create a copy of the message and send it to the validation */ request = buffer.CreateMessage(); try { this.ValidateMessage(request); } catch (XmlSchemaValidationException ex) { this.OnValidationError(buffer.CreateMessage(), channel, instanceContext, ex); FaultReasonText reasonText = new FaultReasonText(Resources.MessageDoesNotComplyWithSchema, CultureInfo.InvariantCulture); throw new FaultException <string>(ex.Message, new FaultReason(reasonText), FaultCode.CreateSenderFaultCode(new FaultCode("InvalidMessage"))); } this.OnValidationSuccess(buffer.CreateMessage(), channel, instanceContext); /* Validation was succesfull. Create a new copy of the message and pass it to the WCF process. */ request = buffer.CreateMessage(); /* There is no need to correlate the AfterReceiveRequest en BeforeSendReply calls, so simply return null */ return(null); }
public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { if (!_traceSoapMessages && !_traceSoapMessageHeaders) { return; } StringBuilder logMessage = new StringBuilder(); MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); reply = buffer.CreateMessage(); Message originalMessage = buffer.CreateMessage(); logMessage.AppendLine("Sending:"); logMessage.AppendLine(); if (_traceSoapMessageHeaders) { foreach (MessageHeader header in originalMessage.Headers) { string headerString = header.ToString(); logMessage.AppendLine(headerString); } } if (_traceSoapMessages) { logMessage.AppendLine(); string soapMessage = originalMessage.ToString(); logMessage.AppendLine(soapMessage); } string logMessageString = logMessage.ToString(); GOCWindows.Instance.Logger.LogMessage(new LogMessage(logMessageString, LogMessageType.Information, LoggingLevel.Maximum)); }
public void AfterReceiveReply(ref Message reply, object correlationState) { MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); reply = buffer.CreateMessage(); LogService.Log("Reply:" + Environment.NewLine + buffer.CreateMessage()); }
public void AfterReceiveReply(ref Message reply, object correlationState) { MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); reply = buffer.CreateMessage(); Console.WriteLine("Received:\n{0}", buffer.CreateMessage().ToString()); }
public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); reply = buffer.CreateMessage(); Console.WriteLine("Message Sending:\n{0}", buffer.CreateMessage().ToString()); }
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext) { MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); request = buffer.CreateMessage(); Message messageCopy = buffer.CreateMessage(); //para obtener el metodo y la peticion del ws var action = OperationContext.Current.IncomingMessageHeaders.Action; var operationName = action.Substring(action.LastIndexOf("/") + 1); StringWriter stringWriter = new StringWriter(); XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter); xmlTextWriter.Formatting = Formatting.Indented; xmlTextWriter.Indentation = 1; xmlTextWriter.IndentChar = '\t'; messageCopy.WriteMessage(xmlTextWriter); // Read the custom context data from the headers ModelInterceptor requestHeaders = Header.ReadHeader(request); // Add an extension to the current operation context so // that our custom context can be easily accessed anywhere. //ServerContext customContext = new ServerContext(); if (!System.Diagnostics.Debugger.IsAttached) { Utilerias.validaUsuario(requestHeaders.usuario, requestHeaders.contrasena); new Logg().Info("Mensaje de Entrada: (Request) \n\n" + stringWriter.ToString()); log4netRequest.Info("Mensaje de Entrada: (Request) \n\n" + stringWriter.ToString()); } OperationContext.Current.IncomingMessageProperties.Add( "CurrentContext", new ModelInterceptor()); return(null); }
private Message TraceMessage(MessageBuffer buffer) { Message msg = buffer.CreateMessage(); Console.WriteLine("\n{0}\n", msg); return(buffer.CreateMessage()); }
private Message LogMessage(MessageBuffer buffer) { Message msg = buffer.CreateMessage(); StringBuilder sb = new StringBuilder(); using (XmlWriter xw = XmlWriter.Create(sb)) { msg.WriteMessage(xw); xw.Close(); } string logMsg = $"Message via: '{msg.Properties.Via}' with '{msg.Headers?.Count}' Headers -> content:\n {sb.ToString().CleanWhiteSpaces()}"; Debug.WriteLine(logMsg); _log.Trace(logMsg); foreach (var header in msg.Headers) { string headerMsg = $"Header: {header}"; Debug.WriteLine(headerMsg); _log.Trace(headerMsg); } return(buffer.CreateMessage()); }
internal static bool IsMessageVersionNoneFault(ref Message message, int maxFaultSize) { if (message.Version != MessageVersion.None || message.IsEmpty) { return(false); } HttpResponseMessageProperty prop = message.Properties[HttpResponseMessageProperty.Name] as HttpResponseMessageProperty; if (prop == null || prop.StatusCode != HttpStatusCode.InternalServerError) { return(false); } using (MessageBuffer buffer = message.CreateBufferedCopy(maxFaultSize)) { message.Close(); message = buffer.CreateMessage(); using (Message copy = buffer.CreateMessage()) { using (XmlDictionaryReader reader = copy.GetReaderAtBodyContents()) { return(reader.IsStartElement(XD.MessageDictionary.Fault, MessageVersion.None.Envelope.DictionaryNamespace)); } } } }
public string SelectOperation(ref Message message) { // TODO: check message format (raw) // Ignore non-POST requests if (!EnsurePostRequest(message)) { return(null); } if (message.Properties.ContainsKey(DispatcherUtils.OperationNameKey)) { return((string)message.Properties[DispatcherUtils.OperationNameKey]); } Message messageCopy; using (MessageBuffer buffer = message.CreateBufferedCopy(Int32.MaxValue)) { message = buffer.CreateMessage(); messageCopy = buffer.CreateMessage(); } string operation = SelectOperationInternal(messageCopy); if (operation == null) { throw new InvalidOperationException("Invalid message format."); } message.Properties[DispatcherUtils.OperationNameKey] = operation; return(operation); }
/// <summary> /// Extracts the body of a WCF Message and returns it as an XmlDocment /// </summary> /// <param name="msg">The WCF message</param> /// <param name="discardOriginalMessage">If true, the body of the original message will not be /// readable after calling this method</param> /// <returns>The body of the Message as an XmlDocument</returns> public static XmlDocument GetMessageBodyAsXmlDocument(Message msg, bool discardOriginalMessage) { XmlDocument messageXml; if (msg.IsEmpty) { messageXml = null; } else { messageXml = new XmlDocument(); if (!discardOriginalMessage) { MessageBuffer bufferCopy = msg.CreateBufferedCopy(int.MaxValue); XmlDictionaryReader reader = bufferCopy.CreateMessage().GetReaderAtBodyContents(); messageXml.Load(reader); reader.Close(); msg = bufferCopy.CreateMessage(); bufferCopy.Close(); } else { XmlDictionaryReader reader = msg.GetReaderAtBodyContents(); messageXml.Load(reader); reader.Close(); } } return(messageXml); }
/// <summary> /// <see cref="System.ServiceModel.Dispatcher.IDispatchMessageInspector"/> /// </summary> /// <param name="request"><see cref="System.ServiceModel.Dispatcher.IDispatchMessageInspector"/></param> /// <param name="channel"><see cref="System.ServiceModel.Dispatcher.IDispatchMessageInspector"/></param> /// <param name="instanceContext"><see cref="System.ServiceModel.Dispatcher.IDispatchMessageInspector"/></param> /// <returns><see cref="System.ServiceModel.Dispatcher.IDispatchMessageInspector"/></returns> public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext) { if (IsEnabled) { OperationContext context = OperationContext.Current; MessageBuffer buffer = request.CreateBufferedCopy(int.MaxValue); request = buffer.CreateMessage(); if (context != null && buffer.BufferSize <= this.MaxMessageSize) { try { Message tmpMesage = buffer.CreateMessage(); Process CurrentProcess = Process.GetCurrentProcess(); IIdentity SourceIdentity = GenericPrincipal.Current.Identity; MessageProperties messageProperties = context.IncomingMessageProperties; RemoteEndpointMessageProperty endpointProperty = messageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty; IIdentity ClientIdentity = null; if (context.ServiceSecurityContext != null) { ClientIdentity = context.ServiceSecurityContext.PrimaryIdentity; } WcfEvent wcfEvent = new WcfEvent() { MessageID = Guid.NewGuid(), ProcessID = CurrentProcess.Id, ThreadID = Thread.CurrentThread.ManagedThreadId, TimeCreated = DateTime.Now, ServiceName = context.Host.Description.Name, ServiceMachineName = Environment.MachineName, ServiceUri = context.Channel.LocalAddress.ToString(), ServiceIP = context.Channel.LocalAddress.Uri.Host, ServicePort = context.Channel.LocalAddress.Uri.Port, ServiceIdentity = SourceIdentity.Name, ServiceAuthenticationType = SourceIdentity.AuthenticationType, ClientIP = endpointProperty.Address, ClientPort = endpointProperty.Port, ClientIdentity = ClientIdentity == null ? "Anonymous" : ClientIdentity.Name, ClientAuthenticationType = ClientIdentity == null ? "None" : ClientIdentity.AuthenticationType, Action = request.Headers.Action, Request = tmpMesage.GetReaderAtBodyContents().ReadOuterXml(), Response = null, Misc = null, IsFault = request.IsFault }; return(wcfEvent); } catch (Exception ex) { if (!System.Diagnostics.EventLog.SourceExists(this.EventLogSource)) { System.Diagnostics.EventLog.CreateEventSource(this.EventLogSource, this.EventLogName); } System.Diagnostics.EventLog.WriteEntry(this.EventLogSource, ex.ToString(), System.Diagnostics.EventLogEntryType.Error); } } } return(null); }
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext) { MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); request = buffer.CreateMessage(); Console.WriteLine("Received:\n{0}", buffer.CreateMessage()); return(null); }
/// <summary> /// Gets the message body as a string. /// </summary> /// <returns>The message body.</returns> /// <param name="message">Message.</param> private string GetMessageBody(ref Message message) { using (MessageBuffer buffer = message.CreateBufferedCopy(Int32.MaxValue)) { // Message can only be read once, so replace it with a copy. message = buffer.CreateMessage(); return(buffer.CreateMessage().ToString()); } }
public object BeforeSendRequest(ref Message request, IClientChannel channel) { MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); request = buffer.CreateMessage(); Console.WriteLine("Sending:\n{0}", buffer.CreateMessage().ToString()); return(request); }