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

Question

用户 kokos 回答了精彩的C# 的隐藏功能 通过提及 using 关键字提出问题。 你能详细说明一下吗？ using 有什么用处？

Answer 1

因为很多人仍然这样做：

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

我想很多人仍然不知道你可以这样做：

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

Answer 2

像这样的事情：

using (var conn = new SqlConnection("connection string"))
{
   conn.Open();

    // Execute SQL statement here on the connection you created
}

这个SqlConnection将被关闭，而不需要显式调用.Close()函数，并且即使抛出异常也会发生这种情况 em>，不需要 try/catch/finally。

Answer 3

using 子句用于定义特定变量的范围。

例如：

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.
}

Answer 4

使用 using 语句的原因是确保对象在超出范围后立即被释放，并且不需要显式代码来确保发生这种情况。

如 理解 C# 中的 'using' 语句（代码项目） 和使用实现 IDisposable (microsoft) 的对象，C# 编译器转换

using (MyResource myRes = new MyResource())
{
    myRes.DoSomething();
}

为

{ // 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();
    }
}

C# 8，引入了一种新语法，名为“使用声明"：

using 声明是前面带有 using 关键字的变量声明。 它告诉编译器所声明的变量应该在封闭范围的末尾进行处理。

所以上面的等效代码是：

using var myRes = new MyResource();
myRes.DoSomething();

当控制离开包含范围（通常是一个方法，但也可以是一个代码块）时，myRes 将被释放。

Answer 5

using 可用于调用 IDisposable。 它还可以用于别名类型。

using (SqlConnection cnn = new SqlConnection()) { /* Code */}
using f1 = System.Windows.Forms.Form;

Answer 6

使用，实际上

using (var foo = new Bar())
{
  Baz();
}

是 try/finally 块的简写。 它相当于代码：

var foo = new Bar();
try
{
  Baz();
}
finally
{
  foo.Dispose();
}

当然，您会注意到，第一个片段比第二个片段简洁得多，而且即使抛出异常，您也可能需要执行多种操作来进行清理。 因此，我们提出了一个名为 Scope 的类，它允许您在 Dispose 方法中执行任意代码。 因此，例如，如果您有一个名为 IsWorking 的属性，在尝试执行操作后您总是希望将其设置为 false，那么您可以这样做：

using (new Scope(() => IsWorking = false))
{
  IsWorking = true;
  MundaneYetDangerousWork();
}

您可以阅读有关我们的解决方案以及我们如何派生它的更多信息 此处。

Answer 7

Microsoft 文档指出 using 具有双重功能 (https: //msdn.microsoft.com/en-us/library/zhdeatwt.aspx），既作为指令，也作为语句。 作为一个声明，正如在其他答案中指出的那样，关键字基本上是语法糖，用于确定处置 IDisposable 对象的范围。 作为指令，它通常用于导入命名空间和类型。 另外，作为指令，您可以为命名空间和类型创建别名，如《C# 5.0 简而言之：权威指南》(http://www.amazon.com/5-0-Nutshell-The-Definitive-Reference-ebook/dp/B008E6I1K8) ，约瑟夫和本阿尔巴哈里。 一个例子：

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;
        }
    }
}

这是一种明智的做法，因为滥用这种做法可能会损害代码的清晰度。 DotNetPearls (http://www.dotnetperls .com/using-alias）。

Answer 8

有趣的是，您还可以将 using/IDisposable 模式用于其他有趣的事情（例如 Rhino Mocks 使用它的方式的另一点）。 基本上，您可以利用编译器始终对“已使用”对象调用 .Dispose 的事实。 如果您需要在某个操作之后发生某些事情……有明确的开始和结束的事情……那么您可以简单地创建一个 IDisposable 类，该类在构造函数中开始操作，然后在 Dispose 方法中完成。

这允许您使用非常好的 using 语法来表示所述操作的显式开始和结束。 这也是 System.Transactions 的工作原理。

Answer 9

using 的另一个重要用途是实例化模式对话框。

Using frm as new Form1

    Form1.ShowDialog

    ' Do stuff here

End Using

Answer 10

您可以通过以下示例来使用别名命名空间：

using LegacyEntities = CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects;

这称为 using alias 指令，如您所见，如果您想隐藏冗长的引用，它可以用于隐藏冗长的引用在你的代码中很明显你所指的是什么
例如

LegacyEntities.Account

代替

CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account

或简单地

Account   // It is not obvious this is a legacy entity

Answer 11

只是添加了一些令我惊讶的东西并没有出现。 using 最有趣的特性（在我看来）是，无论你如何退出 using 块，它总是会释放该对象。 这包括退货和例外。

using (var db = new DbContext())
{
    if(db.State == State.Closed)
        throw new Exception("Database connection is closed.");
    return db.Something.ToList();
}

抛出异常或返回列表并不重要。 DbContext 对象将始终被释放。

Answer 12

我过去经常使用它来处理输入和输出流。 您可以很好地嵌套它们，并且它可以消除您通常遇到的许多潜在问题（通过自动调用 dispose）。 例如：

        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();
                }
            }
        }

Answer 13

使用 ADO.NET 时，您可以将 keywork 用于连接对象或读取器对象等。 这样，当代码块完成时，它将自动释放您的连接。

Answer 14

“using”也可以用来解决命名空间冲突。

请参阅http://www.davidarno.org/c -howtos/aliases-overcoming-name-conflicts/ 我就该主题编写了一个简短的教程。

Answer 15

C# 中 using 关键字有两种用法，如下所示。

1. 作为指令

   通常我们使用 using 关键字在代码隐藏和类文件中添加命名空间。 然后它使当前页面中的所有类、接口和抽象类及其方法和属性都可用。

   示例：

   使用 System.IO； 
     

2. 作为声明

   这是在 C# 中使用 using 关键字的另一种方式。 它对于提高垃圾收集性能起着至关重要的作用。

   using 语句可确保即使在创建对象以及调用方法、属性等时发生异常，也会调用 Dispose()。 Dispose() 是 IDisposable 接口中提供的一种方法，有助于实现自定义垃圾收集。 换句话说，如果我正在执行一些数据库操作（插入、更新、删除），但不知何故发生异常，那么这里的 using 语句会自动关闭连接。 无需显式调用连接 Close() 方法。

   另一个重要因素是它有助于连接池。 .NET 中的连接池有助于消除多次关闭数据库连接的情况。 它将连接对象发送到池以供将来使用（下一次数据库调用）。 下次从应用程序调用数据库连接时，连接池将获取池中可用的对象。 因此它有助于提高应用程序的性能。 因此，当我们使用using语句时，控制器会自动将对象发送到连接池，无需显式调用Close()和Dispose()方法。

   您可以通过使用 try-catch 块执行与 using 语句相同的操作，并显式调用 finally 块内的 Dispose()。 但 using 语句会自动进行调用，使代码更干净、更优雅。 在 using 块内，对象是只读的，不能修改或重新分配。

   示例：

   string connString = "数据源=localhost;集成安全性=SSPI;初始目录=Northwind;"; 
   
     使用 (SqlConnection conn = new SqlConnection(connString)) 
     { 
           SqlCommand cmd = conn.CreateCommand(); 
           cmd.CommandText = "从客户中选择客户 ID、公司名称"; 
           conn.Open(); 
           使用 (SqlDataReader dr = cmd.ExecuteReader()) 
           { 
              while (dr.Read()) 
              Console.WriteLine("{0}\t{1}", dr.GetString(0), dr.GetString(1)); 
           } 
     } 
     

在前面的代码中，我没有关闭任何连接； 它会自动关闭。 由于 using 语句 (using (SqlConnection conn = new SqlConnection(connString)) 和对于 SqlDataReader 对象也是如此，如果发生任何异常，它将自动关闭连接。

有关详细信息，请参阅C# 中使用的用法和重要性。

Answer 16

public class ClassA:IDisposable
{
    #region IDisposable Members
    public void Dispose()
    {
        GC.SuppressFinalize(this);
    }
    #endregion
}

---

public void fn_Data()
{
    using (ClassA ObjectName = new ClassA())
    {
        // Use objectName
    }
}

Answer 17

当您使用实现 IDisposable 的类型的局部变量时，始终，无一例外地使用 using¹。

如果您使用非本地 IDisposable 变量，则始终实现 IDisposable 模式。

两条简单的规则，可能有一个例外¹。 否则防止资源泄漏是一个真正的痛苦。

---

¹⁾：唯一的例外是 – 当您处理异常时。 这样，在 finally 块中显式调用 Dispose 的代码可能会更少。

Answer 18

using 用于当您想要在使用某个资源后将其释放时。

例如，如果您分配了一个文件资源，并且只需要在一段代码中使用它来进行少量读取或写入，则使用有助于在完成后立即处理文件资源。

正在使用的资源需要实现 IDisposable 才能正常工作。

例子：

using (File file = new File (parameters))
{
    // Code to do stuff with the file
}

Answer 19

立即处置该对象的合理使用的另一个例子：

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);
    }
}

Answer 20

它还可用于创建示例范围：

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);
          }
      }
   }

}

Answer 21

对我来说，“using”这个名字有点令人困惑，因为它可以是导入命名空间或语句（如此处讨论的）以进行错误处理的指令。

错误处理的不同名称会很好，而且也许是一个更明显的名称。

Answer 22

大括号之外的所有内容都已被丢弃，因此如果您不使用对象，最好将其丢弃。 之所以如此，是因为如果您有一个 SqlDataAdapter 对象，并且在应用程序生命周期中仅使用它一次，并且您只填充一个数据集并且不再需要它，则可以使用以下代码：

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

Answer 23

当您使用 using 时，它将在 using 作用域末尾调用对象上的 Dispose() 方法。 因此，您可以在 Dispose() 方法中包含大量出色的清理代码。

要点：

如果您实现 IDisposable，请确保在 Dispose() 实现中调用 GC.SuppressFinalize()，否则自动垃圾收集将尝试在某个时刻出现并最终确定它，这至少会造成浪费资源（如果您已经 Dispose()d 了）。

Answer 24

并不是说它非常重要，但是使用也可以用于动态更改资源。

是的，如前所述，是一次性的，但也许您不希望在其余执行过程中资源与其他资源不匹配。 所以你想处理掉它，这样它就不会干扰其他地方。

Answer 25

using 关键字定义对象的范围，然后在范围完成时释放该对象。 例如。

using (Font font2 = new Font("Arial", 10.0f))
{
    // Use font2
}

有关 C# 的 MSDN 文章，请参阅此处 使用关键字。

Answer 26

Rhino Mocks 记录播放语法 对 using 进行了有趣的使用。

Answer 27

using 语句告诉 .NET 在不再需要时释放 using 块中指定的对象。

因此，您应该对需要在之后进行清理的类使用“using”块，例如 System.IO 类型。

Answer 28

using 作为语句自动调用指定的 dispose
目的。 该对象必须实现 IDisposable 接口。 这是
可以在一个语句中使用多个对象，只要它们是
相同类型。

CLR 将您的代码转换为 CIL。 using 语句被转换为 try 和finally 块。 这就是 using 语句在 CIL 中的表示方式。 using 语句被翻译成三个部分：获取、使用和处置。 首先获取资源，然后将使用情况包含在带有 finally 子句的 try 语句中。 然后该对象在finally子句中被释放。

Answer 29

using 语句提供了一种正确使用 IDisposable 对象的便捷机制。 通常，当您使用 IDisposable 对象时，应在 using 语句中声明并实例化它。

using 语句以正确的方式调用对象上的 Dispose 方法，并且（当您如前面所示使用它时）它还会导致对象本身在调用 Dispose 后立即超出范围。 在 using 块中，对象是只读的，不能修改或重新分配。

这来自此处 。