尝试/捕获+使用正确的语法

哪一个：

using (var myObject = new MyClass())
{
   try
   {
      // something here...
   }
   catch(Exception ex)
   {
      // Handle exception
   }
}

要么

try
{
   using (var myObject = new MyClass())
   {
      // something here...
   }
}
catch(Exception ex)
{
   // Handle exception
}

我喜欢第二个。也可以捕获与对象创建有关的错误。

由于using块只是try / finally（MSDN）的语法简化，因此我个人将采用以下内容，尽管我怀疑它与您的第二种选择有很大不同：

MyClass myObject = null;
try {
  myObject = new MyClass();
  //important stuff
} catch (Exception ex) {
  //handle exception
} finally {
  if(myObject is IDisposable) myObject.Dispose();
}

这取决于。如果您使用的是Windows Communication Foundation（WCF），using(...) { try... }则in using语句中的代理处于异常状态将无法正常工作，即，处置此代理将导致另一个异常。

就我个人而言，我相信使用最少的处理方法，即仅处理您在执行时意识到的异常。换句话说，如果您知道in中的变量的初始化using可能会引发特定的异常，请使用进行包装try-catch。同样，如果using体内可能发生某些事情，而这与中的变量没有直接关系using，则try针对该特定异常，我将其包裹起来。我很少Exception在catchES中使用。

但是我确实喜欢IDisposable，using尽管如此，我还是有偏见。

如果您的catch语句需要访问using语句中声明的变量，那么inside是您唯一的选择。

如果您的catch语句在处理之前需要使用中引用的对象，则内部是您唯一的选择。

如果您的catch语句执行的持续时间未知，例如向用户显示一条消息，并且您希望在这种情况发生之前就处理掉资源，那么外部是您的最佳选择。

每当我有一个与此相似的场景时，try-catch块通常会以与使用相比更远的调用堆栈采用另一种方法。这样的方法通常并不知道如何处理其中发生的异常。

因此，我的一般建议是在外面，在外面。

private void saveButton_Click(object sender, EventArgs args)
{
    try
    {
        SaveFile(myFile); // The using statement will appear somewhere in here.
    }
    catch (IOException ex)
    {
        MessageBox.Show(ex.Message);
    }
}

两者都是有效的语法。这实际上取决于您要执行的操作：如果要捕获与创建/处置对象有关的错误，请使用第二个。如果不是，请使用第一个。

我在这里要指出一件事：第一个不会捕获任何由于调用MyClass构造函数而引起的异常。

从C＃8.0开始，我更喜欢这样使用第二个

public class Person : IDisposable
{
    public Person()
    {
        int a = 0;
        int b = Id / a;
    }
    public int Id { get; set; }

    public void Dispose()
    {
    }
}

然后

static void Main(string[] args)
    {

        try
        {
            using var person = new Person();
        }
        catch (Exception ex) when
        (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
        ex.TargetSite.MemberType == System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Constructor Person");
        }
        catch (Exception ex) when
       (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
       ex.TargetSite.MemberType != System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Person");
        }
        catch (Exception ex)
        {
            Debug.Write(ex.Message);
        }
        finally
        {
            Debug.Write("finally");
        }
    }

如果要在Using（）块中初始化的对象可能引发任何异常，则应采用第二种语法，否则两者都同样有效。

在我的场景中，我必须打开一个文件，并在正在使用Using（）块初始化的对象的构造函数中传递filePath，如果filePath错误/为空，则可能会引发异常。因此，在这种情况下，第二种语法才有意义。

我的示例代码：-

try
{
    using (var obj= new MyClass("fileName.extension"))
    {

    }
}
catch(Exception ex)
{
     //Take actions according to the exception.
}

从C＃8.0开始，您可以using在某些情况下简化语句以摆脱嵌套块，然后将其仅应用于封闭块。

因此，您的两个示例可以简化为：

using var myObject = new MyClass();
try
{
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

和：

try
{
   using var myObject = new MyClass();
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

两者都很清楚。然后将这两者之间的选择减少到您希望对象范围是什么，要处理实例化错误的时间以及要处置它的时间。