blocks|key|1125131|text|class+ConcatenatedStream+:+Stream
{
++++Queue<Stream>+streams;

++++public+ConcatenatedStream(IEnumerable<Stream>+streams)
++++{
++++++++this.streams+=+new+Queue<Stream>(streams);
++++}

++++public+override+bool+CanRead
++++{
++++++++get+{+return+true;+}
++++}

++++public+override+int+Read(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++int+totalBytesRead+=+0;

++++++++while+(count+>+0+&&+streams.Count+>+0)
++++++++{
++++++++++++int+bytesRead+=+streams.Peek().Read(buffer,+offset,+count);
++++++++++++if+(bytesRead+==+0)
++++++++++++{
++++++++++++++++streams.Dequeue().Dispose();
++++++++++++++++continue;
++++++++++++}

++++++++++++totalBytesRead+%2B=+bytesRead;
++++++++++++offset+%2B=+bytesRead;
++++++++++++count+-=+bytesRead;
++++++++}

++++++++return+totalBytesRead;
++++}

++++public+override+bool+CanSeek
++++{
++++++++get+{+return+false;+}
++++}

++++public+override+bool+CanWrite
++++{
++++++++get+{+return+false;+}
++++}

++++public+override+void+Flush()
++++{
++++++++throw+new+NotImplementedException();
++++}

++++public+override+long+Length
++++{
++++++++get+{+throw+new+NotImplementedException();+}
++++}

++++public+override+long+Position
++++{
++++++++get
++++++++{
++++++++++++throw+new+NotImplementedException();
++++++++}
++++++++set
++++++++{
++++++++++++throw+new+NotImplementedException();
++++++++}
++++}

++++public+override+long+Seek(long+offset,+SeekOrigin+origin)
++++{
++++++++throw+new+NotImplementedException();
++++}

++++public+override+void+SetLength(long+value)
++++{
++++++++throw+new+NotImplementedException();
++++}

++++public+override+void+Write(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++throw+new+NotImplementedException();
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1125132|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class ConcatenatedStream : Stream
{
 Queue&lt;Stream&gt; streams;

 public ConcatenatedStream(IEnumerable&lt;Stream&gt; streams)
 {
 this.streams = new Queue&lt;Stream&gt;(streams);
 }

 public override bool CanRead
 {
 get { return true; }
 }

 public override int Read(byte[] buffer, int offset, int count)
 {
 int totalBytesRead = 0;

 while (count &gt; 0 &amp;&amp; streams.Count &gt; 0)
 {
 int bytesRead = streams.Peek().Read(buffer, offset, count);
 if (bytesRead == 0)
 {
 streams.Dequeue().Dispose();
 continue;
 }

 totalBytesRead += bytesRead;
 offset += bytesRead;
 count -= bytesRead;
 }

 return totalBytesRead;
 }

 public override bool CanSeek
 {
 get { return false; }
 }

 public override bool CanWrite
 {
 get { return false; }
 }

 public override void Flush()
 {
 throw new NotImplementedException();
 }

 public override long Length
 {
 get { throw new NotImplementedException(); }
 }

 public override long Position
 {
 get
 {
 throw new NotImplementedException();
 }
 set
 {
 throw new NotImplementedException();
 }
 }

 public override long Seek(long offset, SeekOrigin origin)
 {
 throw new NotImplementedException();
 }

 public override void SetLength(long value)
 {
 throw new NotImplementedException();
 }

 public override void Write(byte[] buffer, int offset, int count)
 {
 throw new NotImplementedException();
 }
}
</code></pre>

blocks|key|1125191|text|未经测试，但类似于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1125192|class+StreamEnumerator+:+Stream
{
++++private+long+position;
++++bool+closeStreams;
++++IEnumerator<Stream>+iterator;
++++Stream+current;
++++private+void+EndOfStream()+{
++++++++if+(closeStreams+&&+current+!=+null)
++++++++{
++++++++++++current.Close();
++++++++++++current.Dispose();
++++++++}
++++++++current+=+null;
++++}
++++private+Stream+Current
++++{
++++++++get+{
++++++++++++if(current+!=+null)+return+current;
++++++++++++if+(iterator+==+null)+throw+new+ObjectDisposedException(GetType().Name);
++++++++++++if+(iterator.MoveNext())+{
++++++++++++++++current+=+iterator.Current;
++++++++++++}
++++++++++++return+current;
++++++++}
++++}
++++protected+override+void+Dispose(bool+disposing)
++++{
++++++++if+(disposing)
++++++++{
++++++++++++EndOfStream();
++++++++++++iterator.Dispose();
++++++++++++iterator+=+null;
++++++++++++current+=+null;
++++++++}
++++++++base.Dispose(disposing);
++++}
++++public+StreamEnumerator(IEnumerable<Stream>+source,+bool+closeStreams)
++++{
++++++++if+(source+==+null)+throw+new+ArgumentNullException("source");
++++++++iterator+=+source.GetEnumerator();
++++++++this.closeStreams+=+closeStreams;
++++}
++++public+override+bool+CanRead+{+get+{+return+true;+}+}
++++public+override+bool+CanWrite+{+get+{+return+false;+}+}
++++public+override+void+Write(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++throw+new+NotSupportedException();
++++}
++++public+override+void+WriteByte(byte+value)
++++{
++++++++throw+new+NotSupportedException();
++++}
++++public+override+bool+CanSeek+{+get+{+return+false;+}+}
++++public+override+bool+CanTimeout+{+get+{+return+false;+}+}
++++public+override+void+SetLength(long+value)
++++{
++++++++throw+new+NotSupportedException();
++++}
++++public+override+long+Seek(long+offset,+SeekOrigin+origin)
++++{
++++++++throw+new+NotSupportedException();
++++}
++++public+override+void+Flush()
++++{+/*+nothing+to+do+*/+}
++++public+override+long+Length
++++{
++++++++get+{+throw+new+NotSupportedException();+}
++++}
++++public+override+long+Position
++++{
++++++++get+{+return+position;+}
++++++++set+{+if+(value+!=+this.position)+throw+new+NotSupportedException();+}
++++}
++++public+override+int+Read(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++int+result+=+0;
++++++++while+(count+>+0)
++++++++{
++++++++++++Stream+stream+=+Current;
++++++++++++if+(stream+==+null)+break;
++++++++++++int+thisCount+=+stream.Read(buffer,+offset,+count);
++++++++++++result+%2B=+thisCount;
++++++++++++count+-=+thisCount;
++++++++++++offset+%2B=+thisCount;
++++++++++++if+(thisCount+==+0)+EndOfStream();
++++++++}
++++++++position+%2B=+result;
++++++++return+result;
++++}
}|code-block|syntax|javascript|1125193|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Untested, but something like:

<pre><code>class StreamEnumerator : Stream
{
 private long position;
 bool closeStreams;
 IEnumerator&lt;Stream&gt; iterator;
 Stream current;
 private void EndOfStream() {
 if (closeStreams &amp;&amp; current != null)
 {
 current.Close();
 current.Dispose();
 }
 current = null;
 }
 private Stream Current
 {
 get {
 if(current != null) return current;
 if (iterator == null) throw new ObjectDisposedException(GetType().Name);
 if (iterator.MoveNext()) {
 current = iterator.Current;
 }
 return current;
 }
 }
 protected override void Dispose(bool disposing)
 {
 if (disposing)
 {
 EndOfStream();
 iterator.Dispose();
 iterator = null;
 current = null;
 }
 base.Dispose(disposing);
 }
 public StreamEnumerator(IEnumerable&lt;Stream&gt; source, bool closeStreams)
 {
 if (source == null) throw new ArgumentNullException("source");
 iterator = source.GetEnumerator();
 this.closeStreams = closeStreams;
 }
 public override bool CanRead { get { return true; } }
 public override bool CanWrite { get { return false; } }
 public override void Write(byte[] buffer, int offset, int count)
 {
 throw new NotSupportedException();
 }
 public override void WriteByte(byte value)
 {
 throw new NotSupportedException();
 }
 public override bool CanSeek { get { return false; } }
 public override bool CanTimeout { get { return false; } }
 public override void SetLength(long value)
 {
 throw new NotSupportedException();
 }
 public override long Seek(long offset, SeekOrigin origin)
 {
 throw new NotSupportedException();
 }
 public override void Flush()
 { /* nothing to do */ }
 public override long Length
 {
 get { throw new NotSupportedException(); }
 }
 public override long Position
 {
 get { return position; }
 set { if (value != this.position) throw new NotSupportedException(); }
 }
 public override int Read(byte[] buffer, int offset, int count)
 {
 int result = 0;
 while (count &gt; 0)
 {
 Stream stream = Current;
 if (stream == null) break;
 int thisCount = stream.Read(buffer, offset, count);
 result += thisCount;
 count -= thisCount;
 offset += thisCount;
 if (thisCount == 0) EndOfStream();
 }
 position += result;
 return result;
 }
}
</code></pre>

blocks|key|1125239|text|为什么不使用已经封装了多个文件概念的容器，比如使用来自SharpZipLib的ZipOutputStream|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1125240|entityMap|0|LINK|mutability|MUTABLE|url|http://www.icsharpcode.net/opensource/sharpziplib/^0|R|B|13|F|R|B|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Why not use a container that already encapsulates the idea of multiple files, like say using <code>ZipOutputStream</code> from <a href="http://www.icsharpcode.net/opensource/sharpziplib/" rel="nofollow"><code>SharpZipLib</code></a>?

blocks|key|910263|text|这里有一个支持搜索的选项，这在许多情况下都是必要的。它缺少一些处理底层流的功能，如果您愿意假设底层流不会改变长度，那么它可能会更高效一些。然后可以一次计算总长度和流偏移量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|910264|public+sealed+class+ConcatenatedStream+:+Stream
{
++++List<Stream>+streams;
++++private+long+_Position+{+get;+set;+}

++++public+ConcatenatedStream(List<Stream>+streams)
++++{
++++++++this.streams+=+streams;
++++++++Seek(0,+SeekOrigin.Begin);
++++}

++++public+override+bool+CanRead
++++{
++++++++get+{+return+true;+}
++++}

++++public+override+int+Read(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++if+(streams.Count+==+0)
++++++++++++return+0;

++++++++var+startStream+=+0;
++++++++var+cumulativeCapacity+=+0L;
++++++++for+(var+i+=+0;+i+<+streams.Count;+i%2B%2B)
++++++++{
++++++++++++cumulativeCapacity+%2B=+streams[i].Length;
++++++++++++if+(_Position+<+cumulativeCapacity)
++++++++++++{
++++++++++++++++startStream+=+i;
++++++++++++++++break;
++++++++++++}
++++++++}

++++++++var+bytesRead+=+0;
++++++++var+curStream+=+startStream;

++++++++while+(_Position+<+Length+&&+bytesRead+<+count+&&+curStream+<+streams.Count)
++++++++{
++++++++++++var+r+=+streams[curStream].Read(buffer,+offset+%2B+bytesRead,+count+-+bytesRead);
++++++++++++bytesRead+%2B=+r;
++++++++++++Seek(_Position+%2B+r,+SeekOrigin.Begin);
++++++++++++curStream%2B%2B;
++++++++}

++++++++return+bytesRead;
++++}

++++public+override+bool+CanSeek
++++{
++++++++get+{+return+true;+}
++++}

++++public+override+bool+CanWrite
++++{
++++++++get+{+return+false;+}
++++}

++++public+override+void+Flush()
++++{
++++++++throw+new+NotImplementedException();
++++}

++++public+override+long+Length
++++{
++++++++get+{
++++++++++++long+length+=+0;
++++++++++++for+(var+i+=+0;+i+<+streams.Count;+i%2B%2B)
++++++++++++{
++++++++++++++++length+%2B=+streams[i].Length;
++++++++++++}
++++++++++++return+length;
++++++++}
++++}

++++public+override+long+Position
++++{
++++++++get
++++++++{
++++++++++++return+_Position;
++++++++}
++++++++set
++++++++{
++++++++++++Seek(value,+SeekOrigin.Begin);
++++++++}
++++}

++++public+override+long+Seek(long+offset,+SeekOrigin+origin)
++++{
++++++++if+(origin+==+SeekOrigin.Begin)
++++++++{
++++++++++++_Position+=+offset;

++++++++++++var+prevLength+=+0L;
++++++++++++var+cumulativeLength+=+0L;
++++++++++++for+(var+i+=+0;+i+<+streams.Count;+i%2B%2B)
++++++++++++{
++++++++++++++++cumulativeLength+%2B=+streams[i].Length;
++++++++++++++++if+(offset+<+cumulativeLength)
++++++++++++++++{
++++++++++++++++++++streams[i].Seek(offset+-+prevLength,+SeekOrigin.Begin);
++++++++++++++++++++return+_Position;
++++++++++++++++}
++++++++++++++++prevLength+=+cumulativeLength;
++++++++++++}
++++++++}

++++++++if+(origin+==+SeekOrigin.Current)
++++++++{
++++++++++++var+newAbs+=+_Position+%2B+offset;
++++++++++++return+Seek(newAbs,+SeekOrigin.Begin);
++++++++}+
++++++++else+if(origin+==+SeekOrigin.End)
++++++++{
++++++++++++var+newAbs+=+Length+-+offset;
++++++++++++return+Seek(newAbs,+SeekOrigin.Begin);
++++++++}

++++++++throw+new+NotImplementedException();
++++}

++++public+override+void+SetLength(long+value)
++++{
++++++++throw+new+NotImplementedException();
++++}

++++public+override+void+Write(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++throw+new+NotImplementedException();
++++}
}|code-block|syntax|javascript|910265|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is an option that supports seeking which is necessary in many situations. It is missing some functionality for disposing the underlying streams and could be a little more efficient if you were willing to assume that the underlying streams do not change length. Total length and stream offsets could then be calculated once.

<pre><code>public sealed class ConcatenatedStream : Stream
{
 List&lt;Stream&gt; streams;
 private long _Position { get; set; }

 public ConcatenatedStream(List&lt;Stream&gt; streams)
 {
 this.streams = streams;
 Seek(0, SeekOrigin.Begin);
 }

 public override bool CanRead
 {
 get { return true; }
 }

 public override int Read(byte[] buffer, int offset, int count)
 {
 if (streams.Count == 0)
 return 0;

 var startStream = 0;
 var cumulativeCapacity = 0L;
 for (var i = 0; i &lt; streams.Count; i++)
 {
 cumulativeCapacity += streams[i].Length;
 if (_Position &lt; cumulativeCapacity)
 {
 startStream = i;
 break;
 }
 }

 var bytesRead = 0;
 var curStream = startStream;

 while (_Position &lt; Length &amp;&amp; bytesRead &lt; count &amp;&amp; curStream &lt; streams.Count)
 {
 var r = streams[curStream].Read(buffer, offset + bytesRead, count - bytesRead);
 bytesRead += r;
 Seek(_Position + r, SeekOrigin.Begin);
 curStream++;
 }

 return bytesRead;
 }

 public override bool CanSeek
 {
 get { return true; }
 }

 public override bool CanWrite
 {
 get { return false; }
 }

 public override void Flush()
 {
 throw new NotImplementedException();
 }

 public override long Length
 {
 get {
 long length = 0;
 for (var i = 0; i &lt; streams.Count; i++)
 {
 length += streams[i].Length;
 }
 return length;
 }
 }

 public override long Position
 {
 get
 {
 return _Position;
 }
 set
 {
 Seek(value, SeekOrigin.Begin);
 }
 }

 public override long Seek(long offset, SeekOrigin origin)
 {
 if (origin == SeekOrigin.Begin)
 {
 _Position = offset;

 var prevLength = 0L;
 var cumulativeLength = 0L;
 for (var i = 0; i &lt; streams.Count; i++)
 {
 cumulativeLength += streams[i].Length;
 if (offset &lt; cumulativeLength)
 {
 streams[i].Seek(offset - prevLength, SeekOrigin.Begin);
 return _Position;
 }
 prevLength = cumulativeLength;
 }
 }

 if (origin == SeekOrigin.Current)
 {
 var newAbs = _Position + offset;
 return Seek(newAbs, SeekOrigin.Begin);
 } 
 else if(origin == SeekOrigin.End)
 {
 var newAbs = Length - offset;
 return Seek(newAbs, SeekOrigin.Begin);
 }

 throw new NotImplementedException();
 }

 public override void SetLength(long value)
 {
 throw new NotImplementedException();
 }

 public override void Write(byte[] buffer, int offset, int count)
 {
 throw new NotImplementedException();
 }
}
</code></pre>

Let's imagine I want to stream three files to a user all in a row, but instead of him handing me a <code>Stream</code> object to push bytes down, I have to hand him a <code>Stream</code> object he'll pull bytes from. I'd like to take my three <code>FileStream</code> objects (or even cleverer, an <code>IEnumerable&lt;Stream&gt;</code>) and return a new <code>ConcatenatedStream</code> object that would pull from the source streams on demand.

How do I concatenate two System.Io.Stream instances into one?

假设我想要将三个文件一起流式传输给一个用户，但是他没有给我一个Stream对象来下推字节，而是我必须给他一个Stream对象，让他从中提取字节。我想获取我的三个FileStream对象(或者更聪明的是一个IEnumerable<Stream>)，并返回一个新的ConcatenatedStream对象，该对象将按需从源流...

问如何将两个System.Io.Stream实例连接成一个实例？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将两个System.Io.Stream实例连接成一个实例？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将两个System.Io.Stream实例连接成一个实例？
EN