We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Channels \ AsyncCopyStreamResult

SSCLI
  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. //============================================================
  16. //
  17. // File: StreamHelper.cs
  18. //
  19. // Summary: Helper methods for streams.
  20. //
  21. //===========================================================
  24. using System;
  25. using System.IO;
  26. using System.Runtime.Remoting;
  27. using System.Threading;
  29. namespace System.Runtime.Remoting.Channels
  30. {
  31.    
  32.     static internal class StreamHelper
  33.     {
  34.         private static AsyncCallback _asyncCopyStreamReadCallback = new AsyncCallback(AsyncCopyStreamReadCallback);
  35.         private static AsyncCallback _asyncCopyStreamWriteCallback = new AsyncCallback(AsyncCopyStreamWriteCallback);
  36.        
  37.         static internal void CopyStream(Stream source, Stream target)
  38.         {
  39.             if (source == null)
  40.                 return;
  41.            
  42.             // see if this is a ChunkedMemoryStream (we can do a direct write)
  43.             ChunkedMemoryStream chunkedMemStream = source as ChunkedMemoryStream;
  44.             if (chunkedMemStream != null) {
  45.                 chunkedMemStream.WriteTo(target);
  46.             }
  47.             else {
  48.                 // see if this is a MemoryStream (we can do a direct write)
  49.                 MemoryStream memContentStream = source as MemoryStream;
  50.                 if (memContentStream != null) {
  51.                     memContentStream.WriteTo(target);
  52.                 }
  53.                 else {
  54.                     // otherwise, we need to copy the data through an intermediate buffer
  55.                    
  56.                     byte[] buffer = CoreChannel.BufferPool.GetBuffer();
  57.                     int bufferSize = buffer.Length;
  58.                     int readCount = source.Read(buffer, 0, bufferSize);
  59.                     while (readCount > 0) {
  60.                         target.Write(buffer, 0, readCount);
  61.                         readCount = source.Read(buffer, 0, bufferSize);
  62.                     }
  63.                     CoreChannel.BufferPool.ReturnBuffer(buffer);
  64.                 }
  65.             }
  66.            
  67.         }
  68.         // CopyStream
  69.        
  70.        
  71.         static internal void BufferCopy(byte[] source, int srcOffset, byte[] dest, int destOffset, int count)
  72.         {
  73.             if (count > 8) {
  74.                 Buffer.BlockCopy(source, srcOffset, dest, destOffset, count);
  75.             }
  76.             else {
  77.                 for (int co = 0; co < count; co++)
  78.                     dest[destOffset + co] = source[srcOffset + co];
  79.             }
  80.         }
  81.         // BufferCopy
  82.        
  83.        
  84.        
  85.         static internal IAsyncResult BeginAsyncCopyStream(Stream source, Stream target, bool asyncRead, bool asyncWrite, bool closeSource, bool closeTarget, AsyncCallback callback, object state)
  86.         {
  87.             AsyncCopyStreamResult streamState = new AsyncCopyStreamResult(callback, state);
  88.            
  89.             byte[] buffer = CoreChannel.BufferPool.GetBuffer();
  90.            
  91.             streamState.Source = source;
  92.             streamState.Target = target;
  93.             streamState.Buffer = buffer;
  94.             streamState.AsyncRead = asyncRead;
  95.             streamState.AsyncWrite = asyncWrite;
  96.             streamState.CloseSource = closeSource;
  97.             streamState.CloseTarget = closeTarget;
  98.            
  99.             try {
  100.                 AsyncCopyReadHelper(streamState);
  101.             }
  102.             catch (Exception e) {
  103.                 streamState.SetComplete(null, e);
  104.             }
  105.             catch {
  106.                 streamState.SetComplete(null, new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
  107.             }
  108.            
  109.             return streamState;
  110.         }
  111.         // BeginAsyncCopyStream
  112.         static internal void EndAsyncCopyStream(IAsyncResult iar)
  113.         {
  114.             AsyncCopyStreamResult asyncResult = (AsyncCopyStreamResult)iar;
  115.            
  116.             if (!iar.IsCompleted) {
  117.                 iar.AsyncWaitHandle.WaitOne();
  118.             }
  119.            
  120.             if (asyncResult.Exception != null) {
  121.                 throw asyncResult.Exception;
  122.             }
  123.         }
  124.         // EndAsyncCopyStream
  125.        
  126.         private static void AsyncCopyReadHelper(AsyncCopyStreamResult streamState)
  127.         {
  128.             // There is no try-catch here because the calling method always has a try-catch.
  129.            
  130.             if (streamState.AsyncRead) {
  131.                 byte[] buffer = streamState.Buffer;
  132.                 streamState.Source.BeginRead(buffer, 0, buffer.Length, _asyncCopyStreamReadCallback, streamState);
  133.             }
  134.             else {
  135.                 byte[] buffer = streamState.Buffer;
  136.                 int bytesRead = streamState.Source.Read(buffer, 0, buffer.Length);
  137.                 if (bytesRead == 0) {
  138.                     streamState.SetComplete(null, null);
  139.                 }
  140.                 else if (bytesRead < 0) {
  141.                     throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
  142.                 }
  143.                 else {
  144.                     AsyncCopyWriteHelper(streamState, bytesRead);
  145.                 }
  146.             }
  147.         }
  148.         // AsyncCopyReadHelper
  149.        
  150.         private static void AsyncCopyWriteHelper(AsyncCopyStreamResult streamState, int bytesRead)
  151.         {
  152.             // There is no try-catch here because the calling method always has a try-catch.
  153.            
  154.             if (streamState.AsyncWrite) {
  155.                 byte[] buffer = streamState.Buffer;
  156.                 streamState.Target.BeginWrite(buffer, 0, bytesRead, _asyncCopyStreamWriteCallback, streamState);
  157.             }
  158.             else {
  159.                 byte[] buffer = streamState.Buffer;
  160.                 streamState.Target.Write(buffer, 0, bytesRead);
  161.                
  162.                 AsyncCopyReadHelper(streamState);
  163.             }
  164.         }
  165.         // AsyncCopyWriteHelper
  166.        
  167.         private static void AsyncCopyStreamReadCallback(IAsyncResult iar)
  168.         {
  169.             AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
  170.            
  171.             try {
  172.                 Stream source = state.Source;
  173.                
  174.                 int bytesRead = source.EndRead(iar);
  175.                 if (bytesRead == 0) {
  176.                     state.SetComplete(null, null);
  177.                 }
  178.                 else if (bytesRead < 0) {
  179.                     throw new RemotingException(CoreChannel.GetResourceString("Remoting_Stream_UnknownReadError"));
  180.                 }
  181.                 else {
  182.                     AsyncCopyWriteHelper(state, bytesRead);
  183.                 }
  184.             }
  185.             catch (Exception e) {
  186.                 state.SetComplete(null, e);
  187.             }
  188.             catch {
  189.                 state.SetComplete(null, new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
  190.             }
  191.         }
  192.         // AsyncCopyStreamReadCallback
  193.        
  194.         private static void AsyncCopyStreamWriteCallback(IAsyncResult iar)
  195.         {
  196.             AsyncCopyStreamResult state = (AsyncCopyStreamResult)iar.AsyncState;
  197.            
  198.             try {
  199.                 state.Target.EndWrite(iar);
  200.                
  201.                 AsyncCopyReadHelper(state);
  202.             }
  203.             catch (Exception e) {
  204.                 state.SetComplete(null, e);
  205.             }
  206.             catch {
  207.                 state.SetComplete(null, new Exception(CoreChannel.GetResourceString("Remoting_nonClsCompliantException")));
  208.             }
  209.         }
  210.         // AsyncCopyStreamWriteCallback
  211.     }
  212.     // class StreamHelper
  213.    
  214.    
  215.     internal class AsyncCopyStreamResult : BasicAsyncResult
  216.     {
  217.         internal Stream Source;
  218.         internal Stream Target;
  219.         internal byte[] Buffer;
  220.         internal bool AsyncRead;
  221.         internal bool AsyncWrite;
  222.         internal bool CloseSource;
  223.         internal bool CloseTarget;
  224.        
  225.         internal AsyncCopyStreamResult(AsyncCallback callback, object state) : base(callback, state)
  226.         {
  227.         }
  228.        
  229.         internal override void CleanupOnComplete()
  230.         {
  231.             if (Buffer != null)
  232.                 CoreChannel.BufferPool.ReturnBuffer(Buffer);
  233.            
  234.             if (CloseSource)
  235.                 Source.Close();
  236.             if (CloseTarget)
  237.                 Target.Close();
  238.            
  239.         }
  240.         // CleanupOnComplete
  241.     }
  242.     // class AsyncCopyStreamResult
  243.    
  244. }
  245. // namespace System.Runtime.Remoting.Channels

Developer Fusion