是否可以在 C# 中扩展“使用”块？

Question

有没有办法在 C# 中扩展 using 块，将委托作为 IDisposable 对象旁边的第二个参数，并在每次在 using 块内引发异常时执行？

假设我们有一个委托，如下所示：

public delegate void ExceptionHandler(Exception ex);

假设我有一个与该委托匹配的方法，如下所示：

public void Log(Exception ex)
{
  // Some logging stuff goes here
}

我想完成这样的事情：

using(SqlConnection connection = new SqlConnection(""), Log)
{

}

有没有办法以这种方式扩展 C#？

Answer 1

using 块是 try finally 块的简写，在 finally 中调用 Dispose。它不能扩展到更多的东西。你想要的是try catch finally 的功能，所以为什么不完全使用它：

SqlConnection connection = new SqlConnection("");
try {

}
catch (Exception exc) {
    Log(exc);
}
finally {
    connection.Dispose();
}

这具有 try catch finally 的所有优点，例如捕获多种异常类型和 C# 6.0 异常过滤器。考虑一下：

SqlConnection connection = new SqlConnection("");
try {

}
catch (SqlException exc) when (exc.Number > 0) {
    //Handle SQL error
}
catch (Exception exc) {
    Log(exc);
}
finally {
    connection.Dispose();
}

如果你想重用标准化的try catch finally 块，你可以使用委托：

static class ErrorHandler {
    public static ExecuteWithErrorHandling<T>(Func<T> createObject,
        Action<Exception> exceptionHandler, Action<T> operation) where T : IDisposable {

        T disposable = createObject();
        try {
            operation(disposable);
        }
        catch (Exception exc) {
            exceptionHandler(exc);
        }
        finally {
            disposable.Dispose();
        }
    }
}

你可以这样称呼：

ErrorHandler.ExecuteWithErrorHandling(() => new SqlConnection(""), Log, connection => {
    //Use connection here
});

Answer 2

您不能扩展 using 语句，但可以将其包装在方法中：

void DoStuff(Action action, ExceptionHandler log)
{
    using(var connction = new SqlConnection(""))
    {
        try
        {
            action();
        }
        catch(Exception e)
        {
            log(e)
        }
    }
}

Answer 3

在语法糖上稍微退后一点。

自：

using(var obj = factory_or_constructor())
{
  // Do Stuff
}

是通用模式的简写

obj = factory_or_constructor();
try
{
  // Do Stuff
}
finally
{
  ((IDisposable)obj)?.Dispose();
}

然后你可以把它改成：

try
{
  // Do Stuff
}
catch(Exception ex)
{
  Log(ex);
  throw;
}
finally
{
  ((IDisposable)obj)?.Dispose();
}

但它并没有真正提供比更简单和更清晰的更多。

using(var obj = factory_or_constructor())
{
  try
  {
    // Do Stuff
  }
  catch(Exception ex)
  {
    Log(ex);
    throw;
  }
}

这并不是真正的“扩展使用”，但如果using 的目的是为常见模式提供简洁的语法，那么为稀有模式提供简洁的语法就没那么有用了。