blocks|key|2935961|text|不，您不应该手动调用这些方法。在using块的末尾，将自动调用Dispose()方法，该方法将负责释放非托管资源(至少对于标准的.NET+BCL类，如流、读取器/写入器等)。所以你也可以像这样写你的代码：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2935962|using+(Stream+responseStream+=+response.GetResponseStream())
++++using+(StreamReader+reader+=+new+StreamReader(responseStream))
++++++++using+(StreamWriter+writer+=+new+StreamWriter(filename))
++++++++{
++++++++++++int+chunkSize+=+1024;
++++++++++++while+(!reader.EndOfStream)
++++++++++++{
+++++++++++++++++char[]+buffer+=+new+char[chunkSize];
+++++++++++++++++int+count+=+reader.Read(buffer,+0,+chunkSize);
+++++++++++++++++if+(count+!=+0)
+++++++++++++++++{
+++++++++++++++++++++writer.Write(buffer,+0,+count);
+++++++++++++++++}
++++++++++++}
+++++++++}|code-block|syntax|javascript|2935963|Close()方法调用Dispose()。|2935964|entityMap^0|G|5|V|9|0|0|0|7|B|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

No, you shouldn't call those methods manually. At the end of the <code>using</code> block the <code>Dispose()</code> method is automatically called which will take care to free unmanaged resources (at least for standard .NET BCL classes such as streams, readers/writers, ...). So you could also write your code like this:

<pre><code>using (Stream responseStream = response.GetResponseStream())
 using (StreamReader reader = new StreamReader(responseStream))
 using (StreamWriter writer = new StreamWriter(filename))
 {
 int chunkSize = 1024;
 while (!reader.EndOfStream)
 {
 char[] buffer = new char[chunkSize];
 int count = reader.Read(buffer, 0, chunkSize);
 if (count != 0)
 {
 writer.Write(buffer, 0, count);
 }
 }
 }
</code></pre>

The <code>Close()</code> method calls <code>Dispose()</code>.

blocks|key|2935982|text|快速跳转到Reflector.NET，可以看到StreamWriter上的Close()方法是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2935983|public+override+void+Close()
{
++++this.Dispose(true);
++++GC.SuppressFinalize(this);
}|code-block|syntax|javascript|2935984|StreamReader是：|2935985|public+override+void+Close()
{
++++this.Dispose(true);
}|2935986|StreamReader中的Dispose(bool+disposing)覆盖是：|2935987|protected+override+void+Dispose(bool+disposing)
{
++++try
++++{
++++++++if+((this.Closable+&&+disposing)+&&+(this.stream+!=+null))
++++++++{
++++++++++++this.stream.Close();
++++++++}
++++}
++++finally
++++{
++++++++if+(this.Closable+&&+(this.stream+!=+null))
++++++++{
++++++++++++this.stream+=+null;
++++++++++++/*+deleted+for+brevity+*/
++++++++++++base.Dispose(disposing);
++++++++}
++++}
}|2935988|StreamWriter方法与此类似。|2935989|因此，阅读代码可以清楚地看到，您可以根据自己的喜好以任意顺序对流调用Close()+&+Dispose()。它不会以任何方式改变行为。|2935990|因此，这归结于使用Dispose()、Close()和/或using+(+...+)+{+...+}是否更具可读性。|2935991|我个人的偏好是，只要有可能，就应该总是使用using+(+...+)+{+...+}，因为它可以帮助你“不用剪刀”。|2935992|但是，虽然这有助于正确性，但它确实降低了可读性。在C#中，我们已经有了过多的右大括号，那么我们如何知道哪一个是在流上执行关闭的呢？|2935993|所以我认为最好这样做：|2935994|using+(var+stream+=+...)
{
++++/*+code+*/

++++stream.Close();
}|2935995|它不会影响代码的行为，但确实有助于提高可读性。|2935996|entityMap^0|N|C|11|7|0|0|0|C|0|0|0|C|E|N|0|0|0|C|0|Y|7|18|9|0|9|9|J|7|T|L|0|L|L|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1K|8|@$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1P|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|25|8|@$9|26|A|27|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|28|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|29|8|@]|D|@]|E|$]]|$1|14|3|15|5|H|7|2A|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|2B|8|@]|D|@]|E|$]]|$1|18|3|-4|5|6|7|2C|8|@]|D|@]|E|$]]]|19|$]]

A quick jump into Reflector.NET shows that the <code>Close()</code> method on <code>StreamWriter</code> is:

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

And <code>StreamReader</code> is:

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

The <code>Dispose(bool disposing)</code> override in <code>StreamReader</code> is:

<pre><code>protected override void Dispose(bool disposing)
{
 try
 {
 if ((this.Closable &amp;&amp; disposing) &amp;&amp; (this.stream != null))
 {
 this.stream.Close();
 }
 }
 finally
 {
 if (this.Closable &amp;&amp; (this.stream != null))
 {
 this.stream = null;
 /* deleted for brevity */
 base.Dispose(disposing);
 }
 }
}
</code></pre>

The <code>StreamWriter</code> method is similar.

So, reading the code it is clear that that you can call <code>Close()</code> &amp; <code>Dispose()</code> on streams as often as you like and in any order. It won't change the behaviour in any way.

So it comes down to whether or not it is more readable to use <code>Dispose()</code>, <code>Close()</code> and/or <code>using ( ... ) { ... }</code>.

My personal preference is that <code>using ( ... ) { ... }</code> should always be used when possible as it helps you to "not run with scissors".

But, while this helps correctness, it does reduce readability. In C# we already have plethora of closing curly braces so how do we know which one actually performs the close on the stream?

So I think it is best to do this:

<pre><code>using (var stream = ...)
{
 /* code */

 stream.Close();
}
</code></pre>

It doesn't affect the behaviour of the code, but it does aid readability.

blocks|key|2936017|text|文档中说这两种方法是等价的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2936018|2936019|+StreamReader.Close：此Close实现调用传递真值的Dispose方法。|blockquote|offset|length|2936020|2936021|StreamWriter.Close：Close的这个实现调用Dispose方法，传递一个真值。|2936022|Stream.Close：此方法调用Dispose，指定为true以释放所有资源。|2936023|2936024|因此，这两种方法都是有效的：|2936025|/*+Option+1,+implicitly+calling+Dispose+*/
using+(StreamWriter+writer+=+new+StreamWriter(filename))+{+
+++//+do+something
}+

/*+Option+2,+explicitly+calling+Close+*/
StreamWriter+writer+=+new+StreamWriter(filename)
try+{
++++//+do+something
}
finally+{
++++writer.Close();
}|code-block|syntax|javascript|2936026|就我个人而言，我会坚持第一种选择，因为它包含的“噪音”较少。|2936027|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.io.streamreader.close|1|https://docs.microsoft.com/en-us/dotnet/api/system.io.streamwriter.close|2|https://docs.microsoft.com/en-us/dotnet/api/system.io.stream.close^0|0|0|1|I|0|0|0|0|I|1|0|0|C|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1A|8|@]|9|@$F|1B|G|1C|1|1D]]|A|$]]|$1|H|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1F|8|@]|9|@$F|1G|G|1H|1|1I]]|A|$]]|$1|K|3|L|5|6|7|1J|8|@]|9|@$F|1K|G|1L|1|1M]]|A|$]]|$1|M|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1O|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|1P|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]|16|$5|Z|10|11|A|$12|17]]]]

The documentation says that these two methods are equivalent:

<blockquote>
 <a href="https://docs.microsoft.com/en-us/dotnet/api/system.io.streamreader.close" rel="noreferrer">StreamReader.Close</a>: This implementation of Close calls the Dispose method passing a true value.
 
 <a href="https://docs.microsoft.com/en-us/dotnet/api/system.io.streamwriter.close" rel="noreferrer">StreamWriter.Close</a>: 
 This implementation of Close calls the Dispose method passing a true value.
 
 <a href="https://docs.microsoft.com/en-us/dotnet/api/system.io.stream.close" rel="noreferrer">Stream.Close</a>: This method calls Dispose, specifying true to release all resources.
</blockquote>

So, both of these are equally valid:

<pre><code>/* Option 1, implicitly calling Dispose */
using (StreamWriter writer = new StreamWriter(filename)) { 
 // do something
} 

/* Option 2, explicitly calling Close */
StreamWriter writer = new StreamWriter(filename)
try {
 // do something
}
finally {
 writer.Close();
}
</code></pre>

Personally, I would stick with the first option, since it contains less "noise".

blocks|key|2936086|text|在许多同时支持Close()和Dispose()方法的类上，这两个调用是等效的。但是，在某些类中，可以重新打开已关闭的对象。一些这样的类可能会在关闭后保留一些资源，以便允许重新打开；其他类可能不会在Close()上保持任何资源活动，但可能会在Dispose()上设置一个标志，明确禁止重新打开。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2936087|IDisposable.Dispose的约定明确要求，在永远不会再次使用的对象上调用它是无害的，因此我建议在每个IDisposable对象上调用IDisposable.Dispose或名为Dispose()的方法，无论是否也调用Close()。|2936088|entityMap^0|7|7|F|9|2R|7|3D|9|0|0|J|1K|B|20|J|2M|9|36|7|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]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|I|$]]

On many classes which support both <code>Close()</code> and <code>Dispose()</code> methods, the two calls would be equivalent. On some classes, however, it is possible to re-open an object which has been closed. Some such classes may keep some resources alive after a Close, in order to permit reopening; others may not keep any resources alive on <code>Close()</code>, but might set a flag on <code>Dispose()</code> to explicitly forbid re-opening.

The contract for <code>IDisposable.Dispose</code> explicitly requires that calling it on an object which will never be used again will be at worst harmless, so I would recommend calling either <code>IDisposable.Dispose</code> or a method called <code>Dispose()</code> on every <code>IDisposable</code> object, whether or not one also calls <code>Close()</code>.

blocks|key|253067|text|这是一个老问题，但您现在可以使用语句编写，而不需要阻止每个语句。当包含块完成时，它们将以相反的顺序被释放。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|253068|using+var+responseStream+=+response.GetResponseStream();
using+var+reader+=+new+StreamReader(responseStream);
using+var+writer+=+new+StreamWriter(filename);

int+chunkSize+=+1024;
while+(!reader.EndOfStream)
{
++++char[]+buffer+=+new+char[chunkSize];
++++int+count+=+reader.Read(buffer,+0,+chunkSize);
++++if+(count+!=+0)
++++{
++++++++writer.Write(buffer,+0,+count);
++++}
}|code-block|syntax|javascript|253069|https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/using|offset|length|253070|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|2K|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

This is an old question, but you can now write using statements without needing to block each one. They will be disposed of in reverse order when the containing block is finished.

<pre><code>using var responseStream = response.GetResponseStream();
using var reader = new StreamReader(responseStream);
using var writer = new StreamWriter(filename);

int chunkSize = 1024;
while (!reader.EndOfStream)
{
 char[] buffer = new char[chunkSize];
 int count = reader.Read(buffer, 0, chunkSize);
 if (count != 0)
 {
 writer.Write(buffer, 0, count);
 }
}
</code></pre>

<a href="https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/using" rel="noreferrer">https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/using</a>

blocks|key|2936132|text|为了说明它的价值，the+source+code+for+Stream.Close解释了为什么有两种方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2936133|2936134|+//流过去要求所有清理逻辑都进入Close()，//这是在我们发明IDisposable之前就想到的。然而，我们//需要遵循IDisposable模式，这样用户就可以编写//敏感的子类，而不需要检查他们的所有基类，也不需要担心版本脆弱性，从//基类切换到Dispose模式。我们将//+Stream转移到Dispose(bool)模式--这就是现在所有子类//应该把它们的清理工作放到的地方。|blockquote|2936135|2936136|2936137|简而言之，Close之所以存在，只是因为它早于Dispose，出于兼容性的原因，它不能被删除。|2936138|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/dotnet/runtime/blob/2ba65159b970de1af69e350bf8ac67ab4c21e38b/src/libraries/System.Private.CoreLib/src/System/IO/Stream.cs#L190-L198^0|T|C|9|W|0|0|0|0|0|0|5|5|N|7|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|-4|5|6|7|11|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|12|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|13|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]]]

For what it's worth, <a href="https://github.com/dotnet/runtime/blob/2ba65159b970de1af69e350bf8ac67ab4c21e38b/src/libraries/System.Private.CoreLib/src/System/IO/Stream.cs#L190-L198" rel="nofollow noreferrer">the source code for <code>Stream.Close</code></a> explains why there are two methods:
<blockquote>
<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 now.
</code></pre>
</blockquote>
In short, <code>Close</code> is only there because it predates <code>Dispose</code>, and it can't be deleted for compatibility reasons.

Classes such as <code>Stream</code>, <code>StreamReader</code>, <code>StreamWriter</code> etc implements <code>IDisposable</code> interface. That means, we can call <code>Dispose()</code> method on objects of these classes. They've also defined a <code>public</code> method called <code>Close()</code>. Now that confuses me, as to what should I call once I'm done with objects? What if I call both? 

My current code is this:

<pre><code>using (Stream responseStream = response.GetResponseStream())
{
 using (StreamReader reader = new StreamReader(responseStream))
 {
 using (StreamWriter writer = new StreamWriter(filename))
 {
 int chunkSize = 1024;
 while (!reader.EndOfStream)
 {
 char[] buffer = new char[chunkSize];
 int count = reader.Read(buffer, 0, chunkSize);
 if (count != 0)
 {
 writer.Write(buffer, 0, count);
 }
 }
 writer.Close();
 }
 reader.Close();
 }
}
</code></pre>

As you see, I've written <code>using()</code> constructs, which automatically call <code>Dispose()</code> method on each object. But I also call <code>Close()</code> methods. Is it right?

Please suggest me the best practices when using stream objects. :-)

MSDN example doesn't use <code>using()</code> constructs, and call <code>Close()</code> method:

<ul>
<li><a href="http://msdn.microsoft.com/en-us/library/ms229711.aspx" rel="noreferrer">How to: Download Files with FTP</a></li>
</ul>

Is it good?

Should I call Close() or Dispose() for stream objects?

Stream、StreamReader、StreamWriter等类实现了IDisposable接口。这意味着，我们可以在这些类的对象上调用Dispose()方法。他们还定义了一个名为Close()的public方法。现在这让我很困惑，一旦我处理完对象，我应该调用什么呢？如果我把两个都叫来呢？我当前的代码是：using...

问我应该为流对象调用Close()还是Dispose()？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我应该为流对象调用Close()还是Dispose()？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我应该为流对象调用Close()还是Dispose()？
EN