< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Channels.MessageHeaders
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Channels/MessageHeaders.cs
Line coverage
57%
Covered lines: 465
Uncovered lines: 338
Coverable lines: 803
Total lines: 1934
Line coverage: 57.9%
Branch coverage
54%
Covered branches: 264
Total branches: 486
Branch coverage: 54.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)83.33%181884.37%
.ctor(...)100%11100%
.ctor(...)100%110%
.ctor(...)50%2285.71%
Add(...)100%11100%
AddActionHeader(...)100%11100%
AddMessageIDHeader(...)100%11100%
AddRelatesToHeader(...)100%110%
AddReplyToHeader(...)100%11100%
AddToHeader(...)100%11100%
Add(...)100%11100%
AddHeader(...)100%11100%
AddUnderstood(...)100%11100%
AddUnderstood(...)75%8866.66%
CaptureBufferedHeaders()100%110%
CaptureBufferedHeaders(...)0%10100%
CaptureBufferedHeader(...)100%110%
CaptureBufferedHeader(...)100%110%
CaptureWriteableHeader(...)100%11100%
Clear()100%22100%
CopyHeaderFrom(...)0%220%
CopyHeaderFrom(...)61.11%181847.61%
CopyHeadersFrom(...)0%220%
CopyHeadersFrom(...)75%4480%
CopyTo(...)0%880%
CreateDuplicateHeaderException(...)0%880%
FindHeader(...)50%6657.14%
FindAddressingHeader(...)0%10100%
FindNonAddressingHeader(...)81.25%161676.92%
FindHeader(...)70%202066.66%
FindHeaderProperty(...)83.33%6685.71%
FindRelatesTo(...)87.5%8864.7%
System.Collections.IEnumerable.GetEnumerator()100%110%
GetEnumerator()100%110%
GetEnumerator(...)100%110%
GetUnderstoodEnumerator()0%440%
GetBufferedMessageHeaderReaderAtHeaderContents(...)75%4487.5%
GetBufferedMessageHeaderReader(...)75%8880%
Skip(...)70%101066.66%
GetHeader(...)100%11100%
GetHeader(...)0%220%
GetHeader(...)50%4466.66%
GetHeader(...)50%4450%
GetHeader(...)50%2280%
GetHeaderKind(...)78.12%323269.23%
ValidateHeaderKind(...)85.71%141455.55%
GetReaderAtHeader(...)62.5%8869.23%
GetRelatesTo(...)50%2275%
GetRelatesToValues(...)50%2242.85%
GetHeaderAttributes(...)0%18180%
GetMessageHeader(...)50%8827.27%
GetHeadersNotUnderstood()50%6650%
HaveMandatoryHeadersBeenUnderstood()100%110%
HaveMandatoryHeadersBeenUnderstood(...)0%10100%
Init(...)50%4466.66%
Init(...)100%110%
Init(...)90%1010100%
Insert(...)50%4466.66%
Insert(...)83.33%6685.71%
InsertHeader(...)37.5%161654.54%
IsUnderstood(...)100%11100%
IsUnderstood(...)0%880%
ReadBufferedHeader(...)80%202081.25%
Recycle(...)100%66100%
RemoveUnderstood(...)0%880%
RemoveAll(...)0%10100%
RemoveAt(...)50%8860%
ReplaceAt(...)0%660%
ReplaceAt(...)66.66%6687.5%
SetAction(...)0%220%
SetActionHeader(...)100%11100%
SetFaultToHeader(...)100%110%
SetFromHeader(...)100%110%
SetMessageIDHeader(...)100%11100%
SetRelatesTo(...)50%4471.42%
SetRelatesTo(...)50%6662.5%
SetReplyToHeader(...)100%11100%
SetToHeader(...)100%11100%
SetHeaderProperty(...)100%66100%
WriteHeader(...)100%11100%
WriteHeader(...)100%11100%
WriteStartHeader(...)100%110%
WriteStartHeader(...)60%101058.33%
WriteHeaderContents(...)100%110%
WriteHeaderContents(...)60%101058.33%
TraceUnderstood(...)100%11100%
WriteBufferedMessageHeader(...)100%110%
WriteStartBufferedMessageHeader(...)100%11100%
WriteBufferedMessageHeaderContents(...)100%44100%
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)100%11100%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Channels/MessageHeaders.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System;
 5using System.Collections;
 6using System.Collections.Generic;
 7using System.Collections.ObjectModel;
 8using System.Runtime.Serialization;
 9using System.Threading;
 10using System.Xml;
 11using CoreWCF.Dispatcher;
 12using CoreWCF.Runtime;
 13
 14namespace CoreWCF.Channels
 15{
 16    public sealed class MessageHeaders : IEnumerable<MessageHeaderInfo>
 17    {
 18        private Header[] _headers;
 19        private IBufferedMessageData _bufferedMessageData;
 20        private UnderstoodHeaders _understoodHeaders;
 21        private const int InitialHeaderCount = 4;
 22        private const int MaxRecycledArrayLength = 8;
 23        private static XmlDictionaryString[] s_localNames;
 24
 25        public const string WildcardAction = "*";
 26
 27        // The highest node and attribute counts reached by the BVTs were 1829 and 667 respectively.
 28        private const int MaxBufferedHeaderNodes = 4096;
 29        private const int MaxBufferedHeaderAttributes = 2048;
 30        private int _nodeCount = 0;
 31        private int _attrCount = 0;
 32        private bool _understoodHeadersModified;
 33
 591734        public MessageHeaders(MessageVersion version, int initialSize)
 35        {
 591736            Init(version, initialSize);
 591737        }
 38
 39        public MessageHeaders(MessageVersion version)
 591340            : this(version, InitialHeaderCount)
 41        {
 591342        }
 43
 44        internal MessageHeaders(MessageVersion version, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttribu
 293945            : this(version)
 46        {
 293947            if (maxSizeOfHeaders < 0)
 48            {
 049                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 050                    new ArgumentOutOfRangeException(nameof(maxSizeOfHeaders), maxSizeOfHeaders,
 051                    SRCommon.ValueMustBeNonNegative));
 52            }
 53
 293954            if (version == null)
 55            {
 056                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(version));
 57            }
 58
 293959            if (reader == null)
 60            {
 061                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(reader));
 62            }
 63
 293964            if (reader.IsEmptyElement)
 65            {
 266                reader.Read();
 267                return;
 68            }
 293769            XmlBuffer xmlBuffer = null;
 293770            EnvelopeVersion envelopeVersion = version.Envelope;
 293771            reader.ReadStartElement(XD.MessageDictionary.Header, envelopeVersion.DictionaryNamespace);
 2122672            while (reader.IsStartElement())
 73            {
 1828974                if (xmlBuffer == null)
 75                {
 293776                    xmlBuffer = new XmlBuffer(maxSizeOfHeaders);
 77                }
 78
 1828979                BufferedHeader bufferedHeader = new BufferedHeader(version, xmlBuffer, reader, envelopeAttributes, heade
 1828980                HeaderProcessing processing = bufferedHeader.MustUnderstand ? HeaderProcessing.MustUnderstand : 0;
 1828981                HeaderKind kind = GetHeaderKind(bufferedHeader);
 1828982                if (kind != HeaderKind.Unknown)
 83                {
 385084                    processing |= HeaderProcessing.Understood;
 385085                    TraceUnderstood(bufferedHeader);
 86                }
 1828987                Header newHeader = new Header(kind, bufferedHeader, processing);
 1828988                AddHeader(newHeader);
 89            }
 293790            if (xmlBuffer != null)
 91            {
 293792                xmlBuffer.Close();
 293793                maxSizeOfHeaders -= xmlBuffer.BufferSize;
 94            }
 293795            reader.ReadEndElement();
 293796            CollectionVersion = 0;
 293797        }
 98
 48999        public MessageHeaders(MessageVersion version, XmlDictionaryReader reader, IBufferedMessageData bufferedMessageDa
 100        {
 489101            _headers = new Header[InitialHeaderCount];
 489102            Init(version, reader, bufferedMessageData, recycledMessageState, understoodHeaders, understoodHeadersModifie
 489103        }
 104
 0105        internal MessageHeaders(MessageVersion version, MessageHeaders headers, IBufferedMessageData bufferedMessageData
 106        {
 0107            MessageVersion = version;
 0108            _bufferedMessageData = bufferedMessageData;
 0109            Count = headers.Count;
 0110            _headers = new Header[Count];
 0111            Array.Copy(headers._headers, _headers, Count);
 0112            CollectionVersion = 0;
 0113        }
 114
 542115        public MessageHeaders(MessageHeaders collection)
 116        {
 542117            if (collection == null)
 118            {
 0119                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(collection));
 120            }
 121
 542122            Init(collection.MessageVersion, collection._headers.Length);
 542123            CopyHeadersFrom(collection);
 542124            CollectionVersion = 0;
 542125        }
 126
 127        public string Action
 128        {
 129            get
 130            {
 9778131                int index = FindHeaderProperty(HeaderKind.Action);
 9778132                if (index < 0)
 133                {
 765134                    return null;
 135                }
 136
 9013137                if (_headers[index].HeaderInfo is ActionHeader actionHeader)
 138                {
 3467139                    return actionHeader.Action;
 140                }
 141
 5546142                using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 143                {
 5546144                    return ActionHeader.ReadHeaderValue(reader, MessageVersion.Addressing);
 145                }
 5546146            }
 147            set
 148            {
 2762149                if (value != null)
 150                {
 2141151                    SetActionHeader(ActionHeader.Create(value, MessageVersion.Addressing));
 152                }
 153                else
 154                {
 621155                    SetHeaderProperty(HeaderKind.Action, null);
 156                }
 621157            }
 158        }
 159
 160        public bool CanRecycle
 161        {
 621162            get { return _headers.Length <= MaxRecycledArrayLength; }
 163        }
 164
 165        public bool ContainsOnlyBufferedMessageHeaders
 166        {
 178167            get { return (_bufferedMessageData != null && CollectionVersion == 0); }
 168        }
 169
 115391170        internal int CollectionVersion { get; private set; }
 171
 537003172        public int Count { get; private set; }
 173
 174        public EndpointAddress FaultTo
 175        {
 176            get
 177            {
 684178                int index = FindHeaderProperty(HeaderKind.FaultTo);
 684179                if (index < 0)
 180                {
 684181                    return null;
 182                }
 183
 0184                if (_headers[index].HeaderInfo is FaultToHeader faultToHeader)
 185                {
 0186                    return faultToHeader.FaultTo;
 187                }
 188
 0189                using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 190                {
 0191                    return FaultToHeader.ReadHeaderValue(reader, MessageVersion.Addressing);
 192                }
 0193            }
 194            set
 195            {
 0196                if (value != null)
 197                {
 0198                    SetFaultToHeader(FaultToHeader.Create(value, MessageVersion.Addressing));
 199                }
 200                else
 201                {
 0202                    SetHeaderProperty(HeaderKind.FaultTo, null);
 203                }
 0204            }
 205        }
 206
 207        public EndpointAddress From
 208        {
 209            get
 210            {
 15211                int index = FindHeaderProperty(HeaderKind.From);
 15212                if (index < 0)
 213                {
 15214                    return null;
 215                }
 216
 0217                if (_headers[index].HeaderInfo is FromHeader fromHeader)
 218                {
 0219                    return fromHeader.From;
 220                }
 221
 0222                using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 223                {
 0224                    return FromHeader.ReadHeaderValue(reader, MessageVersion.Addressing);
 225                }
 0226            }
 227            set
 228            {
 0229                if (value != null)
 230                {
 0231                    SetFromHeader(FromHeader.Create(value, MessageVersion.Addressing));
 232                }
 233                else
 234                {
 0235                    SetHeaderProperty(HeaderKind.From, null);
 236                }
 0237            }
 238        }
 239
 240        internal bool HasMustUnderstandBeenModified
 241        {
 242            get
 243            {
 356244                if (_understoodHeaders != null)
 245                {
 0246                    return _understoodHeaders.Modified;
 247                }
 248                else
 249                {
 356250                    return _understoodHeadersModified;
 251                }
 252            }
 253        }
 254
 255        public UniqueId MessageId
 256        {
 257            get
 258            {
 960259                int index = FindHeaderProperty(HeaderKind.MessageId);
 960260                if (index < 0)
 261                {
 472262                    return null;
 263                }
 264
 488265                if (_headers[index].HeaderInfo is MessageIDHeader messageIDHeader)
 266                {
 340267                    return messageIDHeader.MessageId;
 268                }
 269
 148270                using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 271                {
 148272                    return MessageIDHeader.ReadHeaderValue(reader, MessageVersion.Addressing);
 273                }
 148274            }
 275            set
 276            {
 1277                if (value != null)
 278                {
 1279                    SetMessageIDHeader(MessageIDHeader.Create(value, MessageVersion.Addressing));
 280                }
 281                else
 282                {
 0283                    SetHeaderProperty(HeaderKind.MessageId, null);
 284                }
 0285            }
 286        }
 287
 451531288        public MessageVersion MessageVersion { get; private set; }
 289
 290        public UniqueId RelatesTo
 291        {
 292            get
 293            {
 503294                return GetRelatesTo(RelatesToHeader.ReplyRelationshipType);
 295            }
 296            set
 297            {
 353298                SetRelatesTo(RelatesToHeader.ReplyRelationshipType, value);
 353299            }
 300        }
 301
 302        public EndpointAddress ReplyTo
 303        {
 304            get
 305            {
 715306                int index = FindHeaderProperty(HeaderKind.ReplyTo);
 715307                if (index < 0)
 308                {
 391309                    return null;
 310                }
 311
 324312                if (_headers[index].HeaderInfo is ReplyToHeader replyToHeader)
 313                {
 176314                    return replyToHeader.ReplyTo;
 315                }
 316
 148317                using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 318                {
 148319                    return ReplyToHeader.ReadHeaderValue(reader, MessageVersion.Addressing);
 320                }
 148321            }
 322            set
 323            {
 1324                if (value != null)
 325                {
 1326                    SetReplyToHeader(ReplyToHeader.Create(value, MessageVersion.Addressing));
 327                }
 328                else
 329                {
 0330                    SetHeaderProperty(HeaderKind.ReplyTo, null);
 331                }
 0332            }
 333        }
 334
 335        public Uri To
 336        {
 337            get
 338            {
 5651339                int index = FindHeaderProperty(HeaderKind.To);
 5651340                if (index < 0)
 341                {
 2466342                    return null;
 343                }
 344
 3185345                if (_headers[index].HeaderInfo is ToHeader toHeader)
 346                {
 2192347                    return toHeader.To;
 348                }
 349
 993350                using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 351                {
 993352                    return ToHeader.ReadHeaderValue(reader, MessageVersion.Addressing);
 353                }
 993354            }
 355            set
 356            {
 2515357                if (value != null)
 358                {
 1977359                    SetToHeader(ToHeader.Create(value, MessageVersion.Addressing));
 360                }
 361                else
 362                {
 538363                    SetHeaderProperty(HeaderKind.To, null);
 364                }
 538365            }
 366        }
 367
 368        public UnderstoodHeaders UnderstoodHeaders
 369        {
 370            get
 371            {
 63372                if (_understoodHeaders == null)
 373                {
 28374                    _understoodHeaders = new UnderstoodHeaders(this, _understoodHeadersModified);
 375                }
 376
 63377                return _understoodHeaders;
 378            }
 379        }
 380
 381        public MessageHeaderInfo this[int index]
 382        {
 383            get
 384            {
 20731385                if (index < 0 || index >= Count)
 386                {
 0387                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0388                        new ArgumentOutOfRangeException(nameof(index), index,
 0389                        SR.Format(SR.ValueMustBeInRange, 0, Count)));
 390                }
 391
 20731392                return _headers[index].HeaderInfo;
 393            }
 394        }
 395
 396        public void Add(MessageHeader header)
 397        {
 28936398            Insert(Count, header);
 28936399        }
 400
 401        internal void AddActionHeader(ActionHeader actionHeader)
 402        {
 68403            Insert(Count, actionHeader, HeaderKind.Action);
 68404        }
 405
 406        internal void AddMessageIDHeader(MessageIDHeader messageIDHeader)
 407        {
 68408            Insert(Count, messageIDHeader, HeaderKind.MessageId);
 68409        }
 410
 411        internal void AddRelatesToHeader(RelatesToHeader relatesToHeader)
 412        {
 0413            Insert(Count, relatesToHeader, HeaderKind.RelatesTo);
 0414        }
 415
 416        internal void AddReplyToHeader(ReplyToHeader replyToHeader)
 417        {
 68418            Insert(Count, replyToHeader, HeaderKind.ReplyTo);
 68419        }
 420
 421        internal void AddToHeader(ToHeader toHeader)
 422        {
 68423            Insert(Count, toHeader, HeaderKind.To);
 68424        }
 425
 426        private void Add(MessageHeader header, HeaderKind kind)
 427        {
 4940428            Insert(Count, header, kind);
 4940429        }
 430
 431        private void AddHeader(Header header)
 432        {
 19984433            InsertHeader(Count, header);
 19984434        }
 435
 436        internal void AddUnderstood(int i)
 437        {
 241438            _headers[i].HeaderProcessing |= HeaderProcessing.Understood;
 241439            TraceUnderstood(_headers[i].HeaderInfo);
 241440        }
 441
 442        internal void AddUnderstood(MessageHeaderInfo headerInfo)
 443        {
 63444            if (headerInfo == null)
 445            {
 0446                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(headerInfo));
 447            }
 448
 736449            for (int i = 0; i < Count; i++)
 450            {
 305451                if ((object)_headers[i].HeaderInfo == (object)headerInfo)
 452                {
 63453                    if ((_headers[i].HeaderProcessing & HeaderProcessing.Understood) != 0)
 454                    {
 0455                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(
 0456                            SR.Format(SR.HeaderAlreadyUnderstood, headerInfo.Name, headerInfo.Namespace), nameof(headerI
 457                    }
 458
 63459                    AddUnderstood(i);
 460                }
 461            }
 63462        }
 463
 464        private void CaptureBufferedHeaders()
 465        {
 0466            CaptureBufferedHeaders(-1);
 0467        }
 468
 469        private void CaptureBufferedHeaders(int exceptIndex)
 470        {
 0471            using (XmlDictionaryReader reader = GetBufferedMessageHeaderReaderAtHeaderContents(_bufferedMessageData))
 472            {
 0473                for (int i = 0; i < Count; i++)
 474                {
 0475                    if (reader.NodeType != XmlNodeType.Element)
 476                    {
 0477                        if (reader.MoveToContent() != XmlNodeType.Element)
 478                        {
 0479                            break;
 480                        }
 481                    }
 482
 0483                    Header header = _headers[i];
 0484                    if (i == exceptIndex || header.HeaderType != HeaderType.BufferedMessageHeader)
 485                    {
 0486                        reader.Skip();
 487                    }
 488                    else
 489                    {
 0490                        _headers[i] = new Header(header.HeaderKind, CaptureBufferedHeader(reader,
 0491                            header.HeaderInfo), header.HeaderProcessing);
 492                    }
 493                }
 0494            }
 0495            _bufferedMessageData = null;
 0496        }
 497
 498        private BufferedHeader CaptureBufferedHeader(XmlDictionaryReader reader, MessageHeaderInfo headerInfo)
 499        {
 0500            XmlBuffer buffer = new XmlBuffer(int.MaxValue);
 0501            XmlDictionaryWriter writer = buffer.OpenSection(_bufferedMessageData.Quotas);
 0502            writer.WriteNode(reader, false);
 0503            buffer.CloseSection();
 0504            buffer.Close();
 0505            return new BufferedHeader(MessageVersion, buffer, 0, headerInfo);
 506        }
 507
 508        private BufferedHeader CaptureBufferedHeader(IBufferedMessageData bufferedMessageData, MessageHeaderInfo headerI
 509        {
 0510            XmlBuffer buffer = new XmlBuffer(int.MaxValue);
 0511            XmlDictionaryWriter writer = buffer.OpenSection(bufferedMessageData.Quotas);
 0512            WriteBufferedMessageHeader(bufferedMessageData, bufferedMessageHeaderIndex, writer);
 0513            buffer.CloseSection();
 0514            buffer.Close();
 0515            return new BufferedHeader(MessageVersion, buffer, 0, headerInfo);
 516        }
 517
 518        private BufferedHeader CaptureWriteableHeader(MessageHeader writeableHeader)
 519        {
 12520            XmlBuffer buffer = new XmlBuffer(int.MaxValue);
 12521            XmlDictionaryWriter writer = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
 12522            writeableHeader.WriteHeader(writer, MessageVersion);
 12523            buffer.CloseSection();
 12524            buffer.Close();
 12525            return new BufferedHeader(MessageVersion, buffer, 0, writeableHeader);
 526        }
 527
 528        public void Clear()
 529        {
 4578530            for (int i = 0; i < Count; i++)
 531            {
 1668532                _headers[i] = new Header();
 533            }
 534
 621535            Count = 0;
 621536            CollectionVersion++;
 621537            _bufferedMessageData = null;
 621538        }
 539
 540        public void CopyHeaderFrom(Message message, int headerIndex)
 541        {
 0542            if (message == null)
 543            {
 0544                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(message));
 545            }
 546
 0547            CopyHeaderFrom(message.Headers, headerIndex);
 0548        }
 549
 550        public void CopyHeaderFrom(MessageHeaders collection, int headerIndex)
 551        {
 708552            if (collection == null)
 553            {
 0554                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(collection));
 555            }
 556
 708557            if (collection.MessageVersion != MessageVersion)
 558            {
 0559                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.MessageHead
 560            }
 561
 708562            if (headerIndex < 0 || headerIndex >= collection.Count)
 563            {
 0564                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0565                    new ArgumentOutOfRangeException(nameof(headerIndex), headerIndex,
 0566                    SR.Format(SR.ValueMustBeInRange, 0, collection.Count)));
 567            }
 708568            Header header = collection._headers[headerIndex];
 708569            HeaderProcessing processing = header.HeaderInfo.MustUnderstand ? HeaderProcessing.MustUnderstand : 0;
 708570            if ((header.HeaderProcessing & HeaderProcessing.Understood) != 0 || header.HeaderKind != HeaderKind.Unknown)
 571            {
 706572                processing |= HeaderProcessing.Understood;
 573            }
 574
 708575            switch (header.HeaderType)
 576            {
 577                case HeaderType.BufferedMessageHeader:
 0578                    AddHeader(new Header(header.HeaderKind, collection.CaptureBufferedHeader(collection._bufferedMessage
 0579                        header.HeaderInfo, headerIndex), processing));
 0580                    break;
 581                case HeaderType.ReadableHeader:
 0582                    AddHeader(new Header(header.HeaderKind, header.ReadableHeader, processing));
 0583                    break;
 584                case HeaderType.WriteableHeader:
 708585                    AddHeader(new Header(header.HeaderKind, header.MessageHeader, processing));
 708586                    break;
 587                default:
 0588                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 589            }
 590        }
 591
 592        public void CopyHeadersFrom(Message message)
 593        {
 0594            if (message == null)
 595            {
 0596                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(message));
 597            }
 598
 0599            CopyHeadersFrom(message.Headers);
 0600        }
 601
 602        public void CopyHeadersFrom(MessageHeaders collection)
 603        {
 542604            if (collection == null)
 605            {
 0606                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(collection));
 607            }
 608
 2500609            for (int i = 0; i < collection.Count; i++)
 610            {
 708611                CopyHeaderFrom(collection, i);
 612            }
 542613        }
 614
 615        public void CopyTo(MessageHeaderInfo[] array, int index)
 616        {
 0617            if (array == null)
 618            {
 0619                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(array));
 620            }
 621
 0622            if (index < 0 || (index + Count) > array.Length)
 623            {
 0624                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0625                    new ArgumentOutOfRangeException(nameof(index), index,
 0626                    SR.Format(SR.ValueMustBeInRange, 0, array.Length - Count)));
 627            }
 0628            for (int i = 0; i < Count; i++)
 629            {
 0630                array[i + index] = _headers[i].HeaderInfo;
 631            }
 0632        }
 633
 634        private Exception CreateDuplicateHeaderException(HeaderKind kind)
 635        {
 636            string name;
 637            switch (kind)
 638            {
 639                case HeaderKind.Action:
 0640                    name = AddressingStrings.Action;
 0641                    break;
 642                case HeaderKind.FaultTo:
 0643                    name = AddressingStrings.FaultTo;
 0644                    break;
 645                case HeaderKind.From:
 0646                    name = AddressingStrings.From;
 0647                    break;
 648                case HeaderKind.MessageId:
 0649                    name = AddressingStrings.MessageId;
 0650                    break;
 651                case HeaderKind.ReplyTo:
 0652                    name = AddressingStrings.ReplyTo;
 0653                    break;
 654                case HeaderKind.To:
 0655                    name = AddressingStrings.To;
 0656                    break;
 657                default:
 0658                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 659            }
 660
 0661            return new MessageHeaderException(
 0662                SR.Format(SR.MultipleMessageHeaders, name, MessageVersion.Addressing.Namespace),
 0663                name,
 0664                MessageVersion.Addressing.Namespace,
 0665                true);
 666        }
 667
 668        public int FindHeader(string name, string ns)
 669        {
 28670            if (name == null)
 671            {
 0672                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(name));
 673            }
 674
 28675            if (ns == null)
 676            {
 0677                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(ns));
 678            }
 679
 28680            if (ns == MessageVersion.Addressing.Namespace)
 681            {
 0682                return FindAddressingHeader(name, ns);
 683            }
 684            else
 685            {
 28686                return FindNonAddressingHeader(name, ns, MessageVersion.Envelope.UltimateDestinationActorValues);
 687            }
 688        }
 689
 690        private int FindAddressingHeader(string name, string ns)
 691        {
 0692            int foundAt = -1;
 0693            for (int i = 0; i < Count; i++)
 694            {
 0695                if (_headers[i].HeaderKind != HeaderKind.Unknown)
 696                {
 0697                    MessageHeaderInfo info = _headers[i].HeaderInfo;
 0698                    if (info.Name == name && info.Namespace == ns)
 699                    {
 0700                        if (foundAt >= 0)
 701                        {
 0702                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0703                                new MessageHeaderException(SR.Format(SR.MultipleMessageHeaders, name, ns), name, ns, tru
 704                        }
 0705                        foundAt = i;
 706                    }
 707                }
 708            }
 0709            return foundAt;
 710        }
 711
 712        private int FindNonAddressingHeader(string name, string ns, string[] actors)
 713        {
 28714            int foundAt = -1;
 322715            for (int i = 0; i < Count; i++)
 716            {
 133717                if (_headers[i].HeaderKind == HeaderKind.Unknown)
 718                {
 31719                    MessageHeaderInfo info = _headers[i].HeaderInfo;
 31720                    if (info.Name == name && info.Namespace == ns)
 721                    {
 224722                        for (int j = 0; j < actors.Length; j++)
 723                        {
 84724                            if (actors[j] == info.Actor)
 725                            {
 28726                                if (foundAt >= 0)
 727                                {
 0728                                    if (actors.Length == 1)
 729                                    {
 0730                                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderExcep
 731                                    }
 732
 0733                                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException
 734                                }
 28735                                foundAt = i;
 736                            }
 737                        }
 738                    }
 739                }
 740            }
 28741            return foundAt;
 742        }
 743
 744        public int FindHeader(string name, string ns, params string[] actors)
 745        {
 114746            if (name == null)
 747            {
 0748                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(name));
 749            }
 750
 114751            if (ns == null)
 752            {
 0753                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(ns));
 754            }
 755
 114756            if (actors == null)
 757            {
 0758                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(actors));
 759            }
 760
 114761            int foundAt = -1;
 1342762            for (int i = 0; i < Count; i++)
 763            {
 557764                MessageHeaderInfo info = _headers[i].HeaderInfo;
 557765                if (info.Name == name && info.Namespace == ns)
 766                {
 536767                    for (int j = 0; j < actors.Length; j++)
 768                    {
 154769                        if (actors[j] == info.Actor)
 770                        {
 114771                            if (foundAt >= 0)
 772                            {
 0773                                if (actors.Length == 1)
 774                                {
 0775                                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException
 776                                }
 777
 0778                                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(SR.
 779                            }
 114780                            foundAt = i;
 781                        }
 782                    }
 783                }
 784            }
 114785            return foundAt;
 786        }
 787
 788        private int FindHeaderProperty(HeaderKind kind)
 789        {
 23670790            int index = -1;
 127684791            for (int i = 0; i < Count; i++)
 792            {
 40172793                if (_headers[i].HeaderKind == kind)
 794                {
 13487795                    if (index >= 0)
 796                    {
 0797                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateDuplicateHeaderException(kind));
 798                    }
 799
 13487800                    index = i;
 801                }
 802            }
 23670803            return index;
 804        }
 805
 806        private int FindRelatesTo(Uri relationshipType, out UniqueId messageId)
 807        {
 856808            UniqueId foundValue = null;
 856809            int foundIndex = -1;
 4878810            for (int i = 0; i < Count; i++)
 811            {
 1583812                if (_headers[i].HeaderKind == HeaderKind.RelatesTo)
 813                {
 77814                    GetRelatesToValues(i, out Uri tempRelationship, out UniqueId tempValue);
 815
 77816                    if (relationshipType == tempRelationship)
 817                    {
 77818                        if (foundValue != null)
 819                        {
 0820                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0821                                new MessageHeaderException(
 0822                                    SR.Format(SR.MultipleRelatesToHeaders, relationshipType.AbsoluteUri),
 0823                                    AddressingStrings.RelatesTo,
 0824                                    MessageVersion.Addressing.Namespace,
 0825                                    true));
 826                        }
 77827                        foundValue = tempValue;
 77828                        foundIndex = i;
 829                    }
 830                }
 831            }
 832
 856833            messageId = foundValue;
 856834            return foundIndex;
 835        }
 836
 837        IEnumerator IEnumerable.GetEnumerator()
 838        {
 0839            return GetEnumerator();
 840        }
 841
 842        public IEnumerator<MessageHeaderInfo> GetEnumerator()
 843        {
 0844            MessageHeaderInfo[] headers = new MessageHeaderInfo[Count];
 0845            CopyTo(headers, 0);
 0846            return GetEnumerator(headers);
 847        }
 848
 849        private IEnumerator<MessageHeaderInfo> GetEnumerator(MessageHeaderInfo[] headers)
 850        {
 0851            IList<MessageHeaderInfo> list = new ReadOnlyCollection<MessageHeaderInfo>(headers);
 0852            return list.GetEnumerator();
 853        }
 854
 855        internal IEnumerator<MessageHeaderInfo> GetUnderstoodEnumerator()
 856        {
 0857            List<MessageHeaderInfo> understoodHeaders = new List<MessageHeaderInfo>();
 858
 0859            for (int i = 0; i < Count; i++)
 860            {
 0861                if ((_headers[i].HeaderProcessing & HeaderProcessing.Understood) != 0)
 862                {
 0863                    understoodHeaders.Add(_headers[i].HeaderInfo);
 864                }
 865            }
 866
 0867            return understoodHeaders.GetEnumerator();
 868        }
 869
 870        private static XmlDictionaryReader GetBufferedMessageHeaderReaderAtHeaderContents(IBufferedMessageData bufferedM
 871        {
 709872            XmlDictionaryReader reader = bufferedMessageData.GetMessageReader();
 709873            if (reader.NodeType == XmlNodeType.Element)
 874            {
 0875                reader.Read();
 876            }
 877            else
 878            {
 709879                reader.ReadStartElement();
 880            }
 881
 709882            if (reader.NodeType == XmlNodeType.Element)
 883            {
 344884                reader.Read();
 885            }
 886            else
 887            {
 365888                reader.ReadStartElement();
 889            }
 890
 709891            return reader;
 892        }
 893
 894        private XmlDictionaryReader GetBufferedMessageHeaderReader(IBufferedMessageData bufferedMessageData, int buffere
 895        {
 896            // Check if we need to change representations
 709897            if (_nodeCount > MaxBufferedHeaderNodes || _attrCount > MaxBufferedHeaderAttributes)
 898            {
 0899                CaptureBufferedHeaders();
 0900                return _headers[bufferedMessageHeaderIndex].ReadableHeader.GetHeaderReader();
 901            }
 902
 709903            XmlDictionaryReader reader = GetBufferedMessageHeaderReaderAtHeaderContents(bufferedMessageData);
 904            for (; ; )
 905            {
 1598906                if (reader.NodeType != XmlNodeType.Element)
 907                {
 21908                    reader.MoveToContent();
 909                }
 910
 1598911                if (bufferedMessageHeaderIndex == 0)
 912                {
 913                    break;
 914                }
 915
 889916                Skip(reader);
 889917                bufferedMessageHeaderIndex--;
 918            }
 919
 709920            return reader;
 921        }
 922
 923        private void Skip(XmlDictionaryReader reader)
 924        {
 889925            if (reader.MoveToContent() == XmlNodeType.Element && !reader.IsEmptyElement)
 926            {
 889927                int depth = reader.Depth;
 928                do
 929                {
 2394930                    _attrCount += reader.AttributeCount;
 2394931                    _nodeCount++;
 2394932                } while (reader.Read() && depth < reader.Depth);
 933
 934                // consume end tag
 889935                if (reader.NodeType == XmlNodeType.EndElement)
 936                {
 889937                    _nodeCount++;
 889938                    reader.Read();
 939                }
 940            }
 941            else
 942            {
 0943                _attrCount += reader.AttributeCount;
 0944                _nodeCount++;
 0945                reader.Read();
 946            }
 0947        }
 948
 949        public T GetHeader<T>(string name, string ns)
 950        {
 1951            return GetHeader<T>(name, ns, DataContractSerializerDefaults.CreateSerializer(typeof(T), name, ns, int.MaxVa
 952        }
 953
 954        public T GetHeader<T>(string name, string ns, params string[] actors)
 955        {
 0956            int index = FindHeader(name, ns, actors);
 0957            if (index < 0)
 958            {
 0959                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(SR.Format(SR.Header
 960            }
 961
 0962            return GetHeader<T>(index);
 963        }
 964
 965        public T GetHeader<T>(string name, string ns, XmlObjectSerializer serializer)
 966        {
 1967            if (serializer == null)
 968            {
 0969                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(serializer));
 970            }
 971
 1972            int index = FindHeader(name, ns);
 1973            if (index < 0)
 974            {
 0975                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(SR.Format(SR.Header
 976            }
 977
 1978            return GetHeader<T>(index, serializer);
 979        }
 980
 981        public T GetHeader<T>(int index)
 982        {
 1983            if (index < 0 || index >= Count)
 984            {
 0985                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 0986                    new ArgumentOutOfRangeException(nameof(index), index,
 0987                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 988            }
 989
 1990            MessageHeaderInfo headerInfo = _headers[index].HeaderInfo;
 1991            return GetHeader<T>(index, DataContractSerializerDefaults.CreateSerializer(typeof(T), headerInfo.Name, heade
 992        }
 993
 994        public T GetHeader<T>(int index, XmlObjectSerializer serializer)
 995        {
 2996            if (serializer == null)
 997            {
 0998                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(serializer));
 999            }
 1000
 21001            using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 1002            {
 21003                return (T)serializer.ReadObject(reader);
 1004            }
 21005        }
 1006
 1007        private HeaderKind GetHeaderKind(MessageHeaderInfo headerInfo)
 1008        {
 472251009            HeaderKind headerKind = HeaderKind.Unknown;
 1010
 472251011            if (headerInfo.Namespace == MessageVersion.Addressing.Namespace)
 1012            {
 38501013                if (MessageVersion.Envelope.IsUltimateDestinationActor(headerInfo.Actor))
 1014                {
 38501015                    string name = headerInfo.Name;
 38501016                    if (name.Length > 0)
 1017                    {
 38501018                        switch (name[0])
 1019                        {
 1020                            case 'A':
 29321021                                if (name == AddressingStrings.Action)
 1022                                {
 29321023                                    headerKind = HeaderKind.Action;
 1024                                }
 29321025                                break;
 1026                            case 'F':
 01027                                if (name == AddressingStrings.From)
 1028                                {
 01029                                    headerKind = HeaderKind.From;
 1030                                }
 01031                                else if (name == AddressingStrings.FaultTo)
 1032                                {
 01033                                    headerKind = HeaderKind.FaultTo;
 1034                                }
 01035                                break;
 1036                            case 'M':
 1481037                                if (name == AddressingStrings.MessageId)
 1038                                {
 1481039                                    headerKind = HeaderKind.MessageId;
 1040                                }
 1481041                                break;
 1042                            case 'R':
 1481043                                if (name == AddressingStrings.ReplyTo)
 1044                                {
 1481045                                    headerKind = HeaderKind.ReplyTo;
 1046                                }
 01047                                else if (name == AddressingStrings.RelatesTo)
 1048                                {
 01049                                    headerKind = HeaderKind.RelatesTo;
 1050                                }
 01051                                break;
 1052                            case 'T':
 6221053                                if (name == AddressingStrings.To)
 1054                                {
 6221055                                    headerKind = HeaderKind.To;
 1056                                }
 1057                                break;
 1058                        }
 1059                    }
 1060                }
 1061            }
 1062
 472251063            ValidateHeaderKind(headerKind);
 472251064            return headerKind;
 1065        }
 1066
 1067        private void ValidateHeaderKind(HeaderKind headerKind)
 1068        {
 1013571069            if (MessageVersion.Envelope == EnvelopeVersion.None)
 1070            {
 351071                if (headerKind != HeaderKind.Action && headerKind != HeaderKind.To)
 1072                {
 01073                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01074                        new InvalidOperationException(SR.Format(SR.HeadersCannotBeAddedToEnvelopeVersion, MessageVersion
 1075                }
 1076            }
 1077
 1013571078            if (MessageVersion.Addressing == AddressingVersion.None)
 1079            {
 14651080                if (headerKind != HeaderKind.Unknown && headerKind != HeaderKind.Action && headerKind != HeaderKind.To)
 1081                {
 01082                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01083                        new InvalidOperationException(SR.Format(SR.AddressingHeadersCannotBeAddedToAddressingVersion, Me
 1084                }
 1085            }
 1013571086        }
 1087
 1088        public XmlDictionaryReader GetReaderAtHeader(int headerIndex)
 1089        {
 69801090            if (headerIndex < 0 || headerIndex >= Count)
 1091            {
 01092                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01093                    new ArgumentOutOfRangeException(nameof(headerIndex), headerIndex,
 01094                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 1095            }
 1096
 69801097            switch (_headers[headerIndex].HeaderType)
 1098            {
 1099                case HeaderType.ReadableHeader:
 68431100                    return _headers[headerIndex].ReadableHeader.GetHeaderReader();
 1101                case HeaderType.WriteableHeader:
 121102                    MessageHeader writeableHeader = _headers[headerIndex].MessageHeader;
 121103                    BufferedHeader bufferedHeader = CaptureWriteableHeader(writeableHeader);
 121104                    _headers[headerIndex] = new Header(_headers[headerIndex].HeaderKind, bufferedHeader, _headers[header
 121105                    CollectionVersion++;
 121106                    return bufferedHeader.GetHeaderReader();
 1107                case HeaderType.BufferedMessageHeader:
 1251108                    return GetBufferedMessageHeaderReader(_bufferedMessageData, headerIndex);
 1109                default:
 01110                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 1111            }
 1112        }
 1113
 1114        internal UniqueId GetRelatesTo(Uri relationshipType)
 1115        {
 5031116            if (relationshipType == null)
 1117            {
 01118                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(relationshipType));
 1119            }
 1120
 5031121            FindRelatesTo(relationshipType, out UniqueId messageId);
 5031122            return messageId;
 1123        }
 1124
 1125        private void GetRelatesToValues(int index, out Uri relationshipType, out UniqueId messageId)
 1126        {
 771127            if (_headers[index].HeaderInfo is RelatesToHeader relatesToHeader)
 1128            {
 771129                relationshipType = relatesToHeader.RelationshipType;
 771130                messageId = relatesToHeader.UniqueId;
 1131            }
 1132            else
 1133            {
 01134                using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 1135                {
 01136                    RelatesToHeader.ReadHeaderValue(reader, MessageVersion.Addressing, out relationshipType, out message
 01137                }
 1138            }
 01139        }
 1140
 1141        internal string[] GetHeaderAttributes(string localName, string ns)
 1142        {
 01143            string[] attrs = null;
 1144
 01145            if (ContainsOnlyBufferedMessageHeaders)
 1146            {
 01147                XmlDictionaryReader reader = _bufferedMessageData.GetMessageReader();
 01148                reader.ReadStartElement(); // Envelope
 01149                reader.ReadStartElement(); // Header
 01150                for (int index = 0; reader.IsStartElement(); index++)
 1151                {
 01152                    string value = reader.GetAttribute(localName, ns);
 01153                    if (value != null)
 1154                    {
 01155                        if (attrs == null)
 1156                        {
 01157                            attrs = new string[Count];
 1158                        }
 1159
 01160                        attrs[index] = value;
 1161                    }
 01162                    if (index == Count - 1)
 1163                    {
 1164                        break;
 1165                    }
 1166
 01167                    reader.Skip();
 1168                }
 01169                reader.Dispose();
 1170            }
 1171            else
 1172            {
 01173                for (int index = 0; index < Count; index++)
 1174                {
 01175                    if (_headers[index].HeaderType != HeaderType.WriteableHeader)
 1176                    {
 01177                        using (XmlDictionaryReader reader = GetReaderAtHeader(index))
 1178                        {
 01179                            string value = reader.GetAttribute(localName, ns);
 01180                            if (value != null)
 1181                            {
 01182                                if (attrs == null)
 1183                                {
 01184                                    attrs = new string[Count];
 1185                                }
 1186
 01187                                attrs[index] = value;
 1188                            }
 01189                        }
 1190                    }
 1191                }
 1192            }
 1193
 01194            return attrs;
 1195        }
 1196
 1197        internal MessageHeader GetMessageHeader(int index)
 1198        {
 1221199            if (index < 0 || index >= Count)
 1200            {
 01201                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01202                    new ArgumentOutOfRangeException("headerIndex", index,
 01203                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 1204            }
 1205            MessageHeader messageHeader;
 1221206            switch (_headers[index].HeaderType)
 1207            {
 1208                case HeaderType.WriteableHeader:
 1209                case HeaderType.ReadableHeader:
 1221210                    return _headers[index].MessageHeader;
 1211                case HeaderType.BufferedMessageHeader:
 01212                    messageHeader = CaptureBufferedHeader(_bufferedMessageData, _headers[index].HeaderInfo, index);
 01213                    _headers[index] = new Header(_headers[index].HeaderKind, messageHeader, _headers[index].HeaderProces
 01214                    CollectionVersion++;
 01215                    return messageHeader;
 1216                default:
 01217                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 1218            }
 1219        }
 1220
 1221        internal Collection<MessageHeaderInfo> GetHeadersNotUnderstood()
 1222        {
 25051223            Collection<MessageHeaderInfo> notUnderstoodHeaders = null;
 1224
 163721225            for (int headerIndex = 0; headerIndex < Count; headerIndex++)
 1226            {
 56811227                if (_headers[headerIndex].HeaderProcessing == HeaderProcessing.MustUnderstand)
 1228                {
 01229                    if (notUnderstoodHeaders == null)
 1230                    {
 01231                        notUnderstoodHeaders = new Collection<MessageHeaderInfo>();
 1232                    }
 1233
 01234                    MessageHeaderInfo headerInfo = _headers[headerIndex].HeaderInfo;
 1235                    //if (DiagnosticUtility.ShouldTraceWarning)
 1236                    //{
 1237                    //    TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.DidNotUnderstandMessageHeader,
 1238                    //        SR.TraceCodeDidNotUnderstandMessageHeader,
 1239                    //        new MessageHeaderInfoTraceRecord(headerInfo), null, null);
 1240                    //}
 1241
 01242                    notUnderstoodHeaders.Add(headerInfo);
 1243                }
 1244            }
 1245
 25051246            return notUnderstoodHeaders;
 1247        }
 1248
 1249        public bool HaveMandatoryHeadersBeenUnderstood()
 1250        {
 01251            return HaveMandatoryHeadersBeenUnderstood(MessageVersion.Envelope.MustUnderstandActorValues);
 1252        }
 1253
 1254        public bool HaveMandatoryHeadersBeenUnderstood(params string[] actors)
 1255        {
 01256            if (actors == null)
 1257            {
 01258                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(actors));
 1259            }
 1260
 01261            for (int headerIndex = 0; headerIndex < Count; headerIndex++)
 1262            {
 01263                if (_headers[headerIndex].HeaderProcessing == HeaderProcessing.MustUnderstand)
 1264                {
 01265                    for (int actorIndex = 0; actorIndex < actors.Length; ++actorIndex)
 1266                    {
 01267                        if (_headers[headerIndex].HeaderInfo.Actor == actors[actorIndex])
 1268                        {
 01269                            return false;
 1270                        }
 1271                    }
 1272                }
 1273            }
 1274
 01275            return true;
 1276        }
 1277
 1278        internal void Init(MessageVersion version, int initialSize)
 1279        {
 64591280            _nodeCount = 0;
 64591281            _attrCount = 0;
 64591282            if (initialSize < 0)
 1283            {
 01284                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01285                    new ArgumentOutOfRangeException(nameof(initialSize), initialSize,
 01286                    SRCommon.ValueMustBeNonNegative));
 1287            }
 1288
 64591289            MessageVersion = version ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(version)
 64591290            _headers = new Header[initialSize];
 64591291        }
 1292
 1293        internal void Init(MessageVersion version)
 1294        {
 01295            _nodeCount = 0;
 01296            _attrCount = 0;
 01297            MessageVersion = version;
 01298            CollectionVersion = 0;
 01299        }
 1300
 1301        public void Init(MessageVersion version, XmlDictionaryReader reader, IBufferedMessageData bufferedMessageData, R
 1302        {
 5371303            _nodeCount = 0;
 5371304            _attrCount = 0;
 5371305            MessageVersion = version;
 5371306            _bufferedMessageData = bufferedMessageData;
 1307
 5371308            if (version.Envelope != EnvelopeVersion.None)
 1309            {
 5371310                _understoodHeadersModified = (understoodHeaders != null) && understoodHeadersModified;
 5371311                if (reader.IsEmptyElement)
 1312                {
 341313                    reader.Read();
 341314                    return;
 1315                }
 5031316                EnvelopeVersion envelopeVersion = version.Envelope;
 1317                Fx.Assert(reader.IsStartElement(XD.MessageDictionary.Header, envelopeVersion.DictionaryNamespace), "");
 5031318                reader.ReadStartElement();
 1319
 5031320                AddressingDictionary dictionary = XD.AddressingDictionary;
 1321
 5031322                if (s_localNames == null)
 1323                {
 31324                    XmlDictionaryString[] strings = new XmlDictionaryString[7];
 31325                    strings[(int)HeaderKind.To] = dictionary.To;
 31326                    strings[(int)HeaderKind.Action] = dictionary.Action;
 31327                    strings[(int)HeaderKind.MessageId] = dictionary.MessageId;
 31328                    strings[(int)HeaderKind.RelatesTo] = dictionary.RelatesTo;
 31329                    strings[(int)HeaderKind.ReplyTo] = dictionary.ReplyTo;
 31330                    strings[(int)HeaderKind.From] = dictionary.From;
 31331                    strings[(int)HeaderKind.FaultTo] = dictionary.FaultTo;
 31332                    Interlocked.MemoryBarrier();
 31333                    s_localNames = strings;
 1334                }
 1335
 1336
 5031337                int i = 0;
 14901338                while (reader.IsStartElement())
 1339                {
 9871340                    ReadBufferedHeader(reader, recycledMessageState, s_localNames, (understoodHeaders == null) ? false :
 1341                }
 1342
 5031343                reader.ReadEndElement();
 1344            }
 5031345            CollectionVersion = 0;
 5031346        }
 1347
 1348        public void Insert(int headerIndex, MessageHeader header)
 1349        {
 289361350            if (header == null)
 1351            {
 01352                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(header));
 1353            }
 1354
 289361355            if (!header.IsMessageVersionSupported(MessageVersion))
 1356            {
 01357                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.MessageHead
 1358            }
 1359
 289361360            Insert(headerIndex, header, GetHeaderKind(header));
 289361361        }
 1362
 1363        private void Insert(int headerIndex, MessageHeader header, HeaderKind kind)
 1364        {
 341481365            HeaderProcessing processing = header.MustUnderstand ? HeaderProcessing.MustUnderstand : 0;
 341481366            if (kind != HeaderKind.Unknown)
 1367            {
 52121368                processing |= HeaderProcessing.Understood;
 1369            }
 1370
 341481371            if (header is ReadableMessageHeader readableMessageHeader)
 1372            {
 01373                InsertHeader(headerIndex, new Header(kind, readableMessageHeader, processing));
 1374            }
 1375            else
 1376            {
 341481377                InsertHeader(headerIndex, new Header(kind, header, processing));
 1378            }
 341481379        }
 1380
 1381        private void InsertHeader(int headerIndex, Header header)
 1382        {
 541321383            ValidateHeaderKind(header.HeaderKind);
 1384
 541321385            if (headerIndex < 0 || headerIndex > Count)
 1386            {
 01387                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01388                    new ArgumentOutOfRangeException(nameof(headerIndex), headerIndex,
 01389                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 1390            }
 1391
 541321392            if (Count == _headers.Length)
 1393            {
 27771394                if (_headers.Length == 0)
 1395                {
 01396                    _headers = new Header[1];
 1397                }
 1398                else
 1399                {
 27771400                    Header[] newHeaders = new Header[_headers.Length * 2];
 27771401                    _headers.CopyTo(newHeaders, 0);
 27771402                    _headers = newHeaders;
 1403                }
 1404            }
 541321405            if (headerIndex < Count)
 1406            {
 01407                if (_bufferedMessageData != null)
 1408                {
 01409                    for (int i = headerIndex; i < Count; i++)
 1410                    {
 01411                        if (_headers[i].HeaderType == HeaderType.BufferedMessageHeader)
 1412                        {
 01413                            CaptureBufferedHeaders();
 01414                            break;
 1415                        }
 1416                    }
 1417                }
 01418                Array.Copy(_headers, headerIndex, _headers, headerIndex + 1, Count - headerIndex);
 1419            }
 541321420            _headers[headerIndex] = header;
 541321421            Count++;
 541321422            CollectionVersion++;
 541321423        }
 1424
 1425        public bool IsUnderstood(int i)
 1426        {
 1781427            return (_headers[i].HeaderProcessing & HeaderProcessing.Understood) != 0;
 1428        }
 1429
 1430        internal bool IsUnderstood(MessageHeaderInfo headerInfo)
 1431        {
 01432            if (headerInfo == null)
 1433            {
 01434                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(headerInfo));
 1435            }
 1436
 01437            for (int i = 0; i < Count; i++)
 1438            {
 01439                if ((object)_headers[i].HeaderInfo == (object)headerInfo)
 1440                {
 01441                    if (IsUnderstood(i))
 1442                    {
 01443                        return true;
 1444                    }
 1445                }
 1446            }
 1447
 01448            return false;
 1449        }
 1450
 1451        private void ReadBufferedHeader(XmlDictionaryReader reader, RecycledMessageState recycledMessageState, XmlDictio
 1452        {
 9871453            if (MessageVersion.Addressing == AddressingVersion.None && reader.NamespaceURI == AddressingVersion.None.Nam
 1454            {
 01455                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01456                    new InvalidOperationException(SR.Format(SR.AddressingHeadersCannotBeAddedToAddressingVersion, Messag
 1457            }
 1458
 9871459            MessageHeader.GetHeaderAttributes(reader, MessageVersion, out string actor, out bool mustUnderstand, out boo
 1460
 9871461            HeaderKind kind = HeaderKind.Unknown;
 9871462            MessageHeaderInfo info = null;
 1463
 9871464            if (MessageVersion.Envelope.IsUltimateDestinationActor(actor))
 1465            {
 1466                Fx.Assert(MessageVersion.Addressing.DictionaryNamespace != null, "non-None Addressing requires a non-nul
 9871467                kind = (HeaderKind)reader.IndexOfLocalName(localNames, MessageVersion.Addressing.DictionaryNamespace);
 1468                switch (kind)
 1469                {
 1470                    case HeaderKind.To:
 1311471                        info = ToHeader.ReadHeader(reader, MessageVersion.Addressing, recycledMessageState.UriCache, act
 1311472                        break;
 1473                    case HeaderKind.Action:
 4921474                        info = ActionHeader.ReadHeader(reader, MessageVersion.Addressing, actor, mustUnderstand, relay);
 4921475                        break;
 1476                    case HeaderKind.MessageId:
 1291477                        info = MessageIDHeader.ReadHeader(reader, MessageVersion.Addressing, actor, mustUnderstand, rela
 1291478                        break;
 1479                    case HeaderKind.RelatesTo:
 11480                        info = RelatesToHeader.ReadHeader(reader, MessageVersion.Addressing, actor, mustUnderstand, rela
 11481                        break;
 1482                    case HeaderKind.ReplyTo:
 1301483                        info = ReplyToHeader.ReadHeader(reader, MessageVersion.Addressing, actor, mustUnderstand, relay)
 1301484                        break;
 1485                    case HeaderKind.From:
 01486                        info = FromHeader.ReadHeader(reader, MessageVersion.Addressing, actor, mustUnderstand, relay);
 01487                        break;
 1488                    case HeaderKind.FaultTo:
 01489                        info = FaultToHeader.ReadHeader(reader, MessageVersion.Addressing, actor, mustUnderstand, relay)
 01490                        break;
 1491                    default:
 1041492                        kind = HeaderKind.Unknown;
 1493                        break;
 1494                }
 1495            }
 1496
 9871497            if (info == null)
 1498            {
 1041499                info = recycledMessageState.HeaderInfoCache.TakeHeaderInfo(reader, actor, mustUnderstand, relay, isRefPa
 1041500                reader.Skip();
 1501            }
 1502
 9871503            HeaderProcessing processing = mustUnderstand ? HeaderProcessing.MustUnderstand : 0;
 9871504            if (kind != HeaderKind.Unknown || understood)
 1505            {
 8831506                processing |= HeaderProcessing.Understood;
 8831507                TraceUnderstood(info);
 1508            }
 9871509            AddHeader(new Header(kind, info, processing));
 9871510        }
 1511
 1512        internal void Recycle(HeaderInfoCache headerInfoCache)
 1513        {
 45781514            for (int i = 0; i < Count; i++)
 1515            {
 16681516                if (_headers[i].HeaderKind == HeaderKind.Unknown)
 1517                {
 691518                    headerInfoCache.ReturnHeaderInfo(_headers[i].HeaderInfo);
 1519                }
 1520            }
 6211521            Clear();
 6211522            CollectionVersion = 0;
 6211523            if (_understoodHeaders != null)
 1524            {
 611525                _understoodHeaders.Modified = false;
 1526            }
 6211527        }
 1528
 1529        internal void RemoveUnderstood(MessageHeaderInfo headerInfo)
 1530        {
 01531            if (headerInfo == null)
 1532            {
 01533                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(headerInfo));
 1534            }
 1535
 01536            for (int i = 0; i < Count; i++)
 1537            {
 01538                if ((object)_headers[i].HeaderInfo == (object)headerInfo)
 1539                {
 01540                    if ((_headers[i].HeaderProcessing & HeaderProcessing.Understood) == 0)
 1541                    {
 01542                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(
 01543                            SR.Format(SR.HeaderAlreadyNotUnderstood, headerInfo.Name, headerInfo.Namespace), nameof(head
 1544                    }
 1545
 01546                    _headers[i].HeaderProcessing &= ~HeaderProcessing.Understood;
 1547                }
 1548            }
 01549        }
 1550
 1551        public void RemoveAll(string name, string ns)
 1552        {
 01553            if (name == null)
 1554            {
 01555                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(name));
 1556            }
 1557
 01558            if (ns == null)
 1559            {
 01560                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(ns));
 1561            }
 1562
 01563            for (int i = Count - 1; i >= 0; i--)
 1564            {
 01565                MessageHeaderInfo info = _headers[i].HeaderInfo;
 01566                if (info.Name == name && info.Namespace == ns)
 1567                {
 01568                    RemoveAt(i);
 1569                }
 1570            }
 01571        }
 1572
 1573        public void RemoveAt(int headerIndex)
 1574        {
 4191575            if (headerIndex < 0 || headerIndex >= Count)
 1576            {
 01577                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01578                    new ArgumentOutOfRangeException(nameof(headerIndex), headerIndex,
 01579                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 1580            }
 4191581            if (_bufferedMessageData != null && _headers[headerIndex].HeaderType == HeaderType.BufferedMessageHeader)
 1582            {
 01583                CaptureBufferedHeaders(headerIndex);
 1584            }
 1585
 4191586            Array.Copy(_headers, headerIndex + 1, _headers, headerIndex, Count - headerIndex - 1);
 4191587            _headers[--Count] = new Header();
 4191588            CollectionVersion++;
 4191589        }
 1590
 1591        internal void ReplaceAt(int headerIndex, MessageHeader header)
 1592        {
 01593            if (headerIndex < 0 || headerIndex >= Count)
 1594            {
 01595                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01596                    new ArgumentOutOfRangeException(nameof(headerIndex), headerIndex,
 01597                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 1598            }
 1599
 01600            if (header == null)
 1601            {
 01602                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(header));
 1603            }
 1604
 01605            ReplaceAt(headerIndex, header, GetHeaderKind(header));
 01606        }
 1607
 1608        private void ReplaceAt(int headerIndex, MessageHeader header, HeaderKind kind)
 1609        {
 1211610            HeaderProcessing processing = header.MustUnderstand ? HeaderProcessing.MustUnderstand : 0;
 1211611            if (kind != HeaderKind.Unknown)
 1612            {
 1211613                processing |= HeaderProcessing.Understood;
 1614            }
 1615
 1211616            if (header is ReadableMessageHeader readableMessageHeader)
 1617            {
 01618                _headers[headerIndex] = new Header(kind, readableMessageHeader, processing);
 1619            }
 1620            else
 1621            {
 1211622                _headers[headerIndex] = new Header(kind, header, processing);
 1623            }
 1624
 1211625            CollectionVersion++;
 1211626        }
 1627
 1628        public void SetAction(XmlDictionaryString action)
 1629        {
 01630            if (action == null)
 1631            {
 01632                SetHeaderProperty(HeaderKind.Action, null);
 1633            }
 1634            else
 1635            {
 01636                SetActionHeader(ActionHeader.Create(action, MessageVersion.Addressing));
 1637            }
 01638        }
 1639
 1640        internal void SetActionHeader(ActionHeader actionHeader)
 1641        {
 27291642            SetHeaderProperty(HeaderKind.Action, actionHeader);
 27291643        }
 1644
 1645        internal void SetFaultToHeader(FaultToHeader faultToHeader)
 1646        {
 01647            SetHeaderProperty(HeaderKind.FaultTo, faultToHeader);
 01648        }
 1649
 1650        internal void SetFromHeader(FromHeader fromHeader)
 1651        {
 01652            SetHeaderProperty(HeaderKind.From, fromHeader);
 01653        }
 1654
 1655        internal void SetMessageIDHeader(MessageIDHeader messageIDHeader)
 1656        {
 11657            SetHeaderProperty(HeaderKind.MessageId, messageIDHeader);
 11658        }
 1659
 1660        internal void SetRelatesTo(Uri relationshipType, UniqueId messageId)
 1661        {
 3531662            if (relationshipType == null)
 1663            {
 01664                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(relationshipType));
 1665            }
 1666
 1667            RelatesToHeader relatesToHeader;
 3531668            if (!ReferenceEquals(messageId, null))
 1669            {
 3531670                relatesToHeader = RelatesToHeader.Create(messageId, MessageVersion.Addressing, relationshipType);
 1671            }
 1672            else
 1673            {
 01674                relatesToHeader = null;
 1675            }
 1676
 3531677            SetRelatesTo(RelatesToHeader.ReplyRelationshipType, relatesToHeader);
 3531678        }
 1679
 1680        private void SetRelatesTo(Uri relationshipType, RelatesToHeader relatesToHeader)
 1681        {
 3531682            int index = FindRelatesTo(relationshipType, out UniqueId previousUniqueId);
 3531683            if (index >= 0)
 1684            {
 01685                if (relatesToHeader == null)
 1686                {
 01687                    RemoveAt(index);
 1688                }
 1689                else
 1690                {
 01691                    ReplaceAt(index, relatesToHeader, HeaderKind.RelatesTo);
 1692                }
 1693            }
 3531694            else if (relatesToHeader != null)
 1695            {
 3531696                Add(relatesToHeader, HeaderKind.RelatesTo);
 1697            }
 3531698        }
 1699
 1700        internal void SetReplyToHeader(ReplyToHeader replyToHeader)
 1701        {
 11702            SetHeaderProperty(HeaderKind.ReplyTo, replyToHeader);
 11703        }
 1704
 1705        internal void SetToHeader(ToHeader toHeader)
 1706        {
 19771707            SetHeaderProperty(HeaderKind.To, toHeader);
 19771708        }
 1709
 1710        private void SetHeaderProperty(HeaderKind kind, MessageHeader header)
 1711        {
 58671712            int index = FindHeaderProperty(kind);
 58671713            if (index >= 0)
 1714            {
 4771715                if (header == null)
 1716                {
 3561717                    RemoveAt(index);
 1718                }
 1719                else
 1720                {
 1211721                    ReplaceAt(index, header, kind);
 1722                }
 1723            }
 53901724            else if (header != null)
 1725            {
 45871726                Add(header, kind);
 1727            }
 53901728        }
 1729
 1730        public void WriteHeader(int headerIndex, XmlWriter writer)
 1731        {
 1181732            WriteHeader(headerIndex, XmlDictionaryWriter.CreateDictionaryWriter(writer));
 1181733        }
 1734
 1735        public void WriteHeader(int headerIndex, XmlDictionaryWriter writer)
 1736        {
 467751737            WriteStartHeader(headerIndex, writer);
 467751738            WriteHeaderContents(headerIndex, writer);
 467751739            writer.WriteEndElement();
 467751740        }
 1741
 1742        public void WriteStartHeader(int headerIndex, XmlWriter writer)
 1743        {
 01744            WriteStartHeader(headerIndex, XmlDictionaryWriter.CreateDictionaryWriter(writer));
 01745        }
 1746
 1747        public void WriteStartHeader(int headerIndex, XmlDictionaryWriter writer)
 1748        {
 467751749            if (writer == null)
 1750            {
 01751                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(writer));
 1752            }
 1753
 467751754            if (headerIndex < 0 || headerIndex >= Count)
 1755            {
 01756                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01757                    new ArgumentOutOfRangeException(nameof(headerIndex), headerIndex,
 01758                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 1759            }
 467751760            switch (_headers[headerIndex].HeaderType)
 1761            {
 1762                case HeaderType.ReadableHeader:
 1763                case HeaderType.WriteableHeader:
 464831764                    _headers[headerIndex].MessageHeader.WriteStartHeader(writer, MessageVersion);
 464831765                    break;
 1766                case HeaderType.BufferedMessageHeader:
 2921767                    WriteStartBufferedMessageHeader(_bufferedMessageData, headerIndex, writer);
 2921768                    break;
 1769                default:
 01770                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 1771            }
 1772        }
 1773
 1774        public void WriteHeaderContents(int headerIndex, XmlWriter writer)
 1775        {
 01776            WriteHeaderContents(headerIndex, XmlDictionaryWriter.CreateDictionaryWriter(writer));
 01777        }
 1778
 1779        public void WriteHeaderContents(int headerIndex, XmlDictionaryWriter writer)
 1780        {
 467751781            if (writer == null)
 1782            {
 01783                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(writer));
 1784            }
 1785
 467751786            if (headerIndex < 0 || headerIndex >= Count)
 1787            {
 01788                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
 01789                    new ArgumentOutOfRangeException(nameof(headerIndex), headerIndex,
 01790                    SR.Format(SR.ValueMustBeInRange, 0, Count)));
 1791            }
 467751792            switch (_headers[headerIndex].HeaderType)
 1793            {
 1794                case HeaderType.ReadableHeader:
 1795                case HeaderType.WriteableHeader:
 464831796                    _headers[headerIndex].MessageHeader.WriteHeaderContents(writer, MessageVersion);
 464831797                    break;
 1798                case HeaderType.BufferedMessageHeader:
 2921799                    WriteBufferedMessageHeaderContents(_bufferedMessageData, headerIndex, writer);
 2921800                    break;
 1801                default:
 01802                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 1803            }
 1804        }
 1805
 1806        private static void TraceUnderstood(MessageHeaderInfo info)
 1807        {
 1808            //if (DiagnosticUtility.ShouldTraceVerbose)
 1809            //{
 1810            //    TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.UnderstoodMessageHeader,
 1811            //        SR.TraceCodeUnderstoodMessageHeader,
 1812            //        new MessageHeaderInfoTraceRecord(info), null, null);
 1813            //}
 49741814        }
 1815
 1816        private void WriteBufferedMessageHeader(IBufferedMessageData bufferedMessageData, int bufferedMessageHeaderIndex
 1817        {
 01818            using (XmlReader reader = GetBufferedMessageHeaderReader(bufferedMessageData, bufferedMessageHeaderIndex))
 1819            {
 01820                writer.WriteNode(reader, false);
 01821            }
 01822        }
 1823
 1824        private void WriteStartBufferedMessageHeader(IBufferedMessageData bufferedMessageData, int bufferedMessageHeader
 1825        {
 2921826            using (XmlReader reader = GetBufferedMessageHeaderReader(bufferedMessageData, bufferedMessageHeaderIndex))
 1827            {
 2921828                writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
 2921829                writer.WriteAttributes(reader, false);
 2921830            }
 2921831        }
 1832
 1833        private void WriteBufferedMessageHeaderContents(IBufferedMessageData bufferedMessageData, int bufferedMessageHea
 1834        {
 2921835            using (XmlReader reader = GetBufferedMessageHeaderReader(bufferedMessageData, bufferedMessageHeaderIndex))
 1836            {
 2921837                if (!reader.IsEmptyElement)
 1838                {
 2921839                    reader.ReadStartElement();
 6301840                    while (reader.NodeType != XmlNodeType.EndElement)
 1841                    {
 3381842                        writer.WriteNode(reader, false);
 1843                    }
 2921844                    reader.ReadEndElement();
 1845                }
 2921846            }
 2921847        }
 1848
 1849        private enum HeaderType : byte
 1850        {
 1851            Invalid,
 1852            ReadableHeader,
 1853            BufferedMessageHeader,
 1854            WriteableHeader
 1855        }
 1856
 1857        private enum HeaderKind : byte
 1858        {
 1859            Action,
 1860            FaultTo,
 1861            From,
 1862            MessageId,
 1863            ReplyTo,
 1864            RelatesTo,
 1865            To,
 1866            Unknown,
 1867        }
 1868
 1869        [Flags]
 1870        private enum HeaderProcessing : byte
 1871        {
 1872            MustUnderstand = 0x1,
 1873            Understood = 0x2,
 1874        }
 1875
 1876        private struct Header
 1877        {
 1878            private readonly MessageHeaderInfo _info;
 1879
 1880            public Header(HeaderKind kind, MessageHeaderInfo info, HeaderProcessing processing)
 1881            {
 9871882                HeaderKind = kind;
 9871883                HeaderType = HeaderType.BufferedMessageHeader;
 9871884                _info = info;
 9871885                HeaderProcessing = processing;
 9871886            }
 1887
 1888            public Header(HeaderKind kind, ReadableMessageHeader readableHeader, HeaderProcessing processing)
 1889            {
 183011890                HeaderKind = kind;
 183011891                HeaderType = HeaderType.ReadableHeader;
 183011892                _info = readableHeader;
 183011893                HeaderProcessing = processing;
 183011894            }
 1895
 1896            public Header(HeaderKind kind, MessageHeader header, HeaderProcessing processing)
 1897            {
 349771898                HeaderKind = kind;
 349771899                HeaderType = HeaderType.WriteableHeader;
 349771900                _info = header;
 349771901                HeaderProcessing = processing;
 349771902            }
 1903
 1013601904            public HeaderType HeaderType { get; }
 1905
 984101906            public HeaderKind HeaderKind { get; }
 1907
 1908            public MessageHeaderInfo HeaderInfo
 1909            {
 357301910                get { return _info; }
 1911            }
 1912
 1913            public MessageHeader MessageHeader
 1914            {
 1915                get
 1916                {
 1917                    Fx.Assert(HeaderType == HeaderType.WriteableHeader || HeaderType == HeaderType.ReadableHeader, "");
 938081918                    return (MessageHeader)_info;
 1919                }
 1920            }
 1921
 613891922            public HeaderProcessing HeaderProcessing { get; set; }
 1923
 1924            public ReadableMessageHeader ReadableHeader
 1925            {
 1926                get
 1927                {
 1928                    Fx.Assert(HeaderType == HeaderType.ReadableHeader, "");
 68431929                    return (ReadableMessageHeader)_info;
 1930                }
 1931            }
 1932        }
 1933    }
 1934}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:49
GitHub | reportgenerator.io

Methods/Properties

.ctor(CoreWCF.Channels.MessageVersion,System.Int32)
.ctor(CoreWCF.Channels.MessageVersion)
.ctor(CoreWCF.Channels.MessageVersion,System.Xml.XmlDictionaryReader,CoreWCF.Channels.XmlAttributeHolder[],CoreWCF.Channels.XmlAttributeHolder[],System.Int32&)
.ctor(CoreWCF.Channels.MessageVersion,System.Xml.XmlDictionaryReader,CoreWCF.Channels.IBufferedMessageData,CoreWCF.Channels.RecycledMessageState,System.Boolean[],System.Boolean)
.ctor(CoreWCF.Channels.MessageVersion,CoreWCF.Channels.MessageHeaders,CoreWCF.Channels.IBufferedMessageData)
.ctor(CoreWCF.Channels.MessageHeaders)
Action()
Action(System.String)
CanRecycle()
ContainsOnlyBufferedMessageHeaders()
CollectionVersion()
Count()
FaultTo()
FaultTo(CoreWCF.EndpointAddress)
From()
From(CoreWCF.EndpointAddress)
HasMustUnderstandBeenModified()
MessageId()
MessageId(System.Xml.UniqueId)
MessageVersion()
RelatesTo()
RelatesTo(System.Xml.UniqueId)
ReplyTo()
ReplyTo(CoreWCF.EndpointAddress)
To()
To(System.Uri)
UnderstoodHeaders()
Item(System.Int32)
Add(CoreWCF.Channels.MessageHeader)
AddActionHeader(CoreWCF.Channels.ActionHeader)
AddMessageIDHeader(CoreWCF.Channels.MessageIDHeader)
AddRelatesToHeader(CoreWCF.Channels.RelatesToHeader)
AddReplyToHeader(CoreWCF.Channels.ReplyToHeader)
AddToHeader(CoreWCF.Channels.ToHeader)
Add(CoreWCF.Channels.MessageHeader,CoreWCF.Channels.MessageHeaders/HeaderKind)
AddHeader(CoreWCF.Channels.MessageHeaders/Header)
AddUnderstood(System.Int32)
AddUnderstood(CoreWCF.Channels.MessageHeaderInfo)
CaptureBufferedHeaders()
CaptureBufferedHeaders(System.Int32)
CaptureBufferedHeader(System.Xml.XmlDictionaryReader,CoreWCF.Channels.MessageHeaderInfo)
CaptureBufferedHeader(CoreWCF.Channels.IBufferedMessageData,CoreWCF.Channels.MessageHeaderInfo,System.Int32)
CaptureWriteableHeader(CoreWCF.Channels.MessageHeader)
Clear()
CopyHeaderFrom(CoreWCF.Channels.Message,System.Int32)
CopyHeaderFrom(CoreWCF.Channels.MessageHeaders,System.Int32)
CopyHeadersFrom(CoreWCF.Channels.Message)
CopyHeadersFrom(CoreWCF.Channels.MessageHeaders)
CopyTo(CoreWCF.Channels.MessageHeaderInfo[],System.Int32)
CreateDuplicateHeaderException(CoreWCF.Channels.MessageHeaders/HeaderKind)
FindHeader(System.String,System.String)
FindAddressingHeader(System.String,System.String)
FindNonAddressingHeader(System.String,System.String,System.String[])
FindHeader(System.String,System.String,System.String[])
FindHeaderProperty(CoreWCF.Channels.MessageHeaders/HeaderKind)
FindRelatesTo(System.Uri,System.Xml.UniqueId&)
System.Collections.IEnumerable.GetEnumerator()
GetEnumerator()
GetEnumerator(CoreWCF.Channels.MessageHeaderInfo[])
GetUnderstoodEnumerator()
GetBufferedMessageHeaderReaderAtHeaderContents(CoreWCF.Channels.IBufferedMessageData)
GetBufferedMessageHeaderReader(CoreWCF.Channels.IBufferedMessageData,System.Int32)
Skip(System.Xml.XmlDictionaryReader)
GetHeader(System.String,System.String)
GetHeader(System.String,System.String,System.String[])
GetHeader(System.String,System.String,System.Runtime.Serialization.XmlObjectSerializer)
GetHeader(System.Int32)
GetHeader(System.Int32,System.Runtime.Serialization.XmlObjectSerializer)
GetHeaderKind(CoreWCF.Channels.MessageHeaderInfo)
ValidateHeaderKind(CoreWCF.Channels.MessageHeaders/HeaderKind)
GetReaderAtHeader(System.Int32)
GetRelatesTo(System.Uri)
GetRelatesToValues(System.Int32,System.Uri&,System.Xml.UniqueId&)
GetHeaderAttributes(System.String,System.String)
GetMessageHeader(System.Int32)
GetHeadersNotUnderstood()
HaveMandatoryHeadersBeenUnderstood()
HaveMandatoryHeadersBeenUnderstood(System.String[])
Init(CoreWCF.Channels.MessageVersion,System.Int32)
Init(CoreWCF.Channels.MessageVersion)
Init(CoreWCF.Channels.MessageVersion,System.Xml.XmlDictionaryReader,CoreWCF.Channels.IBufferedMessageData,CoreWCF.Channels.RecycledMessageState,System.Boolean[],System.Boolean)
Insert(System.Int32,CoreWCF.Channels.MessageHeader)
Insert(System.Int32,CoreWCF.Channels.MessageHeader,CoreWCF.Channels.MessageHeaders/HeaderKind)
InsertHeader(System.Int32,CoreWCF.Channels.MessageHeaders/Header)
IsUnderstood(System.Int32)
IsUnderstood(CoreWCF.Channels.MessageHeaderInfo)
ReadBufferedHeader(System.Xml.XmlDictionaryReader,CoreWCF.Channels.RecycledMessageState,System.Xml.XmlDictionaryString[],System.Boolean)
Recycle(CoreWCF.Channels.HeaderInfoCache)
RemoveUnderstood(CoreWCF.Channels.MessageHeaderInfo)
RemoveAll(System.String,System.String)
RemoveAt(System.Int32)
ReplaceAt(System.Int32,CoreWCF.Channels.MessageHeader)
ReplaceAt(System.Int32,CoreWCF.Channels.MessageHeader,CoreWCF.Channels.MessageHeaders/HeaderKind)
SetAction(System.Xml.XmlDictionaryString)
SetActionHeader(CoreWCF.Channels.ActionHeader)
SetFaultToHeader(CoreWCF.Channels.FaultToHeader)
SetFromHeader(CoreWCF.Channels.FromHeader)
SetMessageIDHeader(CoreWCF.Channels.MessageIDHeader)
SetRelatesTo(System.Uri,System.Xml.UniqueId)
SetRelatesTo(System.Uri,CoreWCF.Channels.RelatesToHeader)
SetReplyToHeader(CoreWCF.Channels.ReplyToHeader)
SetToHeader(CoreWCF.Channels.ToHeader)
SetHeaderProperty(CoreWCF.Channels.MessageHeaders/HeaderKind,CoreWCF.Channels.MessageHeader)
WriteHeader(System.Int32,System.Xml.XmlWriter)
WriteHeader(System.Int32,System.Xml.XmlDictionaryWriter)
WriteStartHeader(System.Int32,System.Xml.XmlWriter)
WriteStartHeader(System.Int32,System.Xml.XmlDictionaryWriter)
WriteHeaderContents(System.Int32,System.Xml.XmlWriter)
WriteHeaderContents(System.Int32,System.Xml.XmlDictionaryWriter)
TraceUnderstood(CoreWCF.Channels.MessageHeaderInfo)
WriteBufferedMessageHeader(CoreWCF.Channels.IBufferedMessageData,System.Int32,System.Xml.XmlWriter)
WriteStartBufferedMessageHeader(CoreWCF.Channels.IBufferedMessageData,System.Int32,System.Xml.XmlWriter)
WriteBufferedMessageHeaderContents(CoreWCF.Channels.IBufferedMessageData,System.Int32,System.Xml.XmlWriter)
.ctor(CoreWCF.Channels.MessageHeaders/HeaderKind,CoreWCF.Channels.MessageHeaderInfo,CoreWCF.Channels.MessageHeaders/HeaderProcessing)
.ctor(CoreWCF.Channels.MessageHeaders/HeaderKind,CoreWCF.Channels.ReadableMessageHeader,CoreWCF.Channels.MessageHeaders/HeaderProcessing)
.ctor(CoreWCF.Channels.MessageHeaders/HeaderKind,CoreWCF.Channels.MessageHeader,CoreWCF.Channels.MessageHeaders/HeaderProcessing)
HeaderType()
HeaderKind()
HeaderInfo()
MessageHeader()
HeaderProcessing()
ReadableHeader()