XmlAtomErrorReader.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWeb / Client / System / Data / Services / Client / Xml / XmlAtomErrorReader.cs / 1407647 / XmlAtomErrorReader.cs
                        

                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//  
//      Provides a wrapping XmlReader that can detect in-line errors.
//  
// 
// @owner  [....]
//--------------------------------------------------------------------- 

namespace System.Data.Services.Client.Xml
{
    #region Namespaces. 

    using System.Diagnostics; 
    using System.Xml; 

    #endregion Namespaces. 

    /// Use this class to wrap an existing .
    [DebuggerDisplay("XmlAtomErrorReader {NodeType} {Name} {Value}")]
    internal class XmlAtomErrorReader : XmlWrappingReader 
    {
        /// Initializes a new  instance. 
        /// Reader to wrap. 
        internal XmlAtomErrorReader(XmlReader baseReader) : base(baseReader)
        { 
            Debug.Assert(baseReader != null, "baseReader != null");
            this.Reader = baseReader;
        }
 
        #region Methods.
 
        /// Reads the next node from the stream. 
        /// true if the next node was read successfully; false if there are no more nodes to read.
        public override bool Read() 
        {
            bool result = base.Read();

            if (this.NodeType == XmlNodeType.Element && 
                Util.AreSame(this.Reader, XmlConstants.XmlErrorElementName, XmlConstants.DataWebMetadataNamespace))
            { 
                string message = ReadErrorMessage(this.Reader); 

                // In case of instream errors, the status code should be 500 (which is the default) 
                throw new DataServiceClientException(Strings.Deserialize_ServerException(message));
            }

            return result; 
        }
 
        /// Reads an element string from the specified . 
        /// Reader to get value from.
        /// Whether a null attribute marker should be checked on the element. 
        /// The text value within the element, possibly null.
        /// 
        /// Simple values only are expected - mixed content will throw an error.
        /// Interspersed comments are ignored. 
        /// 
        internal static string ReadElementString(XmlReader reader, bool checkNullAttribute) 
        { 
            Debug.Assert(reader != null, "reader != null");
            Debug.Assert(XmlNodeType.Element == reader.NodeType, "not positioned on Element"); 

            string result = null;
            bool empty = checkNullAttribute && !Util.DoesNullAttributeSayTrue(reader);
 
            if (reader.IsEmptyElement)
            { 
                return (empty ? String.Empty : null); 
            }
 
            while (reader.Read())
            {
                switch (reader.NodeType)
                { 
                    case XmlNodeType.EndElement:
                        return result ?? (empty ? String.Empty : null); 
                    case XmlNodeType.CDATA: 
                    case XmlNodeType.Text:
                    case XmlNodeType.SignificantWhitespace: 
                        if (null != result)
                        {
                            throw Error.InvalidOperation(Strings.Deserialize_MixedTextWithComment);
                        } 

                        result = reader.Value; 
                        break; 
                    case XmlNodeType.Comment:
                    case XmlNodeType.Whitespace: 
                        break;
                    case XmlNodeType.Element:
                    default:
                        throw Error.InvalidOperation(Strings.Deserialize_ExpectingSimpleValue); 
                }
            } 
 
            // xml ended before EndElement?
            throw Error.InvalidOperation(Strings.Deserialize_ExpectingSimpleValue); 
        }

        /// With the reader positioned on an 'error' element, reads the text of the 'message' child.
        ///  from which to read a WCF Data Service inline error message. 
        /// The text of the 'message' child element, empty if not found.
        private static string ReadErrorMessage(XmlReader reader) 
        { 
            Debug.Assert(reader != null, "reader != null");
            Debug.Assert(reader.NodeType == XmlNodeType.Element, "reader.NodeType == XmlNodeType.Element"); 
            Debug.Assert(reader.LocalName == XmlConstants.XmlErrorElementName, "reader.LocalName == XmlConstants.XmlErrorElementName");

            int depth = 1;
            while (depth > 0 && reader.Read()) 
            {
                if (reader.NodeType == XmlNodeType.Element) 
                { 
                    if (!reader.IsEmptyElement)
                    { 
                        depth++;
                    }

                    if (depth == 2 && 
                        Util.AreSame(reader, XmlConstants.XmlErrorMessageElementName, XmlConstants.DataWebMetadataNamespace))
                    { 
                        return ReadElementString(reader, false); 
                    }
                } 
                else if (reader.NodeType == XmlNodeType.EndElement)
                {
                    depth--;
                } 
            }
 
            return String.Empty; 
        }
 
        #endregion Methods.
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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