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.IO \ UnmanagedMemoryStreamWrapper

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. ** Class:  UnmanagedMemoryStreamWrapper
  18. **
  19. ** Purpose: Create a Memorystream over an UnmanagedMemoryStream
  20. **
  21. ===========================================================*/
  23. using System;
  24. using System.Runtime.InteropServices;
  25. using System.Security.Permissions;
  27. namespace System.IO
  28. {
  29.     // Needed for backwards compatibility with V1.x usages of the
  30.     // ResourceManager, where a MemoryStream is now returned as an
  31.     // UnmanagedMemoryStream from ResourceReader.
  32.     internal sealed class UnmanagedMemoryStreamWrapper : MemoryStream
  33.     {
  34.         private UnmanagedMemoryStream _unmanagedStream;
  35.        
  36.         internal UnmanagedMemoryStreamWrapper(UnmanagedMemoryStream stream)
  37.         {
  38.             _unmanagedStream = stream;
  39.         }
  40.        
  41.         public override bool CanRead {
  42.             get { return _unmanagedStream.CanRead; }
  43.         }
  44.        
  45.         public override bool CanSeek {
  46.             get { return _unmanagedStream.CanSeek; }
  47.         }
  48.        
  49.         public override bool CanWrite {
  50.             get { return _unmanagedStream.CanWrite; }
  51.         }
  52.        
  53.         protected override void Dispose(bool disposing)
  54.         {
  55.             try {
  56.                 if (disposing)
  57.                     _unmanagedStream.Close();
  58.             }
  59.             finally {
  60.                 base.Dispose(disposing);
  61.             }
  62.         }
  63.        
  64.         public override void Flush()
  65.         {
  66.             _unmanagedStream.Flush();
  67.         }
  68.        
  69.         public override byte[] GetBuffer()
  70.         {
  71.             throw new UnauthorizedAccessException(Environment.GetResourceString("UnauthorizedAccess_MemStreamBuffer"));
  72.         }
  73.        
  74.         public override int Capacity {
  75.             get { return (int)_unmanagedStream.Capacity; }
  76.             set {
  77.                 throw new IOException(Environment.GetResourceString("IO.IO_FixedCapacity"));
  78.             }
  79.         }
  80.        
  81.         public override long Length {
  82.             get { return _unmanagedStream.Length; }
  83.         }
  84.        
  85.         public override long Position {
  86.             get { return _unmanagedStream.Position; }
  87.             set { _unmanagedStream.Position = value; }
  88.         }
  89.        
  90.         public override int Read(        [In(), Out()]
  91. byte[] buffer, int offset, int count)
  92.         {
  93.             return _unmanagedStream.Read(buffer, offset, count);
  94.         }
  95.        
  96.         public override int ReadByte()
  97.         {
  98.             return _unmanagedStream.ReadByte();
  99.         }
  100.        
  101.        
  102.         public override long Seek(long offset, SeekOrigin loc)
  103.         {
  104.             return _unmanagedStream.Seek(offset, loc);
  105.         }
  106.        
  107.         unsafe public override byte[] ToArray()
  108.         {
  109.             if (!_unmanagedStream._isOpen)
  110.                 __Error.StreamIsClosed();
  111.             if (!_unmanagedStream.CanRead)
  112.                 __Error.ReadNotSupported();
  113.            
  114.             byte[] buffer = new byte[_unmanagedStream.Length];
  115.             Buffer.memcpy(_unmanagedStream.Pointer, 0, buffer, 0, (int)_unmanagedStream.Length);
  116.             return buffer;
  117.         }
  118.        
  119.         public override void Write(byte[] buffer, int offset, int count)
  120.         {
  121.             _unmanagedStream.Write(buffer, offset, count);
  122.         }
  123.        
  124.         public override void WriteByte(byte value)
  125.         {
  126.             _unmanagedStream.WriteByte(value);
  127.         }
  128.        
  129.         // Writes this MemoryStream to another stream.
  130.         unsafe public override void WriteTo(Stream stream)
  131.         {
  132.             if (!_unmanagedStream._isOpen)
  133.                 __Error.StreamIsClosed();
  134.             if (!_unmanagedStream.CanRead)
  135.                 __Error.ReadNotSupported();
  136.             if (stream == null)
  137.                 throw new ArgumentNullException("stream", Environment.GetResourceString("ArgumentNull_Stream"));
  138.            
  139.             byte[] buffer = ToArray();
  140.            
  141.             stream.Write(buffer, 0, buffer.Length);
  142.         }
  143.     }
  144. }

Developer Fusion