blocks|key|2010766|text|以下是我正在选修的一门在线课程的课文：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2010767|BufferedStream类是一个具体的类，它扩展了stream类，并用于向另一种类型的流提供额外的内存缓冲区，包括同步和异步。在创建类的实例时，必须将BufferedStream类配置为读或写，但不能将BufferedStream配置为同时执行两个任务。
微软通过包含一个内置缓冲区，改善了.NET框架中所有流的性能。通过将BufferedStream应用于现有流(如FileStream或MemoryStream+)，性能明显提高。将BufferedStream应用于现有的.NET框架流会产生双缓冲区。
BufferedStream类最常见的应用程序是在不包含内置缓冲区的自定义流类中。|blockquote|2010768|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|H|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|I|8|@]|9|@]|A|$]]]|F|$]]

The following is some text from an online course I am taking:

<blockquote>
 The BufferedStream class is a concrete
 class that extends the Stream class
 and is used to provide an additional
 memory buffer to another type of
 stream, both synchronously and
 asynchronously. The BufferedStream
 class must be configured to either
 read or write when an instance of the
 class is created, but the
 BufferedStream cannot be configured to
 perform both the tasks at the same
 time.
 
 Microsoft improved the performance of
 all streams in the .NET Framework by
 including a built-in buffer. The
 performance noticeably improved by
 applying a BufferedStream to existing
 streams, such as a FileStream or
 MemoryStream. Applying a
 BufferedStream to an existing .NET
 Framework stream results in a double
 buffer.
 
 The most common application of the
 BufferedStream class is in custom
 stream classes that do not include a
 built-in buffer.
</blockquote>

blocks|key|773095|text|根据布拉德·艾布拉姆斯的说法，几乎从来没有过：链接|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|773096|不，将BufferedStream封装在FileStream上没有任何好处。我们在4年前将BufferedStream的缓冲逻辑复制到FileStream中，以鼓励更好的默认性能。事实上，我不认为.NET框架中有任何流需要它，但是如果它们在默认情况下不进行缓冲，那么定制的Stream实现可能需要它。|blockquote|773097|entityMap|0|LINK|mutability|MUTABLE|url|http://blogs.msdn.com/brada/archive/2004/04/15/114329.aspx^0|N|2|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@$A|P|B|Q|1|R]]|C|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|C|$]]|$1|G|3|-4|5|6|7|T|8|@]|9|@]|C|$]]]|H|$I|$5|J|K|L|C|$M|N]]]]

According to Brad Abrams, almost never: <a href="http://blogs.msdn.com/brada/archive/2004/04/15/114329.aspx" rel="noreferrer">link</a>

<blockquote>
 No, there is zero benefit from wrapping a BufferedStream around a
 FileStream. We copied BufferedStream’s buffering logic into
 FileStream about 4 years ago to encourage better default
 performance... In fact, I don’t think there are any Streams in the
 .NET Framework that require it, but it might be needed by custom
 Stream implementations if they do not do buffering by default.
</blockquote>

blocks|key|773099|text|我所知道的最好的情况是当BinaryFormatter从NetworkStream直接序列化/反序列化时。使用BufferedStream在性能提高十倍之间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|773100|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Best case I know of is when BinaryFormatter serialize/deserialize directly from NetworkStream. Use of BufferedStream inbetween increase performance tenfold.

blocks|key|477673|text|普通文件I/O流已经通过使用StreamReader/StreamWriter进行缓冲。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|477674|由于流上的读/写操作(通常使用采用字节数组的读/写方法)，您自然会为自己提供一些缓冲。|477675|如果使用非常小的数组，或者使用WriteByte，那么在中间使用BufferedStream可能会获得更好的性能。|477676|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The normal file I/O streams are already buffered by using a StreamReader/StreamWriter.

Since read/write operations on streams, normally use the Read/Write methods that take a byte array, you will naturally provide some buffering yourself.

If you use very small arrays, or use WriteByte, you might get better performance by using a BufferedStream in between.

blocks|key|773106|text|迟回答，但无论如何都会回答的。如果您了解它是如何工作的，那么您就可以理解为什么在某些情况下使用它没有意义，而在其他情况下不使用是有意义的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|773107|为了证明这一点，我使用了StreamWrapper类。只使用这个类来查看您击中一个断点的次数！在这个类中放置断点。我们的目标是查看我们调用写、读和其他方法的次数。|offset|length|style|CODE|773108|//+This+class+is+only+used+for+demo+purposes.+Place+a+breakpoint+on+all+parts
class+StreamWrapper+:+Stream
{
++++Stream+stream;

++++public+StreamWrapper(Stream+s)
++++{
++++++++stream+=+s;
++++}

++++public+override+bool+CanRead+=>+stream.CanRead;

++++public+override+bool+CanSeek+=>+stream.CanSeek;

++++public+override+bool+CanWrite+=>+stream.CanWrite;

++++public+override+long+Length+=>+stream.Length;

++++public+override+long+Position+{+get+=>+stream.Position;+set+=>+stream.Position+=+value;+}

++++public+override+void+Flush()
++++{
++++++++stream.Flush();
++++}

++++public+override+int+Read(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++return+stream.Read(buffer,+offset,+count);
++++}

++++public+override+long+Seek(long+offset,+SeekOrigin+origin)
++++{
++++++++return+stream.Seek(offset,origin);
++++}

++++public+override+void+SetLength(long+value)
++++{
++++++++stream.SetLength(value);
++++}

++++public+override+void+Write(byte[]+buffer,+int+offset,+int+count)
++++{
++++++++stream.Write(buffer,+offset,+count);
++++}


}|code-block|syntax|javascript|773109|既然您已经拥有了这个包装类，它基本上是现有strem的包装器，那么您可以执行以下测试：|773110|示例写入：|BOLD|773111|//+in+real+life+you+want+this+to+be+larger.+
int+bufferSize+=+8;


//+Use+BufferedStream+to+buffer+writes+to+a+MemoryStream.
using+(var+memory_test+=+new+StreamWrapper(new+MemoryStream()))
using+(BufferedStream+stream+=+new+BufferedStream(memory_test,+bufferSize))
{


++++//+all+this+will+only+send+one+write+to+memory_test!
++++stream.Write(new+byte[]+{+1,+2+});
++++stream.Write(new+byte[]+{+1,+2+});
++++stream.Write(new+byte[]+{+1,+2+});
++++stream.Write(new+byte[]+{+1,+2+});
++++//+BREAKPOINT+ONLY+HITS+ONE+TIME+


++++//+All+this+will+also+send+only+one+write+to+memory_test
++++for+(int+i+=+0;+i+<+8;+i%2B%2B)++++++++++++++++++++++++++++
++++++++stream.WriteByte(5);
++++//+BREAKPOINT+ONLY+HITS+ONE+TIME+AGAIN+INSTAD+OF+8


++++//+this+will+send+one+write+to+memory_test.+Writes+of+more+than+8+bytes+can+happen!
++++stream.Write(new+byte[]+{+1,+2,+3,+4,+5,+6,+7,+8,+9,+10,+11,+12,+13,+14,+15,+16,+17,+18+});
++++//+ALL+THIS+WILL+SEND+ONE+WRITE+AGAIN
}|773112|示例阅读：|773113|//+example+reading
{
++++//+create+stream+with+some+data+in+it+that+we+will+be+reading
++++var+ms+=+new+MemoryStream();
++++{
++++++++//+Write+256+bytes
++++++++for+(int+i+=+0;+i+<=+byte.MaxValue;+i%2B%2B)
++++++++{
++++++++++++ms.WriteByte((byte)i);
++++++++}
++++++++ms.Position+=+0;
++++}

++++//+Use+BufferedStream+to+buffer+writes+to+a+MemoryStream.
++++using+(var+memory_test+=+new+StreamWrapper(ms))
++++{++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++using+(BufferedStream+stream+=+new+BufferedStream(memory_test,+8))
++++++++{
++++++++++++//+note+I+do+not+care+about+the+output+of+each+read+for+demo+breakpoint.+On+real+life+you+will+store+that+output
++++++++++++//+for+now+we+only+care+how+many+times+we+hit+the+breakpoint+because+on+real+life+that+could+be+a+slow/expensive+
++++++++++++//+operation+such+as+opening+a+file+for+writing+and+you+want+to+do+those+as+few+as+possible.

++++++++++++//+hit+breakpoint+only+one+time+with+all+this+reads
++++++++++++stream.ReadByte();
++++++++++++stream.ReadByte();
++++++++++++stream.ReadByte();
++++++++++++stream.ReadByte();
++++++++++++stream.ReadByte();
++++++++++++stream.ReadByte();
++++++++++++stream.ReadByte();
++++++++++++stream.ReadByte();


++++++++++++//+hit+breakpoint+only+one+time+with+all+this+reads
++++++++++++stream.Read(new+byte[2]+);
++++++++++++stream.Read(new+byte[2]+);
++++++++++++stream.Read(new+byte[2]+);
++++++++++++stream.Read(new+byte[2]+);


++++++++++++//+hit+breakpoint+only+one+time+even+though+it+is+larger+than+our+buffer+size+8
++++++++++++//+our+goal+is+to+hit+the+breakpoint+as+fewest+time+as+possible+because+in+real+life
++++++++++++//+this+could+be+slow/expensive+operations
++++++++++++stream.Read(new+byte[1024]+);

++++++++}
++++}
}|773114|如果将操作写入文件的位置(例如，通过确保每次写入至少8个字节而不是每次写1个字节)，可以提高性能。在现实生活中，您希望这个数字大约为4+KB。|773115|entityMap^0|0|C|D|0|0|0|0|5|0|0|0|5|0|0|16|S|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@$D|18|E|19|F|Q]]|9|@]|A|$]]|$1|R|3|S|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|T|3|U|5|6|7|1B|8|@$D|1C|E|1D|F|Q]]|9|@]|A|$]]|$1|V|3|W|5|J|7|1E|8|@]|9|@]|A|$K|L]]|$1|X|3|Y|5|6|7|1F|8|@$D|1G|E|1H|F|Q]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|10|$]]

Late answer but going to answer it anyways. If you understand how it works you can understand why it makes no sense to use in some cases and why it makes sense to not use in other cases. 

To proof this I am using <code>StreamWrapper</code> class. Only use this class to see how many times you hit a breakpoint! Place breakpoints all over this class. Our goal is to see how many times we call the Write, Read, and other methods.

<pre><code>// This class is only used for demo purposes. Place a breakpoint on all parts
class StreamWrapper : Stream
{
 Stream stream;

 public StreamWrapper(Stream s)
 {
 stream = s;
 }

 public override bool CanRead =&gt; stream.CanRead;

 public override bool CanSeek =&gt; stream.CanSeek;

 public override bool CanWrite =&gt; stream.CanWrite;

 public override long Length =&gt; stream.Length;

 public override long Position { get =&gt; stream.Position; set =&gt; stream.Position = value; }

 public override void Flush()
 {
 stream.Flush();
 }

 public override int Read(byte[] buffer, int offset, int count)
 {
 return stream.Read(buffer, offset, count);
 }

 public override long Seek(long offset, SeekOrigin origin)
 {
 return stream.Seek(offset,origin);
 }

 public override void SetLength(long value)
 {
 stream.SetLength(value);
 }

 public override void Write(byte[] buffer, int offset, int count)
 {
 stream.Write(buffer, offset, count);
 }


}
</code></pre>

Now that you have that wrapper class that is basically a wrapper to an existing strem you may do the following tests:

Example Writting:

<pre><code>// in real life you want this to be larger. 
int bufferSize = 8;


// Use BufferedStream to buffer writes to a MemoryStream.
using (var memory_test = new StreamWrapper(new MemoryStream()))
using (BufferedStream stream = new BufferedStream(memory_test, bufferSize))
{


 // all this will only send one write to memory_test!
 stream.Write(new byte[] { 1, 2 });
 stream.Write(new byte[] { 1, 2 });
 stream.Write(new byte[] { 1, 2 });
 stream.Write(new byte[] { 1, 2 });
 // BREAKPOINT ONLY HITS ONE TIME 


 // All this will also send only one write to memory_test
 for (int i = 0; i &lt; 8; i++) 
 stream.WriteByte(5);
 // BREAKPOINT ONLY HITS ONE TIME AGAIN INSTAD OF 8


 // this will send one write to memory_test. Writes of more than 8 bytes can happen!
 stream.Write(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 });
 // ALL THIS WILL SEND ONE WRITE AGAIN
}
</code></pre>

Example reading:

<pre><code>// example reading
{
 // create stream with some data in it that we will be reading
 var ms = new MemoryStream();
 {
 // Write 256 bytes
 for (int i = 0; i &lt;= byte.MaxValue; i++)
 {
 ms.WriteByte((byte)i);
 }
 ms.Position = 0;
 }

 // Use BufferedStream to buffer writes to a MemoryStream.
 using (var memory_test = new StreamWrapper(ms))
 { 
 using (BufferedStream stream = new BufferedStream(memory_test, 8))
 {
 // note I do not care about the output of each read for demo breakpoint. On real life you will store that output
 // for now we only care how many times we hit the breakpoint because on real life that could be a slow/expensive 
 // operation such as opening a file for writing and you want to do those as few as possible.

 // hit breakpoint only one time with all this reads
 stream.ReadByte();
 stream.ReadByte();
 stream.ReadByte();
 stream.ReadByte();
 stream.ReadByte();
 stream.ReadByte();
 stream.ReadByte();
 stream.ReadByte();


 // hit breakpoint only one time with all this reads
 stream.Read(new byte[2] );
 stream.Read(new byte[2] );
 stream.Read(new byte[2] );
 stream.Read(new byte[2] );


 // hit breakpoint only one time even though it is larger than our buffer size 8
 // our goal is to hit the breakpoint as fewest time as possible because in real life
 // this could be slow/expensive operations
 stream.Read(new byte[1024] );

 }
 }
}
</code></pre>

If this where to be write operations to a file for example performance could increase by ensuring you always write at least 8 bytes instead of 1 at a time. In real life you want this number to be about 4 KB

blocks|key|477657|text|在每一个可能的场合都必须使用的是常识。在从MemoryStream中读取-写入-时，使用这个类是没有用的，但是在执行网络或磁盘IO时(如果这些子系统的流不单独缓冲的话)，它可能非常有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|477658|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

What must be used in every possible occasion is common sense. There's no use in utilizing this class when reading-writing to-from a MemoryStream, but it might be quite useful when doing network or disk IO (if Streams for these subsystems do not do buffering on their own).

The <a href="http://msdn.microsoft.com/en-us/library/system.io.bufferedstream.aspx" rel="noreferrer">MSDN site</a> states:

<blockquote>
 A buffer is a block of bytes in memory
 used to cache data, thereby reducing
 the number of calls to the operating
 system. Buffers improve read and write
 performance. A buffer can be used for
 either reading or writing, but never
 both simultaneously. The Read and
 Write methods of BufferedStream
 automatically maintain the buffer.
</blockquote>

Should I use this class in every possible occasion?

When to use .NET BufferedStream class?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

指出：缓冲区是内存中用于缓存数据的字节块，从而减少了对操作系统的调用次数。缓冲区提高了读写性能。缓冲器可以用于读写，但绝不能同时使用。BufferedStream的读写方法自动维护缓冲区。我应该在每一次可能的场合上使用这个课程吗？

问什么时候使用.NET BufferedStream类？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用.NET BufferedStream类？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候使用.NET BufferedStream类？
EN