ContractReference.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Services / Web / System / Web / Services / Discovery / ContractReference.cs / 1305376 / ContractReference.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.Services.Discovery { 
 
    using System;
    using System.Net; 
    using System.Xml.Serialization;
    using System.Web.Services.Description;
    using System.IO;
    using System.Xml; 
    using System.Xml.Schema;
    using System.Web.Services.Protocols; 
    using System.Text; 
    using System.Collections;
    using System.Threading; 
    using System.Diagnostics;
    using System.Web.Services.Diagnostics;

    ///  
    /// 
    ///    [To be supplied.] 
    ///  
    [XmlRoot("contractRef", Namespace=ContractReference.Namespace)]
    public class ContractReference : DiscoveryReference { 

        /// 
        /// 
        ///    [To be supplied.] 
        /// 
        public const string Namespace = "http://schemas.xmlsoap.org/disco/scl/"; 
 
        private string docRef;
        private string reference; 

        /// 
        /// 
        ///    [To be supplied.] 
        /// 
        public ContractReference() { 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        public ContractReference(string href) { 
            Ref = href;
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        public ContractReference(string href, string docRef) {
            Ref = href; 
            DocRef = docRef;
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        [XmlAttribute("ref")]
        public string Ref { 
            get {
                return reference; 
            } 
            set {
                reference = value; 
            }
        }

        ///  
        /// 
        ///    [To be supplied.] 
        ///  
        [XmlAttribute("docRef")]
        public string DocRef { 
            get {
                return docRef;
            }
            set { 
                docRef = value;
            } 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        [XmlIgnore] 
        public override string Url {
            get { 
                return Ref; 
            }
            set { 
                Ref = value;
            }
        }
 
        internal override void LoadExternals(Hashtable loadedExternals) {
            ServiceDescription contract = null; 
 
            try {
                contract = Contract; 
            }
            catch (Exception e) {
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                    throw; 
                }
                // don't let the exception out - keep going. Just add it to the list of errors. 
                ClientProtocol.Errors[Url] = e; 
                if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "LoadExternals", e);
            } 
            if (contract != null) {
                foreach (XmlSchema schema in Contract.Types.Schemas) {
                    SchemaReference.LoadExternals(schema, Url, ClientProtocol, loadedExternals);
                } 
            }
        } 
 
        /// 
        ///  
        ///    [To be supplied.]
        /// 
        [XmlIgnore]
        public ServiceDescription Contract { 
            get {
                if (ClientProtocol == null) 
                    throw new InvalidOperationException(Res.GetString(Res.WebMissingClientProtocol)); 
                object document = ClientProtocol.Documents[Url];
                if (document == null) { 
                    Resolve();
                    document = ClientProtocol.Documents[Url];
                }
                ServiceDescription contract = document as ServiceDescription; 
                if (contract == null) {
                    throw new InvalidOperationException(Res.GetString(Res.WebInvalidDocType, 
                                                      typeof(ServiceDescription).FullName, 
                                                      document == null ? string.Empty: document.GetType().FullName,
                                                      Url)); 
                }
                return contract;
            }
        } 

        ///  
        ///  
        ///    [To be supplied.]
        ///  
        [XmlIgnore]
        public override string DefaultFilename {
            get {
                string fileName = MakeValidFilename(Contract.Name); 
                if (fileName == null || fileName.Length == 0)
                    fileName = FilenameFromUrl(Url); 
                return Path.ChangeExtension(fileName, ".wsdl"); 
            }
        } 

        /// 
        /// 
        ///    [To be supplied.] 
        /// 
        public override void WriteDocument(object document, Stream stream) { 
            ((ServiceDescription) document).Write(new StreamWriter(stream, new UTF8Encoding(false))); 
        }
 
        /// 
        /// 
        ///    [To be supplied.]
        ///  
        public override object ReadDocument(Stream stream) {
            return ServiceDescription.Read(stream, true); 
        } 

        ///  
        /// 
        ///    [To be supplied.]
        /// 
        protected internal override void Resolve(string contentType, Stream stream) { 
            if (ContentType.IsHtml(contentType))
                throw new InvalidContentTypeException(Res.GetString(Res.WebInvalidContentType, contentType), contentType); 
            ServiceDescription serviceDescription = ClientProtocol.Documents[Url] as ServiceDescription; 
            if( serviceDescription == null ) {
                serviceDescription = ServiceDescription.Read(stream, true); 
                serviceDescription.RetrievalUrl = Url;
                ClientProtocol.Documents[Url] = serviceDescription;
            }
 
            ClientProtocol.References[Url] = this;
 
            ArrayList importUrls = new ArrayList(); 
            foreach (Import import in serviceDescription.Imports)
                if (import.Location != null) 
                    importUrls.Add(import.Location);
            foreach (XmlSchema schema in serviceDescription.Types.Schemas) {
                foreach (XmlSchemaExternal external in schema.Includes) {
                    if (external.SchemaLocation != null && external.SchemaLocation.Length > 0) { 
                        importUrls.Add(external.SchemaLocation);
                    } 
                } 
            }
 
            foreach (string urlFromImport in importUrls) {
                // make the (possibly) relative Uri in the contract fully qualified with respect to the contract URL
                string importUrl = UriToString(Url, urlFromImport);
                if( ClientProtocol.Documents[importUrl] != null ) { 
                    continue;
                } 
 
                string oldUrl = importUrl;
                try { 
                    stream = ClientProtocol.Download(ref importUrl, ref contentType);
                    try {
                        //Proceed only if not been here before
                        if( ClientProtocol.Documents[importUrl] == null ) { 
                            XmlTextReader reader = new XmlTextReader(new StreamReader(stream, RequestResponseUtils.GetEncoding(contentType)));
                            reader.WhitespaceHandling = WhitespaceHandling.Significant; 
                            reader.XmlResolver = null; 
                            reader.DtdProcessing = DtdProcessing.Prohibit;
                            //Resolve on WSDL and XSD will go recursivelly 
                            if (ServiceDescription.CanRead(reader)) {
                                ServiceDescription doc = ServiceDescription.Read(reader, true);
                                doc.RetrievalUrl = importUrl;
                                ClientProtocol.Documents[importUrl] = doc; 
                                ContractReference contractReference = new ContractReference(importUrl, null);
                                contractReference.ClientProtocol = ClientProtocol; 
                                try { 
                                    contractReference.Resolve(contentType, stream);
                                } 
                                catch (Exception e) {
                                    if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                                        throw;
                                    } 
                                    contractReference.Url = oldUrl;
                                    if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "Resolve", e); 
                                } 
                            }
                            else if (reader.IsStartElement("schema", XmlSchema.Namespace)) { 
                                ClientProtocol.Documents[importUrl] = XmlSchema.Read(reader, null);
                                SchemaReference schemaReference = new SchemaReference(importUrl);
                                schemaReference.ClientProtocol = ClientProtocol;
                                try { 
                                    schemaReference.Resolve(contentType, stream);
                                } 
                                catch (Exception e) { 
                                    if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                                        throw; 
                                    }
                                    schemaReference.Url = oldUrl;
                                    if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "Resolve", e);
                                } 
                            }
                            // If it's not XML, or we don't know what kind of XML it is, skip the file.  The user 
                            // will have to download the dependent file(s) manually, but at least we will continue 
                            // to discover files instead of throwing an exception.
                        } 
                    }
                    finally {
                        stream.Close();
                    } 
                }
                catch (Exception e) { 
                    if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { 
                        throw;
                    } 
                    throw new InvalidDocumentContentsException(Res.GetString(Res.TheWSDLDocumentContainsLinksThatCouldNotBeResolved, importUrl), e);
                }
            }
        } 
    }
} 

// 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
ContractReference.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
