blocks|key|2220287|text|using块确保在抛出异常时调用Dispose()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2220288|你的第二个样本不会那么做。|2220289|如果Con.Open()抛出了异常，那么在第一种情况下，您将得到调用Con.Dispose()的保证。在第二种情况下，异常会向上传播，因此不会调用Con.Dispose()。|2220290|entityMap^0|G|9|0|0|2|A|Y|D|21|D|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|K|$]]

The using block makes sure that <code>Dispose()</code> is called if an exception is thrown. 

Your second sample does not do that.

If <code>Con.Open()</code> threw an exception, in the first case you are guaranteed that <code>Con.Dispose()</code> is called. In the second case, the exception propagates up and <code>Con.Dispose()</code> will not be called.

blocks|key|2243956|text|两者的区别在于，如果抛出一个异常|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2243957|Con.Open()
'do+whatever|code-block|syntax|javascript|2243958|不会调用Con.Dispose。|offset|length|style|CODE|2243959|我不了解VB语法，但是在C#中，等价的代码应该是|2243960|try
{
++++con+=+new+Connection();
++++//+Do+whatever
}
finally
{
++++if+(con+!=+null)+con.Dispose();
}|2243961|entityMap^0|0|0|4|B|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

The difference between the two is that, if an Exception is thrown in 

<pre><code>Con.Open()
'do whatever
</code></pre>

<code>Con.Dispose</code> will not be called.

I'm not up on VB syntax, but in C#, the equivalent code would be

<pre><code>try
{
 con = new Connection();
 // Do whatever
}
finally
{
 if (con != null) con.Dispose();
}
</code></pre>

blocks|key|3100497|text|using语句确保在抛出异常时释放对象。这相当于在finally块中调用dispose。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3100498|entityMap^0|0|5|P|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

The <code>using</code> statement guarantees that the object is disposed in the event an exception is thrown. It's the equivalent of calling dispose in a <code>finally</code> block.

blocks|key|2244043|text|using基本上相当于：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2244044|try
{
++//+code
}
finally
{
++obj.Dispose();
}|code-block|syntax|javascript|2244045|因此，即使在块内的代码中抛出未处理的异常，它也具有调用Dispose()的好处。|2244046|entityMap^0|0|5|0|0|R|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

<code>using</code> is basically the equivalent of:

<pre><code>try
{
 // code
}
finally
{
 obj.Dispose();
}
</code></pre>

So it also has the benefit of calling <code>Dispose()</code> even if an unhandled exception is thrown in the code within the block.

blocks|key|3100508|text|在try/finally中使用封装的块，调用finally块中的Dispose。这确保即使发生异常也会调用Dispose。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3100509|您应该在几乎所有的情况下使用，出于安全原因。|3100510|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Using wraps the enclosed block in a try/finally that calls Dispose in the finally block. This ensures that Dispose will be called even if an exception occurs.

You should use using in almost all cases, for safety reasons

blocks|key|2220391|text|如果内存可用，则使用可以保证一个对象被释放，而不管它周围的代码块如何退出它。它通过在try...finally块中包围块，检查所使用的变量是否为空，然后如果它不是null，则对其进行处理。如果抛出异常，则允许它将堆栈冒泡。除此之外，它所做的只是保证非空可弃对象的处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2220392|try
{
++var+myDisposable+=+new+DisposableObject();
++myDisposable.DoSomething();
}
finally
{
++if+(myDisposable+!=+null)
++++((IDisposable)myDisposable).Dispose();
}|code-block|syntax|javascript|2220393|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|$]]

If memory serves, using is a guarantee that an object is disposed of regardless of how the block of code it surrounds exits it. It does this by surrounding the block in a try...finally block, and checking the used variable for nullness, and then disposing of it if it is not null. If an exception was thrown, it's allowed to bubble up the stack. Aside from that, all it does is guarantee disposal of non-null disposable objects.

<pre><code>try
{
 var myDisposable = new DisposableObject();
 myDisposable.DoSomething();
}
finally
{
 if (myDisposable != null)
 ((IDisposable)myDisposable).Dispose();
}
</code></pre>

blocks|key|3100543|text|//preceeding+code
using+(con+=+new+Connection())+{
++++con.Open()
++++//do+whatever
}
//following+code|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3100544|相当于以下内容(请注意con的有限范围)：|unstyled|3100545|//preceeding+code
{
++++var+con+=+new+Connection();
++++try+{
++++++++con.Open()
++++++++//do+whatever
++++}+finally+{
++++++++if+(con+!=+null)+con.Dispose();
++++}
}
//following+code|3100546|这里描述了这一点：http://msdn.microsoft.com/en-us/library/yh598w02.aspx|offset|length|3100547|3100548|使用语句确保在调用对象上的方法时发生异常，也会调用Dispose。--您可以通过将对象放入try块中，然后在一个最终块中调用Dispose来实现相同的结果；实际上，编译器.|blockquote|style|BOLD|3100549|
就是这样翻译using语句的。|3100550|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/yh598w02.aspx^0|0|0|0|9|1H|0|0|0|X|1G|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|13|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|15|8|@]|9|@$K|16|L|17|1|18]]|A|$]]|$1|M|3|-4|5|F|7|19|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1A|8|@$K|1B|L|1C|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|F|7|1D|8|@]|9|@]|A|$]]|$1|U|3|-4|5|F|7|1E|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

<pre><code>//preceeding code
using (con = new Connection()) {
 con.Open()
 //do whatever
}
//following code
</code></pre>

is equivalent to the following (note the limited scope for con):

<pre><code>//preceeding code
{
 var con = new Connection();
 try {
 con.Open()
 //do whatever
 } finally {
 if (con != null) con.Dispose();
 }
}
//following code
</code></pre>

This is described here: <a href="http://msdn.microsoft.com/en-us/library/yh598w02.aspx" rel="noreferrer">http://msdn.microsoft.com/en-us/library/yh598w02.aspx</a>

<blockquote>
 The using statement ensures that Dispose is called even if an
 exception occurs while you are calling methods on the object. You can
 achieve the same result by putting the object inside a try block and
 then calling Dispose in a finally block; in fact, this is how the
 using statement is translated by the compiler.
</blockquote>

blocks|key|2220441|text|正如Brian在here中所指出的，它只是try和finally块的一个实现，以确保对象被释放。除了他的答案之外，using块还确保即使使用作用域返回，也会释放对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|2220442|我曾经对此感到好奇，并使用以下方法对其进行了测试：|2220443|自定义IDisposable测试类和主|2220444|private+class+DisposableTest+:+IDisposable
{
++++public+string+Name+{+get;+set;+}

++++public+void+Dispose()+{+Console.WriteLine("{0}.Dispose()+is+called+!",+Name);+}
}

public+static+void+Main(string[]+args)
{
++++try
++++{
++++++++UsingReturnTest();
++++++++UsingExceptionTest();++++++++++++++++
++++}
++++catch+{+}

++++try
++++{
++++++++DisposeReturnTest();
++++++++DisposeExceptionTest();++++++++++++++++
++++}
++++catch+{+}

++++DisposeExtraTest();

++++Console.ReadLine();
}++++++++|code-block|syntax|javascript|2220445|测试用例实现|2220446|private+static+string+UsingReturnTest()
{
++++using+(DisposableTest+usingReturn+=+new+DisposableTest()+{+Name+=+"UsingReturn"+})
++++{
++++++++return+usingReturn.Name;
++++}
}

private+static+void+UsingExceptionTest()
{
++++using+(DisposableTest+usingException+=+new+DisposableTest()+{+Name+=+"UsingException"+})
++++{
++++++++int+x+=+int.Parse("NaN");
++++}
}

private+static+string+DisposeReturnTest()
{++++++++
++++DisposableTest+disposeReturn+=+new+DisposableTest()+{+Name+=+"DisposeReturn"+};
++++return+disposeReturn.Name;
++++disposeReturn.Dispose();+//+#+IDE+Warning;+Unreachable+code+detected
}

private+static+void+DisposeExceptionTest()
{
++++DisposableTest+disposeException+=+new+DisposableTest()+{+Name+=+"DisposeException"+};
++++int+x+=+int.Parse("NaN");
++++disposeException.Dispose();
}

private+static+void+DisposeExtraTest()
{
++++DisposableTest+disposeExtra+=+null;
++++try
++++{
++++++++disposeExtra+=+new+DisposableTest()+{+Name+=+"DisposeExtra"+};
++++++++return;
++++}
++++catch+{+}
++++finally
++++{
++++++++if+(disposeExtra+!=+null)+{+disposeExtra.Dispose();+}
++++}
}|2220447|输出是：|2220448|2220449|UsingReturn.Dispose()叫做!|unordered-list-item|2220450|UsingException.Dispose()，叫!|2220451|DisposeExtra.Dispose()+!|2220452|2220453|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/10984336/net-using-using-blocks-vs-calling-dispose^0|L|3|P|7|1L|5|1W|7|8|4|0|0|0|0|J|0|0|0|6|0|0|0|2|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|D]]|E|@$9|1L|A|1M|1|1N]]|F|$]]|$1|G|3|H|5|6|7|1O|8|@]|E|@]|F|$]]|$1|I|3|J|5|6|7|1P|8|@$9|1Q|A|1R|B|D]]|E|@]|F|$]]|$1|K|3|L|5|M|7|1S|8|@]|E|@]|F|$N|O]]|$1|P|3|Q|5|6|7|1T|8|@$9|1U|A|1V|B|D]]|E|@]|F|$]]|$1|R|3|S|5|M|7|1W|8|@]|E|@]|F|$N|O]]|$1|T|3|U|5|6|7|1X|8|@$9|1Y|A|1Z|B|D]]|E|@]|F|$]]|$1|V|3|-4|5|6|7|20|8|@]|E|@]|F|$]]|$1|W|3|X|5|Y|7|21|8|@]|E|@]|F|$]]|$1|Z|3|10|5|Y|7|22|8|@]|E|@]|F|$]]|$1|11|3|12|5|Y|7|23|8|@]|E|@]|F|$]]|$1|13|3|-4|5|6|7|24|8|@]|E|@]|F|$]]|$1|14|3|-4|5|6|7|25|8|@]|E|@]|F|$]]]|15|$16|$5|17|18|19|F|$1A|1B]]]]

As Brian Warshaw stated in <a href="https://stackoverflow.com/questions/10984336/net-using-using-blocks-vs-calling-dispose">here</a> it's simply an implementation of <code>try</code> and <code>finally</code> block to make sure object is disposed. Adding to his answer, <code>using</code> block also makes sure that the object is disposed even if you return inside using scope.

I was once curious about this myself and tested it out using the following approach:

Custom IDisposable test class and Main

<pre><code>private class DisposableTest : IDisposable
{
 public string Name { get; set; }

 public void Dispose() { Console.WriteLine("{0}.Dispose() is called !", Name); }
}

public static void Main(string[] args)
{
 try
 {
 UsingReturnTest();
 UsingExceptionTest(); 
 }
 catch { }

 try
 {
 DisposeReturnTest();
 DisposeExceptionTest(); 
 }
 catch { }

 DisposeExtraTest();

 Console.ReadLine();
} 
</code></pre>

Test cases implementation

<pre><code>private static string UsingReturnTest()
{
 using (DisposableTest usingReturn = new DisposableTest() { Name = "UsingReturn" })
 {
 return usingReturn.Name;
 }
}

private static void UsingExceptionTest()
{
 using (DisposableTest usingException = new DisposableTest() { Name = "UsingException" })
 {
 int x = int.Parse("NaN");
 }
}

private static string DisposeReturnTest()
{ 
 DisposableTest disposeReturn = new DisposableTest() { Name = "DisposeReturn" };
 return disposeReturn.Name;
 disposeReturn.Dispose(); // # IDE Warning; Unreachable code detected
}

private static void DisposeExceptionTest()
{
 DisposableTest disposeException = new DisposableTest() { Name = "DisposeException" };
 int x = int.Parse("NaN");
 disposeException.Dispose();
}

private static void DisposeExtraTest()
{
 DisposableTest disposeExtra = null;
 try
 {
 disposeExtra = new DisposableTest() { Name = "DisposeExtra" };
 return;
 }
 catch { }
 finally
 {
 if (disposeExtra != null) { disposeExtra.Dispose(); }
 }
}
</code></pre>

And the output is:

<ul>
<li>UsingReturn.Dispose() is called !</li>
<li>UsingException.Dispose() is called !</li>
<li>DisposeExtra.Dispose() is called !</li>
</ul>

It has been my understanding that the <a href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-statement" rel="noreferrer"><code>using</code> statement</a> in .NET calls an <code>IDisposable</code> object's <code>Dispose()</code> method once the code exits the block.

Does the <code>using</code> statement do anything else? If not, it would seem that the following two code samples achieve the exact same thing:

<pre><code>Using Con as New Connection()
 Con.Open()
 'do whatever '
End Using

Dim Con as New Connection()
Con.Open()
'do whatever '
Con.Dispose()
</code></pre>

I will give the best answer to whoever confirms that I am correct or points out that I am wrong and explains why. Keep in mind that I am aware that certain classes can do different things in their <code>Dispose()</code> methods. This question is about whether or not the <code>using</code> statement achieves the exact same result as calling an object's <code>Dispose()</code> method.

Using statement vs. IDisposable.Dispose()

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我的理解是，一旦代码退出块，.NET中的.NET调用IDisposable对象的Dispose()方法。using语句还能做什么吗？如果不是，以下两个代码示例似乎实现了完全相同的目标：Using Con as New Connection()    Con.Open()    'do whatever 'End Usi...

问使用语句与IDisposable.Dispose()
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用语句与IDisposable.Dispose()EN