Apakah ini pendekatan yang baik untuk memanggil kembali ke dalam menggunakan pernyataan {}?

Saya hanya ingin tahu apakah itu pendekatan yang aman / baik untuk menelepon ke returndalam usingblok.

Misalnya.

using(var scope = new TransactionScope())
{
  // my core logic
  return true; // if condition met else
  return false;
  scope.Complete();
}

Kami tahu bahwa penjepit paling keriting terakhir dispose()akan dibatalkan. Tapi apa yang akan terjadi dalam kasus di atas, karena returnmelompati kontrol dari cakupan yang diberikan (AFAIK) ...

1. Apakah saya scope.Complete()dipanggil?
2. Dan untuk metode ruang lingkup dispose().

Sangat aman untuk menelepon ke returndalam usingblok Anda , karena blok yang menggunakan hanyalah sebuah try/finallyblok.

Dalam contoh Anda di atas setelah pengembalian true, ruang lingkup akan dibuang dan nilainya dikembalikan. return false, dan tidakscope.Complete() akan dipanggil. Namun akan dipanggil karena itu berada di dalam blok terakhir.Dispose

Kode Anda pada dasarnya sama dengan ini (jika itu membuatnya lebih mudah untuk dipahami):

var scope = new TransactionScope())
try
{
  // my core logic
  return true; // if condition met else
  return false;
  scope.Complete();
}
finally
{
  if( scope != null) 
    ((IDisposable)scope).Dispose();
}

Perlu diketahui bahwa transaksi Anda tidak akan pernah berhasil karena tidak ada cara scope.Complete()untuk melakukan transaksi tersebut.

Tidak apa-apa - finallyklausa (yang dilakukan oleh kurung kurawal penutup usingklausa di bawah kap) selalu dijalankan saat ruang lingkup ditinggalkan, tidak peduli bagaimana caranya.

Namun, ini hanya berlaku untuk pernyataan yang ada di blok akhirnya (yang tidak dapat diatur secara eksplisit saat menggunakan using). Oleh karena itu, dalam contoh Anda, scope.Complete()tidak akan pernah dipanggil (saya berharap kompilator memperingatkan Anda tentang kode yang tidak dapat dijangkau).

Secara umum, ini adalah pendekatan yang bagus. Namun dalam kasus Anda, jika Anda kembali sebelum memanggil scope.Complete(), itu hanya akan membuang TransactionScope. Tergantung desain Anda.

Jadi, dalam contoh ini, Complete () tidak dipanggil, dan cakupan dibuang, dengan anggapan itu mewarisi antarmuka IDisposable.

scope.Complete pasti harus dipanggil sebelumnya return. Compiler akan menampilkan peringatan dan kode ini tidak akan pernah dipanggil.

Mengenai returndirinya sendiri - ya, aman untuk menyebutnya usingpernyataan dalam . Menggunakan diterjemahkan untuk mencoba-akhirnya memblokir di belakang layar dan akhirnya memblokir harus dieksekusi.

Dalam contoh yang Anda berikan, ada masalah; scope.Complete()tidak pernah dipanggil. Kedua, bukanlah praktik yang baik untuk menggunakan returnpernyataan di dalam usingpernyataan. Lihat berikut ini:

using(var scope = new TransactionScope())
{
    //have some logic here
    return scope;      
}

Dalam contoh sederhana ini, intinya adalah; nilai scopeakan menjadi null saat menggunakan pernyataan selesai.

Jadi lebih baik tidak kembali ke dalam menggunakan pernyataan.

Untuk memastikan bahwa scope.Complete()akan dipanggil, bungkus dengan try/finally. The disposedisebut karena Anda harus membungkusnya dengan usingyang alternatif try/finallyblok.

using(var scope = new TransactionScope())
{
  try
  {
  // my core logic
  return true; // if condition met else
  return false;
  }
  finally
  {
   scope.Complete();
  }
}

Dalam contoh ini, scope.Complete () tidak akan pernah dijalankan. Namun, perintah return akan membersihkan semua yang ditugaskan di tumpukan. GC akan menangani semua yang tidak direferensikan. Jadi, kecuali ada objek yang tidak bisa diambil oleh GC, tidak ada masalah.