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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="filewebrequest.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.IO;
  18.     using System.Runtime.Serialization;
  19.     using System.Security.Permissions;
  20.     using System.Threading;
  21.     using System.Runtime.Versioning;
  22.    
  23.     [Serializable()]
  24.     public class FileWebRequest : WebRequest, ISerializable
  25.     {
  26.        
  27.         private static WaitCallback s_GetRequestStreamCallback = new WaitCallback(GetRequestStreamCallback);
  28.         private static WaitCallback s_GetResponseCallback = new WaitCallback(GetResponseCallback);
  29.         private static ContextCallback s_WrappedGetRequestStreamCallback = new ContextCallback(WrappedGetRequestStreamCallback);
  30.         private static ContextCallback s_WrappedResponseCallback = new ContextCallback(WrappedGetResponseCallback);
  31.        
  32.         // fields
  33.        
  34.         string m_connectionGroupName;
  35.         long m_contentLength;
  36.         ICredentials m_credentials;
  37.         FileAccess m_fileAccess;
  38.         WebHeaderCollection m_headers;
  39.         string m_method = "GET";
  40.         bool m_preauthenticate;
  41.         IWebProxy m_proxy;
  42.         ManualResetEvent m_readerEvent;
  43.         bool m_readPending;
  44.         WebResponse m_response;
  45.         Stream m_stream;
  46.         bool m_syncHint;
  47.         int m_timeout = WebRequest.DefaultTimeout;
  48.         Uri m_uri;
  49.         bool m_writePending;
  50.         bool m_writing;
  51.         private ContextAwareResult m_WriteAResult;
  52.         private ContextAwareResult m_ReadAResult;
  53.         private int m_Aborted;
  54.        
  55.         // constructors
  56.        
  57.         internal FileWebRequest(Uri uri)
  58.         {
  59.             if ((object)uri.Scheme != (object)Uri.UriSchemeFile)
  60.                 throw new ArgumentOutOfRangeException("uri");
  61.            
  62.             m_uri = uri;
  63.             m_fileAccess = FileAccess.Read;
  64.             m_headers = new WebHeaderCollection(WebHeaderCollectionType.FileWebRequest);
  65.         }
  66.        
  67.        
  68.         //
  69.         // ISerializable constructor
  70.         //
  71.        
  72.         [Obsolete("Serialization is obsoleted for this type. http://go.microsoft.com/fwlink/?linkid=14202")]
  73.         protected FileWebRequest(SerializationInfo serializationInfo, StreamingContext streamingContext) : base(serializationInfo, streamingContext)
  74.         {
  75.             m_headers = (WebHeaderCollection)serializationInfo.GetValue("headers", typeof(WebHeaderCollection));
  76.             m_proxy = (IWebProxy)serializationInfo.GetValue("proxy", typeof(IWebProxy));
  77.             m_uri = (Uri)serializationInfo.GetValue("uri", typeof(Uri));
  78.             m_connectionGroupName = serializationInfo.GetString("connectionGroupName");
  79.             m_method = serializationInfo.GetString("method");
  80.             m_contentLength = serializationInfo.GetInt64("contentLength");
  81.             m_timeout = serializationInfo.GetInt32("timeout");
  82.             m_fileAccess = (FileAccess)serializationInfo.GetInt32("fileAccess");
  83.         }
  84.        
  85.         //
  86.         // ISerializable method
  87.         //
  88.         /// <internalonly/>
  89.         [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter, SerializationFormatter = true)]
  90.         void ISerializable.GetObjectData(SerializationInfo serializationInfo, StreamingContext streamingContext)
  91.         {
  92.             GetObjectData(serializationInfo, streamingContext);
  93.         }
  94.        
  95.         //
  96.         // FxCop: provide some way for derived classes to access GetObjectData even if the derived class
  97.         // explicitly re-inherits ISerializable.
  98.         //
  99.         [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
  100.         protected override void GetObjectData(SerializationInfo serializationInfo, StreamingContext streamingContext)
  101.         {
  102.             serializationInfo.AddValue("headers", m_headers, typeof(WebHeaderCollection));
  103.             serializationInfo.AddValue("proxy", m_proxy, typeof(IWebProxy));
  104.             serializationInfo.AddValue("uri", m_uri, typeof(Uri));
  105.             serializationInfo.AddValue("connectionGroupName", m_connectionGroupName);
  106.             serializationInfo.AddValue("method", m_method);
  107.             serializationInfo.AddValue("contentLength", m_contentLength);
  108.             serializationInfo.AddValue("timeout", m_timeout);
  109.             serializationInfo.AddValue("fileAccess", m_fileAccess);
  110.            
  111.             //we're leaving this for legacy. V1.1 and V1.0 had this field in the serialization constructor
  112.             serializationInfo.AddValue("preauthenticate", false);
  113.             base.GetObjectData(serializationInfo, streamingContext);
  114.         }
  115.        
  116.        
  117.         // properties
  118.        
  119.         internal bool Aborted {
  120.             get { return m_Aborted != 0; }
  121.         }
  122.        
  123.         public override string ConnectionGroupName {
  124.             get { return m_connectionGroupName; }
  125.             set { m_connectionGroupName = value; }
  126.         }
  127.        
  128.         public override long ContentLength {
  129.             get { return m_contentLength; }
  130.             set {
  131.                 if (value < 0) {
  132.                     throw new ArgumentException(SR.GetString(SR.net_clsmall), "value");
  133.                 }
  134.                 m_contentLength = value;
  135.             }
  136.         }
  137.        
  138.         public override string ContentType {
  139.             get { return m_headers["Content-Type"]; }
  140.             set { m_headers["Content-Type"] = value; }
  141.         }
  142.        
  143.         public override ICredentials Credentials {
  144.             get { return m_credentials; }
  145.             set { m_credentials = value; }
  146.         }
  147.        
  148.         public override WebHeaderCollection Headers {
  149.             get { return m_headers; }
  150.         }
  151.        
  152.         public override string Method {
  153.             get { return m_method; }
  154.             set {
  155.                 if (ValidationHelper.IsBlankString(value)) {
  156.                     throw new ArgumentException(SR.GetString(SR.net_badmethod), "value");
  157.                 }
  158.                 m_method = value;
  159.             }
  160.         }
  161.        
  162.         public override bool PreAuthenticate {
  163.             get { return m_preauthenticate; }
  164.             set { m_preauthenticate = true; }
  165.         }
  166.        
  167.         public override IWebProxy Proxy {
  168.             get { return m_proxy; }
  169.             set { m_proxy = value; }
  170.         }
  171.        
  172.         //UEUE changed default from infinite to 100 seconds
  173.         public override int Timeout {
  174.             get { return m_timeout; }
  175.             set {
  176.                 if ((value < 0) && (value != System.Threading.Timeout.Infinite)) {
  177.                     throw new ArgumentOutOfRangeException(SR.GetString(SR.net_io_timeout_use_ge_zero));
  178.                 }
  179.                 m_timeout = value;
  180.             }
  181.         }
  182.        
  183.         public override Uri RequestUri {
  184.             get { return m_uri; }
  185.         }
  186.        
  187.         // methods
  188.        
  189.         [HostProtection(ExternalThreading = true)]
  190.         public override IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
  191.         {
  192.             GlobalLog.Enter("FileWebRequest::BeginGetRequestStream");
  193.            
  194.             try {
  195.                 if (Aborted)
  196.                     throw ExceptionHelper.RequestAbortedException;
  197.                 if (!CanGetRequestStream()) {
  198.                     Exception e = new ProtocolViolationException(SR.GetString(SR.net_nouploadonget));
  199.                     GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
  200.                     throw e;
  201.                 }
  202.                 if (m_response != null) {
  203.                     Exception e = new InvalidOperationException(SR.GetString(SR.net_reqsubmitted));
  204.                     GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
  205.                     throw e;
  206.                 }
  207.                 lock (this) {
  208.                     if (m_writePending) {
  209.                         Exception e = new InvalidOperationException(SR.GetString(SR.net_repcall));
  210.                         GlobalLog.LeaveException("FileWebRequest::BeginGetRequestStream", e);
  211.                         throw e;
  212.                     }
  213.                     m_writePending = true;
  214.                 }
  215.                
  216.                 //we need to force the capture of the identity and context to make sure the
  217.                 //posted callback doesn't inavertently gain access to something it shouldn't.
  218.                 m_ReadAResult = new ContextAwareResult(true, true, true, this, state, callback);
  219.                 lock (m_ReadAResult.StartPostingAsyncOp()) {
  220.                     ThreadPool.UnsafeQueueUserWorkItem(s_GetRequestStreamCallback, m_ReadAResult);
  221.                     m_ReadAResult.FinishPostingAsyncOp();
  222.                 }
  223.             }
  224.             catch (Exception exception) {
  225.                 if (Logging.On)
  226.                     Logging.Exception(Logging.Web, this, "BeginGetRequestStream", exception);
  227.                 throw;
  228.             }
  229.             finally {
  230.                 GlobalLog.Leave("FileWebRequest::BeginGetRequestSteam");
  231.             }
  232.             return m_ReadAResult;
  233.         }
  234.        
  235.         [HostProtection(ExternalThreading = true)]
  236.         public override IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
  237.         {
  238.             GlobalLog.Enter("FileWebRequest::BeginGetResponse");
  239.            
  240.             try {
  241.                 if (Aborted)
  242.                     throw ExceptionHelper.RequestAbortedException;
  243.                 lock (this) {
  244.                     if (m_readPending) {
  245.                         Exception e = new InvalidOperationException(SR.GetString(SR.net_repcall));
  246.                         GlobalLog.LeaveException("FileWebRequest::BeginGetResponse", e);
  247.                         throw e;
  248.                     }
  249.                     m_readPending = true;
  250.                 }
  251.                
  252.                 //we need to force the capture of the identity and context to make sure the
  253.                 //posted callback doesn't inavertently gain access to something it shouldn't.
  254.                 m_WriteAResult = new ContextAwareResult(true, true, true, this, state, callback);
  255.                 lock (m_WriteAResult.StartPostingAsyncOp()) {
  256.                     ThreadPool.UnsafeQueueUserWorkItem(s_GetResponseCallback, m_WriteAResult);
  257.                     m_WriteAResult.FinishPostingAsyncOp();
  258.                 }
  259.             }
  260.             catch (Exception exception) {
  261.                 if (Logging.On)
  262.                     Logging.Exception(Logging.Web, this, "BeginGetResponse", exception);
  263.                 throw;
  264.             }
  265.             finally {
  266.                 GlobalLog.Leave("FileWebRequest::BeginGetResponse");
  267.             }
  268.             return m_WriteAResult;
  269.         }
  270.        
  271.         private bool CanGetRequestStream()
  272.         {
  273.             return !KnownHttpVerb.Parse(m_method).ContentBodyNotAllowed;
  274.         }
  275.        
  276.         public override Stream EndGetRequestStream(IAsyncResult asyncResult)
  277.         {
  278.             GlobalLog.Enter("FileWebRequest::EndGetRequestStream");
  279.            
  280.             Stream stream;
  281.             try {
  282.                 ContextAwareResult ar = asyncResult as ContextAwareResult;
  283.                 if (asyncResult == null || ar == null) {
  284.                     Exception e = asyncResult == null ? new ArgumentNullException("asyncResult") : new ArgumentException(SR.GetString(SR.InvalidAsyncResult), "asyncResult");
  285.                     GlobalLog.LeaveException("FileWebRequest::EndGetRequestStream", e);
  286.                     throw e;
  287.                 }
  288.                
  289.                 object result = ar.InternalWaitForCompletion();
  290.                 if (result is Exception) {
  291.                     throw (Exception)result;
  292.                 }
  293.                 stream = (Stream)result;
  294.                 m_writePending = false;
  295.             }
  296.             catch (Exception exception) {
  297.                 if (Logging.On)
  298.                     Logging.Exception(Logging.Web, this, "EndGetRequestStream", exception);
  299.                 throw;
  300.             }
  301.             finally {
  302.                 GlobalLog.Leave("FileWebRequest::EndGetRequestStream");
  303.             }
  304.             return stream;
  305.         }
  306.        
  307.         public override WebResponse EndGetResponse(IAsyncResult asyncResult)
  308.         {
  309.             GlobalLog.Enter("FileWebRequest::EndGetResponse");
  310.            
  311.             WebResponse response;
  312.             try {
  313.                 ContextAwareResult ar = asyncResult as ContextAwareResult;
  314.                 if (asyncResult == null || ar == null) {
  315.                     Exception e = asyncResult == null ? new ArgumentNullException("asyncResult") : new ArgumentException(SR.GetString(SR.InvalidAsyncResult), "asyncResult");
  316.                     GlobalLog.LeaveException("FileWebRequest::EndGetRequestStream", e);
  317.                     throw e;
  318.                 }
  319.                
  320.                
  321.                 object result = ar.InternalWaitForCompletion();
  322.                 if (result is Exception) {
  323.                     throw (Exception)result;
  324.                 }
  325.                 response = (WebResponse)result;
  326.                 m_readPending = false;
  327.             }
  328.             catch (Exception exception) {
  329.                 if (Logging.On)
  330.                     Logging.Exception(Logging.Web, this, "EndGetResponse", exception);
  331.                 throw;
  332.             }
  333.             finally {
  334.                 GlobalLog.Leave("FileWebRequest::EndGetResponse");
  335.             }
  336.             return response;
  337.         }
  338.        
  339.         public override Stream GetRequestStream()
  340.         {
  341.             GlobalLog.Enter("FileWebRequest::GetRequestStream");
  342.            
  343.             IAsyncResult result;
  344.            
  345.             try {
  346.                 result = BeginGetRequestStream(null, null);
  347.                
  348.                 if ((Timeout != System.Threading.Timeout.Infinite) && !result.IsCompleted) {
  349.                     if (!result.AsyncWaitHandle.WaitOne(Timeout, false) || !result.IsCompleted) {
  350.                         if (m_stream != null) {
  351.                             m_stream.Close();
  352.                         }
  353.                         Exception e = new WebException(NetRes.GetWebStatusString(WebExceptionStatus.Timeout), WebExceptionStatus.Timeout);
  354.                         GlobalLog.LeaveException("FileWebRequest::GetRequestStream", e);
  355.                         throw e;
  356.                     }
  357.                 }
  358.             }
  359.             catch (Exception exception) {
  360.                 if (Logging.On)
  361.                     Logging.Exception(Logging.Web, this, "GetRequestStream", exception);
  362.                 throw;
  363.             }
  364.             finally {
  365.                 GlobalLog.Leave("FileWebRequest::GetRequestStream");
  366.             }
  367.             return EndGetRequestStream(result);
  368.         }
  369.        
  370.         public override WebResponse GetResponse()
  371.         {
  372.             GlobalLog.Enter("FileWebRequest::GetResponse");
  373.            
  374.             m_syncHint = true;
  375.            
  376.             IAsyncResult result;
  377.            
  378.             try {
  379.                 result = BeginGetResponse(null, null);
  380.                
  381.                 if ((Timeout != System.Threading.Timeout.Infinite) && !result.IsCompleted) {
  382.                     if (!result.AsyncWaitHandle.WaitOne(Timeout, false) || !result.IsCompleted) {
  383.                         if (m_response != null) {
  384.                             m_response.Close();
  385.                         }
  386.                         Exception e = new WebException(NetRes.GetWebStatusString(WebExceptionStatus.Timeout), WebExceptionStatus.Timeout);
  387.                         GlobalLog.LeaveException("FileWebRequest::GetResponse", e);
  388.                         throw e;
  389.                     }
  390.                 }
  391.             }
  392.             catch (Exception exception) {
  393.                 if (Logging.On)
  394.                     Logging.Exception(Logging.Web, this, "GetResponse", exception);
  395.                 throw;
  396.             }
  397.             finally {
  398.                 GlobalLog.Leave("FileWebRequest::GetResponse");
  399.             }
  400.             return EndGetResponse(result);
  401.         }
  402.        
  403.         [PermissionSet(SecurityAction.Assert, Name = "FullTrust")]
  404.         private static void GetRequestStreamCallback(object state)
  405.         {
  406.             ContextAwareResult asyncResult = (ContextAwareResult)state;
  407.             try {
  408.                 ExecutionContext context = asyncResult.ContextCopy;
  409.                 if (context == null)
  410.                     WrappedGetRequestStreamCallback(state);
  411.                 else
  412.                     ExecutionContext.Run(context, s_WrappedGetRequestStreamCallback, state);
  413.             }
  414.             catch (InvalidOperationException) {
  415.                 // ContextCopy must have returned InvalidOperation because the
  416.                 // operation is already completed (e.g. due to Abort)
  417.                 // Verify it is completed and return.
  418.                 if (asyncResult.InternalPeekCompleted)
  419.                     return;
  420.                 else
  421.                     throw;
  422.             }
  423.         }
  424.         //
  425.         // this method runs in the context of the user Begin call .
  426.         //
  427.         private static void WrappedGetRequestStreamCallback(object state)
  428.         {
  429.             GlobalLog.Enter("FileWebRequest::GetRequestStreamCallback");
  430.             ContextAwareResult asyncResult = (ContextAwareResult)state;
  431.             FileWebRequest request = (FileWebRequest)asyncResult.AsyncObject;
  432.            
  433.             try {
  434.                 if (request.m_stream == null) {
  435.                     request.m_stream = new FileWebStream(request, request.m_uri.LocalPath, FileMode.Create, FileAccess.Write, FileShare.Read);
  436.                     request.m_fileAccess = FileAccess.Write;
  437.                     request.m_writing = true;
  438.                     asyncResult.InvokeCallback(request.m_stream);
  439.                     GlobalLog.Leave("FileWebRequest::GetRequestStreamCallback");
  440.                 }
  441.             }
  442.             catch (Exception e) {
  443.                 if (asyncResult.IsCompleted || NclUtilities.IsFatal(e)) {
  444.                     throw;
  445.                 }
  446.                
  447.                 Exception ex = new WebException(e.Message, e);
  448.                 GlobalLog.LeaveException("FileWebRequest::GetRequestStreamCallback", ex);
  449.                 asyncResult.InvokeCallback(ex);
  450.             }
  451.         }
  452.        
  453.         [PermissionSet(SecurityAction.Assert, Name = "FullTrust")]
  454.         private static void GetResponseCallback(object state)
  455.         {
  456.             ContextAwareResult asyncResult = (ContextAwareResult)state;
  457.             try {
  458.                 ExecutionContext context = asyncResult.ContextCopy;
  459.                 if (context == null)
  460.                     WrappedGetResponseCallback(state);
  461.                 else
  462.                     ExecutionContext.Run(context, s_WrappedResponseCallback, state);
  463.             }
  464.             catch (InvalidOperationException) {
  465.                 // ContextCopy must have returned InvalidOperation because the
  466.                 // operation is already completed (e.g. due to Abort)
  467.                 // Verify it is completed and return.
  468.                 if (asyncResult.InternalPeekCompleted)
  469.                     return;
  470.                 else
  471.                     throw;
  472.             }
  473.         }
  474.         //
  475.         // this method runs in the context of the user Begin call .
  476.         //
  477.         private static void WrappedGetResponseCallback(object state)
  478.         {
  479.             GlobalLog.Enter("FileWebRequest::GetResponseCallback");
  480.             ContextAwareResult asyncResult = (ContextAwareResult)state;
  481.             FileWebRequest request = (FileWebRequest)asyncResult.AsyncObject;
  482.            
  483.             if (request.m_writePending || request.m_writing) {
  484.                 lock (request) {
  485.                     if (request.m_writePending || request.m_writing) {
  486.                         request.m_readerEvent = new ManualResetEvent(false);
  487.                     }
  488.                 }
  489.             }
  490.             if (request.m_readerEvent != null)
  491.                 request.m_readerEvent.WaitOne();
  492.            
  493.             try {
  494.                 if (request.m_response == null)
  495.                     request.m_response = new FileWebResponse(request, request.m_uri, request.m_fileAccess, !request.m_syncHint);
  496.                
  497.                 GlobalLog.Leave("FileWebRequest::GetResponseCallback");
  498.                 asyncResult.InvokeCallback(request.m_response);
  499.             }
  500.             catch (Exception e) {
  501.                 if (asyncResult.IsCompleted || NclUtilities.IsFatal(e)) {
  502.                     throw;
  503.                 }
  504.                 Exception ex = new WebException(e.Message, e);
  505.                 GlobalLog.LeaveException("FileWebRequest::GetResponseCallback", ex);
  506.                 asyncResult.InvokeCallback(ex);
  507.             }
  508.         }
  509.        
  510.         internal void UnblockReader()
  511.         {
  512.             GlobalLog.Enter("FileWebRequest::UnblockReader");
  513.             lock (this) {
  514.                 if (m_readerEvent != null) {
  515.                     m_readerEvent.Set();
  516.                 }
  517.             }
  518.             m_writing = false;
  519.             GlobalLog.Leave("FileWebRequest::UnblockReader");
  520.         }
  521.        
  522.         // NOT SUPPORTED method
  523.         public override bool UseDefaultCredentials {
  524.             get {
  525.                 throw ExceptionHelper.PropertyNotSupportedException;
  526.             }
  527.             set {
  528.                 throw ExceptionHelper.PropertyNotSupportedException;
  529.             }
  530.         }
  531.        
  532.         public override void Abort()
  533.         {
  534.             GlobalLog.Enter("FileWebRequest::Abort");
  535.             if (Logging.On)
  536.                 Logging.PrintWarning(Logging.Web, NetRes.GetWebStatusString("net_requestaborted", WebExceptionStatus.RequestCanceled));
  537.             try {
  538.                 if (Interlocked.Increment(ref m_Aborted) == 1) {
  539.                     ContextAwareResult readAResult = m_ReadAResult;
  540.                     ContextAwareResult writeAResult = m_WriteAResult;
  541.                    
  542.                     WebException webException = new WebException(NetRes.GetWebStatusString("net_requestaborted", WebExceptionStatus.RequestCanceled), WebExceptionStatus.RequestCanceled);
  543.                    
  544.                     Stream requestStream = m_stream;
  545.                    
  546.                     if (readAResult != null && !readAResult.IsCompleted)
  547.                         readAResult.InvokeCallback(webException);
  548.                     if (writeAResult != null && !writeAResult.IsCompleted)
  549.                         writeAResult.InvokeCallback(webException);
  550.                    
  551.                     if (requestStream != null)
  552.                         if (requestStream is ICloseEx)
  553.                             ((ICloseEx)requestStream).CloseEx(CloseExState.Abort);
  554.                         else
  555.                             requestStream.Close();
  556.                    
  557.                     if (m_response != null)
  558.                         ((ICloseEx)m_response).CloseEx(CloseExState.Abort);
  559.                 }
  560.             }
  561.             catch (Exception exception) {
  562.                 if (Logging.On)
  563.                     Logging.Exception(Logging.Web, this, "Abort", exception);
  564.                 throw;
  565.             }
  566.             finally {
  567.                 GlobalLog.Leave("FileWebRequest::Abort");
  568.             }
  569.         }
  570.     }
  571.    
  572.     internal class FileWebRequestCreator : IWebRequestCreate
  573.     {
  574.        
  575.         internal FileWebRequestCreator()
  576.         {
  577.         }
  578.        
  579.         public WebRequest Create(Uri uri)
  580.         {
  581.             return new FileWebRequest(uri);
  582.         }
  583.     }
  584.    
  585.     internal sealed class FileWebStream : FileStream, ICloseEx
  586.     {
  587.        
  588.         FileWebRequest m_request;
  589.        
  590.         [ResourceExposure(ResourceScope.Machine)]
  591.         [ResourceConsumption(ResourceScope.Machine)]
  592.         public FileWebStream(FileWebRequest request, string path, FileMode mode, FileAccess access, FileShare sharing) : base(path, mode, access, sharing)
  593.         {
  594.             GlobalLog.Enter("FileWebStream::FileWebStream");
  595.             m_request = request;
  596.             GlobalLog.Leave("FileWebStream::FileWebStream");
  597.         }
  598.        
  599.         [ResourceExposure(ResourceScope.Machine)]
  600.         [ResourceConsumption(ResourceScope.Machine)]
  601.         public FileWebStream(FileWebRequest request, string path, FileMode mode, FileAccess access, FileShare sharing, int length, bool async) : base(path, mode, access, sharing, length, async)
  602.         {
  603.             GlobalLog.Enter("FileWebStream::FileWebStream");
  604.             m_request = request;
  605.             GlobalLog.Leave("FileWebStream::FileWebStream");
  606.         }
  607.        
  608.         protected override void Dispose(bool disposing)
  609.         {
  610.             GlobalLog.Enter("FileWebStream::Close");
  611.             try {
  612.                 if (disposing && m_request != null) {
  613.                     m_request.UnblockReader();
  614.                 }
  615.             }
  616.             finally {
  617.                 base.Dispose(disposing);
  618.             }
  619.             GlobalLog.Leave("FileWebStream::Close");
  620.         }
  621.        
  622.         void ICloseEx.CloseEx(CloseExState closeState)
  623.         {
  624.             if ((closeState & CloseExState.Abort) != 0)
  625.                 SafeFileHandle.Close();
  626.             else
  627.                 Close();
  628.         }
  629.        
  630.         public override int Read(byte[] buffer, int offset, int size)
  631.         {
  632.             CheckError();
  633.             try {
  634.                 return base.Read(buffer, offset, size);
  635.             }
  636.             catch {
  637.                 CheckError();
  638.                 throw;
  639.             }
  640.         }
  641.        
  642.         public override void Write(byte[] buffer, int offset, int size)
  643.         {
  644.             CheckError();
  645.             try {
  646.                 base.Write(buffer, offset, size);
  647.             }
  648.             catch {
  649.                 CheckError();
  650.                 throw;
  651.             }
  652.         }
  653.        
  654.         public override IAsyncResult BeginRead(byte[] buffer, int offset, int size, AsyncCallback callback, object state)
  655.         {
  656.             CheckError();
  657.             try {
  658.                 return base.BeginRead(buffer, offset, size, callback, state);
  659.             }
  660.             catch {
  661.                 CheckError();
  662.                 throw;
  663.             }
  664.         }
  665.        
  666.         public override int EndRead(IAsyncResult ar)
  667.         {
  668.             try {
  669.                 return base.EndRead(ar);
  670.             }
  671.             catch {
  672.                 CheckError();
  673.                 throw;
  674.             }
  675.         }
  676.        
  677.         public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback callback, object state)
  678.         {
  679.             CheckError();
  680.             try {
  681.                 return base.BeginWrite(buffer, offset, size, callback, state);
  682.             }
  683.             catch {
  684.                 CheckError();
  685.                 throw;
  686.             }
  687.         }
  688.        
  689.         public override void EndWrite(IAsyncResult ar)
  690.         {
  691.             try {
  692.                 base.EndWrite(ar);
  693.             }
  694.             catch {
  695.                 CheckError();
  696.                 throw;
  697.             }
  698.         }
  699.        
  700.         private void CheckError()
  701.         {
  702.             if (m_request.Aborted) {
  703.                 throw new WebException(NetRes.GetWebStatusString("net_requestaborted", WebExceptionStatus.RequestCanceled), WebExceptionStatus.RequestCanceled);
  704.             }
  705.         }
  706.     }
  707. }

Developer Fusion