thử / bắt + sử dụng, cú pháp đúng

Cái nào:

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

HOẶC LÀ

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

Tôi thích cái thứ hai. Cũng có thể bẫy các lỗi liên quan đến việc tạo ra các đối tượng là tốt.

Vì một khối sử dụng chỉ là một đơn giản hóa cú pháp của một lần thử / cuối cùng ( MSDN ), cá nhân tôi sẽ đi theo cách sau, mặc dù tôi nghi ngờ nó khác biệt đáng kể so với tùy chọn thứ hai của bạn:

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

Nó phụ thuộc. Nếu bạn đang sử dụng Windows Communication Foundation (WCF), using(...) { try... }sẽ không hoạt động chính xác nếu proxy trong usingcâu lệnh ở trạng thái ngoại lệ, tức là việc loại bỏ proxy này sẽ gây ra ngoại lệ khác.

Cá nhân, tôi tin vào phương pháp xử lý tối thiểu, tức là chỉ xử lý ngoại lệ mà bạn biết ở điểm thực thi. Nói cách khác, nếu bạn biết rằng việc khởi tạo một biến trong usingcó thể đưa ra một ngoại lệ cụ thể, tôi sẽ bọc nó lại try-catch. Tương tự, nếu trong usingcơ thể một cái gì đó có thể xảy ra, không liên quan trực tiếp đến biến số using, thì tôi bọc nó với một cái khác trycho ngoại lệ cụ thể đó. Tôi hiếm khi sử dụng Exceptiontrong catches của tôi .

Nhưng tôi thích IDisposablevà usingmặc dù vậy tôi có thể thiên vị.

Nếu câu lệnh bắt của bạn cần truy cập vào biến được khai báo trong câu lệnh sử dụng, thì bên trong là tùy chọn duy nhất của bạn.

Nếu câu lệnh bắt của bạn cần đối tượng được tham chiếu trong quá trình sử dụng trước khi nó được xử lý, thì bên trong là tùy chọn duy nhất của bạn.

Nếu câu lệnh bắt của bạn thực hiện một hành động có thời lượng không xác định, như hiển thị thông báo cho người dùng và bạn muốn loại bỏ tài nguyên của mình trước khi điều đó xảy ra, thì bên ngoài là lựa chọn tốt nhất của bạn.

Bất cứ khi nào tôi có một scenerio tương tự như thế này, khối thử bắt thường ở một phương thức khác để tăng thêm ngăn xếp cuộc gọi từ việc sử dụng. Nó không phải là điển hình cho một phương pháp để biết cách xử lý các trường hợp ngoại lệ xảy ra trong nó như thế này.

Vì vậy, giới thiệu chung của tôi là bên ngoài cách thức bên ngoài.

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

Cả hai đều là cú pháp hợp lệ. Nó thực sự phụ thuộc vào những gì bạn muốn làm: nếu bạn muốn bắt lỗi liên quan đến việc tạo / xử lý đối tượng, hãy sử dụng cái thứ hai. Nếu không, sử dụng đầu tiên.

Có một điều quan trọng mà tôi sẽ gọi ra ở đây: Điều đầu tiên sẽ không bắt gặp bất kỳ ngoại lệ nào phát sinh từ việc gọi hàm MyClasstạo.

Từ C # 8.0, tôi thích sử dụng cái thứ hai giống như thế này

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

    public void Dispose()
    {
    }
}

và sau đó

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

Nếu đối tượng bạn đang khởi tạo trong khối Sử dụng () có thể đưa ra bất kỳ ngoại lệ nào thì bạn nên sử dụng cú pháp thứ hai nếu không cả hai đều hợp lệ như nhau.

Trong kịch bản của tôi, tôi đã phải mở một tệp và tôi đã truyền tệpPath trong hàm tạo của đối tượng mà tôi đang khởi tạo trong khối Sử dụng () và nó có thể ném ngoại lệ nếu tệpPath sai / trống. Vì vậy, trong trường hợp này, cú pháp thứ hai có ý nghĩa.

Mã mẫu của tôi: -

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

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

Từ C # 8.0 trở đi , bạn có thể đơn giản hóa các usingcâu lệnh trong một số điều kiện để thoát khỏi khối lồng nhau, và sau đó nó chỉ áp dụng cho khối kèm theo.

Vì vậy, hai ví dụ của bạn có thể được giảm xuống thành:

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

Và:

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

Cả hai đều khá rõ ràng; và sau đó điều đó làm giảm sự lựa chọn giữa hai vấn đề về vấn đề bạn muốn phạm vi của đối tượng là gì, nơi bạn muốn xử lý các lỗi khởi tạo và khi nào bạn muốn loại bỏ nó.