protected void AddParameterOrder(MessageDescription message)
 {
     if (this.operation != null)
     {
         Operation operation = this.contractContext.GetOperation(this.operation);
         if (operation != null)
         {
             if (operation.ParameterOrder == null)
             {
                 operation.ParameterOrder = new string[this.GetParameterCount()];
             }
             if (operation.ParameterOrder.Length != 0)
             {
                 foreach (MessagePartDescription description in message.Body.Parts)
                 {
                     ParameterInfo additionalAttributesProvider = description.AdditionalAttributesProvider as ParameterInfo;
                     if ((additionalAttributesProvider != null) && (additionalAttributesProvider.Position >= 0))
                     {
                         operation.ParameterOrder[additionalAttributesProvider.Position] = description.Name;
                     }
                 }
             }
         }
     }
 }

 internal static StreamFormatter Create(MessageDescription messageDescription, string operationName, bool isRequest)
 {
     MessagePartDescription streamPart = ValidateAndGetStreamPart(messageDescription, isRequest, operationName);
     if (streamPart == null)
         return null;
     return new StreamFormatter(messageDescription, streamPart, operationName, isRequest);
 }

 protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest)
 {
     MessageInfo info = isRequest ? this.requestMessageInfo : this.replyMessageInfo;
     PartInfo[] headerParts = info.HeaderParts;
     if ((headerParts != null) && (headerParts.Length != 0))
     {
         MessageHeaders headers = message.Headers;
         for (int i = 0; i < headerParts.Length; i++)
         {
             PartInfo headerPart = headerParts[i];
             MessageHeaderDescription description = (MessageHeaderDescription) headerPart.Description;
             object parameterValue = parameters[description.Index];
             if (description.Multiple)
             {
                 if (parameterValue != null)
                 {
                     bool isXmlElement = description.Type == typeof(XmlElement);
                     foreach (object obj3 in (IEnumerable) parameterValue)
                     {
                         this.AddMessageHeaderForParameter(headers, headerPart, message.Version, obj3, isXmlElement);
                     }
                 }
             }
             else
             {
                 this.AddMessageHeaderForParameter(headers, headerPart, message.Version, parameterValue, false);
             }
         }
     }
 }

        /// <summary>
        /// Add the Ping method to the existing contract
        /// </summary>
        private void AddPingToContractDescription(ContractDescription contractDescription)
        {
            OperationDescription pingOperationDescription = new OperationDescription(PingOperationName, contractDescription);

            MessageDescription inputMessageDescription = new MessageDescription(
                GetAction(contractDescription, PingOperationName),
                MessageDirection.Input);

            MessageDescription outputMessageDescription = new MessageDescription(
                GetAction(contractDescription, PingResponse),
                MessageDirection.Output);

            MessagePartDescription returnValue = new MessagePartDescription("PingResult", contractDescription.Namespace);

            returnValue.Type = typeof(DateTime);
            outputMessageDescription.Body.ReturnValue = returnValue;

            inputMessageDescription.Body.WrapperName = PingOperationName;
            inputMessageDescription.Body.WrapperNamespace = contractDescription.Namespace;
            outputMessageDescription.Body.WrapperName = PingResponse;
            outputMessageDescription.Body.WrapperNamespace = contractDescription.Namespace;

            pingOperationDescription.Messages.Add(inputMessageDescription);
            pingOperationDescription.Messages.Add(outputMessageDescription);

            pingOperationDescription.Behaviors.Add(new DataContractSerializerOperationBehavior(pingOperationDescription));
            pingOperationDescription.Behaviors.Add(new PingOperationBehavior());

            contractDescription.Operations.Add(pingOperationDescription);
        }

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

 private static KeyValuePair<string, ComplexType> getExistingElement(XmlTypeExtractor schemaImporter, MessageDescription message)
 {
     Func<KeyValuePair<string, ComplexType>, bool> existingElementPredicate =
         _ => _.Key == message.Body.WrapperNamespace && _.Value.Name == message.Body.WrapperName;
     if (!schemaImporter.Elements.Any(existingElementPredicate))
     {
         throw new InvalidOperationException("Couldn't find the element definition");
     }
     var existingElement = schemaImporter.Elements.Single(existingElementPredicate);
     return existingElement;
 }

 private static bool IsUntypedMessage(MessageDescription message)
 {
     if (message == null)
     {
         return false;
     }
     return ((((message.Body.ReturnValue != null) &&
         (message.Body.Parts.Count == 0)) &&
         (message.Body.ReturnValue.Type == typeof(Message))) ||
         (((message.Body.ReturnValue == null) && (message.Body.Parts.Count == 1)) &&
         (message.Body.Parts[0].Type == typeof(Message))));
 }

 private StreamFormatter(MessageDescription messageDescription, MessagePartDescription streamPart, string operationName, bool isRequest)
 {
     if ((object)streamPart == (object)messageDescription.Body.ReturnValue)
         _streamIndex = returnValueIndex;
     else
         _streamIndex = streamPart.Index;
     _wrapperName = messageDescription.Body.WrapperName;
     _wrapperNS = messageDescription.Body.WrapperNamespace;
     _partName = streamPart.Name;
     _partNS = streamPart.Namespace;
     _isRequest = isRequest;
     _operationName = operationName;
 }

 private static bool HasStream(MessageDescription messageDescription)
 {
     if ((messageDescription.Body.ReturnValue != null) && (messageDescription.Body.ReturnValue.Type == typeof(Stream)))
     {
         return true;
     }
     foreach (MessagePartDescription description in messageDescription.Body.Parts)
     {
         if (description.Type == typeof(Stream))
         {
             return true;
         }
     }
     return false;
 }

 private static MessagePartDescription GetStreamPart(MessageDescription messageDescription)
 {
     if (OperationFormatter.IsValidReturnValue(messageDescription.Body.ReturnValue))
     {
         if ((messageDescription.Body.Parts.Count == 0) && (messageDescription.Body.ReturnValue.Type == typeof(Stream)))
         {
             return messageDescription.Body.ReturnValue;
         }
     }
     else if ((messageDescription.Body.Parts.Count == 1) && (messageDescription.Body.Parts[0].Type == typeof(Stream)))
     {
         return messageDescription.Body.Parts[0];
     }
     return null;
 }

		public static void AssertMessageAndBodyDescription (
			string action, MessageDirection dir,
			Type messageType, string bodyWrapperName,
			string bodyWrapperNS, bool bodyHasReturn,
			MessageDescription md, string label)
		{
			Assert.AreEqual (action, md.Action, label + " Action");
			Assert.AreEqual (dir, md.Direction, label + " Direction");
			Assert.AreEqual (messageType, md.MessageType, label + " MessageType");
			Assert.AreEqual (bodyWrapperName, md.Body.WrapperName,
				label + " Body.WrapperName");
			Assert.AreEqual (bodyWrapperNS, md.Body.WrapperNamespace,
				label + " Body.WrapperNamespace");
			Assert.AreEqual (bodyHasReturn, md.Body.ReturnValue != null,
				label + "Body hasReturn");
		}

 static void ShowMessageBody(MessageDescription message)
 {
     Console.WriteLine(message.Direction == MessageDirection.Input ?"请求消息：" : "回复消息：");
     MessageBodyDescription body = message.Body;
     Console.WriteLine("<tns:{0} xmlns:tns=\"{1}\">", body.WrapperName,body.WrapperNamespace);
     foreach (var part in body.Parts)
     {
         Console.WriteLine("\t<tns:{0}>...</tns:{0}>", part.Name);
     }
     if (null != body.ReturnValue)
     {
         Console.WriteLine("\t<tns:{0}>...</tns:{0}>",
             body.ReturnValue.Name);
     }
     Console.WriteLine("</tns:{0}>", body.WrapperName);
 }

 private StreamFormatter(MessageDescription messageDescription, MessagePartDescription streamPart, string operationName, bool isRequest)
 {
     if (streamPart == messageDescription.Body.ReturnValue)
     {
         this.streamIndex = -1;
     }
     else
     {
         this.streamIndex = streamPart.Index;
     }
     this.wrapperName = messageDescription.Body.WrapperName;
     this.wrapperNS = messageDescription.Body.WrapperNamespace;
     this.partName = streamPart.Name;
     this.partNS = streamPart.Namespace;
     this.isRequest = isRequest;
     this.operationName = operationName;
 }

        private static OperationDescription CreatePreflightOperation(OperationDescription operation)
        {
            ContractDescription contract = operation.DeclaringContract;
            var preflightOperation = new OperationDescription(operation.Name + CorsConstants.PreflightSuffix, contract);
            var inputMessage = new MessageDescription(
                operation.Messages[0].Action + CorsConstants.PreflightSuffix, MessageDirection.Input);
            inputMessage.Body.Parts.Add(
                new MessagePartDescription("input", contract.Namespace) { Index = 0, Type = typeof(Message) });
            preflightOperation.Messages.Add(inputMessage);
            var outputMessage = new MessageDescription(
                operation.Messages[1].Action + CorsConstants.PreflightSuffix, MessageDirection.Output);
            outputMessage.Body.ReturnValue = new MessagePartDescription(
                preflightOperation.Name + "Return", contract.Namespace) { Type = typeof(Message) };
            preflightOperation.Messages.Add(outputMessage);

            return preflightOperation;
        }

 public static void AddMessagePartDescription(OperationDescription operation, bool isResponse, MessageDescription message, string[] argumentNames, Type[] argumentTypes)
 {
     string ns = operation.DeclaringContract.Namespace;
     for (int i = 0; i < argumentNames.Length; i++)
     {
         string name = argumentNames[i];
         MessagePartDescription item = new MessagePartDescription(NamingHelper.XmlName(name), ns) {
             Index = i,
             Type = argumentTypes[i]
         };
         message.Body.Parts.Add(item);
     }
     if (isResponse)
     {
         SetReturnValue(message, operation);
     }
 }

 internal MessageDescription(MessageDescription other)
 {
     this.action = other.action;
     this.direction = other.direction;
     this.Items.Body = other.Items.Body.Clone();
     foreach (MessageHeaderDescription description in other.Items.Headers)
     {
         this.Items.Headers.Add(description.Clone() as MessageHeaderDescription);
     }
     foreach (MessagePropertyDescription description2 in other.Items.Properties)
     {
         this.Items.Properties.Add(description2.Clone() as MessagePropertyDescription);
     }
     this.MessageName = other.MessageName;
     this.MessageType = other.MessageType;
     this.XsdTypeName = other.XsdTypeName;
     this.hasProtectionLevel = other.hasProtectionLevel;
     this.ProtectionLevel = other.ProtectionLevel;
 }

 internal MessageDescription(MessageDescription other)
 {
     _action = other._action;
     _direction = other._direction;
     this.Items.Body = other.Items.Body.Clone();
     foreach (MessageHeaderDescription mhd in other.Items.Headers)
     {
         this.Items.Headers.Add(mhd.Clone() as MessageHeaderDescription);
     }
     foreach (MessagePropertyDescription mpd in other.Items.Properties)
     {
         this.Items.Properties.Add(mpd.Clone() as MessagePropertyDescription);
     }
     this.MessageName = other.MessageName;
     this.MessageType = other.MessageType;
     this.XsdTypeName = other.XsdTypeName;
     _hasProtectionLevel = other._hasProtectionLevel;
     this.ProtectionLevel = other.ProtectionLevel;
 }

 public override PolicyAssertionCollection GetMessageBindingAssertions(MessageDescription message)
 {
     lock (this.messageBindingAssertions)
     {
         if (!this.messageBindingAssertions.ContainsKey(message))
         {
             this.messageBindingAssertions.Add(message, new PolicyAssertionCollection());
         }
     }
     return this.messageBindingAssertions[message];
 }

        private static OperationDescription GetCopyOfOperationDescription(OperationDescription other)
        {
            OperationDescription operationDecription = new OperationDescription(other.Name, other.DeclaringContract)
            {
                BeginMethod = other.BeginMethod,
                EndMethod = other.EndMethod,
                IsInitiating = other.IsInitiating,
                IsTerminating = other.IsTerminating,
                ProtectionLevel = other.ProtectionLevel,
                SyncMethod = other.SyncMethod,
            };

            // copy Behaviors, Known Types, Faults
            foreach (IOperationBehavior behavior in other.Behaviors)
            {
                operationDecription.Behaviors.Add(behavior);
            }

            foreach (Type knownType in other.KnownTypes)
            {
                operationDecription.KnownTypes.Add(knownType);
            }

            foreach (FaultDescription fault in other.Faults)
            {
                operationDecription.Faults.Add(fault);
            }

            // copy the Messages from the original OperationDescription
            foreach (MessageDescription messageDescription in other.Messages)
            {
                MessageDescription newMessageDescription = new MessageDescription(messageDescription.Action, messageDescription.Direction);
                operationDecription.Messages.Add(newMessageDescription);
            }

            return operationDecription;
        }

		void CreateOutputBinding (ServiceEndpoint endpoint, OperationBinding op_binding,
		                          MessageDescription sm_md)
		{
			var out_binding = new OutputBinding ();
			op_binding.Output = out_binding;

			var message_version = endpoint.Binding.MessageVersion ?? MessageVersion.None;
			if (message_version == MessageVersion.None)
				return;

			SoapBodyBinding soap_body_binding;
			if (message_version.Envelope == EnvelopeVersion.Soap11) {
				soap_body_binding = new SoapBodyBinding ();
			} else if (message_version.Envelope == EnvelopeVersion.Soap12) {
				soap_body_binding = new Soap12BodyBinding ();
			} else {
				throw new InvalidOperationException ();
			}

			soap_body_binding.Use = SoapBindingUse.Literal;
			out_binding.Extensions.Add (soap_body_binding);
		}