XmlDownloadManager.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / XmlDownloadManager.cs / 1305376 / XmlDownloadManager.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml { 

    using System; 
    using System.IO;
    using System.Security;
    using System.Collections;
    using System.Net; 
    using System.Net.Cache;
    using System.Runtime.Versioning; 
 
//
// XmlDownloadManager 
//
    internal class XmlDownloadManager {

        Hashtable connections; 

        [ResourceConsumption(ResourceScope.Machine)] 
        [ResourceExposure(ResourceScope.Machine)] 
        internal Stream GetStream(Uri uri, ICredentials credentials, IWebProxy proxy,
            RequestCachePolicy cachePolicy) { 
            if ( uri.Scheme == "file" ) {
                return new FileStream( uri.LocalPath, FileMode.Open, FileAccess.Read, FileShare.Read, 1 );
            }
            else { 
                return GetNonFileStream( uri, credentials, proxy, cachePolicy );
            } 
        } 

        private Stream GetNonFileStream( Uri uri, ICredentials credentials, IWebProxy proxy, 
            RequestCachePolicy cachePolicy ) {
            WebRequest req = WebRequest.Create( uri );
            if ( credentials != null ) {
                req.Credentials = credentials; 
            }
            if ( proxy != null ) { 
                req.Proxy = proxy; 
            }
            if ( cachePolicy != null ) { 
                req.CachePolicy = cachePolicy;
            }
            WebResponse resp = req.GetResponse();
            HttpWebRequest webReq = req as HttpWebRequest; 
            if ( webReq != null ) {
                lock ( this ) { 
                    if ( connections == null ) { 
                        connections = new Hashtable();
                    } 
                    OpenedHost openedHost = (OpenedHost)connections[webReq.Address.Host];
                    if ( openedHost == null ) {
                        openedHost = new OpenedHost();
                    } 

                    if ( openedHost.nonCachedConnectionsCount < webReq.ServicePoint.ConnectionLimit - 1 ) { 
                        // we are not close to connection limit -> don't cache the stream 
                        if ( openedHost.nonCachedConnectionsCount == 0 ) {
                            connections.Add( webReq.Address.Host, openedHost ); 
                        }
                        openedHost.nonCachedConnectionsCount++;
                        return new XmlRegisteredNonCachedStream( resp.GetResponseStream(), this, webReq.Address.Host );
                    } 
                    else {
                        // cache the stream and save the connection for the next request 
                        return new XmlCachedStream( resp.ResponseUri, resp.GetResponseStream() ); 
                    }
                } 
            }
            else {
                return resp.GetResponseStream();
            } 
        }
 
        internal void Remove( string host ) { 
            lock ( this ) {
                OpenedHost openedHost = (OpenedHost)connections[host]; 
                if ( openedHost != null ) {
                    if ( --openedHost.nonCachedConnectionsCount == 0 ) {
                        connections.Remove( host );
                    } 
                }
            } 
        } 
    }
 
//
// OpenedHost
//
    internal class OpenedHost { 
        internal int nonCachedConnectionsCount;
    } 
 
//
// XmlRegisteredNonCachedStream 
//
    internal class XmlRegisteredNonCachedStream : Stream {
        protected Stream stream;
        XmlDownloadManager downloadManager; 
        string host;
 
        internal XmlRegisteredNonCachedStream( Stream stream, XmlDownloadManager downloadManager, string host ) { 
            this.stream = stream;
            this.downloadManager = downloadManager; 
            this.host = host;
        }

        ~XmlRegisteredNonCachedStream() { 
            if ( downloadManager != null ) {
                downloadManager.Remove( host ); 
            } 
            stream = null;
            // The base class, Stream, provides its own finalizer 
        }

        protected override void Dispose( bool disposing ) {
            try { 
                if ( disposing && stream != null ) {
                    if ( downloadManager != null ) { 
                        downloadManager.Remove( host ); 
                    }
                    stream.Close(); 
                }
                stream = null;
                GC.SuppressFinalize( this ); // do not call finalizer
            } 
            finally {
                base.Dispose( disposing ); 
            } 
        }
 
        //
        // Stream
        //
        public override IAsyncResult BeginRead( byte[] buffer, int offset, int count, AsyncCallback callback, object state ) { 
            return stream.BeginRead( buffer, offset, count, callback, state );
        } 
 
        public override IAsyncResult BeginWrite( byte[] buffer, int offset, int count, AsyncCallback callback, object state ) {
            return BeginWrite( buffer, offset, count, callback, state ); 
        }

        public override int EndRead( IAsyncResult asyncResult ) {
            return stream.EndRead( asyncResult ); 
        }
 
        public override void EndWrite( IAsyncResult asyncResult ) { 
            stream.EndWrite( asyncResult );
        } 

        public override void Flush() {
            stream.Flush();
        } 

        public override int Read( byte[] buffer, int offset, int count ) { 
            return stream.Read( buffer, offset, count ); 
        }
 
        public override int ReadByte() {
            return stream.ReadByte();
        }
 
        public override long Seek( long offset, SeekOrigin origin ) {
            return stream.Seek( offset, origin ); 
        } 

        public override void SetLength( long value ) { 
            stream.SetLength( value );
        }

        public override void Write( byte[] buffer, int offset, int count ) { 
            stream.Write( buffer, offset, count );
        } 
 
        public override void WriteByte( byte value ) {
            stream.WriteByte( value ); 
        }

        public override Boolean CanRead {
            get { return stream.CanRead; } 
        }
 
        public override Boolean CanSeek { 
            get { return stream.CanSeek; }
        } 

        public override Boolean CanWrite {
            get { return stream.CanWrite; }
        } 

        public override long Length { 
            get { return stream.Length; } 
        }
 
        public override long Position {
            get { return stream.Position; }
            set { stream.Position = value; }
        } 
    }
 
// 
// XmlCachedStream
// 
    internal class XmlCachedStream : MemoryStream {
        private const int MoveBufferSize = 4096;

        private Uri uri; 

        internal XmlCachedStream( Uri uri, Stream stream ) 
            : base() { 

            this.uri = uri; 

            try {
                byte[] bytes = new byte[MoveBufferSize];
                int read = 0; 
                while ( ( read = stream.Read( bytes, 0, MoveBufferSize ) ) > 0 ) {
                    this.Write( bytes, 0, read ); 
                } 
                base.Position = 0;
            } 
            finally {
                stream.Close();
            }
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml { 

    using System; 
    using System.IO;
    using System.Security;
    using System.Collections;
    using System.Net; 
    using System.Net.Cache;
    using System.Runtime.Versioning; 
 
//
// XmlDownloadManager 
//
    internal class XmlDownloadManager {

        Hashtable connections; 

        [ResourceConsumption(ResourceScope.Machine)] 
        [ResourceExposure(ResourceScope.Machine)] 
        internal Stream GetStream(Uri uri, ICredentials credentials, IWebProxy proxy,
            RequestCachePolicy cachePolicy) { 
            if ( uri.Scheme == "file" ) {
                return new FileStream( uri.LocalPath, FileMode.Open, FileAccess.Read, FileShare.Read, 1 );
            }
            else { 
                return GetNonFileStream( uri, credentials, proxy, cachePolicy );
            } 
        } 

        private Stream GetNonFileStream( Uri uri, ICredentials credentials, IWebProxy proxy, 
            RequestCachePolicy cachePolicy ) {
            WebRequest req = WebRequest.Create( uri );
            if ( credentials != null ) {
                req.Credentials = credentials; 
            }
            if ( proxy != null ) { 
                req.Proxy = proxy; 
            }
            if ( cachePolicy != null ) { 
                req.CachePolicy = cachePolicy;
            }
            WebResponse resp = req.GetResponse();
            HttpWebRequest webReq = req as HttpWebRequest; 
            if ( webReq != null ) {
                lock ( this ) { 
                    if ( connections == null ) { 
                        connections = new Hashtable();
                    } 
                    OpenedHost openedHost = (OpenedHost)connections[webReq.Address.Host];
                    if ( openedHost == null ) {
                        openedHost = new OpenedHost();
                    } 

                    if ( openedHost.nonCachedConnectionsCount < webReq.ServicePoint.ConnectionLimit - 1 ) { 
                        // we are not close to connection limit -> don't cache the stream 
                        if ( openedHost.nonCachedConnectionsCount == 0 ) {
                            connections.Add( webReq.Address.Host, openedHost ); 
                        }
                        openedHost.nonCachedConnectionsCount++;
                        return new XmlRegisteredNonCachedStream( resp.GetResponseStream(), this, webReq.Address.Host );
                    } 
                    else {
                        // cache the stream and save the connection for the next request 
                        return new XmlCachedStream( resp.ResponseUri, resp.GetResponseStream() ); 
                    }
                } 
            }
            else {
                return resp.GetResponseStream();
            } 
        }
 
        internal void Remove( string host ) { 
            lock ( this ) {
                OpenedHost openedHost = (OpenedHost)connections[host]; 
                if ( openedHost != null ) {
                    if ( --openedHost.nonCachedConnectionsCount == 0 ) {
                        connections.Remove( host );
                    } 
                }
            } 
        } 
    }
 
//
// OpenedHost
//
    internal class OpenedHost { 
        internal int nonCachedConnectionsCount;
    } 
 
//
// XmlRegisteredNonCachedStream 
//
    internal class XmlRegisteredNonCachedStream : Stream {
        protected Stream stream;
        XmlDownloadManager downloadManager; 
        string host;
 
        internal XmlRegisteredNonCachedStream( Stream stream, XmlDownloadManager downloadManager, string host ) { 
            this.stream = stream;
            this.downloadManager = downloadManager; 
            this.host = host;
        }

        ~XmlRegisteredNonCachedStream() { 
            if ( downloadManager != null ) {
                downloadManager.Remove( host ); 
            } 
            stream = null;
            // The base class, Stream, provides its own finalizer 
        }

        protected override void Dispose( bool disposing ) {
            try { 
                if ( disposing && stream != null ) {
                    if ( downloadManager != null ) { 
                        downloadManager.Remove( host ); 
                    }
                    stream.Close(); 
                }
                stream = null;
                GC.SuppressFinalize( this ); // do not call finalizer
            } 
            finally {
                base.Dispose( disposing ); 
            } 
        }
 
        //
        // Stream
        //
        public override IAsyncResult BeginRead( byte[] buffer, int offset, int count, AsyncCallback callback, object state ) { 
            return stream.BeginRead( buffer, offset, count, callback, state );
        } 
 
        public override IAsyncResult BeginWrite( byte[] buffer, int offset, int count, AsyncCallback callback, object state ) {
            return BeginWrite( buffer, offset, count, callback, state ); 
        }

        public override int EndRead( IAsyncResult asyncResult ) {
            return stream.EndRead( asyncResult ); 
        }
 
        public override void EndWrite( IAsyncResult asyncResult ) { 
            stream.EndWrite( asyncResult );
        } 

        public override void Flush() {
            stream.Flush();
        } 

        public override int Read( byte[] buffer, int offset, int count ) { 
            return stream.Read( buffer, offset, count ); 
        }
 
        public override int ReadByte() {
            return stream.ReadByte();
        }
 
        public override long Seek( long offset, SeekOrigin origin ) {
            return stream.Seek( offset, origin ); 
        } 

        public override void SetLength( long value ) { 
            stream.SetLength( value );
        }

        public override void Write( byte[] buffer, int offset, int count ) { 
            stream.Write( buffer, offset, count );
        } 
 
        public override void WriteByte( byte value ) {
            stream.WriteByte( value ); 
        }

        public override Boolean CanRead {
            get { return stream.CanRead; } 
        }
 
        public override Boolean CanSeek { 
            get { return stream.CanSeek; }
        } 

        public override Boolean CanWrite {
            get { return stream.CanWrite; }
        } 

        public override long Length { 
            get { return stream.Length; } 
        }
 
        public override long Position {
            get { return stream.Position; }
            set { stream.Position = value; }
        } 
    }
 
// 
// XmlCachedStream
// 
    internal class XmlCachedStream : MemoryStream {
        private const int MoveBufferSize = 4096;

        private Uri uri; 

        internal XmlCachedStream( Uri uri, Stream stream ) 
            : base() { 

            this.uri = uri; 

            try {
                byte[] bytes = new byte[MoveBufferSize];
                int read = 0; 
                while ( ( read = stream.Read( bytes, 0, MoveBufferSize ) ) > 0 ) {
                    this.Write( bytes, 0, read ); 
                } 
                base.Position = 0;
            } 
            finally {
                stream.Close();
            }
        } 
    }
} 

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

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• IndexedEnumerable.cs
• OutputCacheProfileCollection.cs
• MenuItem.cs
• SpecularMaterial.cs
• datacache.cs
• Keyboard.cs
• EventProperty.cs
• XsltOutput.cs
• CollectionViewGroupInternal.cs
• SamlSubject.cs
• CodeTypeOfExpression.cs
• PresentationAppDomainManager.cs
• _ProxyChain.cs
• HtmlInputButton.cs
• EncryptedKey.cs
• Int32RectValueSerializer.cs
• BaseParaClient.cs
• TextParagraphProperties.cs
• ToolStripArrowRenderEventArgs.cs
• ListSurrogate.cs
• RenderContext.cs
• MDIClient.cs
• UnsupportedPolicyOptionsException.cs
• ErrorWrapper.cs
• Item.cs
• TransactionState.cs
• ReferencedCategoriesDocument.cs
• CommandHelpers.cs
• SchemaNamespaceManager.cs
• TreeViewBindingsEditor.cs
• EnumConverter.cs
• LogLogRecordHeader.cs
• CachedRequestParams.cs
• ExtenderControl.cs
• TraceContext.cs
• ValidationEventArgs.cs
• FormViewActionList.cs
• MarkupCompiler.cs
• OrderedDictionaryStateHelper.cs
• hresults.cs
• DtrList.cs
• ModelItemImpl.cs
• ListBindableAttribute.cs
• ListViewEditEventArgs.cs
• SizeConverter.cs
• HWStack.cs
• MultiBinding.cs
• SecurityRuntime.cs
• FloaterParagraph.cs
• SmtpMail.cs
• ValidationEventArgs.cs
• KeySpline.cs
• SmtpLoginAuthenticationModule.cs
• PrintEvent.cs
• MessageEncoderFactory.cs
• FileNameEditor.cs
• PeerContact.cs
• Substitution.cs
• HttpRequestMessageProperty.cs
• HttpListenerRequest.cs
• EventRoute.cs
• HuffModule.cs
• DecoderNLS.cs
• Metafile.cs
• FastEncoder.cs
• ApplicationTrust.cs
• XamlFilter.cs
• AnimationClockResource.cs
• ContourSegment.cs
• ClientSettingsSection.cs
• UriSectionData.cs
• COMException.cs
• CheckPair.cs
• AspProxy.cs
• DefaultMemberAttribute.cs
• OutputScope.cs
• documentsequencetextcontainer.cs
• UrlRoutingHandler.cs
• RootBuilder.cs
• CompleteWizardStep.cs
• RecognizerBase.cs
• HelpProvider.cs
• CustomValidator.cs
• BlockCollection.cs
• DivideByZeroException.cs
• ContentDefinition.cs
• QfeChecker.cs
• Crypto.cs
• ToolStripDropDownClosingEventArgs.cs
• BitHelper.cs
• DiscoveryMessageSequence11.cs
• ImageAnimator.cs
• MetadataUtil.cs
• KeyTime.cs
• EmptyQuery.cs
• EditorBrowsableAttribute.cs
• SelectionEditingBehavior.cs
• FullTrustAssembly.cs
• EventTrigger.cs
• ConfigurationProperty.cs