The Labs \ Source Viewer \ SSCLI \ System.Net \ WebProxyWrapper

  1. //------------------------------------------------------------------------------
  2. // <copyright file="WebRequest.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Net
  16. {
  17.     using System.Collections;
  18.     using System.Collections.Generic;
  19.     using System.Configuration;
  20.     using System.Globalization;
  21.     using System.IO;
  22.     using System.Net.Cache;
  23.     using System.Net.Configuration;
  24.     using System.Runtime.Serialization;
  25.     using System.Security.Permissions;
  26.     using System.Security.Principal;
  27.     using System.Threading;
  28.     using System.Net.Security;
  29.     //
  30.     // WebRequest - the base class of all Web resource/protocol objects. Provides
  31.     // common methods, data and proprties for making the top level request
  32.     //
  33.    
  34.     /// <devdoc>
  35.     /// <para>A request to a Uniform Resource Identifier (Uri). This
  36.     /// is an abstract class.</para>
  37.     /// </devdoc>
  38.     [Serializable()]
  39.     public abstract class WebRequest : MarshalByRefObject, ISerializable
  40.     {
  41.         #if DEBUG
  42.         internal const int DefaultTimeout = 100000 * 10;
  43.         #else // DEBUG
  44.         internal const int DefaultTimeout = 100000 * 5;
  45.         #endif // DEBUG
  46.         private static ArrayList s_PrefixList;
  47.         private static object s_InternalSyncObject;
  48.         private static TimerThread.Queue s_DefaultTimerQueue = TimerThread.CreateQueue(DefaultTimeout);
  49.        
  50.         private RequestCachePolicy m_CachePolicy;
  51.         private RequestCacheProtocol m_CacheProtocol;
  52.         private RequestCacheBinding m_CacheBinding;
  53.        
  54.        
  55.         private static object InternalSyncObject {
  56.             get {
  57.                 if (s_InternalSyncObject == null) {
  58.                     object o = new object();
  59.                     Interlocked.CompareExchange(ref s_InternalSyncObject, o, null);
  60.                 }
  61.                 return s_InternalSyncObject;
  62.             }
  63.         }
  64.        
  65.         static internal TimerThread.Queue DefaultTimerQueue {
  66.             get { return s_DefaultTimerQueue; }
  67.         }
  68.        
  69. /*++
  70.             Create - Create a WebRequest.
  71.             This is the main creation routine. We take a Uri object, look
  72.             up the Uri in the prefix match table, and invoke the appropriate
  73.             handler to create the object. We also have a parameter that
  74.             tells us whether or not to use the whole Uri or just the
  75.             scheme portion of it.
  76.             Input:
  77.                 RequestUri          - Uri object for request.
  78.                 UseUriBase          - True if we're only to look at the scheme
  79.                                         portion of the Uri.
  80.             Returns:
  81.                 Newly created WebRequest.
  82.         --*/       
  83.        
  84.         private static WebRequest Create(Uri requestUri, bool useUriBase)
  85.         {
  86.             if (Logging.On)
  87.                 Logging.Enter(Logging.Web, "WebRequest", "Create", requestUri.ToString());
  88.            
  89.             string LookupUri;
  90.             WebRequestPrefixElement Current = null;
  91.             bool Found = false;
  92.            
  93.             if (!useUriBase) {
  94.                 LookupUri = requestUri.AbsoluteUri;
  95.             }
  96.             else {
  97.                
  98.                 //
  99.                 // schemes are registered as <schemeName>":", so add the separator
  100.                 // to the string returned from the Uri object
  101.                 //
  102.                
  103.                 LookupUri = requestUri.Scheme + ':';
  104.             }
  105.            
  106.             int LookupLength = LookupUri.Length;
  107.            
  108.             // Copy the prefix list so that if it is updated it will
  109.             // not affect us on this thread.
  110.            
  111.             ArrayList prefixList = PrefixList;
  112.            
  113.             // Look for the longest matching prefix.
  114.            
  115.             // Walk down the list of prefixes. The prefixes are kept longest
  116.             // first. When we find a prefix that is shorter or the same size
  117.             // as this Uri, we'll do a compare to see if they match. If they
  118.             // do we'll break out of the loop and call the creator.
  119.            
  120.             for (int i = 0; i < prefixList.Count; i++) {
  121.                 Current = (WebRequestPrefixElement)prefixList[i];
  122.                
  123.                 //
  124.                 // See if this prefix is short enough.
  125.                 //
  126.                
  127.                 if (LookupLength >= Current.Prefix.Length) {
  128.                    
  129.                     //
  130.                     // It is. See if these match.
  131.                     //
  132.                    
  133.                     if (String.Compare(Current.Prefix, 0, LookupUri, 0, Current.Prefix.Length, StringComparison.OrdinalIgnoreCase) == 0) {
  134.                        
  135.                         //
  136.                         // These match. Remember that we found it and break
  137.                         // out.
  138.                         //
  139.                        
  140.                         Found = true;
  141.                         break;
  142.                     }
  143.                 }
  144.             }
  145.            
  146.             WebRequest webRequest = null;
  147.            
  148.             if (Found) {
  149.                
  150.                 //
  151.                 // We found a match, so just call the creator and return what it
  152.                 // does.
  153.                 //
  154.                
  155.                 webRequest = Current.Creator.Create(requestUri);
  156.                 if (Logging.On)
  157.                     Logging.Exit(Logging.Web, "WebRequest", "Create", webRequest);
  158.                 return webRequest;
  159.             }
  160.            
  161.             if (Logging.On)
  162.                 Logging.Exit(Logging.Web, "WebRequest", "Create", null);
  163.            
  164.             //
  165.             // Otherwise no match, throw an exception.
  166.             //
  167.            
  168.             throw new NotSupportedException(SR.GetString(SR.net_unknown_prefix));
  169.         }
  170.        
  171. /*++
  172.             Create - Create a WebRequest.
  173.             An overloaded utility version of the real Create that takes a
  174.             string instead of an Uri object.
  175.             Input:
  176.                 RequestString      - Uri string to create.
  177.             Returns:
  178.                 Newly created WebRequest.
  179.         --*/       
  180.        
  181.         /// <devdoc>
  182.         /// <para>
  183.         /// Creates a new <see cref='System.Net.WebRequest'/>
  184.         /// instance for
  185.         /// the specified Uri scheme.
  186.         /// </para>
  187.         /// </devdoc>
  188.         public static WebRequest Create(string requestUriString)
  189.         {
  190.             if (requestUriString == null) {
  191.                 throw new ArgumentNullException("requestUriString");
  192.             }
  193.             return Create(new Uri(requestUriString), false);
  194.         }
  195.        
  196. /*++
  197.             Create - Create a WebRequest.
  198.             Another overloaded version of the Create function that doesn't
  199.             take the UseUriBase parameter.
  200.             Input:
  201.                 RequestUri          - Uri object for request.
  202.             Returns:
  203.                 Newly created WebRequest.
  204.         --*/       
  205.        
  206.         /// <devdoc>
  207.         /// <para>
  208.         /// Creates a new <see cref='System.Net.WebRequest'/> instance for the specified Uri scheme.
  209.         /// </para>
  210.         /// </devdoc>
  211.         public static WebRequest Create(Uri requestUri)
  212.         {
  213.             if (requestUri == null) {
  214.                 throw new ArgumentNullException("requestUri");
  215.             }
  216.             return Create(requestUri, false);
  217.         }
  218.        
  219. /*++
  220.             CreateDefault - Create a default WebRequest.
  221.             This is the creation routine that creates a default WebRequest.
  222.             We take a Uri object and pass it to the base create routine,
  223.             setting the useUriBase parameter to true.
  224.             Input:
  225.                 RequestUri          - Uri object for request.
  226.             Returns:
  227.                 Newly created WebRequest.
  228.         --*/       
  229.         /// <devdoc>
  230.         /// <para>[To be supplied.]</para>
  231.         /// </devdoc>
  232.         public static WebRequest CreateDefault(Uri requestUri)
  233.         {
  234.             if (requestUri == null) {
  235.                 throw new ArgumentNullException("requestUri");
  236.             }
  237.             return Create(requestUri, true);
  238.         }
  239.        
  240. /*++
  241.             RegisterPrefix - Register an Uri prefix for creating WebRequests.
  242.             This function registers a prefix for creating WebRequests. When an
  243.             user wants to create a WebRequest, we scan a table looking for a
  244.             longest prefix match for the Uri they're passing. We then invoke
  245.             the sub creator for that prefix. This function puts entries in
  246.             that table.
  247.             We don't allow duplicate entries, so if there is a dup this call
  248.             will fail.
  249.         Input:
  250.             Prefix          - Represents Uri prefix being registered.
  251.             Creator        - Interface for sub creator.
  252.         Returns:
  253.             True if the registration worked, false otherwise.
  254.         --*/       
  255.         /// <devdoc>
  256.         /// <para>
  257.         /// Registers a <see cref='System.Net.WebRequest'/> descendent
  258.         /// for a specific Uniform Resource Identifier.
  259.         /// </para>
  260.         /// </devdoc>
  261.         public static bool RegisterPrefix(string prefix, IWebRequestCreate creator)
  262.         {
  263.            
  264.             bool Error = false;
  265.             int i;
  266.             WebRequestPrefixElement Current;
  267.            
  268.             if (prefix == null) {
  269.                 throw new ArgumentNullException("prefix");
  270.             }
  271.             if (creator == null) {
  272.                 throw new ArgumentNullException("creator");
  273.             }
  274.            
  275.             ExceptionHelper.WebPermissionUnrestricted.Demand();
  276.            
  277.             // Lock this object, then walk down PrefixList looking for a place to
  278.             // to insert this prefix.
  279.            
  280.             lock (InternalSyncObject) {
  281.                 //
  282.                 // clone the object and update the clone thus
  283.                 // allowing other threads to still read from it
  284.                 //
  285.                
  286.                 ArrayList prefixList = (ArrayList)PrefixList.Clone();
  287.                
  288.                 i = 0;
  289.                
  290.                 // The prefix list is sorted with longest entries at the front. We
  291.                 // walk down the list until we find a prefix shorter than this
  292.                 // one, then we insert in front of it. Along the way we check
  293.                 // equal length prefixes to make sure this isn't a dupe.
  294.                
  295.                 while (i < prefixList.Count) {
  296.                     Current = (WebRequestPrefixElement)prefixList[i];
  297.                    
  298.                     // See if the new one is longer than the one we're looking at.
  299.                    
  300.                     if (prefix.Length > Current.Prefix.Length) {
  301.                         // It is. Break out of the loop here.
  302.                         break;
  303.                     }
  304.                    
  305.                     // If these are of equal length, compare them.
  306.                    
  307.                     if (prefix.Length == Current.Prefix.Length) {
  308.                         // They're the same length.
  309.                         if (String.Compare(Current.Prefix, prefix, StringComparison.OrdinalIgnoreCase) == 0) {
  310.                             // ...and the strings are identical. This is an error.
  311.                            
  312.                             Error = true;
  313.                             break;
  314.                         }
  315.                     }
  316.                     i++;
  317.                 }
  318.                
  319.                 // When we get here either i contains the index to insert at or
  320.                 // we've had an error, in which case Error is true.
  321.                
  322.                 if (!Error) {
  323.                     // No error, so insert.
  324.                    
  325.                     prefixList.Insert(i, new WebRequestPrefixElement(prefix, creator));
  326.                    
  327.                     //
  328.                     // no error, assign the clone to the static object, other
  329.                     // threads using it will have copied the oriignal object already
  330.                     //
  331.                     PrefixList = prefixList;
  332.                 }
  333.             }
  334.             return !Error;
  335.         }
  336.        
  337. /*
  338.         public static bool UnregisterPrefix(string prefix) {
  339.             if (prefix == null) {
  340.                 throw new ArgumentNullException("prefix");
  341.             }
  342.             ExceptionHelper.WebPermissionUnrestricted.Demand();
  343.             // Lock this object, then walk down PrefixList looking for a place to
  344.             // to insert this prefix.
  345.             lock(InternalSyncObject) {
  346.                 //
  347.                 // clone the object and update the clone thus
  348.                 // allowing other threads to still read from it
  349.                 //
  350.                 ArrayList prefixList = (ArrayList) PrefixList.Clone();
  351.                 int i = 0;
  352.                 WebRequestPrefixElement Current;
  353.                 // The prefix list is sorted with longest entries at the front. We
  354.                 // walk down the list until we find a prefix shorter than this
  355.                 // one, then we insert in front of it. Along the way we check
  356.                 // equal length prefixes to make sure this isn't a dupe.
  357.                 while (i < prefixList.Count) {
  358.                     Current = (WebRequestPrefixElement)prefixList[i];
  359.                     // See if the new one is longer than the one we're looking at.
  360.                     if (prefix.Length > Current.Prefix.Length) {
  361.                         return fasle;
  362.                     }
  363.                     // If these are of equal length, compare them.
  364.                     if (prefix.Length == Current.Prefix.Length) {
  365.                         // They're the same length.
  366.                         if (String.Compare(Current.Prefix, prefix, StringComparison.OrdinalIgnoreCase ) == 0) {
  367.                             prefixList.RemoveAt(i);
  368.                             PrefixList = prefixList;
  369.                             return true;
  370.                         }
  371.                     }
  372.                     i++;
  373.                 }
  374.             }
  375.             return false;
  376.         }
  377.         */       
  378.        
  379. /*++
  380.             PrefixList - Returns And Initialize our prefix list.
  381.             This is the method that initializes the prefix list. We create
  382.             an ArrayList for the PrefixList, then an HttpRequestCreator object,
  383.             and then we register the HTTP and HTTPS prefixes.
  384.             Input: Nothing
  385.             Returns: true
  386.         --*/       
  387.         static internal ArrayList PrefixList {
  388.            
  389.             get {
  390.                 //
  391.                 // GetConfig() might use us, so we have a circular dependency issue,
  392.                 // that causes us to nest here, we grab the lock, only
  393.                 // if we haven't initialized.
  394.                 //
  395.                 if (s_PrefixList == null) {
  396.                    
  397.                     lock (InternalSyncObject) {
  398.                         if (s_PrefixList == null) {
  399.                             GlobalLog.Print("WebRequest::Initialize(): calling ConfigurationManager.GetSection()");
  400.                             s_PrefixList = WebRequestModulesSectionInternal.GetSection().WebRequestModules;
  401.                         }
  402.                     }
  403.                 }
  404.                
  405.                 return s_PrefixList;
  406.             }
  407.             set { s_PrefixList = value; }
  408.         }
  409.        
  410.         // constructors
  411.        
  412.         /// <devdoc>
  413.         /// <para>
  414.         /// Initializes a new instance of the <see cref='System.Net.WebRequest'/>
  415.         /// class.
  416.         /// </para>
  417.         /// </devdoc>
  418.        
  419.         protected WebRequest()
  420.         {
  421.         }
  422.         //
  423.         // ISerializable constructor
  424.         //
  425.         /// <devdoc>
  426.         /// <para>[To be supplied.]</para>
  427.         /// </devdoc>
  428.         protected WebRequest(SerializationInfo serializationInfo, StreamingContext streamingContext)
  429.         {
  430.         }
  431.        
  432.         //
  433.         // ISerializable method
  434.         //
  435.         /// <internalonly/>
  436.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter, SerializationFormatter = true)]
  437.         void ISerializable.GetObjectData(SerializationInfo serializationInfo, StreamingContext streamingContext)
  438.         {
  439.             GetObjectData(serializationInfo, streamingContext);
  440.         }
  441.        
  442.         //
  443.         // FxCop: Provide a way for inherited classes to access base.GetObjectData in case they also implement ISerializable.
  444.         //
  445.         [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
  446.         protected virtual void GetObjectData(SerializationInfo serializationInfo, StreamingContext streamingContext)
  447.         {
  448.         }
  449.        
  450.         // This is a shortcut that would set the default policy for HTTP/HTTPS.
  451.         // The default policy is overridden by any prefix-registered policy.
  452.         // Will demand permission for set{}
  453.         public static RequestCachePolicy DefaultCachePolicy {
  454.             get { return RequestCacheManager.GetBinding(string.Empty).Policy; }
  455.             set {
  456.                 // This is a replacement of RequestCachePermission demand since we are not including the latest in the product.
  457.                 ExceptionHelper.WebPermissionUnrestricted.Demand();
  458.                
  459.                 RequestCacheBinding binding = RequestCacheManager.GetBinding(string.Empty);
  460.                 RequestCacheManager.SetBinding(string.Empty, new RequestCacheBinding(binding.Cache, binding.Validator, value));
  461.             }
  462.         }
  463.        
  464.         //
  465.         //
  466.         public virtual RequestCachePolicy CachePolicy {
  467.             get { return m_CachePolicy; }
  468. // Delayed creation of CacheProtocol until caching is actually turned on.
  469.             set { InternalSetCachePolicy(value); }
  470.         }
  471.        
  472.        
  473.         void InternalSetCachePolicy(RequestCachePolicy policy)
  474.         {
  475.             // Delayed creation of CacheProtocol until caching is actually turned on.
  476.             if (m_CacheBinding != null && m_CacheBinding.Cache != null && m_CacheBinding.Validator != null && CacheProtocol == null && policy != null && policy.Level != RequestCacheLevel.BypassCache) {
  477.                 CacheProtocol = new RequestCacheProtocol(m_CacheBinding.Cache, m_CacheBinding.Validator.CreateValidator());
  478.             }
  479.            
  480.             m_CachePolicy = policy;
  481.         }
  482.        
  483.        
  484.         /// <devdoc>
  485.         /// <para>When overridden in a derived class, gets and
  486.         /// sets
  487.         /// the
  488.         /// protocol method used in this request. Default value should be
  489.         /// "GET".</para>
  490.         /// </devdoc>
  491.         public virtual string Method {
  492.             get {
  493.                 throw ExceptionHelper.PropertyNotImplementedException;
  494.             }
  495.             set {
  496.                 throw ExceptionHelper.PropertyNotImplementedException;
  497.             }
  498.         }
  499.        
  500.        
  501.         /// <devdoc>
  502.         /// <para>When overridden in a derived class, gets a <see cref='Uri'/>
  503.         /// instance representing the resource associated with
  504.         /// the request.</para>
  505.         /// </devdoc>
  506.         public virtual Uri RequestUri {
  507.             // read-only
  508.             get {
  509.                 throw ExceptionHelper.PropertyNotImplementedException;
  510.             }
  511.         }
  512.        
  513.         //
  514.         // This is a group of connections that may need to be used for
  515.         // grouping connecitons.
  516.         //
  517.         /// <devdoc>
  518.         /// </devdoc>
  519.         public virtual string ConnectionGroupName {
  520.             get {
  521.                 throw ExceptionHelper.PropertyNotImplementedException;
  522.             }
  523.             set {
  524.                 throw ExceptionHelper.PropertyNotImplementedException;
  525.             }
  526.         }
  527.        
  528.        
  529. /*++
  530.             Headers  - Gets any request specific headers associated
  531.             with this request, this is simply a name/value pair collection
  532.             Input: Nothing.
  533.             Returns: This property returns WebHeaderCollection.
  534.                     read-only
  535.         --*/       
  536.        
  537.         /// <devdoc>
  538.         /// <para>When overridden in a derived class,
  539.         /// gets
  540.         /// a collection of header name-value pairs associated with this
  541.         /// request.</para>
  542.         /// </devdoc>
  543.         public virtual WebHeaderCollection Headers {
  544.             get {
  545.                 throw ExceptionHelper.PropertyNotImplementedException;
  546.             }
  547.             set {
  548.                 throw ExceptionHelper.PropertyNotImplementedException;
  549.             }
  550.         }
  551.        
  552.        
  553.         /// <devdoc>
  554.         /// <para>When
  555.         /// overridden in a derived class, gets
  556.         /// and sets
  557.         /// the
  558.         /// content length of request data being sent.</para>
  559.         /// </devdoc>
  560.         public virtual long ContentLength {
  561.             get {
  562.                 throw ExceptionHelper.PropertyNotImplementedException;
  563.             }
  564.             set {
  565.                 throw ExceptionHelper.PropertyNotImplementedException;
  566.             }
  567.         }
  568.        
  569.         /// <devdoc>
  570.         /// <para>When
  571.         /// overridden in a derived class, gets
  572.         /// and
  573.         /// sets
  574.         /// the content type of the request data being sent.</para>
  575.         /// </devdoc>
  576.         public virtual string ContentType {
  577.             get {
  578.                 throw ExceptionHelper.PropertyNotImplementedException;
  579.             }
  580.             set {
  581.                 throw ExceptionHelper.PropertyNotImplementedException;
  582.             }
  583.         }
  584.        
  585.         /// <devdoc>
  586.         /// <para>When overridden in a derived class, gets and sets the network
  587.         /// credentials used for authentication to this Uri.</para>
  588.         /// </devdoc>
  589.         public virtual ICredentials Credentials {
  590.             get {
  591.                 throw ExceptionHelper.PropertyNotImplementedException;
  592.             }
  593.             set {
  594.                 throw ExceptionHelper.PropertyNotImplementedException;
  595.             }
  596.         }
  597.        
  598.         /// <devdoc>
  599.         /// <para>Sets Credentials to CredentialCache.DefaultCredentials</para>
  600.         /// </devdoc>
  601.         public virtual bool UseDefaultCredentials {
  602.             get {
  603.                 throw ExceptionHelper.PropertyNotImplementedException;
  604.             }
  605.             set {
  606.                 throw ExceptionHelper.PropertyNotImplementedException;
  607.             }
  608.         }
  609.        
  610.         /// <devdoc>
  611.         /// <para>When overridden in a derived class,
  612.         /// gets and set proxy info. </para>
  613.         /// </devdoc>
  614.         public virtual IWebProxy Proxy {
  615.             get {
  616.                 throw ExceptionHelper.PropertyNotImplementedException;
  617.             }
  618.             set {
  619.                 throw ExceptionHelper.PropertyNotImplementedException;
  620.             }
  621.         }
  622.        
  623.         /// <devdoc>
  624.         /// <para>When overridden in a derived class,
  625.         /// enables or disables pre-authentication.</para>
  626.         /// </devdoc>
  627.         public virtual bool PreAuthenticate {
  628.             get {
  629.                 throw ExceptionHelper.PropertyNotImplementedException;
  630.             }
  631.             set {
  632.                 throw ExceptionHelper.PropertyNotImplementedException;
  633.             }
  634.         }
  635.        
  636.         //
  637.         // Timeout in milliseconds, if request takes longer
  638.         // than timeout, a WebException is thrown
  639.         //
  640.         //UEUE
  641.         /// <devdoc>
  642.         /// <para>[To be supplied.]</para>
  643.         /// </devdoc>
  644.         public virtual int Timeout {
  645.             get {
  646.                 throw ExceptionHelper.PropertyNotImplementedException;
  647.             }
  648.             set {
  649.                 throw ExceptionHelper.PropertyNotImplementedException;
  650.             }
  651.         }
  652.        
  653.        
  654.         /// <devdoc>
  655.         /// <para>When overridden in a derived class,
  656.         /// returns a <see cref='System.IO.Stream'/> object that is used for writing data
  657.         /// to the resource identified by <see cref='WebRequest.RequestUri'/>
  658.         /// .</para>
  659.         /// </devdoc>
  660.         public virtual Stream GetRequestStream()
  661.         {
  662.             throw ExceptionHelper.MethodNotImplementedException;
  663.         }
  664.        
  665.         /// <devdoc>
  666.         /// <para>When overridden in a derived class,
  667.         /// returns the response
  668.         /// to an Internet request.</para>
  669.         /// </devdoc>
  670.         public virtual WebResponse GetResponse()
  671.         {
  672.             throw ExceptionHelper.MethodNotImplementedException;
  673.         }
  674.        
  675.         /// <devdoc>
  676.         /// <para>Asynchronous version of GetResponse.</para>
  677.         /// </devdoc>
  678.         [HostProtection(ExternalThreading = true)]
  679.         public virtual IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
  680.         {
  681.             throw ExceptionHelper.MethodNotImplementedException;
  682.         }
  683.        
  684.        
  685.         /// <devdoc>
  686.         /// <para>Returns a WebResponse object.</para>
  687.         /// </devdoc>
  688.         public virtual WebResponse EndGetResponse(IAsyncResult asyncResult)
  689.         {
  690.             throw ExceptionHelper.MethodNotImplementedException;
  691.         }
  692.        
  693.         /// <devdoc>
  694.         /// <para>Asynchronous version of GetRequestStream
  695.         /// method.</para>
  696.         /// </devdoc>
  697.         [HostProtection(ExternalThreading = true)]
  698.         public virtual IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
  699.         {
  700.             throw ExceptionHelper.MethodNotImplementedException;
  701.         }
  702.        
  703.         /// <devdoc>
  704.         /// <para>Returns a <see cref='System.IO.Stream'/> object that is used for writing data to the resource
  705.         /// identified by <see cref='System.Net.WebRequest.RequestUri'/>
  706.         /// .</para>
  707.         /// </devdoc>
  708.         public virtual Stream EndGetRequestStream(IAsyncResult asyncResult)
  709.         {
  710.             throw ExceptionHelper.MethodNotImplementedException;
  711.         }
  712.        
  713.         /// <summary>
  714.         /// <para>Aborts the Request</para>
  715.         /// </summary>
  716.         public virtual void Abort()
  717.         {
  718.             throw ExceptionHelper.MethodNotImplementedException;
  719.         }
  720.         //
  721.         //
  722.         //
  723.         internal RequestCacheProtocol CacheProtocol {
  724.             get { return m_CacheProtocol; }
  725.             set { m_CacheProtocol = value; }
  726.         }
  727.        
  728.        
  729.         /// <summary>
  730.         /// <para>Provides an abstract way of having Async code callback into the request (saves a delegate)</para>
  731.         /// </summary>
  732.         internal virtual void RequestCallback(object obj)
  733.         {
  734.             throw ExceptionHelper.MethodNotImplementedException;
  735.         }
  736.        
  737.         //
  738.         // Default Web Proxy implementation.
  739.         //
  740.         private static IWebProxy s_DefaultWebProxy;
  741.         private static bool s_DefaultWebProxyInitialized;
  742.        
  743.         static internal IWebProxy InternalDefaultWebProxy {
  744.             get {
  745.                 if (!s_DefaultWebProxyInitialized) {
  746.                     lock (InternalSyncObject) {
  747.                         if (!s_DefaultWebProxyInitialized) {
  748.                             GlobalLog.Print("WebRequest::get_InternalDefaultWebProxy(): Getting config.");
  749.                             DefaultProxySectionInternal section = DefaultProxySectionInternal.GetSection();
  750.                             if (section != null) {
  751.                                 s_DefaultWebProxy = section.WebProxy;
  752.                             }
  753.                             s_DefaultWebProxyInitialized = true;
  754.                         }
  755.                     }
  756.                 }
  757.                 return s_DefaultWebProxy;
  758.             }
  759.            
  760.             set {
  761.                 // Same lock as above. Avoid hitting config if the proxy is set first.
  762.                 if (!s_DefaultWebProxyInitialized) {
  763.                     lock (InternalSyncObject) {
  764.                         s_DefaultWebProxy = value;
  765.                         s_DefaultWebProxyInitialized = true;
  766.                     }
  767.                 }
  768.                 else {
  769.                     s_DefaultWebProxy = value;
  770.                 }
  771.             }
  772.         }
  773.        
  774.         //
  775.         // Get and set the global default proxy. Use this instead of the old GlobalProxySelection.
  776.         //
  777.         public static IWebProxy DefaultWebProxy {
  778.             get {
  779.                 ExceptionHelper.WebPermissionUnrestricted.Demand();
  780.                 return InternalDefaultWebProxy;
  781.             }
  782.            
  783.             set {
  784.                 ExceptionHelper.WebPermissionUnrestricted.Demand();
  785.                 InternalDefaultWebProxy = value;
  786.             }
  787.         }
  788.        
  789.         //
  790.         // This returns an "IE Proxy" based on the currently impersonated user's proxy settings.
  791.         //
  792.         public static IWebProxy GetSystemWebProxy()
  793.         {
  794.             ExceptionHelper.WebPermissionUnrestricted.Demand();
  795.             return InternalGetSystemWebProxy();
  796.         }
  797.        
  798.         static internal IWebProxy InternalGetSystemWebProxy()
  799.         {
  800.             return new WebProxyWrapperOpaque(new WebProxy(true));
  801.         }
  802.        
  803.         //
  804.         // To maintain backwards-compatibility, GlobalProxySelection.Select must return a proxy castable to WebProxy.
  805.         // To get away from that restriction in the future, new APIs wrap the WebProxy in an internal wrapper.
  806.         // Once Select is removed, the system-proxy functionality can be factored out of the WebProxy class.
  807.         //
  808.        
  809.         //
  810.         // This doesn't expose the WebProxy. It's used by GetSystemWebProxy(), which should never be castable to WebProxy.
  811.         //
  812.         internal class WebProxyWrapperOpaque : IAutoWebProxy
  813.         {
  814.             protected readonly WebProxy webProxy;
  815.            
  816.             internal WebProxyWrapperOpaque(WebProxy webProxy)
  817.             {
  818.                 this.webProxy = webProxy;
  819.             }
  820.            
  821.             public Uri GetProxy(Uri destination)
  822.             {
  823.                 return webProxy.GetProxy(destination);
  824.             }
  825.            
  826.             public bool IsBypassed(Uri host)
  827.             {
  828.                 return webProxy.IsBypassed(host);
  829.             }
  830.            
  831.             public ICredentials Credentials {
  832.                 get { return webProxy.Credentials; }
  833.                
  834.                 set { webProxy.Credentials = value; }
  835.             }
  836.            
  837.             public ProxyChain GetProxies(Uri destination)
  838.             {
  839.                 return ((IAutoWebProxy)webProxy).GetProxies(destination);
  840.             }
  841.         }
  842.        
  843.         //
  844.         // Select returns the WebProxy out of this one.
  845.         //
  846.         internal class WebProxyWrapper : WebProxyWrapperOpaque
  847.         {
  848.             internal WebProxyWrapper(WebProxy webProxy) : base(webProxy)
  849.             {
  850.             }
  851.            
  852.             internal WebProxy WebProxy {
  853.                 get { return webProxy; }
  854.             }
  855.         }
  856.        
  857.        
  858.         //
  859.         internal void SetupCacheProtocol(Uri uri)
  860.         {
  861.             m_CacheBinding = RequestCacheManager.GetBinding(uri.Scheme);
  862.            
  863.             // Note if the cache is disabled it will give back a bypass policy.
  864.             InternalSetCachePolicy(m_CacheBinding.Policy);
  865.             if (m_CachePolicy == null) {
  866.                 // If the protocol cache policy is not specifically configured, grab from the base class.
  867.                 InternalSetCachePolicy(WebRequest.DefaultCachePolicy);
  868.             }
  869.         }
  870.     }
  871.     // class WebRequest
  872. }
  873. // namespace System.Net

Developer Fusion