WebReferenceOptions.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 / Services / Web / System / Web / Services / Description / WebReferenceOptions.cs / 1305376 / WebReferenceOptions.cs
                        

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

namespace System.Web.Services.Description { 
    using System; 
    using System.Globalization;
    using System.IO; 
    using System.ComponentModel;
    using System.Xml;
    using System.Xml.Schema;
    using System.Xml.Serialization; 
    using System.Collections;
    using System.Collections.Specialized; 
 
    /// 
    ///  
    ///    [To be supplied.]
    /// 
    [XmlType("webReferenceOptions", Namespace=WebReferenceOptions.TargetNamespace)]
    [XmlRoot("webReferenceOptions", Namespace=WebReferenceOptions.TargetNamespace)] 
    public class WebReferenceOptions {
        public const string TargetNamespace = "http://microsoft.com/webReference/"; 
        static XmlSchema schema = null; 
        CodeGenerationOptions codeGenerationOptions = CodeGenerationOptions.GenerateOldAsync;
        ServiceDescriptionImportStyle style = ServiceDescriptionImportStyle.Client; 
        StringCollection schemaImporterExtensions;
        bool verbose;

        ///  
        /// 
        ///    [To be supplied.] 
        ///  
        [XmlElement("codeGenerationOptions")]
        [DefaultValue(CodeGenerationOptions.GenerateOldAsync)] 
        public CodeGenerationOptions CodeGenerationOptions {
            get {
                return codeGenerationOptions;
            } 
            set {
                codeGenerationOptions = value; 
            } 
        }
 
        /// 
        /// 
        ///    [To be supplied.]
        ///  
        [XmlArray("schemaImporterExtensions")]
        [XmlArrayItem("type")] 
        public StringCollection SchemaImporterExtensions { 
            get {
                if (schemaImporterExtensions == null) 
                    schemaImporterExtensions = new StringCollection();
                return schemaImporterExtensions;
            }
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [DefaultValue(ServiceDescriptionImportStyle.Client)]
        [XmlElement("style")]
        public ServiceDescriptionImportStyle Style {
            get { 
                return style;
            } 
            set { 
                style = value;
            } 
        }

        /// 
        ///  
        ///    [To be supplied.]
        ///  
        [XmlElement("verbose")] 
        public bool Verbose {
            get { 
                return verbose;
            }
            set {
                verbose = value; 
            }
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        public static XmlSchema Schema {
            get { 
                if (schema == null) {
                    schema = XmlSchema.Read(new StringReader(Schemas.WebRef), null); 
                } 
                return schema;
            } 
        }

        /// 
        ///  
        ///    [To be supplied.]
        ///  
        public static WebReferenceOptions Read(TextReader reader, ValidationEventHandler validationEventHandler) { 
            XmlTextReader readerNew = new XmlTextReader(reader);
            readerNew.XmlResolver = null; 
            readerNew.DtdProcessing = DtdProcessing.Prohibit;
            return Read(readerNew, validationEventHandler);
        }
 
        /// 
        ///  
        ///    [To be supplied.] 
        /// 
        public static WebReferenceOptions Read(Stream stream, ValidationEventHandler validationEventHandler) { 
            XmlTextReader readerNew = new XmlTextReader(stream);
            readerNew.XmlResolver = null;
            readerNew.DtdProcessing = DtdProcessing.Prohibit;
            return Read(readerNew, validationEventHandler); 
        }
 
        ///  
        /// 
        ///    [To be supplied.] 
        /// 
        public static WebReferenceOptions Read(XmlReader xmlReader, ValidationEventHandler validationEventHandler) {
            XmlValidatingReader validatingReader = new XmlValidatingReader(xmlReader);
            validatingReader.ValidationType = ValidationType.Schema; 
            if (validationEventHandler != null) {
                validatingReader.ValidationEventHandler += validationEventHandler; 
            } 
            else {
                validatingReader.ValidationEventHandler += new ValidationEventHandler(SchemaValidationHandler); 
            }
            validatingReader.Schemas.Add(Schema);
            webReferenceOptionsSerializer ser = new webReferenceOptionsSerializer();
            try { 
                return (WebReferenceOptions)ser.Deserialize(validatingReader);
            } 
            catch (Exception e) { 
                throw e;
            } 
            finally {
                validatingReader.Close();
            }
        } 

        private static void SchemaValidationHandler(object sender, ValidationEventArgs args) { 
            if (args.Severity != XmlSeverityType.Error) 
                return;
            throw new InvalidOperationException(Res.GetString(Res.WsdlInstanceValidationDetails, args.Message, args.Exception.LineNumber.ToString(CultureInfo.InvariantCulture), args.Exception.LinePosition.ToString(CultureInfo.InvariantCulture))); 
        }
    }

    internal class WebReferenceOptionsSerializationWriter : XmlSerializationWriter { 
        string Write1_CodeGenerationOptions(System.Xml.Serialization.CodeGenerationOptions v) {
            string s = null; 
            switch (v) { 
                case System.Xml.Serialization.CodeGenerationOptions.@GenerateProperties: s = @"properties"; break;
                case System.Xml.Serialization.CodeGenerationOptions.@GenerateNewAsync: s = @"newAsync"; break; 
                case System.Xml.Serialization.CodeGenerationOptions.@GenerateOldAsync: s = @"oldAsync"; break;
                case System.Xml.Serialization.CodeGenerationOptions.@GenerateOrder: s = @"order"; break;
                case System.Xml.Serialization.CodeGenerationOptions.@EnableDataBinding: s = @"enableDataBinding"; break;
                default: s = FromEnum(((System.Int64)v), new string[] {@"properties", 
                    @"newAsync",
                    @"oldAsync", 
                    @"order", 
                    @"enableDataBinding"}, new System.Int64[] {(long)System.Xml.Serialization.CodeGenerationOptions.@GenerateProperties,
                    (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateNewAsync, 
                    (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOldAsync,
                    (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOrder,
                    (long)System.Xml.Serialization.CodeGenerationOptions.@EnableDataBinding}, @"System.Xml.Serialization.CodeGenerationOptions"); break;
            } 
            return s;
        } 
 
        string Write2_ServiceDescriptionImportStyle(System.Web.Services.Description.ServiceDescriptionImportStyle v) {
            string s = null; 
            switch (v) {
                case System.Web.Services.Description.ServiceDescriptionImportStyle.@Client: s = @"client"; break;
                case System.Web.Services.Description.ServiceDescriptionImportStyle.@Server: s = @"server"; break;
                case System.Web.Services.Description.ServiceDescriptionImportStyle.@ServerInterface: s = @"serverInterface"; break; 
                default: throw CreateInvalidEnumValueException(((System.Int64)v).ToString(System.Globalization.CultureInfo.InvariantCulture), @"System.Web.Services.Description.ServiceDescriptionImportStyle");
            } 
            return s; 
        }
 
        void Write4_WebReferenceOptions(string n, string ns, WebReferenceOptions o, bool isNullable, bool needType) {
            if ((object)o == null) {
                if (isNullable) WriteNullTagLiteral(n, ns);
                return; 
            }
            if (!needType) { 
                System.Type t = o.GetType(); 
                if (t == typeof(WebReferenceOptions)) {
                } 
                else {
                    throw CreateUnknownTypeException(o);
                }
            } 
            EscapeName = false;
            WriteStartElement(n, ns, o); 
            if (needType) WriteXsiType(@"webReferenceOptions", @"http://microsoft.com/webReference/"); 
            if (((CodeGenerationOptions)o.@CodeGenerationOptions) != (CodeGenerationOptions.@GenerateOldAsync)) {
                WriteElementString(@"codeGenerationOptions", @"http://microsoft.com/webReference/", Write1_CodeGenerationOptions(((CodeGenerationOptions)o.@CodeGenerationOptions))); 
            } {
                System.Collections.Specialized.StringCollection a = (System.Collections.Specialized.StringCollection)((System.Collections.Specialized.StringCollection)o.@SchemaImporterExtensions);
                if (a != null){
                    WriteStartElement(@"schemaImporterExtensions", @"http://microsoft.com/webReference/"); 
                    for (int ia = 0; ia < a.Count; ia++) {
                        WriteNullableStringLiteral(@"type", @"http://microsoft.com/webReference/", ((System.String)a[ia])); 
                    } 
                    WriteEndElement();
                } 
            }
            if (((System.Web.Services.Description.ServiceDescriptionImportStyle)o.@Style) != System.Web.Services.Description.ServiceDescriptionImportStyle.@Client) {
                WriteElementString(@"style", @"http://microsoft.com/webReference/", Write2_ServiceDescriptionImportStyle(((System.Web.Services.Description.ServiceDescriptionImportStyle)o.@Style)));
            } 
            WriteElementStringRaw(@"verbose", @"http://microsoft.com/webReference/", System.Xml.XmlConvert.ToString((System.Boolean)((System.Boolean)o.@Verbose)));
            WriteEndElement(o); 
        } 

        protected override void InitCallbacks() { 
        }

        internal void Write5_webReferenceOptions(object o) {
            WriteStartDocument(); 
            if (o == null) {
                WriteNullTagLiteral(@"webReferenceOptions", @"http://microsoft.com/webReference/"); 
                return; 
            }
            TopLevelElement(); 
            Write4_WebReferenceOptions(@"webReferenceOptions", @"http://microsoft.com/webReference/", ((System.Web.Services.Description.WebReferenceOptions)o), true, false);
        }
    }
 
    internal class WebReferenceOptionsSerializationReader : XmlSerializationReader {
        System.Collections.Hashtable _CodeGenerationOptionsValues; 
 
        internal System.Collections.Hashtable CodeGenerationOptionsValues {
            get { 
                if ((object)_CodeGenerationOptionsValues == null) {
                    System.Collections.Hashtable h = new System.Collections.Hashtable();
                    h.Add(@"properties", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateProperties);
                    h.Add(@"newAsync", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateNewAsync); 
                    h.Add(@"oldAsync", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOldAsync);
                    h.Add(@"order", (long)System.Xml.Serialization.CodeGenerationOptions.@GenerateOrder); 
                    h.Add(@"enableDataBinding", (long)System.Xml.Serialization.CodeGenerationOptions.@EnableDataBinding); 
                    _CodeGenerationOptionsValues = h;
                } 
                return _CodeGenerationOptionsValues;
            }
        }
 
        System.Xml.Serialization.CodeGenerationOptions Read1_CodeGenerationOptions(string s) {
            return (System.Xml.Serialization.CodeGenerationOptions)ToEnum(s, CodeGenerationOptionsValues, @"System.Xml.Serialization.CodeGenerationOptions"); 
        } 

        System.Web.Services.Description.ServiceDescriptionImportStyle Read2_ServiceDescriptionImportStyle(string s) { 
            switch (s) {
                case @"client": return System.Web.Services.Description.ServiceDescriptionImportStyle.@Client;
                case @"server": return System.Web.Services.Description.ServiceDescriptionImportStyle.@Server;
                case @"serverInterface": return System.Web.Services.Description.ServiceDescriptionImportStyle.@ServerInterface; 
                default: throw CreateUnknownConstantException(s, typeof(System.Web.Services.Description.ServiceDescriptionImportStyle));
            } 
        } 

        System.Web.Services.Description.WebReferenceOptions Read4_WebReferenceOptions(bool isNullable, bool checkType) { 
            System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null;
            bool isNull = false;
            if (isNullable) isNull = ReadNull();
            if (checkType) { 
            if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id1_webReferenceOptions && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) {
            } 
            else 
                throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType);
            } 
            if (isNull) return null;
            System.Web.Services.Description.WebReferenceOptions o;
            o = new System.Web.Services.Description.WebReferenceOptions();
            System.Collections.Specialized.StringCollection a_1 = (System.Collections.Specialized.StringCollection)o.@SchemaImporterExtensions; 
            bool[] paramsRead = new bool[4];
            while (Reader.MoveToNextAttribute()) { 
                if (!IsXmlnsAttribute(Reader.Name)) { 
                    UnknownNode((object)o);
                } 
            }
            Reader.MoveToElement();
            if (Reader.IsEmptyElement) {
                Reader.Skip(); 
                return o;
            } 
            Reader.ReadStartElement(); 
            Reader.MoveToContent();
            int whileIterations0 = 0; 
            int readerCount0 = ReaderCount;
            while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) {
                if (Reader.NodeType == System.Xml.XmlNodeType.Element) {
                    if (!paramsRead[0] && ((object) Reader.LocalName == (object)id3_codeGenerationOptions && (object) Reader.NamespaceURI == (object)id2_Item)) { 
                        if (Reader.IsEmptyElement) {
                            Reader.Skip(); 
                        } 
                        else {
                            o.@CodeGenerationOptions = Read1_CodeGenerationOptions(Reader.ReadElementString()); 
                        }
                        paramsRead[0] = true;
                    }
                    else if (((object) Reader.LocalName == (object)id4_schemaImporterExtensions && (object) Reader.NamespaceURI == (object)id2_Item)) { 
                        if (!ReadNull()) {
                            System.Collections.Specialized.StringCollection a_1_0 = (System.Collections.Specialized.StringCollection)o.@SchemaImporterExtensions; 
                            if (((object)(a_1_0) == null) || (Reader.IsEmptyElement)) { 
                                Reader.Skip();
                            } 
                            else {
                                Reader.ReadStartElement();
                                Reader.MoveToContent();
                                int whileIterations1 = 0; 
                                int readerCount1 = ReaderCount;
                                while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 
                                    if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 
                                        if (((object) Reader.LocalName == (object)id5_type && (object) Reader.NamespaceURI == (object)id2_Item)) {
                                            if (ReadNull()) { 
                                                a_1_0.Add(null);
                                            }
                                            else {
                                                a_1_0.Add(Reader.ReadElementString()); 
                                            }
                                        } 
                                        else { 
                                            UnknownNode(null, @"http://microsoft.com/webReference/:type");
                                        } 
                                    }
                                    else {
                                        UnknownNode(null, @"http://microsoft.com/webReference/:type");
                                    } 
                                    Reader.MoveToContent();
                                    CheckReaderCount(ref whileIterations1, ref readerCount1); 
                                } 
                            ReadEndElement();
                            } 
                        }
                    }
                    else if (!paramsRead[2] && ((object) Reader.LocalName == (object)id6_style && (object) Reader.NamespaceURI == (object)id2_Item)) {
                        if (Reader.IsEmptyElement) { 
                            Reader.Skip();
                        } 
                        else { 
                            o.@Style = Read2_ServiceDescriptionImportStyle(Reader.ReadElementString());
                        } 
                        paramsRead[2] = true;
                    }
                    else if (!paramsRead[3] && ((object) Reader.LocalName == (object)id7_verbose && (object) Reader.NamespaceURI == (object)id2_Item)) {
                        { 
                            o.@Verbose = System.Xml.XmlConvert.ToBoolean(Reader.ReadElementString());
                        } 
                        paramsRead[3] = true; 
                    }
                    else { 
                        UnknownNode((object)o, @"http://microsoft.com/webReference/:codeGenerationOptions, http://microsoft.com/webReference/:schemaImporterExtensions, http://microsoft.com/webReference/:style, http://microsoft.com/webReference/:verbose");
                    }
                }
                else { 
                    UnknownNode((object)o, @"http://microsoft.com/webReference/:codeGenerationOptions, http://microsoft.com/webReference/:schemaImporterExtensions, http://microsoft.com/webReference/:style, http://microsoft.com/webReference/:verbose");
                } 
                Reader.MoveToContent(); 
                CheckReaderCount(ref whileIterations0, ref readerCount0);
            } 
            ReadEndElement();
            return o;
        }
 
        protected override void InitCallbacks() {
        } 
 
        internal object Read5_webReferenceOptions() {
            object o = null; 
            Reader.MoveToContent();
            if (Reader.NodeType == System.Xml.XmlNodeType.Element) {
                if (((object) Reader.LocalName == (object)id1_webReferenceOptions && (object) Reader.NamespaceURI == (object)id2_Item)) {
                    o = Read4_WebReferenceOptions(true, true); 
                }
                else { 
                    throw CreateUnknownNodeException(); 
                }
            } 
            else {
                UnknownNode(null, @"http://microsoft.com/webReference/:webReferenceOptions");
            }
            return (object)o; 
        }
 
        string id2_Item; 
        string id5_type;
        string id4_schemaImporterExtensions; 
        string id3_codeGenerationOptions;
        string id6_style;
        string id7_verbose;
        string id1_webReferenceOptions; 

        protected override void InitIDs() { 
            id2_Item = Reader.NameTable.Add(@"http://microsoft.com/webReference/"); 
            id5_type = Reader.NameTable.Add(@"type");
            id4_schemaImporterExtensions = Reader.NameTable.Add(@"schemaImporterExtensions"); 
            id3_codeGenerationOptions = Reader.NameTable.Add(@"codeGenerationOptions");
            id6_style = Reader.NameTable.Add(@"style");
            id7_verbose = Reader.NameTable.Add(@"verbose");
            id1_webReferenceOptions = Reader.NameTable.Add(@"webReferenceOptions"); 
        }
    } 
 
    internal sealed class webReferenceOptionsSerializer : XmlSerializer {
        protected override XmlSerializationReader CreateReader() { 
            return new WebReferenceOptionsSerializationReader();
        }
        protected override XmlSerializationWriter CreateWriter() {
            return new WebReferenceOptionsSerializationWriter(); 
        }
        public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { 
            return true; 
        }
 
        protected override void Serialize(System.Object objectToSerialize, XmlSerializationWriter writer) {
            ((WebReferenceOptionsSerializationWriter)writer).Write5_webReferenceOptions(objectToSerialize);
        }
        protected override System.Object Deserialize(XmlSerializationReader reader) { 
            return ((WebReferenceOptionsSerializationReader)reader).Read5_webReferenceOptions();
        } 
    } 
}

// 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