केवल कुछ निश्चित बाइट्स की प्रतिलिपि बनाने के लिए Stream.CopyTo का उपयोग करने का कोई तरीका?

Question

क्या गंतव्य स्ट्रीम में केवल कुछ बाइट्स की प्रतिलिपि बनाने के लिए Stream.CopyTo का उपयोग करने का कोई तरीका है? सबसे अच्छा कामकाज क्या है?

संपादित करें:
मेरे वैकल्पिक हल (कुछ कोड छोड़े गए):

internal sealed class Substream : Stream 
    { 
     private readonly Stream stream; 
     private readonly long origin; 
     private readonly long length; 
     private long position;   

     public Substream(Stream stream, long length) 
     { 
      this.stream = stream; 
      this.origin = stream.Position; 
      this.position = stream.Position; 
      this.length = length;    
     } 

public override int Read(byte[] buffer, int offset, int count) 
     { 
      var n = Math.Max(Math.Min(count, origin + length - position), 0);     
      int bytesRead = stream.Read(buffer, offset, (int) n); 
      position += bytesRead; 
      return bytesRead;    
     } 
} 

तो कॉपी करने के लिए n बाइट्स:

var substream = new Substream(stream, n); 
       substream.CopyTo(stm); 

Answer 1

copying streams के कार्यान्वयन ज्यादा जटिल नहीं है। आप बाइट्स की केवल एक निश्चित संख्या में कॉपी करने के लिए अनुकूल बन सके तो यह मौजूदा विधि, इस

public static void CopyStream(Stream input, Stream output, int bytes) 
{ 
    byte[] buffer = new byte[32768]; 
    int read; 
    while (bytes > 0 && 
      (read = input.Read(buffer, 0, Math.Min(buffer.Length, bytes))) > 0) 
    { 
     output.Write(buffer, 0, read); 
     bytes -= read; 
    } 
} 

bytes > 0 के लिए चेक शायद सख्ती से आवश्यक नहीं है की तरह कुछ बदलाव करने के लिए भी मुश्किल नहीं होना चाहिए, लेकिन कोई नुकसान नहीं कर सकता

Answer 2

क्या सिर्फ बाइट्स को कॉपी आप एक बफर का उपयोग कर की जरूरत के साथ गलत क्या है?

long CopyBytes(long bytesRequired, Stream inStream, Stream outStream) 
{ 
    long readSoFar = 0L; 
    var buffer = new byte[64*1024]; 
    do 
    { 
     var toRead = Math.Min(bytesRequired - readSoFar, buffer.Length); 
     var readNow = inStream.Read(buffer, 0, (int)toRead); 
     if (readNow == 0) 
      break; // End of stream 
     outStream.Write(buffer, 0, readNow); 
     readSoFar += readNow; 
    } while (readSoFar < bytesRequired); 
    return readSoFar; 
}