WsrmFault.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / WsrmFault.cs / 1 / WsrmFault.cs

                            //---------------------------------------------------------------------------- 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//---------------------------------------------------------------------------

namespace System.ServiceModel.Channels 
{
    using System.Collections.Generic; 
    using System.Collections.ObjectModel; 
    using System.ServiceModel;
    using System.Globalization; 
    using System.Xml;

    abstract class WsrmFault : MessageFault
    { 
        FaultCode code;
        string exceptionMessage; 
        bool hasDetail; 
        bool isRemote;
        FaultReason reason; 
        ReliableMessagingVersion reliableMessagingVersion;
        string subcode;

        // local 
        protected WsrmFault(bool isSenderFault, string subcode, string faultReason, string exceptionMessage)
        { 
            if (isSenderFault) 
            {
                this.code = new FaultCode("Sender", ""); 
            }
            else
            {
                this.code = new FaultCode("Receiver", ""); 
            }
 
            this.subcode = subcode; 
            this.reason = new FaultReason(faultReason, CultureInfo.CurrentCulture);
            this.exceptionMessage = exceptionMessage; 
            this.isRemote = false;
        }

        // remote 
        protected WsrmFault(FaultCode code, string subcode, FaultReason reason)
        { 
            this.code = code; 
            this.subcode = subcode;
            this.reason = reason; 
            this.isRemote = true;
        }

        public override FaultCode Code 
        {
            get 
            { 
                return this.code;
            } 
        }

        public override bool HasDetail
        { 
            get
            { 
                // The SOAP 1.1 requires body processing error information to be placed in a detail element 
                // and header processing error information to be placed in a soap fault header.
                // Since wsrm header faults relate to header processing, the information in the detail is placed in a 
                // soap fault header in the SOAP 1.1 case.  SOAP 1.2 is not so restrictive. Thus, this flag is set
                // in CreateMessage if the SOAP version is 1.2.
                return this.hasDetail;
            } 
        }
 
        public bool IsRemote 
        {
            get 
            {
                return this.isRemote;
            }
        } 

        public override FaultReason Reason 
        { 
            get
            { 
                return this.reason;
            }
        }
 
        public string Subcode
        { 
            get 
            {
                return this.subcode; 
            }
        }

        public virtual CommunicationException CreateException() 
        {
            string message; 
 
            if (this.IsRemote)
            { 
                message = FaultException.GetSafeReasonText(this.reason);
                message = SR.GetString(SR.WsrmFaultReceived, message);
            }
            else 
            {
                if (this.exceptionMessage == null) 
                { 
                    DiagnosticUtility.DebugAssert("Exception message must not be accessed unless set.");
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false); 
                }

                message = this.exceptionMessage;
            } 

            if (this.code.IsSenderFault) 
                return new ProtocolException(message); 
            else
                return new CommunicationException(message); 
        }

        public static CommunicationException CreateException(WsrmFault fault)
        { 
            return fault.CreateException();
        } 
 
        public Message CreateMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion)
        { 
            this.SetReliableMessagingVersion(reliableMessagingVersion);
            string action = WsrmIndex.GetFaultActionString(messageVersion.Addressing, reliableMessagingVersion);

            if (messageVersion.Envelope == EnvelopeVersion.Soap11) 
            {
                this.code = this.Get11Code(this.code, this.subcode); 
            } 
            else if (messageVersion.Envelope == EnvelopeVersion.Soap12)
            { 
                if (this.code.SubCode == null)
                {
                    FaultCode subCode = new FaultCode(this.subcode,
                        WsrmIndex.GetNamespaceString(reliableMessagingVersion)); 
                    this.code = new FaultCode(this.code.Name, this.code.Namespace, subCode);
                } 
 
                this.hasDetail = this.Get12HasDetail();
            } 
            else
            {
                DiagnosticUtility.DebugAssert("Unsupported MessageVersion.");
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false); 
            }
 
            Message message = Message.CreateMessage(messageVersion, this, action); 
            this.OnFaultMessageCreated(messageVersion, message);
            return message; 
        }

        protected abstract FaultCode Get11Code(FaultCode code, string subcode);
        protected abstract bool Get12HasDetail(); 

        protected string GetExceptionMessage() 
        { 
            if (this.exceptionMessage == null)
            { 
                DiagnosticUtility.DebugAssert("Exception message must not be accessed unless set.");
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false);
            }
 
            return this.exceptionMessage;
        } 
 
        protected ReliableMessagingVersion GetReliableMessagingVersion()
        { 
            if (this.reliableMessagingVersion == null)
            {
                DiagnosticUtility.DebugAssert("Reliable messaging version must not be accessed unless set.");
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false); 
            }
 
            return this.reliableMessagingVersion; 
        }
 
        protected abstract void OnFaultMessageCreated(MessageVersion version, Message message);

        protected void SetReliableMessagingVersion(ReliableMessagingVersion reliableMessagingVersion)
        { 
            if (reliableMessagingVersion == null)
            { 
                DiagnosticUtility.DebugAssert("Reliable messaging version cannot be set to null."); 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false);
            } 

            if (this.reliableMessagingVersion != null)
            {
                DiagnosticUtility.DebugAssert("Reliable messaging version must not be set twice."); 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(false);
            } 
 
            this.reliableMessagingVersion = reliableMessagingVersion;
        } 

        internal void WriteDetail(XmlDictionaryWriter writer)
        {
            this.OnWriteDetailContents(writer); 
        }
    } 
 
    class WsrmRequiredFault : WsrmFault
    { 
        // local
        public WsrmRequiredFault(string faultReason)
            : base(true, Wsrm11Strings.WsrmRequired, faultReason, null)
        { 
        }
 
        protected override FaultCode Get11Code(FaultCode code, string subcode) 
        {
            return new FaultCode(subcode, WsrmIndex.GetNamespaceString(this.GetReliableMessagingVersion())); 
        }

        protected override bool Get12HasDetail()
        { 
            return false;
        } 
 
        protected override void OnFaultMessageCreated(MessageVersion version, Message message)
        { 
            // do nothing
        }

        protected override void OnWriteDetailContents(XmlDictionaryWriter writer) 
        {
            // do nothing 
        } 
    }
 
    abstract class WsrmHeaderFault : WsrmFault
    {
        bool faultsInput;
        bool faultsOutput; 
        UniqueId sequenceID;
        string subcode; 
 
        // local
        protected WsrmHeaderFault(bool isSenderFault, string subcode, string faultReason, string exceptionMessage, 
            UniqueId sequenceID, bool faultsInput, bool faultsOutput)
            : base(isSenderFault, subcode, faultReason, exceptionMessage)
        {
            this.subcode = subcode; 
            this.sequenceID = sequenceID;
            this.faultsInput = faultsInput; 
            this.faultsOutput = faultsOutput; 
        }
 
        // remote
        protected WsrmHeaderFault(FaultCode code, string subcode, FaultReason reason, XmlDictionaryReader detailReader,
            ReliableMessagingVersion reliableMessagingVersion, bool faultsInput, bool faultsOutput)
            : this(code, subcode, reason, faultsInput, faultsOutput) 
        {
            this.sequenceID = ParseDetail(detailReader, reliableMessagingVersion); 
        } 

        // remote 
        protected WsrmHeaderFault(FaultCode code, string subcode, FaultReason reason, bool faultsInput,
            bool faultsOutput)
            : base(code, subcode, reason)
        { 
            this.subcode = subcode;
            this.faultsInput = faultsInput; 
            this.faultsOutput = faultsOutput; 
        }
 
        public bool FaultsInput
        {
            get
            { 
                return this.faultsInput;
            } 
        } 

        public bool FaultsOutput 
        {
            get
            {
                return this.faultsOutput; 
            }
        } 
 
        public UniqueId SequenceID
        { 
            get
            {
                return this.sequenceID;
            } 
            protected set
            { 
                this.sequenceID = value; 
            }
        } 

        static WsrmHeaderFault CreateWsrmHeaderFault(ReliableMessagingVersion reliableMessagingVersion, FaultCode code,
            string subcode, FaultReason reason, XmlDictionaryReader detailReader)
        { 
            // Sender faults.
            if (code.IsSenderFault) 
            { 
                if (subcode == WsrmFeb2005Strings.InvalidAcknowledgement)
                { 
                    return new InvalidAcknowledgementFault(code, reason, detailReader, reliableMessagingVersion);
                }
                else if (subcode == WsrmFeb2005Strings.MessageNumberRollover)
                { 
                    return new MessageNumberRolloverFault(code, reason, detailReader, reliableMessagingVersion);
                } 
                else if (subcode == WsrmFeb2005Strings.UnknownSequence) 
                {
                    return new UnknownSequenceFault(code, reason, detailReader, reliableMessagingVersion); 
                }
                else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005)
                {
                    if (subcode == WsrmFeb2005Strings.LastMessageNumberExceeded) 
                    {
                        return new LastMessageNumberExceededFault(code, reason, detailReader, reliableMessagingVersion); 
                    } 
                }
                else if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11) 
                {
                    if (subcode == Wsrm11Strings.SequenceClosed)
                    {
                        return new SequenceClosedFault(code, reason, detailReader, reliableMessagingVersion); 
                    }
                } 
            } 

            // Sender or receiver faults. 
            if (code.IsSenderFault || code.IsReceiverFault)
            {
                return new SequenceTerminatedFault(code, reason, detailReader, reliableMessagingVersion);
            } 

            return null; 
        } 

        protected override FaultCode Get11Code(FaultCode code, string subcode) 
        {
            return code;
        }
 
        protected override bool Get12HasDetail()
        { 
            return true; 
        }
 
        static void LookupDetailInformation(ReliableMessagingVersion reliableMessagingVersion, string subcode,
            out string detailName, out string detailNamespace)
        {
            detailName = null; 
            detailNamespace = null;
            string wsrmNs = WsrmIndex.GetNamespaceString(reliableMessagingVersion); 
            bool wsrmFeb2005 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005; 
            bool wsrm11 = reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11;
 
            if (subcode == WsrmFeb2005Strings.InvalidAcknowledgement)
            {
                detailName = WsrmFeb2005Strings.SequenceAcknowledgement;
                detailNamespace = wsrmNs; 
            }
            else if ((subcode == WsrmFeb2005Strings.MessageNumberRollover) 
                || (subcode == WsrmFeb2005Strings.SequenceTerminated) 
                || (subcode == WsrmFeb2005Strings.UnknownSequence)
                || (wsrmFeb2005 && (subcode == WsrmFeb2005Strings.LastMessageNumberExceeded)) 
                || (wsrm11 && (subcode == Wsrm11Strings.SequenceClosed)))
            {
                detailName = WsrmFeb2005Strings.Identifier;
                detailNamespace = wsrmNs; 
            }
            else 
            { 
                detailName = null;
                detailNamespace = null; 
            }
        }

        protected override void OnFaultMessageCreated(MessageVersion version, Message message) 
        {
            if (version.Envelope == EnvelopeVersion.Soap11) 
            { 
                WsrmSequenceFaultHeader header = new WsrmSequenceFaultHeader(this.GetReliableMessagingVersion(), this);
                message.Headers.Add(header); 
            }
        }

        protected override void OnWriteDetailContents(XmlDictionaryWriter writer) 
        {
            WsrmUtilities.WriteIdentifier(writer, this.GetReliableMessagingVersion(), this.sequenceID); 
        } 

        static UniqueId ParseDetail(XmlDictionaryReader reader, ReliableMessagingVersion reliableMessagingVersion) 
        {
            try
            {
                return WsrmUtilities.ReadIdentifier(reader, reliableMessagingVersion); 
            }
            finally 
            { 
                reader.Close();
            } 
        }

        public static bool TryCreateFault11(ReliableMessagingVersion reliableMessagingVersion, Message message,
            MessageFault fault, int index, out WsrmHeaderFault wsrmFault) 
        {
            if (index == -1) 
            { 
                wsrmFault = null;
                return false; 
            }

            // All wsrm header faults must be sender or receiver faults.
            if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault) 
            {
                wsrmFault = null; 
                return false; 
            }
 
            string subcodeName = WsrmSequenceFaultHeader.GetSubcode(message.Headers.GetReaderAtHeader(index),
                reliableMessagingVersion);

            if (subcodeName == null) 
            {
                wsrmFault = null; 
                return false; 
            }
 
            string detailName;
            string detailNamespace;

            LookupDetailInformation(reliableMessagingVersion, subcodeName, out detailName, out detailNamespace); 

            XmlDictionaryReader detailReader = WsrmSequenceFaultHeader.GetReaderAtDetailContents(detailName, 
                detailNamespace, message.Headers.GetReaderAtHeader(index), reliableMessagingVersion); 

            if (detailReader == null) 
            {
                wsrmFault = null;
                return false;
            } 

            wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason, 
                detailReader); 
            if (wsrmFault != null)
            { 
                message.Headers.UnderstoodHeaders.Add(message.Headers[index]);
                return true;
            }
            else 
            {
                return false; 
            } 
        }
 
        public static bool TryCreateFault12(ReliableMessagingVersion reliableMessagingVersion, Message message,
            MessageFault fault, out WsrmHeaderFault wsrmFault)
        {
            // All wsrm header faults must be sender or receiver faults. 
            if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault)
            { 
                wsrmFault = null; 
                return false;
            } 

            if ((fault.Code.SubCode == null)
                || (fault.Code.SubCode.Namespace != WsrmIndex.GetNamespaceString(reliableMessagingVersion)) || !fault.HasDetail)
            { 
                wsrmFault = null;
                return false; 
            } 

            string subcodeName = fault.Code.SubCode.Name; 
            XmlDictionaryReader detailReader = fault.GetReaderAtDetailContents();
            wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason,
                detailReader);
 
            return (wsrmFault != null);
        } 
    } 

    sealed class InvalidAcknowledgementFault : WsrmHeaderFault 
    {
        SequenceRangeCollection ranges;

        public InvalidAcknowledgementFault(UniqueId sequenceID, SequenceRangeCollection ranges) 
            : base(true, WsrmFeb2005Strings.InvalidAcknowledgement, SR.GetString(SR.InvalidAcknowledgementFaultReason),
            SR.GetString(SR.InvalidAcknowledgementReceived), sequenceID, true, false) 
        { 
            this.ranges = ranges;
        } 

        public InvalidAcknowledgementFault(FaultCode code, FaultReason reason,
            XmlDictionaryReader detailReader, ReliableMessagingVersion reliableMessagingVersion)
            : base(code, WsrmFeb2005Strings.InvalidAcknowledgement, reason, true, false) 
        {
            UniqueId sequenceId; 
            bool final; 

            WsrmAcknowledgmentInfo.ReadAck(reliableMessagingVersion, detailReader, out sequenceId, out this.ranges, 
                out final);

            this.SequenceID = sequenceId;
 
            while (detailReader.IsStartElement())
            { 
                detailReader.Skip(); 
            }
 
            detailReader.ReadEndElement();
        }

        protected override void OnWriteDetailContents(XmlDictionaryWriter writer) 
        {
            WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary; 
            ReliableMessagingVersion reliableMessagingVersion = this.GetReliableMessagingVersion(); 
            XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
 
            writer.WriteStartElement(wsrmFeb2005Dictionary.SequenceAcknowledgement, wsrmNs);
            WsrmAcknowledgmentHeader.WriteAckRanges(writer, reliableMessagingVersion, this.SequenceID, this.ranges);
            writer.WriteEndElement();
        } 
    }
 
    sealed class LastMessageNumberExceededFault : WsrmHeaderFault 
    {
        public LastMessageNumberExceededFault(UniqueId sequenceID) 
            : base(true, WsrmFeb2005Strings.LastMessageNumberExceeded, SR.GetString(SR.LastMessageNumberExceededFaultReason),
            SR.GetString(SR.LastMessageNumberExceeded), sequenceID, false, true)
        {
        } 

        public LastMessageNumberExceededFault(FaultCode code, FaultReason reason, 
            XmlDictionaryReader detailReader, ReliableMessagingVersion reliableMessagingVersion) 
            : base(code, WsrmFeb2005Strings.LastMessageNumberExceeded, reason, detailReader, reliableMessagingVersion, false,
            true) 
        {
        }
    }
 
    sealed class MessageNumberRolloverFault : WsrmHeaderFault
    { 
        public MessageNumberRolloverFault(UniqueId sequenceID) 
            : base(true, WsrmFeb2005Strings.MessageNumberRollover, SR.GetString(SR.MessageNumberRolloverFaultReason),
            SR.GetString(SR.MessageNumberRollover), sequenceID, true, true) 
        {
        }

        public MessageNumberRolloverFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader, 
            ReliableMessagingVersion reliableMessagingVersion)
            : base(code, WsrmFeb2005Strings.MessageNumberRollover, reason, true, true) 
        { 
            try
            { 
                this.SequenceID = WsrmUtilities.ReadIdentifier(detailReader, reliableMessagingVersion);

                if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
                { 
                    detailReader.ReadStartElement(DXD.Wsrm11Dictionary.MaxMessageNumber,
                        WsrmIndex.GetNamespace(reliableMessagingVersion)); 
 
                    string maxMessageNumberString = detailReader.ReadContentAsString();
                    ulong maxMessageNumber; 
                    if (!UInt64.TryParse(maxMessageNumberString, out maxMessageNumber)
                        || (maxMessageNumber <= 0))
                    {
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException( 
                            SR.GetString(SR.InvalidSequenceNumber, maxMessageNumber)));
                    } 
                    // otherwise ignore value 

                    detailReader.ReadEndElement(); 
                }
            }
            finally
            { 
                detailReader.Close();
            } 
        } 

        protected override void OnWriteDetailContents(XmlDictionaryWriter writer) 
        {
            ReliableMessagingVersion reliableMessagingVersion = this.GetReliableMessagingVersion();
            WsrmUtilities.WriteIdentifier(writer, reliableMessagingVersion, this.SequenceID);
 
            if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11)
            { 
                writer.WriteStartElement(WsrmFeb2005Strings.Prefix, DXD.Wsrm11Dictionary.MaxMessageNumber, 
                    WsrmIndex.GetNamespace(reliableMessagingVersion));
                writer.WriteValue(Int64.MaxValue); 
                writer.WriteEndElement();
            }
        }
    } 

    sealed class SequenceClosedFault : WsrmHeaderFault 
    { 
        public SequenceClosedFault(UniqueId sequenceID)
            : base(true, Wsrm11Strings.SequenceClosed, SR.GetString(SR.SequenceClosedFaultString), 
            null, sequenceID, false, true)
        {
        }
 
        public SequenceClosedFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
            ReliableMessagingVersion reliableMessagingVersion) 
            : base(code, Wsrm11Strings.SequenceClosed, reason, detailReader, reliableMessagingVersion, false, true) 
        {
        } 
    }

    sealed class SequenceTerminatedFault : WsrmHeaderFault
    { 
        SequenceTerminatedFault(bool isSenderFault, UniqueId sequenceID, string faultReason, string exceptionMessage)
            : base(isSenderFault, WsrmFeb2005Strings.SequenceTerminated, faultReason, exceptionMessage, sequenceID, true, true) 
        { 
        }
 
        public SequenceTerminatedFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
            ReliableMessagingVersion reliableMessagingVersion)
            : base(code, WsrmFeb2005Strings.SequenceTerminated, reason, detailReader, reliableMessagingVersion, true, true)
        { 
        }
 
        public static WsrmFault CreateCommunicationFault(UniqueId sequenceID, string faultReason, 
            string exceptionMessage)
        { 
            return new SequenceTerminatedFault(false, sequenceID, faultReason, exceptionMessage);
        }

        public static WsrmFault CreateMaxRetryCountExceededFault(UniqueId sequenceId) 
        {
            return CreateCommunicationFault(sequenceId, SR.GetString(SR.SequenceTerminatedMaximumRetryCountExceeded), null); 
        } 

        public static WsrmFault CreateProtocolFault(UniqueId sequenceID, string faultReason, 
            string exceptionMessage)
        {
            return new SequenceTerminatedFault(true, sequenceID, faultReason, exceptionMessage);
        } 

        public static WsrmFault CreateQuotaExceededFault(UniqueId sequenceID) 
        { 
            return CreateProtocolFault(sequenceID, SR.GetString(SR.SequenceTerminatedQuotaExceededException), null);
        } 
    }

    sealed class UnknownSequenceFault : WsrmHeaderFault
    { 
        public UnknownSequenceFault(UniqueId sequenceID)
            : base(true, WsrmFeb2005Strings.UnknownSequence, SR.GetString(SR.UnknownSequenceFaultReason), 
            SR.GetString(SR.UnknownSequenceMessageReceived), sequenceID, true, true) 
        {
        } 

        public UnknownSequenceFault(FaultCode code, FaultReason reason, XmlDictionaryReader detailReader,
            ReliableMessagingVersion reliableMessagingVersion)
            : base(code, WsrmFeb2005Strings.UnknownSequence, reason, detailReader, reliableMessagingVersion, true, true) 
        {
        } 
 
        public override CommunicationException CreateException()
        { 
            string message;

            if (this.IsRemote)
            { 
                message = FaultException.GetSafeReasonText(this.Reason);
                message = SR.GetString(SR.UnknownSequenceFaultReceived, message); 
            } 
            else
            { 
                message = this.GetExceptionMessage();
            }

            return new CommunicationException(message); 
        }
    } 
 
    class WsrmSequenceFaultHeader : WsrmMessageHeader
    { 
        WsrmFault fault;

        public WsrmSequenceFaultHeader(ReliableMessagingVersion reliableMessagingVersion, WsrmFault fault)
            : base(reliableMessagingVersion) 
        {
            this.fault = fault; 
        } 

        public WsrmFault Fault 
        {
            get
            {
                return this.fault; 
            }
        } 
 
        public override XmlDictionaryString DictionaryName
        { 
            get
            {
                return XD.WsrmFeb2005Dictionary.SequenceFault;
            } 
        }
 
        public string Subcode 
        {
            get 
            {
                return this.fault.Subcode;
            }
        } 

        public static XmlDictionaryReader GetReaderAtDetailContents(string detailName, string detailNamespace, 
            XmlDictionaryReader headerReader, ReliableMessagingVersion reliableMessagingVersion) 
        {
            if (reliableMessagingVersion == ReliableMessagingVersion.WSReliableMessagingFebruary2005) 
            {
                return GetReaderAtDetailContentsFeb2005(detailName, detailNamespace, headerReader);
            }
            else 
            {
                return GetReaderAtDetailContents11(detailName, detailNamespace, headerReader); 
            } 
        }
 
        public static XmlDictionaryReader GetReaderAtDetailContents11(string detailName, string detailNamespace,
            XmlDictionaryReader headerReader)
        {
            XmlDictionaryString wsrmNs = DXD.Wsrm11Dictionary.Namespace; 
            headerReader.ReadFullStartElement(XD.WsrmFeb2005Dictionary.SequenceFault, wsrmNs);
            headerReader.Skip(); 
            headerReader.ReadFullStartElement(XD.Message12Dictionary.FaultDetail, wsrmNs); 

            if ((headerReader.NodeType != XmlNodeType.Element) 
                || (headerReader.NamespaceURI != detailNamespace)
                || (headerReader.LocalName != detailName))
            {
                headerReader.Close(); 
                return null;
            } 
 
            return headerReader;
        } 

        public static XmlDictionaryReader GetReaderAtDetailContentsFeb2005(string detailName, string detailNamespace,
            XmlDictionaryReader headerReader)
        { 
            try
            { 
                WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary; 
                XmlDictionaryString wsrmNs = wsrmFeb2005Dictionary.Namespace;
                XmlBuffer buffer = null; 
                int index = 0;
                int depth = headerReader.Depth;
                headerReader.ReadFullStartElement(wsrmFeb2005Dictionary.SequenceFault, wsrmNs);
 
                while (headerReader.Depth > depth)
                { 
                    if ((headerReader.NodeType == XmlNodeType.Element) 
                        && (headerReader.NamespaceURI == detailNamespace)
                        && (headerReader.LocalName == detailName)) 
                    {
                        if (buffer != null)
                        {
                            return null; 
                        }
 
                        buffer = new XmlBuffer(int.MaxValue); 

                        try 
                        {
                            index = buffer.SectionCount;
                            XmlDictionaryWriter writer = buffer.OpenSection(headerReader.Quotas);
                            // WriteNode moves the reader to the next sibling. 
                            writer.WriteNode(headerReader, false);
                        } 
                        finally 
                        {
                            buffer.CloseSection(); 
                        }
                    }
                    else
                    { 
                        if (headerReader.Depth == depth)
                            break; 
 
                        headerReader.Read();
                    } 
                }

                // Ensure at least one detail is found;
                if (buffer == null) 
                {
                    return null; 
                } 

                // Close causes a state change.  It moves the buffer from Created to Reading. 
                buffer.Close();
                XmlDictionaryReader detailReader = buffer.GetReader(index);
                return detailReader;
            } 
            finally
            { 
                headerReader.Close(); 
            }
        } 

        public static string GetSubcode(XmlDictionaryReader headerReader,
            ReliableMessagingVersion reliableMessagingVersion)
        { 
            string subCode = null;
 
            try 
            {
                WsrmFeb2005Dictionary wsrmFeb2005Dictionary = XD.WsrmFeb2005Dictionary; 
                XmlDictionaryString wsrmNs = WsrmIndex.GetNamespace(reliableMessagingVersion);
                string ns;

                headerReader.ReadStartElement(wsrmFeb2005Dictionary.SequenceFault, wsrmNs); 
                headerReader.ReadStartElement(wsrmFeb2005Dictionary.FaultCode, wsrmNs);
                XmlUtil.ReadContentAsQName(headerReader, out subCode, out ns); 
 
                if (ns != WsrmIndex.GetNamespaceString(reliableMessagingVersion))
                    subCode = null; 

                headerReader.ReadEndElement();

                while (headerReader.IsStartElement()) 
                    headerReader.Skip();
 
                headerReader.ReadEndElement(); 
            }
            finally 
            {
                headerReader.Close();
            }
 
            return subCode;
        } 
 
        protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
        { 
            writer.WriteStartElement(WsrmFeb2005Strings.Prefix, WsrmFeb2005Strings.FaultCode, this.Namespace);
            writer.WriteXmlnsAttribute(null, this.Namespace);
            writer.WriteQualifiedName(this.Subcode, this.Namespace);
            writer.WriteEndElement(); 

            bool wsrm11 = this.ReliableMessagingVersion == ReliableMessagingVersion.WSReliableMessaging11; 
 
            if (wsrm11)
            { 
                writer.WriteStartElement(WsrmFeb2005Strings.Prefix, XD.Message12Dictionary.FaultDetail, this.DictionaryNamespace);
            }

            this.fault.WriteDetail(writer); 

            if (wsrm11) 
            { 
                writer.WriteEndElement();
            } 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK