coba / tangkap + gunakan, sintaks kanan

Yang mana:

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

ATAU

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

Saya lebih suka yang kedua. Semoga juga menjebak kesalahan yang berkaitan dengan penciptaan objek juga.

Karena blok menggunakan hanyalah penyederhanaan sintaks dari coba / akhirnya ( MSDN ), secara pribadi saya akan mengikuti yang berikut, meskipun saya ragu itu sangat berbeda dari opsi kedua Anda:

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

Tergantung. Jika Anda menggunakan Windows Communication Foundation (WCF), using(...) { try... }tidak akan berfungsi dengan benar jika proksi dalam usingpernyataan berada dalam keadaan pengecualian, yaitu Membuang proksi ini akan menyebabkan pengecualian lain.

Secara pribadi, saya percaya pada pendekatan penanganan minimal, yaitu hanya menangani pengecualian yang Anda sadari pada titik eksekusi. Dengan kata lain, jika Anda tahu bahwa inisialisasi variabel dalam usingdapat membuang pengecualian tertentu, saya membungkusnya dengan try-catch. Demikian pula, jika di dalam usingtubuh sesuatu terjadi, yang tidak terkait langsung dengan variabel using, maka saya membungkusnya dengan yang lain tryuntuk pengecualian khusus itu. Saya jarang menggunakan Exceptiondi saya catches.

Tapi saya suka IDisposabledan usingmungkin saya bias.

Jika pernyataan tangkap Anda perlu mengakses variabel yang dideklarasikan dalam pernyataan menggunakan, maka di dalam adalah satu-satunya pilihan Anda.

Jika pernyataan tangkapan Anda membutuhkan objek yang direferensikan dalam penggunaan sebelum dibuang, maka di dalam adalah satu-satunya pilihan Anda.

Jika pernyataan tangkapan Anda mengambil tindakan berdurasi tidak diketahui, seperti menampilkan pesan kepada pengguna, dan Anda ingin membuang sumber daya Anda sebelum itu terjadi, maka di luar adalah pilihan terbaik Anda.

Setiap kali saya memiliki scenerio yang mirip dengan ini, blok try-catch biasanya dalam metode yang berbeda lebih jauh dari tumpukan panggilan dari menggunakan. Itu tidak khas untuk metode untuk mengetahui bagaimana menangani pengecualian yang terjadi di dalamnya seperti ini.

Jadi rekomendasi umum saya ada di luar — jauh di luar.

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

Keduanya adalah sintaks yang valid. Ini benar-benar tergantung pada apa yang ingin Anda lakukan: jika Anda ingin menangkap kesalahan terkait dengan membuat / membuang objek, gunakan yang kedua. Jika tidak, gunakan dulu.

Ada satu hal penting yang akan saya panggil di sini: Yang pertama tidak akan menangkap pengecualian yang muncul karena memanggil MyClasskonstruktor.

Dari C # 8.0, saya lebih suka menggunakan yang kedua sama seperti ini

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

    public void Dispose()
    {
    }
}

lalu

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

Jika objek yang Anda inisialisasi di blok Using () mungkin melempar pengecualian apa pun, maka Anda harus memilih sintaks kedua jika tidak keduanya sama-sama valid.

Dalam skenario saya, saya harus membuka file dan saya melewati filePath di konstruktor objek yang saya inisialisasi di blok Using () dan mungkin membuang pengecualian jika filePath salah / kosong. Jadi dalam hal ini, sintaks kedua masuk akal.

Kode sampel saya: -

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

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

Dari C # 8.0 pada , Anda dapat menyederhanakan usingpernyataan di bawah beberapa kondisi untuk menyingkirkan blok bersarang, dan kemudian hanya berlaku untuk blok terlampir.

Jadi dua contoh Anda dapat direduksi menjadi:

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

Dan:

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

Keduanya cukup jelas; dan kemudian itu mengurangi pilihan antara keduanya menjadi masalah apa yang Anda inginkan ruang lingkup objek menjadi, di mana Anda ingin menangani kesalahan instantiation, dan ketika Anda ingin membuangnya.