/// <summary>
        /// Gets the eventData body and properties.
        /// </summary>
        /// <param name="builder">The string builder object used to accumulate the trace event data.</param>
        /// <param name="inboundMessage">The inbound event data.</param>
        public void GetMessageAndProperties(StringBuilder builder, EventData inboundMessage)
        {
            string eventDataText = null;
            Stream stream = null;

            if (inboundMessage == null)
            {
                return;
            }
            
            try
            {
                var eventDataClone = inboundMessage.Clone();
                stream = eventDataClone.GetBody<Stream>();
                if (stream != null)
                {
                    using (var reader = new StreamReader(stream))
                    {
                        eventDataText = reader.ReadToEnd();
                    }
                }
            }
            catch (Exception)
            {
                try
                {
                    if (stream != null)
                    {
                        try
                        {
                            stream.Seek(0, SeekOrigin.Begin);
                            var serializer = new CustomDataContractBinarySerializer(typeof(string));
                            eventDataText = serializer.ReadObject(stream) as string;
                        }
                        catch (Exception)
                        {
                            try
                            {
                                stream.Seek(0, SeekOrigin.Begin);
                                using (var reader = new StreamReader(stream))
                                {
                                    eventDataText = reader.ReadToEnd();
                                }
                            }
                            catch (Exception)
                            {
                                eventDataText = UnableToReadMessageBody;
                            }
                        }
                    }
                    else
                    {
                        eventDataText = UnableToReadMessageBody;
                    }
                }
                catch (Exception)
                {
                    eventDataText = UnableToReadMessageBody;
                }
            }
            builder.AppendLine();
            builder.AppendLine(ReceivedMessagePayloadHeader);
            builder.AppendLine(string.Format(MessageTextFormat, eventDataText));
            if (inboundMessage.Properties.Any())
            {
                builder.AppendLine(ReceivedMessagePropertiesHeader);
                foreach (var p in inboundMessage.Properties)
                {
                    builder.AppendLine(string.Format(MessagePropertyFormat,
                                                     p.Key,
                                                     p.Value));
                }
            }
        }
        /// <summary>
        /// Gets the message body and properties.
        /// </summary>
        /// <param name="builder">The string builder object used to accumulate the trace message.</param>
        /// <param name="inboundMessage">The inbound message.</param>
        /// <param name="encoder">The message encoder used to decode a WCF message.</param>
        public void GetMessageAndProperties(StringBuilder builder, BrokeredMessage inboundMessage, MessageEncoder encoder)
        {
            string messageText = null;
            Stream stream = null;

            if (inboundMessage == null)
            {
                return;
            }
            try
            {
                var messageClone = inboundMessage.Clone();
                stream = messageClone.GetBody<Stream>();
                if (stream != null)
                {
                    var stringBuilder = new StringBuilder();
                    var message = encoder.ReadMessage(stream, MaxBufferSize);
                    using (var reader = message.GetReaderAtBodyContents())
                    {
                        // The XmlWriter is used just to indent the XML message
                        var settings = new XmlWriterSettings { Indent = true };
                        using (var writer = XmlWriter.Create(stringBuilder, settings))
                        {
                            writer.WriteNode(reader, true);
                        }
                    }
                    messageText = stringBuilder.ToString();
                }
            }
            catch (Exception)
            {
                try
                {
                    var messageClone = inboundMessage.Clone();
                    stream = messageClone.GetBody<Stream>();
                    if (stream != null)
                    {
                        var message = encoder.ReadMessage(stream, MaxBufferSize);
                        using (var reader = message.GetReaderAtBodyContents())
                        {
                            messageText = reader.ReadString();
                        }
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        if (stream != null)
                        {
                            try
                            {
                                stream.Seek(0, SeekOrigin.Begin);
                                var serializer = new CustomDataContractBinarySerializer(typeof(string));
                                messageText = serializer.ReadObject(stream) as string;
                            }
                            catch (Exception)
                            {
                                try
                                {
                                    stream.Seek(0, SeekOrigin.Begin);
                                    using (var reader = new StreamReader(stream))
                                    {
                                        messageText = reader.ReadToEnd();
                                    }
                                }
                                catch (Exception)
                                {
                                    messageText = UnableToReadMessageBody;
                                }
                            }
                        }
                        else
                        {
                            messageText = UnableToReadMessageBody;
                        }
                    }
                    catch (Exception)
                    {
                        messageText = UnableToReadMessageBody;
                    }
                }
            }
            builder.AppendLine(ReceivedMessagePayloadHeader);
            builder.AppendLine(string.Format(MessageTextFormat, messageText));
            if (inboundMessage.Properties.Any())
            {
                builder.AppendLine(ReceivedMessagePropertiesHeader);
                foreach (var p in inboundMessage.Properties)
                {
                    builder.AppendLine(string.Format(MessagePropertyFormat,
                                                     p.Key,
                                                     p.Value));
                }
            }
        }
 /// <summary>
 /// Reads the message contained in a stream.
 /// </summary>
 /// <param name="stream">The stream containing the message.</param>
 /// <param name="isBinary">Indicates if the body is binary or not.</param>
 /// <returns>The message.</returns>
 private static string GetMessageText(Stream stream, bool isBinary = false)
 {
     string messageText;
     if (stream == null)
     {
         return null;
     }
     try
     {
         var element = new BinaryMessageEncodingBindingElement
         {
             ReaderQuotas = new XmlDictionaryReaderQuotas
             {
                 MaxArrayLength = int.MaxValue,
                 MaxBytesPerRead = int.MaxValue,
                 MaxDepth = int.MaxValue,
                 MaxNameTableCharCount = int.MaxValue,
                 MaxStringContentLength = int.MaxValue
             }
         };
         var encoderFactory = element.CreateMessageEncoderFactory();
         var encoder = encoderFactory.Encoder;
         var stringBuilder = new StringBuilder();
         var message = encoder.ReadMessage(stream, MaxBufferSize);
         using (var reader = message.GetReaderAtBodyContents())
         {
             // The XmlWriter is used just to indent the XML message
             var settings = new XmlWriterSettings { Indent = true };
             using (var writer = XmlWriter.Create(stringBuilder, settings))
             {
                 writer.WriteNode(reader, true);
             }
         }
         messageText = stringBuilder.ToString();
     }
     catch (Exception)
     {
         try
         {
             stream.Seek(0, SeekOrigin.Begin);
             var element = new BinaryMessageEncodingBindingElement
             {
                 ReaderQuotas = new XmlDictionaryReaderQuotas
                 {
                     MaxArrayLength = int.MaxValue,
                     MaxBytesPerRead = int.MaxValue,
                     MaxDepth = int.MaxValue,
                     MaxNameTableCharCount = int.MaxValue,
                     MaxStringContentLength = int.MaxValue
                 }
             };
             var encoderFactory = element.CreateMessageEncoderFactory();
             var encoder = encoderFactory.Encoder;
             var message = encoder.ReadMessage(stream, MaxBufferSize);
             using (var reader = message.GetReaderAtBodyContents())
             {
                 messageText = reader.ReadString();
             }
         }
         catch (Exception)
         {
                 try
                 {
                     stream.Seek(0, SeekOrigin.Begin);
                     var serializer = new CustomDataContractBinarySerializer(typeof(string));
                     messageText = serializer.ReadObject(stream) as string;
                 }
                 catch (Exception)
                 {
                 try
                 {
                     stream.Seek(0, SeekOrigin.Begin);
                     if (isBinary)
                     {
                         using (var binaryReader = new BinaryReader(stream))
                         {
                             var bytes = binaryReader.ReadBytes((int)stream.Length);
                             messageText = BitConverter.ToString(bytes).Replace('-', ' ');
                         }
                     }
                     else
                     {
                         using (var reader = new StreamReader(stream))
                         {
                             messageText = reader.ReadToEnd();
                             if (messageText.ToCharArray().GroupBy(c => c).
                                 Where(g => char.IsControl(g.Key) && g.Key != '\t' && g.Key != '\n' && g.Key != '\r').
                                 Select(g => g.First()).Any())
                             {
                                 stream.Seek(0, SeekOrigin.Begin);
                                 using (var binaryReader = new BinaryReader(stream))
                                 {
                                     var bytes = binaryReader.ReadBytes((int)stream.Length);
                                     messageText = BitConverter.ToString(bytes).Replace('-', ' ');
                                 }
                             }
                         }
                     }
                 }
                 catch (Exception)
                 {
                     messageText = UnableToReadMessageBody;
                 }
             }
         }
     }
     return messageText;
 }
 /// <summary>
 /// Reads the content of the EventData passed as argument.
 /// </summary>
 /// <param name="eventDataToRead">The EventData to read.</param>
 /// <param name="bodyType">BodyType</param>
 /// <returns>The content of the EventData.</returns>
 public string GetMessageText(EventData eventDataToRead, out BodyType bodyType)
 {
     string eventDataText = null;
     Stream stream = null;
     bodyType = BodyType.Stream;
     if (eventDataToRead == null)
     {
         return null;
     }
     var inboundMessage = eventDataToRead.Clone();
     try
     {
         stream = inboundMessage.GetBody<Stream>();
         if (stream != null)
         {
             var element = new BinaryMessageEncodingBindingElement
             {
                 ReaderQuotas = new XmlDictionaryReaderQuotas
                 {
                     MaxArrayLength = int.MaxValue,
                     MaxBytesPerRead = int.MaxValue,
                     MaxDepth = int.MaxValue,
                     MaxNameTableCharCount = int.MaxValue,
                     MaxStringContentLength = int.MaxValue
                 }
             };
             var encoderFactory = element.CreateMessageEncoderFactory();
             var encoder = encoderFactory.Encoder;
             var stringBuilder = new StringBuilder();
             var eventData = encoder.ReadMessage(stream, MaxBufferSize);
             using (var reader = eventData.GetReaderAtBodyContents())
             {
                 // The XmlWriter is used just to indent the XML eventData
                 var settings = new XmlWriterSettings { Indent = true };
                 using (var writer = XmlWriter.Create(stringBuilder, settings))
                 {
                     writer.WriteNode(reader, true);
                 }
             }
             eventDataText = stringBuilder.ToString();
             bodyType = BodyType.Wcf;
         }
     }
     catch (Exception)
     {
         inboundMessage = eventDataToRead.Clone();
         try
         {
             stream = inboundMessage.GetBody<Stream>();
             if (stream != null)
             {
                 var element = new BinaryMessageEncodingBindingElement
                 {
                     ReaderQuotas = new XmlDictionaryReaderQuotas
                     {
                         MaxArrayLength = int.MaxValue,
                         MaxBytesPerRead = int.MaxValue,
                         MaxDepth = int.MaxValue,
                         MaxNameTableCharCount = int.MaxValue,
                         MaxStringContentLength = int.MaxValue
                     }
                 };
                 var encoderFactory = element.CreateMessageEncoderFactory();
                 var encoder = encoderFactory.Encoder;
                 var eventData = encoder.ReadMessage(stream, MaxBufferSize);
                 using (var reader = eventData.GetReaderAtBodyContents())
                 {
                     eventDataText = reader.ReadString();
                 }
                 bodyType = BodyType.Wcf;
             }
         }
         catch (Exception)
         {
             try
             {
                 if (stream != null)
                 {
                     try
                     {
                         stream.Seek(0, SeekOrigin.Begin);
                         var serializer = new CustomDataContractBinarySerializer(typeof(string));
                         eventDataText = serializer.ReadObject(stream) as string;
                         bodyType = BodyType.String;
                     }
                     catch (Exception)
                     {
                         try
                         {
                             stream.Seek(0, SeekOrigin.Begin);
                             using (var reader = new StreamReader(stream))
                             {
                                 eventDataText = reader.ReadToEnd();
                                 if (eventDataText.ToCharArray().GroupBy(c => c).
                                     Where(g => char.IsControl(g.Key) && g.Key != '\t' && g.Key != '\n' && g.Key != '\r').
                                     Select(g => g.First()).Any())
                                 {
                                     stream.Seek(0, SeekOrigin.Begin);
                                     using (var binaryReader = new BinaryReader(stream))
                                     {
                                         var bytes = binaryReader.ReadBytes((int)stream.Length);
                                         eventDataText = BitConverter.ToString(bytes).Replace('-', ' ');
                                     }
                                 }
                             }
                         }
                         catch (Exception)
                         {
                             eventDataText = UnableToReadMessageBody;
                         }
                     }
                 }
                 else
                 {
                     eventDataText = UnableToReadMessageBody;
                 }
             }
             catch (Exception)
             {
                 eventDataText = UnableToReadMessageBody;
             }
         }
     }
     return eventDataText;
 }
Exemple #5
0
        /// <summary>
        /// Reads the content of the BrokeredMessage passed as argument.
        /// </summary>
        /// <param name="messageToRead">The BrokeredMessage to read.</param>
        /// <returns>The content of the BrokeredMessage.</returns>
        private static string GetMessageText(BrokeredMessage messageToRead)
        {
            string messageText = null;
            Stream stream      = null;

            if (messageToRead == null)
            {
                return(null);
            }
            var inboundMessage = messageToRead.Clone();

            try
            {
                stream = inboundMessage.GetBody <Stream>();
                if (stream != null)
                {
                    var element = new BinaryMessageEncodingBindingElement
                    {
                        ReaderQuotas = new XmlDictionaryReaderQuotas
                        {
                            MaxArrayLength         = int.MaxValue,
                            MaxBytesPerRead        = int.MaxValue,
                            MaxDepth               = int.MaxValue,
                            MaxNameTableCharCount  = int.MaxValue,
                            MaxStringContentLength = int.MaxValue
                        }
                    };
                    var encoderFactory = element.CreateMessageEncoderFactory();
                    var encoder        = encoderFactory.Encoder;
                    var stringBuilder  = new StringBuilder();
                    var message        = encoder.ReadMessage(stream, MaxBufferSize);
                    using (var reader = message.GetReaderAtBodyContents())
                    {
                        // The XmlWriter is used just to indent the XML message
                        var settings = new XmlWriterSettings {
                            Indent = true
                        };
                        using (var xmlWriter = XmlWriter.Create(stringBuilder, settings))
                        {
                            xmlWriter.WriteNode(reader, true);
                        }
                    }
                    messageText = stringBuilder.ToString();
                }
            }
            catch (Exception)
            {
                inboundMessage = messageToRead.Clone();
                try
                {
                    stream = inboundMessage.GetBody <Stream>();
                    if (stream != null)
                    {
                        var element = new BinaryMessageEncodingBindingElement
                        {
                            ReaderQuotas = new XmlDictionaryReaderQuotas
                            {
                                MaxArrayLength         = int.MaxValue,
                                MaxBytesPerRead        = int.MaxValue,
                                MaxDepth               = int.MaxValue,
                                MaxNameTableCharCount  = int.MaxValue,
                                MaxStringContentLength = int.MaxValue
                            }
                        };
                        var encoderFactory = element.CreateMessageEncoderFactory();
                        var encoder        = encoderFactory.Encoder;
                        var message        = encoder.ReadMessage(stream, MaxBufferSize);
                        using (var reader = message.GetReaderAtBodyContents())
                        {
                            messageText = reader.ReadString();
                        }
                    }
                }
                catch (Exception)
                {
                    try
                    {
                        if (stream != null)
                        {
                            try
                            {
                                stream.Seek(0, SeekOrigin.Begin);
                                var serializer = new CustomDataContractBinarySerializer(typeof(string));
                                messageText = serializer.ReadObject(stream) as string;
                            }
                            catch (Exception)
                            {
                                try
                                {
                                    stream.Seek(0, SeekOrigin.Begin);
                                    using (var reader = new StreamReader(stream))
                                    {
                                        messageText = reader.ReadToEnd();
                                        if (messageText.ToCharArray().GroupBy(c => c).
                                            Where(g => char.IsControl(g.Key) && g.Key != '\t' && g.Key != '\n' && g.Key != '\r').
                                            Select(g => g.First()).Any())
                                        {
                                            stream.Seek(0, SeekOrigin.Begin);
                                            using (var binaryReader = new BinaryReader(stream))
                                            {
                                                var bytes = binaryReader.ReadBytes((int)stream.Length);
                                                messageText = BitConverter.ToString(bytes).Replace('-', ' ');
                                            }
                                        }
                                    }
                                }
                                catch (Exception)
                                {
                                    messageText = UnableToReadMessageBody;
                                }
                            }
                        }
                        else
                        {
                            messageText = UnableToReadMessageBody;
                        }
                    }
                    catch (Exception)
                    {
                        messageText = UnableToReadMessageBody;
                    }
                }
            }
            return(messageText);
        }