关于使用“using”和“finally”清理资源

Question

有没有需要如下结构的情况？

using (Something something = new Something())
{
    try
    {
    }
    finally
    {
        something.SomeCleanup();
    }
}

或者，是否应该所有在隐式something.Dispose()调用中执行清理任务？

---

这是有问题的代码：

public static DataTable GetDataTable(string cmdText, IEnumerable<Parameter> parameters)
{
    // Create an empty memory table.
    DataTable dataTable = new DataTable();

    // Open a connection to the database.
    using (SqlConnection connection = new SqlConnection(ConfigurationTool.ConnectionString))
    {
        connection.Open();

        // Specify the stored procedure call and its parameters.
        using (SqlCommand command = new SqlCommand(cmdText, connection))
        {
            command.CommandType = CommandType.StoredProcedure;

            SqlParameterCollection parameterCollection = command.Parameters;
            foreach (Parameter parameter in parameters)
                parameterCollection.Add(parameter.SqlParameter);

            try
            {
                // Execute the stored procedure and retrieve the results in the table.
                using (SqlDataAdapter dataAdapter = new SqlDataAdapter(command))
                    try
                    {
                        dataAdapter.Fill(dataTable);
                    }
                    catch
                    {
                        dataTable.Dispose();
                        dataTable = null;
                    }
            }
            finally
            {
                //parameterCollection.Clear();
            }
        }
    }

    return dataTable;
}

注意：我已经定义了Parameter 类，所以这个函数的用户不必直接处理SqlParameters 的创建。 Parameter 类的SqlParameter 属性可用于检索SqlParameter。

在某些时候，我的程序执行以下操作（无法发布代码，因为它涉及很多类；基本上，我有一个创建大量对象的迷你框架）：

1. 创建一个Parameters 的数组。
2. GetDataTable('sp_one', parameters)。
3. GetDataTable('sp_two', parameters)。

Answer 1

using 关键字仅调用.Dispose() 方法。如果您在 IDisposable 对象的 dispose 方法之外进行了 必要 清理，那么您将需要在它自己的 finally 块中执行此操作。这带来了两点：

1. 此时，您可能会争辩说，您不妨跳过 using 块，也只在 finally 块中调用 Dispose()。就个人而言，我仍然会选择using 块。 始终为您的 IDisposable 实例设置一个只是一个好习惯。
2. 我谦虚地建议，如果您满足上述条件，则需要重新设计您的类以利用 IDisposable 模式。

---

根据您发布的代码，问题是您的参数仍然存在于某个地方（也许您正在重新使用它们？）。因为参数仍然是 root 的，所以无法收集它们。它们还包含对它们所附加的命令的引用，因此您的 SqlCommand 对象也不能立即被收集，因为现在它仍然是根目录。

关键是 .Net 框架为 非托管 资源保留了 Dispose() 模式。因为 SqlParameters 和 SqlParameterCollection 是 托管 类型，所以它们在被收集之前不会被触及，这与处置完全分开。当您的 SqlCommand 最终被收集时，它的 SqlParameter 集合也将被处理。只是不要混淆收集、处置和它们的目的。

您要做的是在添加每个参数时对其进行复制，而不是将现有参数添加到集合中。

public static DataTable GetDataTable(string cmdText, IEnumerable<Parameter> parameters)
{
    // Create an empty memory table.
    DataTable dataTable = new DataTable();

    // Prepare a connection to the database and command to execute.
    using (SqlConnection connection = new SqlConnection(ConfigurationTool.ConnectionString))
    using (SqlCommand command = new SqlCommand(cmdText, connection))
    {
        command.CommandType = CommandType.StoredProcedure;

        SqlParameterCollection parameterCollection = command.Parameters;
        foreach (Parameter parameter in parameters)
            parameterCollection.Add(CloneParameter(parameter.SqlParameter));

        // Execute the stored procedure and retrieve the results in the table.
        using (SqlDataAdapter dataAdapter = new SqlDataAdapter(command))
        {
             dataAdapter.Fill(dataTable);
        }
    }

    return dataTable;
}

这里需要注意一些事情：我能够摆脱 所有 你的 try 块。一个都不需要。此外，SqlDataAdapter.Fill() 方法将为您打开和关闭连接，因此您不需要该部分。

现在让我们来谈谈 CloneParameter() 函数。我觉得你觉得它违背了你的代码的目的，即尝试重用参数。我向你保证，在这里重用参数是个坏主意。性能损失可以忽略不计，尤其是与存储过程执行相比。我将 CloneParameter() 实现留给了您，原因有两个：首先它很简单，其次是我们已经超出了我的正常数据访问模式。我通常添加参数的做法是接受一个 Action 委托，而不是一个可枚举的参数。函数声明更像这样：

public IEnumerable<IDataRecord>GetData(string cmdText, Action<SqlParameterCollection> addParameters)

并且是这样调用的：

foreach(var record in GetData("myprocedurename", p => 
  {
      p.Add( /*new parameter here*/ );
      p.Add( /*new parameter here*/ );
    //...
  })
 .Select( /*Returning a IEnumerable rather than a datatable allows me to use it with linq to objects.*/
          /* For example, you could use this spot to convert from DataRecords returned by ADO.Net to business objects */ 
        ))
{
   // use the results here...
}

由于您要连续填充两个表，听起来您需要在客户端做一些工作，这可能证明与 DataReader/IEnumerable 方法相比是合理的，但我确实想提一下，因为大多数时间基于您在 DataReader 上的代码是更好的选择。

在您的情况下，我会使用我现有的基于 Action-delegate 的模式并希望尽可能多地重复使用一组重复的参数，那就是拥有一个知道如何添加参数和匹配项的真实命名方法我的行动代表。然后我可以把那个方法传入，然后得到想要的参数重用。

Answer 2

有趣的问题！

这完全取决于您的 Something 课程。如果它设计不佳并且需要多阶段清理，它会将其特质强加给客户。

您不应该将课程设计成那样。如果您有临时清理工作要做，请将它们封装在自己的类中并使用如下代码：

using (Something something = new Something()) {
  // ...
  using (SomethingElse somethingElse = something.GiveMeSomethingElse()) {
  }
  // ...
} 

更新：

对于您的示例，它可能如下所示：

using (SqlConnection connection = new SqlConnection(connectionString)) {
  connection.Open();

  using (SqlCommand command = new SqlCommand("select * from MyTable where id = @id", connection)) {

    // to "reuse" the parameters collection population, just extract this to a separate method      
    command.Parameters.Add(new SqlParameter("id", id));

    // ... execute the command

  }

}

更新 2：

这样做：

GetDataTable('sp_one', CreateParameters());
GetDataTable('sp_two', CreateParameters());

Answer 3

Dispose 应该清理所有非托管资源。完全有可能使用另一种清理方法，例如执行某些功能或数据库操作。