public void AddHeaders(MessageHeaders headers)
 {
     if (headers.MessageVersion.Envelope == EnvelopeVersion.Soap11)
     {
         headers.Add(new WSAddressing10ProblemHeaderQNameHeader(this.invalidHeaderName));
     }
 }

 private void AddNotUnderstoodHeaders(MessageHeaders headers)
 {
     for (int i = 0; i < _notUnderstoodHeaders.Count; ++i)
     {
         headers.Add(new NotUnderstoodHeader(_notUnderstoodHeaders[i].Name, _notUnderstoodHeaders[i].Namespace));
     }
 }

 public AddressingProperty(MessageHeaders headers)
 {
     this.action = headers.Action;
     this.to = headers.To;
     this.replyTo = headers.ReplyTo;
     this.messageId = headers.MessageId;
 }

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

 internal LocalByRefMessage(MessageVersion version, string action, int id)
     : base()
 {
     this.headers = new MessageHeaders(version);
     this.headers.Action = action;
     this.data = id;
 }

 private void AddNotUnderstoodHeaders(MessageHeaders headers)
 {
     for (int i = 0; i < this.notUnderstoodHeaders.Count; i++)
     {
         headers.Add(new NotUnderstoodHeader(this.notUnderstoodHeaders[i].Name, this.notUnderstoodHeaders[i].Namespace));
     }
 }

		protected AdwsRequestMsg(string instance)
		{
			this._messageProperties = new MessageProperties();
			this._messageHeaders = new MessageHeaders(this.Version, 7);
			this.Headers.Action = this.Action;
			this.Headers.Add(MessageHeader.CreateHeader("instance", "http://schemas.microsoft.com/2008/1/ActiveDirectory", instance));
		}

        /// <summary>
        /// Constructor.
        /// </summary>
        protected AmfMessageBase()
        {
            _properties = new MessageProperties();

            //Make sure that there is no wrapping applied to this message
            _headers = new MessageHeaders(MessageVersion.None);
        }

        public static bool ExtractActivityAndCorrelationId(MessageHeaders headers, out Guid activityId, out Guid correlationId)
        {
            if (headers == null) throw new ArgumentNullException(nameof(headers));

            activityId = Guid.Empty;
            correlationId = Guid.Empty;

            try
            {
                var index = headers.FindHeader("ActivityId", "http://schemas.microsoft.com/2004/09/ServiceModel/Diagnostics");
                if (index >= 0)
                {
                    using (var reader = headers.GetReaderAtHeader(index))
                    {
                        correlationId = new Guid(reader.GetAttribute("CorrelationId", null));
                        activityId = reader.ReadElementContentAsGuid();
                        return true;
                    }
                }
            }
            catch
            {
                if (Debugger.IsAttached)
                {
                    throw;
                }
            }

            return false;
        }

        public void ApplySecurityAndWriteHeaders(MessageHeaders headers, XmlDictionaryWriter writer, SecurityIdGenerator securityIdGenerator)
        {
            // There is no way to look through the headers attributes without changing the way
            // Headers.WriterStartHeader / headers.writeHeadercontents writes the header
            // So i'm using a copy that I can change without worries.
            MessageHeaders copyHeaders = new MessageHeaders(headers);

            for (int i = 0; i < headers.Count; i++)
            {
                MessageHeaderInfo header = headers[i];

                // We are not supporting another d:Security header, throw if there is already one in the message
                if (this.IsSecurityElement(header))
                {
                    throw new ArgumentException("The message already contains a d:security header.");
                }

                if (this.ShouldProtectHeader(header))
                {
                    string headerId;
                    bool idInserted;
                    this.GetHeaderId(copyHeaders.GetReaderAtHeader(i), securityIdGenerator, true, out headerId, out idInserted);

                    // Add a reference for this header
                    this.signer.AddReference(headers, i, writer, headerId, idInserted);
                }
                else
                {
                    headers.WriteHeader(i, writer);
                }
            }
        }

		public void TestConstructor ()
		{
			MessageHeaders headers = new MessageHeaders (MessageVersion.Soap12WSAddressing10);
			Assert.AreEqual (0, headers.Count);

			headers = new MessageHeaders (MessageVersion.Default);
			Assert.AreEqual (0, headers.Count);
		}

 public void ReturnHeaders(MessageHeaders headers)
 {
     if (headers.CanRecycle)
     {
         headers.Recycle(this.HeaderInfoCache);
         this.recycledHeaders = headers;
     }
 }

 protected void SetMessageId(MessageVersion messageVersion, MessageHeaders headers)
 {
     this.messageId = headers.MessageId;
     if (this.messageId == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("MissingMessageIdOnWsrmRequest", new object[] { this.RequestName }), messageVersion.Addressing.Namespace, "MessageID", false));
     }
 }

        public AddressingProperty(MessageHeaders headers)
        {
            Fx.Assert(null != headers, "");

            this.action = headers.Action;
            this.to = headers.To;
            this.replyTo = headers.ReplyTo;
            this.messageId = headers.MessageId;
        }

 internal ChunkingMessage(MessageVersion version, string action, ChunkingReader reader, Guid messageId)
 {
     this.version = version;
     this.chunkReader = reader;
     this.properties = new MessageProperties();
     this.headers = new MessageHeaders(this.version);
     this.headers.Action = action;
     this.messageId = messageId;
 }

		internal DefaultMessageBuffer (int maxBufferSize, MessageHeaders headers, MessageProperties properties, BodyWriter body, bool isFault)
		{
			this.max_buffer_size = maxBufferSize;
			this.headers = headers;
			this.body = body;
			this.closed = false;
			this.is_fault = isFault;
			this.properties = properties;
		}

        public DelegatingHeader(MessageHeaderInfo info, MessageHeaders originalHeaders)
        {
            Fx.Assert(info != null, "info is required");
            Fx.Assert(originalHeaders != null, "originalHeaders is required");

            this.info = info;
            this.originalHeaders = originalHeaders;
            this.index = -1;
        }

 public void SerializeWithAllSerializableHeaders()
 {
     IDictionary<string, object> map = new Dictionary<string, object>();
     map.Add("name", "joe");
     map.Add("age", 42);
     MessageHeaders input = new MessageHeaders(map);
     MessageHeaders output = (MessageHeaders) SerializeAndDeserialize(input);
     Assert.That(output.Get("name"), Is.EqualTo("joe"));
     Assert.That(output.Get("age"), Is.EqualTo(42));
 }

 public HttpStreamMessage(MessageHeaders headers, MessageProperties properties, BodyWriter bodyWriter)
 {
     if (bodyWriter == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bodyWriter");
     }
     this.headers = new MessageHeaders(headers);
     this.properties = new MessageProperties(properties);
     this.bodyWriter = bodyWriter;
 }

 public static Uri GetHeaderUri(MessageHeaders headers, string name, string ns)
 {
     Uri uri = null;
     string uriString = GetHeaderString(headers, name, ns);
     if (uriString != null)
     {
         uri = new Uri(uriString);
     }
     return uri;
 }