blocks|key|835067|text|在使用ADO.NET时，您可以对连接对象或读取器对象等使用关键工作。这样，当代码块完成时，它将自动释放您的连接。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|835068|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|$]]

When using ADO.NET you can use the keywork for things like your connection object or reader object. That way when the code block completes it will automatically dispose of your connection.

blocks|key|839326|text|就像这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|839327|using+(var+conn+=+new+SqlConnection("connection+string"))
{
+++conn.Open();

++++//+Execute+SQL+statement+here+on+the+connection+you+created
}|code-block|syntax|javascript|839328|这个try/catch/finally.将被关闭，而不需要显式调用.Close()函数，即使抛出异常也会发生这种情况，而不需要一个.Close()。|offset|length|style|CODE|839329|entityMap^0|0|0|2|3|6|5|C|7|X|8|1T|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$]]

Things like this:

<pre><code>using (var conn = new SqlConnection("connection string"))
{
 conn.Open();

 // Execute SQL statement here on the connection you created
}
</code></pre>

This <code>SqlConnection</code> will be closed without needing to explicitly call the <code>.Close()</code> function, and this will happen even if an exception is thrown, without the need for a <code>try</code>/<code>catch</code>/<code>finally</code>.

blocks|key|1144011|text|犀牛Mocks录音回放语法很有趣地使用了using。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1144012|entityMap|0|LINK|mutability|MUTABLE|url|http://web.archive.org/web/20080809044303/http://www.ayende.com:80/Wiki/Rhino%2520Mocks%2520Record-playback%2520Syntax.ashx^0|K|5|0|D|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

The <a href="http://web.archive.org/web/20080809044303/http://www.ayende.com:80/Wiki/Rhino%20Mocks%20Record-playback%20Syntax.ashx" rel="nofollow noreferrer">Rhino Mocks Record-playback Syntax</a> makes an interesting use of <code>using</code>.

blocks|key|145184|text|当您使用use时，它将在using的作用域末尾调用对象上的Dispose()方法。因此，您可以在Dispose()方法中使用相当多的清理代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|145185|一个要点：|145186|如果您实现了IDisposable，请确保在Dispose()实现中调用GC.SuppressFinalize()，否则自动垃圾回收将试图在某个时候完成它，如果您已经对其进行了Dispose()d，这至少是浪费资源。|145187|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|$]]

When you use using, it will call the Dispose() method on the object at the end of the using's scope. So you can have quite a bit of great cleanup code in your Dispose() method.
A bullet point:
If you implement IDisposable, make sure you call GC.SuppressFinalize() in your Dispose() implementation, as otherwise automatic garbage collection will try to come along and Finalize it at some point, which at the least would be a waste of resources if you've already Dispose()d of it.

blocks|key|1144064|text|使用可以用来调用IDisposable。它也可以用于别名类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144065|using+(SqlConnection+cnn+=+new+SqlConnection())+{+/*+Code+*/}
using+f1+=+System.Windows.Forms.Form;|code-block|syntax|javascript|1144066|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|$]]

using can be used to call IDisposable. It can also be used to alias types.
<pre><code>using (SqlConnection cnn = new SqlConnection()) { /* Code */}
using f1 = System.Windows.Forms.Form;
</code></pre>

blocks|key|839365|text|“使用”也可用于解决命名空间冲突。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|839366|关于我写的关于这个主题的简短教程，请参阅http://www.davidarno.org/c-howtos/aliases-overcoming-name-conflicts/。|offset|length|839367|entityMap|0|LINK|mutability|MUTABLE|url|http://www.davidarno.org/c-howtos/aliases-overcoming-name-conflicts/^0|0|K|1W|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

&quot;using&quot; can also be used to resolve namespace conflicts.
See <a href="http://www.davidarno.org/c-howtos/aliases-overcoming-name-conflicts/" rel="nofollow noreferrer">http://www.davidarno.org/c-howtos/aliases-overcoming-name-conflicts/</a> for a short tutorial I wrote on the subject.

blocks|key|145268|text|using关键字定义对象的作用域，然后在作用域完成时处理对象。例如。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|145269|using+(Font+font2+=+new+Font("Arial",+10.0f))
{
++++//+Use+font2
}|code-block|syntax|javascript|145270|有关使用关键字的这里关于C#的文章，请参见MSDN。|offset|length|145271|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/yh598w02(VS.80).aspx^0|0|0|8|2|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|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

The using keyword defines the scope for the object and then disposes of the object when the scope is complete. For example.
<pre><code>using (Font font2 = new Font(&quot;Arial&quot;, 10.0f))
{
 // Use font2
}
</code></pre>
See <a href="http://msdn.microsoft.com/en-us/library/yh598w02(VS.80).aspx" rel="nofollow noreferrer">here</a> for the MSDN article on the C# using keyword.

blocks|key|145275|text|使用使用时，当您有要在资源使用后释放的资源时，就会使用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|145276|例如，如果您分配了一个文件资源，并且只需要在一段代码中使用它来进行少量的读或写，那么使用它有助于您完成对文件资源的处理。|145277|所使用的资源需要实现IDisposable才能正常工作。|145278|示例：|145279|using+(File+file+=+new+File+(parameters))
{
++++//+Code+to+do+stuff+with+the+file
}|code-block|syntax|javascript|145280|entityMap^0|2|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|W|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|X|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|Y|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

using is used when you have a resource that you want disposed after it's been used.
For instance if you allocate a File resource and only need to use it in one section of code for a little reading or writing, using is helpful for disposing of the File resource as soon as your done.
The resource being used needs to implement IDisposable to work properly.
Example:
<pre><code>using (File file = new File (parameters))
{
 // Code to do stuff with the file
}
</code></pre>

blocks|key|839419|text|using语句的原因是确保对象一旦超出作用域就被释放，并且它不需要显式代码来确保这种情况的发生。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|839420|与https://www.codeproject.com/Articles/6564/Understanding-the-using-statement-in-C和https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/using-objects一样，C#编译器会转换|839421|using+(MyResource+myRes+=+new+MyResource())
{
++++myRes.DoSomething();
}|code-block|syntax|javascript|839422|至|839423|{+//+Limits+scope+of+myRes
++++MyResource+myRes=+new+MyResource();
++++try
++++{
++++++++myRes.DoSomething();
++++}
++++finally
++++{
++++++++//+Check+for+a+null+resource.
++++++++if+(myRes+!=+null)
++++++++++++//+Call+the+object's+Dispose+method.
++++++++++++((IDisposable)myRes).Dispose();
++++}
}|839424|C#+8引入了一个名为“使用声明”的新语法：|839425|using声明是一个变量声明，前面有using关键字。它告诉编译器，被声明的变量应该在封闭作用域的末尾释放。|blockquote|839426|因此，上面的等效代码是：|839427|using+var+myRes+=+new+MyResource();
myRes.DoSomething();|839428|当控件离开包含的作用域(通常是方法，但也可以是代码块)时，myRes将被释放。|839429|entityMap|0|LINK|mutability|MUTABLE|url|https://www.codeproject.com/Articles/6564/Understanding-the-using-statement-in-C|1|https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/using-objects|2|https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#using-declarations^0|0|5|0|1|28|0|2A|2A|1|0|0|0|0|C|4|2|0|0|0|0|T|5|0^^$0|@$1|2|3|4|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1G|8|@]|D|@$9|1H|A|1I|1|1J]|$9|1K|A|1L|1|1M]]|E|$]]|$1|H|3|I|5|J|7|1N|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1O|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1P|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1Q|8|@]|D|@$9|1R|A|1S|1|1T]]|E|$]]|$1|S|3|T|5|U|7|1U|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1V|8|@]|D|@]|E|$]]|$1|X|3|Y|5|J|7|1W|8|@]|D|@]|E|$K|L]]|$1|Z|3|10|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|11|3|-4|5|6|7|20|8|@]|D|@]|E|$]]]|12|$13|$5|14|15|16|E|$17|18]]|19|$5|14|15|16|E|$17|1A]]|1B|$5|14|15|16|E|$17|1C]]]]

The reason for the <code>using</code> statement is to ensure that the object is disposed as soon as it goes out of scope, and it doesn't require explicit code to ensure that this happens.

As in <a href="https://www.codeproject.com/Articles/6564/Understanding-the-using-statement-in-C" rel="noreferrer">Understanding the 'using' statement in C# (codeproject)</a> and <a href="https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/using-objects" rel="noreferrer">Using objects that implement IDisposable (microsoft)</a>, the C# compiler converts

<pre><code>using (MyResource myRes = new MyResource())
{
 myRes.DoSomething();
}
</code></pre>

to

<pre><code>{ // Limits scope of myRes
 MyResource myRes= new MyResource();
 try
 {
 myRes.DoSomething();
 }
 finally
 {
 // Check for a null resource.
 if (myRes != null)
 // Call the object's Dispose method.
 ((IDisposable)myRes).Dispose();
 }
}
</code></pre>

C# 8 introduces a new syntax, named "<a href="https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-8#using-declarations" rel="noreferrer">using declarations</a>":

<blockquote>
 A using declaration is a variable declaration preceded by the using keyword. It tells the compiler that the variable being declared should be disposed at the end of the enclosing scope.
</blockquote>

So the equivalent code of above would be:

<pre><code>using var myRes = new MyResource();
myRes.DoSomething();
</code></pre>

And when control leaves the containing scope (usually a method, but it can also be a code block), <code>myRes</code> will be disposed.

blocks|key|839442|text|有趣的是，您还可以将use+/IDisposable模式用于其他有趣的事情(例如Rhino使用它的另一点)。基本上，您可以利用这样一个事实:编译器将始终在“”对象上调用.Dispose。如果你有什么事情需要在手术后发生.有明确的开始和结束的东西..。然后，您可以简单地创建一个IDisposable类，它在构造函数中启动操作，然后在Dispose方法中完成。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|839443|这允许您使用非常好的使用语法来表示所述操作的显式开始和结束。这也是System.Transactions的工作原理。|839444|entityMap^0|26|4|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Interestingly, you can also use the using/IDisposable pattern for other interesting things (such as the other point of the way that Rhino Mocks uses it). Basically, you can take advantage of the fact that the compiler will always call .Dispose on the "used" object. If you have something that needs to happen after a certain operation ... something that has a definite start and end ... then you can simply make an IDisposable class that starts the operation in the constructor, and then finishes in the Dispose method.

This allows you to use the really nice using syntax to denote the explicit start and end of said operation. This is also how the System.Transactions stuff works.

blocks|key|145365|text|我过去经常使用它来处理输入和输出流。您可以很好地嵌套它们，它消除了您通常遇到的许多潜在问题(通过自动调用dispose)。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|145366|++++++++using+(FileStream+fs+=+new+FileStream("c:\file.txt",+FileMode.Open))
++++++++{
++++++++++++using+(BufferedStream+bs+=+new+BufferedStream(fs))
++++++++++++{
++++++++++++++++using+(System.IO.StreamReader+sr+=+new+StreamReader(bs))
++++++++++++++++{
++++++++++++++++++++string+output+=+sr.ReadToEnd();
++++++++++++++++}
++++++++++++}
++++++++}|code-block|syntax|javascript|145367|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've used it a lot in the past to work with input and output streams. You can nest them nicely and it takes away a lot of the potential problems you usually run into (by automatically calling dispose). For example:

<pre><code> using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
 {
 using (BufferedStream bs = new BufferedStream(fs))
 {
 using (System.IO.StreamReader sr = new StreamReader(bs))
 {
 string output = sr.ReadToEnd();
 }
 }
 }
</code></pre>

blocks|key|1144198|text|这并不是说它是极端重要的，但使用也可以用来改变资源的动态。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144199|是的，正如前面提到的那样，一次性的，但具体而言，您不希望它们与其他资源不匹配的资源在您执行的其余部分。所以你想把它处理掉这样它就不会干扰其他地方了。|1144200|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|$]]

Not that it is ultra important, but using can also be used to change resources on the fly.
Yes, disposable as mentioned earlier, but perhaps specifically you don't want the resources they mismatch with other resources during the rest of your execution. So you want to dispose of it so it doesn't interfere elsewhere.

blocks|key|145397|text|因为很多人仍然这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|145398|using+(System.IO.StreamReader+r+=+new+System.IO.StreamReader(""))
using+(System.IO.StreamReader+r2+=+new+System.IO.StreamReader(""))+{
+++//code
}|code-block|syntax|javascript|145399|我想很多人还是不知道你能做什么：|145400|using+(System.IO.StreamReader+r+=+new+System.IO.StreamReader(""),+r2+=+new+System.IO.StreamReader(""))+{
+++//code
}|145401|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Since a lot of people still do:

<pre><code>using (System.IO.StreamReader r = new System.IO.StreamReader(""))
using (System.IO.StreamReader r2 = new System.IO.StreamReader("")) {
 //code
}
</code></pre>

I guess a lot of people still don't know that you can do:

<pre><code>using (System.IO.StreamReader r = new System.IO.StreamReader(""), r2 = new System.IO.StreamReader("")) {
 //code
}
</code></pre>

blocks|key|1144226|text|另一个合理使用的例子，即立即处置该物体：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144227|using+(IDataReader+myReader+=+DataFunctions.ExecuteReader(CommandType.Text,+sql.ToString(),+dp.Parameters,+myConnectionString))+
{
++++while+(myReader.Read())+
++++{
++++++++MyObject+theObject+=+new+MyObject();
++++++++theObject.PublicProperty+=+myReader.GetString(0);
++++++++myCollection.Add(theObject);
++++}
}|code-block|syntax|javascript|1144228|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|$]]

Another example of a reasonable use in which the object is immediately disposed:

<pre><code>using (IDataReader myReader = DataFunctions.ExecuteReader(CommandType.Text, sql.ToString(), dp.Parameters, myConnectionString)) 
{
 while (myReader.Read()) 
 {
 MyObject theObject = new MyObject();
 theObject.PublicProperty = myReader.GetString(0);
 myCollection.Add(theObject);
 }
}
</code></pre>

blocks|key|1144252|text|使用的另一个很好的用途是实例化一个模态对话框。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144253|Using+frm+as+new+Form1

++++Form1.ShowDialog

++++'+Do+stuff+here

End+Using|code-block|syntax|javascript|1144254|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|$]]

Another great use of using is when instantiating a modal dialog.
<pre class="lang-vbnet prettyprint-override"><code>Using frm as new Form1

 Form1.ShowDialog

 ' Do stuff here

End Using
</code></pre>

blocks|key|839480|text|使用，在.意义上|type|unstyled|depth|inlineStyleRanges|entityRanges|data|839481|using+(var+foo+=+new+Bar())
{
++Baz();
}|code-block|syntax|javascript|839482|实际上是试/最后块的缩写。它等同于守则：|839483|var+foo+=+new+Bar();
try
{
++Baz();
}
finally
{
++foo.Dispose();
}|839484|当然，您会注意到，第一个片段比第二个片段要简洁得多，而且即使抛出异常，您也可能需要进行许多类型的清理。正因为如此，我们提出了一个类，我们称之为作用域，它允许您在Dispose方法中执行任意代码。因此，例如，如果您有一个名为IsWorking的属性，您一直希望在执行操作后将其设置为false，则可以这样做：|839485|using+(new+Scope(()+=>+IsWorking+=+false))
{
++IsWorking+=+true;
++MundaneYetDangerousWork();
}|839486|您可以阅读更多关于我们的解决方案以及我们如何导出它的这里。|offset|length|839487|entityMap|0|LINK|mutability|MUTABLE|url|https://faithlife.codes/blog/2008/08/leverage_using_blocks_with_scope/^0|0|0|0|0|0|0|Q|2|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@]|9|@$Q|17|R|18|1|19]]|A|$]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

using, in the sense of
<pre><code>using (var foo = new Bar())
{
 Baz();
}
</code></pre>
Is actually shorthand for a try/finally block. It is equivalent to the code:
<pre><code>var foo = new Bar();
try
{
 Baz();
}
finally
{
 foo.Dispose();
}
</code></pre>
You'll note, of course, that the first snippet is much more concise than the second and also that there are many kinds of things that you might want to do as cleanup even if an exception is thrown. Because of this, we've come up with a class that we call Scope that allows you to execute arbitrary code in the Dispose method. So, for example, if you had a property called IsWorking that you always wanted to set to false after trying to perform an operation, you'd do it like this:
<pre><code>using (new Scope(() =&gt; IsWorking = false))
{
 IsWorking = true;
 MundaneYetDangerousWork();
}
</code></pre>
You can read more about our solution and how we derived it <a href="https://faithlife.codes/blog/2008/08/leverage_using_blocks_with_scope/" rel="nofollow noreferrer">here</a>.

blocks|key|145490|text|在花括号之外的所有东西都会被处理掉，所以如果你不使用你的对象的话，那么很好的处理它们。这是因为如果您有一个SqlDataAdapter对象，并且在应用程序生命周期中只使用它一次，并且您只填充了一个数据集，并且不再需要它，那么您可以使用以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|145491|using(SqlDataAdapter+adapter_object+=+new+SqlDataAdapter(sql_command_parameter))
{
+++//+do+stuff
}+//+here+adapter_object+is+disposed+automatically|code-block|syntax|javascript|145492|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|$]]

Everything outside the curly brackets is disposed, so it is great to dispose your objects if you are not using them. This is so because if you have a SqlDataAdapter object and you are using it only once in the application life cycle and you are filling just one dataset and you don't need it anymore, you can use the code:

<pre><code>using(SqlDataAdapter adapter_object = new SqlDataAdapter(sql_command_parameter))
{
 // do stuff
} // here adapter_object is disposed automatically
</code></pre>

blocks|key|145497|text|public+class+ClassA:IDisposable
{
++++#region+IDisposable+Members
++++public+void+Dispose()
++++{
++++++++GC.SuppressFinalize(this);
++++}
++++#endregion
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|145498|public+void+fn_Data()
{
++++using+(ClassA+ObjectName+=+new+ClassA())
++++{
++++++++//+Use+objectName
++++}
}|145499|unstyled|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$B|C]]|$1|F|3|-4|5|G|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>public class ClassA:IDisposable
{
 #region IDisposable Members
 public void Dispose()
 {
 GC.SuppressFinalize(this);
 }
 #endregion
}
</code></pre>
<hr />
<pre><code>public void fn_Data()
{
 using (ClassA ObjectName = new ClassA())
 {
 // Use objectName
 }
}
</code></pre>

blocks|key|1144311|text|using子句用于定义特定变量的作用域。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144312|例如：|1144313|Using(SqlConnection+conn+=+new+SqlConnection(ConnectionString)
{
++++Conn.Open()

++++//+Execute+SQL+statements+here.
++++//+You+do+not+have+to+close+the+connection+explicitly
++++//+here+as+"USING"+will+close+the+connection+once+the
++++//+object+Conn+goes+out+of+the+defined+scope.
}|code-block|syntax|javascript|1144314|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The using clause is used to define the scope for the particular variable.
For example:
<pre><code>Using(SqlConnection conn = new SqlConnection(ConnectionString)
{
 Conn.Open()

 // Execute SQL statements here.
 // You do not have to close the connection explicitly
 // here as &quot;USING&quot; will close the connection once the
 // object Conn goes out of the defined scope.
}
</code></pre>

blocks|key|1144331|text|可以通过以下示例使用别名命名空间：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144332|using+LegacyEntities+=+CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects;|code-block|syntax|javascript|1144333|这被称为使用别名指令，正如您可以看到的，它可以用于隐藏冗长的引用，如果您希望在代码中清楚地显示您所指的是什么。|1144334|LegacyEntities.Account|1144335|而不是|1144336|CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account|1144337|或者简单的|1144338|Account+++//+It+is+not+obvious+this+is+a+legacy+entity|1144339|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

You can make use of the alias namespace by way of the following example:

<pre><code>using LegacyEntities = CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects;
</code></pre>

This is called a using alias directive as as you can see, it can be used to hide long-winded references should you want to make it obvious in your code what you are referring to
e.g.

<pre><code>LegacyEntities.Account
</code></pre>

instead of

<pre><code>CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account
</code></pre>

or simply

<pre><code>Account // It is not obvious this is a legacy entity
</code></pre>

blocks|key|1144373|text|using语句为正确使用IDisposable对象提供了一种方便的机制。通常，当您使用IDisposable对象时，应该在using语句中声明并实例化它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144374|using语句以正确的方式调用对象上的Dispose方法，并且(如前面所示，当您使用它时)，它还会在调用Dispose时导致对象本身超出作用域。在using块中，对象是只读的，不能修改或重新分配.|1144375|这来自这里。|offset|length|1144376|entityMap|0|LINK|mutability|MUTABLE|url|https://social.msdn.microsoft.com/Search/en-US?query=using&emptyWatermark=true&ac=4^0|0|0|3|2|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

The using statement provides a convenience mechanism to correctly use IDisposable objects. As a rule, when you use an IDisposable object, you should declare and instantiate it in a using statement.
The using statement calls the Dispose method on the object in the correct way, and (when you use it as shown earlier) it also causes the object itself to go out of scope as soon as Dispose is called. Within the using block, the object is read-only and cannot be modified or reassigned.
This comes from <a href="https://social.msdn.microsoft.com/Search/en-US?query=using&amp;emptyWatermark=true&amp;ac=4" rel="nofollow noreferrer">here</a>.

blocks|key|839530|text|对我来说，“使用”这个名字有点让人困惑，因为is可以是一个指令，用于导入名称空间或语句(如这里讨论的)，以进行错误处理。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|839531|错误处理的不同名称会很好，而且可能是一个更明显的名称。|839532|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|$]]

For me the name "using" is a little bit confusing, because is can be a directive to import a Namespace or a statement (like the one discussed here) for error handling.

A different name for error handling would've been nice, and maybe a somehow more obvious one.

blocks|key|1144446|text|我只是补充了一点我感到惊讶的东西，却没有提出来。使用(在我看来)最有趣的特性是，无论如何退出using块，它总是会释放对象。这包括返回和例外情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1144447|using+(var+db+=+new+DbContext())
{
++++if(db.State+==+State.Closed)
++++++++throw+new+Exception("Database+connection+is+closed.");
++++return+db.Something.ToList();
}|code-block|syntax|javascript|1144448|是否抛出异常或返回列表并不重要。DbContext对象将始终被释放。|1144449|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|$]]

Just adding a little something that I was surprised did not come up. The most interesting feature of using (in my opinion) is that no matter how you exit the using block, it will always dispose the object. This includes returns and exceptions.
<pre><code>using (var db = new DbContext())
{
 if(db.State == State.Closed)
 throw new Exception(&quot;Database connection is closed.&quot;);
 return db.Something.ToList();
}
</code></pre>
It doesn't matter if the exception is thrown or the list is returned. The DbContext object will always be disposed.

blocks|key|145622|text|Microsoft指出，使用的具有双重函数(https://msdn.microsoft.com/en-us/library/zhdeatwt.aspx)，既可以作为指令，也可以作为语句。作为一种声明，正如这里在其他答案中指出的那样，关键字基本上是用于确定用于释放IDisposable对象的范围的语法糖。作为指令，它通常用于导入命名空间和类型。另外，作为指令，您可以为名称空间和类型创建别名，正如约瑟夫和Ben在书"C#+5.0+:权威指南“(http://www.amazon.com/5-0-Nutshell-The-Definitive-Reference-ebook/dp/B008E6I1K8)中指出的那样。一个例子是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|145623|namespace+HelloWorld
{
++++using+AppFunc+=+Func<IDictionary<DateTime,+string>,+List<string>>;
++++public+class+Startup
++++{
++++++++public+static+AppFunc+OrderEvents()+
++++++++{
++++++++++++AppFunc+appFunc+=+(IDictionary<DateTime,+string>+events)+=>
++++++++++++{
++++++++++++++++if+((events+!=+null)+&&+(events.Count+>+0))
++++++++++++++++{
++++++++++++++++++++List<string>+result+=+events.OrderBy(ev+=>+ev.Key)
++++++++++++++++++++++++.Select(ev+=>+ev.Value)
++++++++++++++++++++++++.ToList();
++++++++++++++++++++return+result;
++++++++++++++++}
++++++++++++++++throw+new+ArgumentException("Event+dictionary+is+null+or+empty.");
++++++++++++};
++++++++++++return+appFunc;
++++++++}
++++}
}|code-block|syntax|javascript|145624|这是明智的做法，因为滥用这种做法可能会损害代码的清晰度。C#别名有一个很好的解释，在DotNetPearls+(http://www.dotnetperls.com/using-alias)中也提到了优点和缺点。|145625|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/zhdeatwt.aspx|1|https://rads.stackoverflow.com/amzn/click/com/B008E6I1K8|2|http://www.dotnetperls.com/using-alias^0|E|1|3O|B|M|1I|0|67|27|1|0|0|1K|12|2|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|M|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]|W|$5|P|Q|R|E|$S|X]]]]

Microsoft documentation states that using has a double function (<a href="https://msdn.microsoft.com/en-us/library/zhdeatwt.aspx" rel="noreferrer">https://msdn.microsoft.com/en-us/library/zhdeatwt.aspx</a>), both as a directive and in statements. As a statement, as it was pointed out here in other answers, the keyword is basically syntactic sugar to determine a scope to dispose an IDisposable object. As a directive, it is routinely used to import namespaces and types. Also as a directive, you can create aliases for namespaces and types, as pointed out in the book "C# 5.0 In a Nutshell: The Definitive Guide" (<a href="https://rads.stackoverflow.com/amzn/click/com/B008E6I1K8" rel="noreferrer" rel="nofollow noreferrer">http://www.amazon.com/5-0-Nutshell-The-Definitive-Reference-ebook/dp/B008E6I1K8</a>), by Joseph and Ben Albahari. One example:

<pre><code>namespace HelloWorld
{
 using AppFunc = Func&lt;IDictionary&lt;DateTime, string&gt;, List&lt;string&gt;&gt;;
 public class Startup
 {
 public static AppFunc OrderEvents() 
 {
 AppFunc appFunc = (IDictionary&lt;DateTime, string&gt; events) =&gt;
 {
 if ((events != null) &amp;&amp; (events.Count &gt; 0))
 {
 List&lt;string&gt; result = events.OrderBy(ev =&gt; ev.Key)
 .Select(ev =&gt; ev.Value)
 .ToList();
 return result;
 }
 throw new ArgumentException("Event dictionary is null or empty.");
 };
 return appFunc;
 }
 }
}
</code></pre>

This is something to adopt wisely, since the abuse of this practice can hurt the clarity of one's code. There is a nice explanation on C# aliases, also mentioning pros and cons, in DotNetPearls (<a href="http://www.dotnetperls.com/using-alias" rel="noreferrer">http://www.dotnetperls.com/using-alias</a>).

blocks|key|145651|text|它还可用于创建作用域，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|145652|class+LoggerScope:IDisposable+{
+++static+ThreadLocal<LoggerScope>+threadScope+=+
++++++++new+ThreadLocal<LoggerScope>();
+++private+LoggerScope+previous;

+++public+static+LoggerScope+Current=>+threadScope.Value;

+++public+bool+WithTime{get;}

+++public+LoggerScope(bool+withTime){
+++++++previous+=+threadScope.Value;
+++++++threadScope.Value+=+this;
+++++++WithTime=withTime;
+++}

+++public+void+Dispose(){
+++++++threadScope.Value+=+previous;
+++}
}


class+Program+{
+++public+static+void+Main(params+string[]+args){
+++++++new+Program().Run();
+++}

+++public+void+Run(){
++++++log("something+happend!");
++++++using(new+LoggerScope(false)){
++++++++++log("the+quick+brown+fox+jumps+over+the+lazy+dog!");
++++++++++using(new+LoggerScope(true)){
++++++++++++++log("nested+scope!");
++++++++++}
++++++}
+++}

+++void+log(string+message){
++++++if(LoggerScope.Current!=null){
++++++++++Console.WriteLine(message);
++++++++++if(LoggerScope.Current.WithTime){
+++++++++++++Console.WriteLine(DateTime.Now);
++++++++++}
++++++}
+++}

}|code-block|syntax|javascript|145653|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|$]]

It also can be used for creating scopes for Example:

<pre><code>class LoggerScope:IDisposable {
 static ThreadLocal&lt;LoggerScope&gt; threadScope = 
 new ThreadLocal&lt;LoggerScope&gt;();
 private LoggerScope previous;

 public static LoggerScope Current=&gt; threadScope.Value;

 public bool WithTime{get;}

 public LoggerScope(bool withTime){
 previous = threadScope.Value;
 threadScope.Value = this;
 WithTime=withTime;
 }

 public void Dispose(){
 threadScope.Value = previous;
 }
}


class Program {
 public static void Main(params string[] args){
 new Program().Run();
 }

 public void Run(){
 log("something happend!");
 using(new LoggerScope(false)){
 log("the quick brown fox jumps over the lazy dog!");
 using(new LoggerScope(true)){
 log("nested scope!");
 }
 }
 }

 void log(string message){
 if(LoggerScope.Current!=null){
 Console.WriteLine(message);
 if(LoggerScope.Current.WithTime){
 Console.WriteLine(DateTime.Now);
 }
 }
 }

}
</code></pre>

blocks|key|839595|text|using语句告诉.NET，一旦不再需要using块中指定的对象，就释放它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|839596|因此，对于需要清理的类，应该使用“使用”块，比如System.IO类型。|839597|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|$]]

The using statement tells .NET to release the object specified in the using block once it is no longer needed.
So you should use the 'using' block for classes that require cleaning up after them, like System.IO types.

blocks|key|145744|text|使用作为语句自动调用指定对象的dispose。对象必须实现IDisposable接口。可以在一个语句中使用多个对象，只要它们是同一类型的。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|145745|CLR将代码转换为CIL。并将using语句转换为一个try，最后一个块。以下是使用CIL表示using语句的方式。使用语句被翻译成三个部分:获取、使用和处理。首先获取资源，然后将其使用包含在带first子句的try语句中。然后，将对象释放到finally子句中。|unstyled|offset|length|145746|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Common_Language_Runtime|1|https://en.wikipedia.org/wiki/Common_Intermediate_Language^0|0|0|3|0|9|3|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@$E|S|F|T|1|U]|$E|V|F|W|1|X]]|A|$]]|$1|G|3|-4|5|D|7|Y|8|@]|9|@]|A|$]]]|H|$I|$5|J|K|L|A|$M|N]]|O|$5|J|K|L|A|$M|P]]]]

<blockquote>
using as a statement automatically calls the dispose on the specified
object. The object must implement the IDisposable interface. It is
possible to use several objects in one statement as long as they are
of the same type.
</blockquote>
The <a href="https://en.wikipedia.org/wiki/Common_Language_Runtime" rel="nofollow noreferrer">CLR</a> converts your code into <a href="https://en.wikipedia.org/wiki/Common_Intermediate_Language" rel="nofollow noreferrer">CIL</a>. And the using statement gets translated into a try and finally block. This is how the using statement is represented in CIL. A using statement is translated into three parts: acquisition, usage, and disposal. The resource is first acquired, then the usage is enclosed in a try statement with a finally clause. The object then gets disposed in the finally clause.

blocks|key|1144558|text|using关键字在C#中有两个用法，如下所示。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1144559|作为指示
通常，我们使用using关键字在代码隐藏和类文件中添加名称空间。然后，它提供当前页面中的所有类、接口和抽象类及其方法和属性。
示例：
使用System.IO；|ordered-list-item|1144560|作为陈述
这是在using中使用C#关键字的另一种方式。它在提高垃圾收集性能方面起着至关重要的作用。
using语句确保调用Dispose()，即使在创建对象和调用方法、属性等时出现异常。Dispose()是一个存在于IDisposable接口中的方法，它帮助实现自定义垃圾回收。换句话说，如果我正在执行某些数据库操作(插入、更新、删除)，但不知怎么会出现异常，那么这里的using语句将自动关闭连接。不需要显式调用connection+()方法。
另一个重要的因素是它有助于连接池。.NET中的连接池有助于消除多次关闭数据库连接。它将连接对象发送到池以供以后使用(下一次数据库调用)。下次从应用程序调用数据库连接时，连接池将获取池中可用的对象。因此，它有助于提高应用程序的性能。因此，当我们使用using语句时，控制器会自动将对象发送到连接池，因此不需要显式调用Close()和Dispose()方法。
您可以通过使用try-catch块来执行与using语句相同的操作，并显式地调用inside块中的Dispose()。但是using语句会自动执行调用，以使代码更简洁、更优雅。在using块中，对象是只读的，不能修改或重新分配.
示例：
字符串connString+=+"Data+Source=localhost;Integrated+Security=SSPI;Initial+Catalog=Northwind;"；使用(SqlConnection+conn+=新的SqlConnection(connString))+{+SqlCommand+cmd+=+conn.CreateCommand()；cmd.CommandText+=+"SELECT+CustomerId，CompanyName+FROM+Customers"；conn.Open()；使用(SqlDataReader+dr+=+cmd.ExecuteReader())+{+while+(dr.Read())+Console.WriteLine("{0}\t{1}"，dr.GetString(0)，dr.GetString(1))；}|1144561|在前面的代码中，我不会关闭任何连接；它将自动关闭。using语句将由于using语句(using+(SqlConnection+conn+=+new+SqlConnection(connString))而自动调用conn.Close()，对于SqlDataReader对象也是如此。而且，如果出现任何异常，它将自动关闭连接。|1144562|有关更多信息，请参见https://www.c-sharpcorner.com/UploadFile/manas1/usage-and-importance-of-using-in-C-Sharp472/。|1144563|entityMap|0|LINK|mutability|MUTABLE|url|https://www.c-sharpcorner.com/UploadFile/manas1/usage-and-importance-of-using-in-C-Sharp472/^0|0|5|0|C|5|0|8|5|1F|5|0|P|5|Z|5|17|1L|0|A|2K|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|I|3|J|5|H|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|K|3|L|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1E|8|@]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|O|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

There are two usages of the <code>using</code> keyword in C# as follows.
<ol>
<li>As a directive
Generally we use the <code>using</code> keyword to add namespaces in code-behind and class files. Then it makes available all the classes, interfaces and abstract classes and their methods and properties in the current page.
Example:
<pre><code>using System.IO;
</code></pre>
</li>
<li>As a statement
This is another way to use the <code>using</code> keyword in C#. It plays a vital role in improving performance in garbage collection.
The <code>using</code> statement ensures that Dispose() is called even if an exception occurs when you are creating objects and calling methods, properties and so on. Dispose() is a method that is present in the IDisposable interface that helps to implement custom garbage collection. In other words if I am doing some database operation (Insert, Update, Delete) but somehow an exception occurs then here the using statement closes the connection automatically. No need to call the connection Close() method explicitly.
Another important factor is that it helps in Connection Pooling. Connection Pooling in .NET helps to eliminate the closing of a database connection multiple times. It sends the connection object to a pool for future use (next database call). The next time a database connection is called from your application the connection pool fetches the objects available in the pool. So it helps to improve the performance of the application. So when we use the using statement the controller sends the object to the connection pool automatically, there is no need to call the Close() and Dispose() methods explicitly.
You can do the same as what the using statement is doing by using try-catch block and call the Dispose() inside the finally block explicitly. But the using statement does the calls automatically to make the code cleaner and more elegant. Within the using block, the object is read-only and cannot be modified or reassigned.
Example:
<pre><code>string connString = &quot;Data Source=localhost;Integrated Security=SSPI;Initial Catalog=Northwind;&quot;;

using (SqlConnection conn = new SqlConnection(connString))
{
 SqlCommand cmd = conn.CreateCommand();
 cmd.CommandText = &quot;SELECT CustomerId, CompanyName FROM Customers&quot;;
 conn.Open();
 using (SqlDataReader dr = cmd.ExecuteReader())
 {
 while (dr.Read())
 Console.WriteLine(&quot;{0}\t{1}&quot;, dr.GetString(0), dr.GetString(1));
 }
}
</code></pre>
</li>
</ol>
In the preceding code I am not closing any connection; it will close automatically. The <code>using</code> statement will call conn.Close() automatically due to the <code>using</code> statement (<code>using (SqlConnection conn = new SqlConnection(connString)</code>) and the same for a SqlDataReader object. And also if any exception occurs it will close the connection automatically.
For more information, see <a href="https://www.c-sharpcorner.com/UploadFile/manas1/usage-and-importance-of-using-in-C-Sharp472/" rel="nofollow noreferrer">Usage and Importance of Using in C#</a>.

User <a href="https://stackoverflow.com/users/1065/kokos">kokos</a> answered the wonderful <a href="https://stackoverflow.com/questions/9033/hidden-features-of-c">Hidden Features of C#</a> question by mentioning the <code>using</code> keyword. Can you elaborate on that? What are the uses of <code>using</code>?

What are the uses of "using" in C#?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

用户通过提到using关键字回答了精彩的问题。你能详细说明一下吗？using的用途是什么？

问在C#中“使用”有什么用途？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中“使用”有什么用途？EN