C# Message.GetReaderAtBodyContents方法代码示例

        /// <summary>
        /// Executes the request message on the target system and returns a response message.
        /// If there isn’t a response, this method should return null
        /// </summary>
        public Message Execute(Message message, TimeSpan timeout)
        {
            if (message.Headers.Action != "Submit")
                throw new ApplicationException("Unexpected Message Action");

            //Parse the request message to extract the string and get out the body to send to the socket
            XmlDictionaryReader rdr = message.GetReaderAtBodyContents();
            rdr.Read();
            string input = rdr.ReadElementContentAsString();

            //Interact with the socket
            this.Connection.Client.SendData(input);
            string output = this.Connection.Client.ReceiveData();
            Debug.WriteLine(output);

            //Produce the response message
            StringBuilder outputString = new StringBuilder();
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.OmitXmlDeclaration = true;
            XmlWriter replywriter = XmlWriter.Create(outputString, settings);
            replywriter.WriteStartElement("SendResponse", "http://acme.wcf.lob.paymentapplication/");
            replywriter.WriteStartElement("SendResult");
            replywriter.WriteString(Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes(output)));
            replywriter.WriteEndElement();
            replywriter.WriteEndElement();
            replywriter.Close();
            XmlReader replyReader = XmlReader.Create(new StringReader(outputString.ToString()));

            Message response = Message.CreateMessage(MessageVersion.Default, "Submit/Response", replyReader);
            return response;
        }

 public object DeserializeMessageWithPayload(Message messageWithPayload, Type expectedType)
 {
     if (messageWithPayload.IsEmpty)
     {
         return null;
     }
     if (typeof(IXmlSerializable).IsAssignableFrom(expectedType))
     {
         var serializable = (IXmlSerializable)Activator.CreateInstance(expectedType);
         serializable.ReadXml(messageWithPayload.GetReaderAtBodyContents());
         return serializable;
     }
     var xs = new XmlSerializer(expectedType);
     return xs.Deserialize(messageWithPayload.GetReaderAtBodyContents());
 }

 public CreateCoordinationContextResponse(Message message, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) : this(protocolVersion)
 {
     if (message.IsEmpty)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody")));
     }
     XmlDictionaryReader readerAtBodyContents = message.GetReaderAtBodyContents();
     using (readerAtBodyContents)
     {
         this.ReadFrom(readerAtBodyContents);
         try
         {
             message.ReadFromBodyContentsToEnd(readerAtBodyContents);
         }
         catch (XmlException exception)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception));
         }
     }
     try
     {
         this.IssuedToken = CoordinationServiceSecurity.GetIssuedToken(message, this.CoordinationContext.Identifier, protocolVersion);
     }
     catch (XmlException exception2)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(exception2.Message, exception2));
     }
 }

        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            if (!request.IsEmpty)
            {
                XmlReader bodyReader = request.GetReaderAtBodyContents().ReadSubtree();

                MemoryStream stream = new MemoryStream();
                XmlWriter writer = XmlWriter.Create(stream);

                if (transform == null)
                {
                    transform = new XslCompiledTransform(true);
                    var reader = XmlReader.Create(new StringReader(Properties.Resources.XmlCleaner));
                    transform.Load(reader);
                }
                transform.Transform(bodyReader, writer);

                stream.Flush();
                stream.Seek(0, SeekOrigin.Begin);

                bodyReader = XmlReader.Create(stream);

                Message changedMessage = Message.CreateMessage(request.Version, null, bodyReader);
                changedMessage.Headers.CopyHeadersFrom(request.Headers);
                changedMessage.Properties.CopyProperties(request.Properties);
                request = changedMessage;
            }

            return null;
        }

 public static byte[] DeserializeBody(Message message)
 {
     using (XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents()) {
         bodyReader.ReadStartElement("Binary");
         return bodyReader.ReadContentAsBase64();
     }
 }

 public static CreateSequenceInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession, Message message, MessageHeaders headers)
 {
     CreateSequenceInfo info;
     if (message.IsEmpty)
     {
         string reason = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion) });
         Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
     }
     using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
     {
         info = CreateSequence.Create(messageVersion, reliableMessagingVersion, securitySession, reader);
         message.ReadFromBodyContentsToEnd(reader);
     }
     info.SetMessageId(messageVersion, headers);
     info.SetReplyTo(messageVersion, headers);
     if (info.AcksTo.Uri != info.ReplyTo.Uri)
     {
         string str2 = System.ServiceModel.SR.GetString("CSRefusedAcksToMustEqualReplyTo");
         Message message3 = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, str2);
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(message3, str2, new ProtocolException(str2)));
     }
     info.to = message.Headers.To;
     if ((info.to == null) && (messageVersion.Addressing == AddressingVersion.WSAddressing10))
     {
         info.to = messageVersion.Addressing.AnonymousUri;
     }
     return info;
 }

 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;
 }

        private string SelectOperationInternal(Message message)
        {
            byte[] rawBody;
            using (XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents()) {
                bodyReader.ReadStartElement("Binary");
                rawBody = bodyReader.ReadContentAsBase64();
            }

            string operation = null;
            using (var bodyReader = new JsonTextReader(new StreamReader(new MemoryStream(rawBody)))) {
                while (bodyReader.Read()) {
                    if (bodyReader.TokenType == JsonToken.PropertyName) {
                        string propertyName = (string)bodyReader.Value;
                        if (propertyName.Equals("method", StringComparison.Ordinal)) {
                            if (!bodyReader.Read() || bodyReader.TokenType != JsonToken.String)
                                throw new InvalidOperationException("Invalid message format.");

                            operation = (string)bodyReader.Value;
                            break;
                        }
                    }
                }
            }

            return operation;
        }

        public void Deserialize(OperationDescription operation, Dictionary<string, int> parameterNames, Message message, object[] parameters)
        {
            object bodyFormatProperty;
            if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
                (bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
            {
                throw new InvalidOperationException(
                    "Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
            }

            var bodyReader = message.GetReaderAtBodyContents();
            bodyReader.ReadStartElement("Binary");
            byte[] rawBody = bodyReader.ReadContentAsBase64();
            using (var ms = new MemoryStream(rawBody))
            using (var sr = new StreamReader(ms))
            {
                var serializer = new System.Xml.Serialization.XmlSerializer(operation.Messages[0].Body.Parts[0].Type);
                if (parameters.Length == 1)
                {
                    // single parameter, assuming bare
                    parameters[0] = serializer.Deserialize(sr);
                }
                else
                {
                    throw new InvalidOperationException("We don't support multiple xml parameters");
                }
                sr.Close();
                ms.Close();
            }
        }

        public object DeserializeReply(Message message, object[] parameters)
        {
            object bodyFormatProperty;
            if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
                (bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
            {
                throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
            }

            var bodyReader = message.GetReaderAtBodyContents();
            var serializer = new JsonSerializer();
            bodyReader.ReadStartElement("Binary");
            byte[] body = bodyReader.ReadContentAsBase64();

            // I tried to use a converter for this. But I failed miserably :-)
            body = WorkAroundCrm15891(body);

            using (var ms = new MemoryStream(body))
            {
                using (var sr = new StreamReader(ms))
                {
                    Type returnType = this._operation.Messages[1].Body.ReturnValue.Type;
                    if (returnType == typeof (EmptyResult))
                    {
                        // If the result of the API cannot be parsed, you can use EmptyResult
                        // as a result. In this case the body is ignored.
                        return new EmptyResult();
                    }
                    var result = serializer.Deserialize(sr, returnType);
                    return result;
                }
            }
        }

        public override ArraySegment<byte> WriteMessage(Message message,
      int maxMessageSize, BufferManager bufferManager, int messageOffset)
        {
            String bodyContent = null;

              lastMessage = message.Headers.Action;

              XmlDictionaryReader reader = message.GetReaderAtBodyContents();
              while (reader.Read())
              {
            if (reader.Name == "request")
            {
              bodyContent = reader.ReadElementContentAsString();
              break;
            }
              }
              reader.Close();

              byte[] messageBytes = System.Text.Encoding.UTF8.GetBytes(bodyContent);

              int totalLength = messageBytes.Length + messageOffset;
              byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
              Array.Copy(messageBytes, 0,
            totalBytes, messageOffset, messageBytes.Length);

              ArraySegment<byte> buffer =
            new ArraySegment<byte>(
              totalBytes, messageOffset, messageBytes.Length);

              return buffer;
        }

        public void DeserializeRequest(Message message, object[] parameters)
        {
            object bodyFormatProperty;
            if (!message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out bodyFormatProperty) ||
                (bodyFormatProperty as WebBodyFormatMessageProperty).Format != WebContentFormat.Raw)
            {
                throw new InvalidOperationException("Incoming messages must have a body format of Raw. Is a ContentTypeMapper set on the WebHttpBinding?");
            }

            XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
            bodyReader.ReadStartElement("Binary");
            byte[] rawBody = bodyReader.ReadContentAsBase64();
            MemoryStream ms = new MemoryStream(rawBody);

            StreamReader sr = new StreamReader(ms);
            JsonSerializer serializer = new JsonSerializer
            {
                PreserveReferencesHandling = PreserveReferencesHandling.Objects
            };

            if (parameters.Length == 1)
            {
                // single parameter, assuming bare
                parameters[0] = serializer.Deserialize(sr, this.operation.Messages[0].Body.Parts[0].Type);
            }
            else
            {
                // multiple parameter, needs to be wrapped
                JsonReader reader = new JsonTextReader(sr);
                reader.Read();
                if (reader.TokenType != JsonToken.StartObject)
                {
                    throw new InvalidOperationException("Input needs to be wrapped in an object");
                }

                reader.Read();
                while (reader.TokenType == JsonToken.PropertyName)
                {
                    string parameterName = reader.Value as string;
                    reader.Read();
                    if (this.parameterNames.ContainsKey(parameterName))
                    {
                        int parameterIndex = this.parameterNames[parameterName];
                        parameters[parameterIndex] = serializer.Deserialize(reader, this.operation.Messages[0].Body.Parts[parameterIndex].Type);
                    }
                    else
                    {
                        reader.Skip();
                    }

                    reader.Read();
                }

                reader.Close();
            }

            sr.Close();
            ms.Close();
        }

        /// <summary>
        /// Executes the request message on the target system and returns a response message.
        /// If there isn’t a response, this method should return null
        /// </summary>
        public Message Execute(Message message, TimeSpan timeout)
        {
            string action = message.Headers.Action;
            string responseAction = action + "Response";

            var operation = ParseAction(action);

            string operationType = operation.Item1;
            string operationTarget = operation.Item2;

            Message result = null;

            using (var bodyReader = message.GetReaderAtBodyContents())
            {
                using (var connection = Connection.CreateDbConnection())
                {
                    connection.Open();

                    var scopeOptions = this.Connection.ConnectionFactory.Adapter.UseAmbientTransaction ? TransactionScopeOption.Required : TransactionScopeOption.RequiresNew;

                    using (var scope = new TransactionScope(scopeOptions, new TransactionOptions { IsolationLevel = Connection.ConnectionFactory.Adapter.IsolationLevel, Timeout = timeout }))
                    {
                        if (operationType == "Execute")
                        {
                            var commandBuilder = Connection.CreateDbCommandBuilder(string.Empty, connection);
                            result = DbHelpers.Execute(bodyReader, connection, operationTarget, commandBuilder.GetType(), responseAction);
                        }
                        else if (operationType == "MultiExecute")
                        {
                            var commandBuilder = Connection.CreateDbCommandBuilder(string.Empty, connection);
                            result = DbHelpers.MultiExecute(bodyReader, connection, operationTarget, commandBuilder.GetType(), responseAction);
                        }
                        else if (operationType == "Create")
                        {
                            var commandBuilder = Connection.CreateDbCommandBuilder(operationTarget, connection);
                            result = DbHelpers.Create(bodyReader, connection, operationType, commandBuilder, responseAction);
                        }
                        else if (operationType == "Read")
                        {
                            result = DbHelpers.Read(bodyReader, connection, responseAction);
                        }
                        else if (operationType == "Update")
                        {
                            var commandBuilder = Connection.CreateDbCommandBuilder(operationTarget, connection);
                            result = DbHelpers.Update(bodyReader, connection, operationType, commandBuilder, responseAction);
                        }
                        else if (operationType == "Delete")
                        {
                            var commandBuilder = Connection.CreateDbCommandBuilder(operationTarget, connection);
                            result = DbHelpers.Delete(bodyReader, connection, operationType, commandBuilder, responseAction);
                        }

                        scope.Complete();
                    }
                }
            }

            return result;
        }

		protected override object [] MessageToParts (MessageDescription md, Message message)
		{
			if (message.IsEmpty)
				return null;
				
			XmlDictionaryReader r = message.GetReaderAtBodyContents ();
			return (object []) GetSerializer (md.Body).Deserialize (r);
		}

		public WstRequestSecurityToken ReadRequest (Message msg)
		{
			using (WSTrustRequestSecurityTokenReader reader =
				new WSTrustRequestSecurityTokenReader (msg.GetReaderAtBodyContents (), serializer)) {
				reader.Read ();
				return reader.Value;
			}
		}