blocks|key|1547255|text|我使用了反射器，发现System.IO.Stream.Dispose看起来像这样：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1547256|public+void+Dispose()
{
++++this.Close();
}|code-block|syntax|javascript|1547257|entityMap^0|A|O|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I used Reflector and found that <code>System.IO.Stream.Dispose</code> looks like this:

<pre><code>public void Dispose()
{
 this.Close();
}
</code></pre>

blocks|key|1332182|text|正如Daniel+Bruckner提到的，Dispose和Close实际上是一回事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332183|但是，Stream在被释放/关闭时不会调用Flush()。FileStream+(我假设任何其他具有缓存机制的流)在被释放时都会调用Flush()。|1332184|如果你在扩展Stream，或者MemoryStream等，你需要在disposed/closed的时候调用Flush()，如果有必要的话。|1332185|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|$]]

As Daniel Bruckner mentioned, Dispose and Close are effectively the same thing. 

However Stream does NOT call Flush() when it is disposed/closed. FileStream (and I assume any other Stream with a caching mechanism) does call Flush() when disposed. 

If you are extending Stream, or MemoryStream etc. you will need to implement a call to Flush() when disposed/closed if it is necessary.

blocks|key|1547457|text|所有标准流(FileStream、CryptoStream)将在关闭/释放时尝试刷新。我认为任何Microsoft流实现都可以依赖这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547458|因此，如果刷新失败，Close/Dispose可能会抛出异常。|1547459|事实上，FileStream的.NET+1.0实现中存在一个错误，如果刷新抛出异常，它将无法释放文件句柄。在.NET+1.1中，通过向Dispose(布尔值)方法添加try/finally块修复了此问题。|1547460|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|$]]

All standard Streams (FileStream, CryptoStream) will attempt to flush when closed/disposed. I think you can rely on this for any Microsoft stream implementations.

As a result, Close/Dispose can throw an exception if the flush fails.

In fact IIRC there was a bug in the .NET 1.0 implementation of FileStream in that it would fail to release the file handle if the flush throws an exception. This was fixed in .NET 1.1 by adding a try/finally block to the Dispose(boolean) method.

blocks|key|1547370|text|StreamWriter.Dispose()和Stream.Dispose()都会释放对象持有的所有资源。它们都关闭了底层的流。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547371|Stream.Dispose()的源代码(请注意，这是实现细节，请不要依赖它)：|1547372|public+void+Dispose()
{
++++this.Close();
}|code-block|syntax|javascript|1547373|StreamWriter.Dispose()+(与Stream.Dispose()相同)：|1547374|protected+override+void+Dispose(bool+disposing)
{
++++try
++++{
++++++++//+Not+relevant+things
++++}
++++finally
++++{
++++++++if+(this.Closable+&&+(this.stream+!=+null))
++++++++{
++++++++++++try
++++++++++++{
++++++++++++++++if+(disposing)
++++++++++++++++{
++++++++++++++++++++this.stream.Close();
++++++++++++++++}
++++++++++++}
++++++++++++finally
++++++++++++{
++++++++++++++++//+Not+relevant+things
++++++++++++}
++++++++}
++++}
}|1547375|尽管如此，在处理流/流编写器之前，我通常会隐式关闭它们--我认为它看起来更干净。|1547376|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Both StreamWriter.Dispose() and Stream.Dispose() release all resources held by the objects. Both of them close the underlying stream.

The source code of Stream.Dispose() (note that this is implementation details so don't rely on it):

<pre><code>public void Dispose()
{
 this.Close();
}
</code></pre>

StreamWriter.Dispose() (same as with Stream.Dispose()):

<pre><code>protected override void Dispose(bool disposing)
{
 try
 {
 // Not relevant things
 }
 finally
 {
 if (this.Closable &amp;&amp; (this.stream != null))
 {
 try
 {
 if (disposing)
 {
 this.stream.Close();
 }
 }
 finally
 {
 // Not relevant things
 }
 }
 }
}
</code></pre>

Still, I usually implicitly close streams/streamwriters before disposing them - I think it looks cleaner.

blocks|key|1547532|text|对于需要手动关闭的对象，应该尽一切努力在using块中创建对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1547533|//Cannot+access+'stream'
using+(FileStream+stream+=+File.Open+("c:\\test.bin"))
{
+++//Do+work+on+'stream'
}+//+'stream'+is+closed+and+disposed+of+even+if+there+is+an+exception+escaping+this+block
//+Cannot+access+'stream'+|code-block|syntax|javascript|1547534|这样，就永远不会在using子句的上下文之外错误地访问'stream‘，并且文件总是关闭的。|1547535|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For objects that need to be manually closed, every effort should be made to create the object in a using block.

<pre><code>//Cannot access 'stream'
using (FileStream stream = File.Open ("c:\\test.bin"))
{
 //Do work on 'stream'
} // 'stream' is closed and disposed of even if there is an exception escaping this block
// Cannot access 'stream' 
</code></pre>

In this way one can never incorrectly access 'stream' out of the context of the using clause and the file is always closed.

blocks|key|1332281|text|我查看了Stream类的.net源代码，它包含以下内容，这表明您可以……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332282|++++//+Stream+used+to+require+that+all+cleanup+logic+went+into+Close(),
++++//+which+was+thought+up+before+we+invented+IDisposable.++However,+we+
++++//+need+to+follow+the+IDisposable+pattern+so+that+users+can+write
++++//+sensible+subclasses+without+needing+to+inspect+all+their+base
++++//+classes,+and+without+worrying+about+version+brittleness,+from+a
++++//+base+class+switching+to+the+Dispose+pattern.++We're+moving+
++++//+Stream+to+the+Dispose(bool)+pattern+-+that's+where+all+subclasses
++++//+should+put+their+cleanup+starting+in+V2.+
++++public+virtual+void+Close()+
++++{
++++++++Dispose(true);+
++++++++GC.SuppressFinalize(this);
++++}

++++public+void+Dispose()+
++++{
++++++++Close();+
++++}+|code-block|syntax|javascript|1332283|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|$]]

I looked in the .net source for the Stream class, it had the following which would suggest that yes you can...

<pre><code> // Stream used to require that all cleanup logic went into Close(),
 // which was thought up before we invented IDisposable. However, we 
 // need to follow the IDisposable pattern so that users can write
 // sensible subclasses without needing to inspect all their base
 // classes, and without worrying about version brittleness, from a
 // base class switching to the Dispose pattern. We're moving 
 // Stream to the Dispose(bool) pattern - that's where all subclasses
 // should put their cleanup starting in V2. 
 public virtual void Close() 
 {
 Dispose(true); 
 GC.SuppressFinalize(this);
 }

 public void Dispose() 
 {
 Close(); 
 } 
</code></pre>

blocks|key|1547308|text|Stream.Close是通过调用Stream.Dispose实现的，反之亦然-因此这两种方法是等效的。Stream.Close之所以存在，只是因为关闭一个流听起来比处理一个流更自然。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1547309|此外，您应该尽量避免显式调用此方法，而应使用using语句，以便免费获得正确的异常处理。|1547310|entityMap^0|0|C|H|E|1G|C|0|M|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

<code>Stream.Close</code> is implemented by a call to <code>Stream.Dispose</code> or vice versa - so the methods are equivalent. <code>Stream.Close</code> exists just because closing a stream sounds more natural than disposing a stream.

Besides you should try to avoid explicit calls to this methods and use the <code>using</code> statement instead in order to get correct exception handling for free.

If I have the following situation:

<pre><code>StreamWriter MySW = null;
try
{
 Stream MyStream = new FileStream("asdf.txt");
 MySW = new StreamWriter(MyStream);
 MySW.Write("blah");
}
finally
{
 if (MySW != null)
 {
 MySW.Flush();
 MySW.Close();
 MySW.Dispose();
 }
}
</code></pre>

Can I just call <code>MySW.Dispose()</code> and skip the Close even though it is provided? Are there any Stream implimentations that don't work as expected (Like CryptoStream)?

If not, then is the following just bad code:

<pre><code>using (StreamWriter MySW = new StreamWriter(MyStream))
{
 MySW.Write("Blah");
}
</code></pre>

Does Stream.Dispose always call Stream.Close (and Stream.Flush)

如果我遇到以下情况：StreamWriter MySW = null;try{   Stream MyStream = new FileStream("asdf.txt");   MySW = new StreamWriter(MyStream);   MySW.Write("blah");}finally{   if (MySW != null)   {      MySW.Flush();  

问Stream.Dispose总是调用Stream.Close (和Stream.Flush)吗
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Stream.Dispose总是调用Stream.Close (和Stream.Flush)吗EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Stream.Dispose总是调用Stream.Close (和Stream.Flush)吗
EN