Mengapa memiliki metode yang mengembalikan bool / int dan memiliki objek aktual sebagai parameter output?

Saya melihat pola kode berikut di semua tempat di basis kode perusahaan saya (aplikasi .NET 3.5):

bool Foo(int barID, out Baz bazObject) { 
    try { 
            // do stuff
            bazObject = someResponseObject;

            return true;
    }
    catch (Exception ex) { 
        // log error
        return false;
    }
}

// calling code
BazObject baz = new BazObject();
fooObject.Foo(barID, out baz);

if (baz != null) { 
    // do stuff with baz
}

Saya mencoba membungkus kepala saya di sekitar mengapa Anda akan melakukan ini daripada memiliki Foometode hanya mengambil ID dan mengembalikan Bazobjek, bukannya mengembalikan nilai yang tidak digunakan dan memiliki objek yang sebenarnya menjadi parameter ref atau output.

Apakah ada beberapa manfaat tersembunyi dari gaya pengkodean ini yang saya lewatkan?

Anda biasanya menggunakan pola itu sehingga Anda dapat menulis kode seperti ini:

if (Foo(barId, out bazObject))
{
  //DoStuff with bazobject
}

misalnya digunakan di CLR untuk TryGetValue di kelas kamus misalnya. Itu menghindari beberapa redundansi tetapi parameter out dan ref selalu tampak agak berantakan bagi saya

Ini adalah kode gaya C lama, sebelum ada pengecualian. Nilai kembali menunjukkan apakah metode itu berhasil atau tidak, dan jika itu, parameter akan diisi dengan hasilnya.

Di .net kami memiliki pengecualian untuk tujuan itu. Seharusnya tidak ada alasan untuk mengikuti pola ini.

[Sunting] Jelas ada implikasi kinerja dalam penanganan pengecualian. Mungkin itu ada hubungannya dengan itu. Namun, dalam cuplikan kode itu sudah ada pengecualian. Akan lebih bersih untuk membiarkannya naik tumpukan sampai tertangkap di tempat yang lebih tepat.

Diberikan potongan kode itu terlihat benar-benar tidak berguna. Bagi saya pola kode awal akan menyarankan bahwa null untuk BazObject akan menjadi kasus yang dapat diterima dan pengembalian bool adalah ukuran menentukan kasus gagal dengan aman. Jika kode berikut adalah:

// calling code
BazObject baz = new BazObject();
bool result = fooObject.Foo(barID, out baz);

if (result) { 
    // do stuff with baz
    // where baz may be 
    // null without a 
    // thrown exception
}

Ini akan lebih masuk akal bagi saya untuk melakukannya dengan cara ini. Mungkin ini adalah metode yang seseorang sebelum Anda gunakan untuk menjamin bahwa baz dilewatkan dengan referensi tanpa memahami bagaimana sebenarnya parameter objek bekerja di C #.

Terkadang pola ini berguna ketika Anda, si penelepon, tidak seharusnya peduli apakah tipe yang dikembalikan adalah tipe referensi atau nilai. Jika Anda memanggil metode seperti itu untuk mengambil tipe nilai, tipe nilai itu akan membutuhkan nilai yang tidak valid (mis. Double.NaN), atau Anda perlu cara lain untuk menentukan kesuksesan.

Idenya adalah mengembalikan nilai yang menunjukkan apakah proses berhasil, memungkinkan kode seperti ini:

Baz b;
if (fooObject.foo(id, out b)) {
   // do something with b
}
else {
   Error.screamAndRun("object lookup/whatever failed! AAaAAAH!");
}

Jika objek tidak boleh nol (yang muncul benar dalam contoh Anda), lebih baik dilakukan sebagai berikut:

Baz b = fooObject.foo(id);
if (b != null) {
   // do something with b
}
else {
   Error.screamAndRun("object lookup/whatever failed! AAaAAAH!");
}

Jika objek bisa nol, pengecualian adalah cara untuk pergi:

try {
   Baz b = fooObject.foo(id);
}
catch (BazException e) {
   Error.screamAndRun("object lookup/whatever failed! AAaAAAH!");
}

Ini adalah pola umum yang digunakan dalam C, di mana tidak ada pengecualian. Ini memungkinkan fungsi untuk mengembalikan kondisi kesalahan. Pengecualian umumnya merupakan solusi yang jauh lebih bersih.