Neden bool / int döndüren ve gerçek nesneyi çıktı parametresi olarak içeren bir yönteminiz var?

Şirketimin kod tabanında (.NET 3.5 uygulaması) aşağıdaki kod desenini her yerde görüyorum:

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
}

Neden Fooyöntem yerine sadece ID almak ve Bazkullanılmayan bir değer döndürme ve gerçek nesne bir ref veya output parametresi olması yerine bir nesne döndürmek yerine bunu yapmak etrafında kafamı sarmaya çalışıyorum .

Eksik olduğum bu kodlama stilinin gizli bir yararı var mı?

Genellikle bu deseni kullanırsınız, böylece şöyle bir kod yazabilirsiniz:

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

örneğin sözlük sınıfında TryGetValue için CLR'de kullanılır. Fazlalıktan kaçınır, ancak dışarı ve ref parametreleri her zaman biraz dağınık görünüyordu

İstisnalar olmadan önce bu eski C stil kodu. Dönüş değeri, yöntemin başarılı olup olmadığını ve eğer öyleyse parametrenin sonuçla doldurulacağını belirtir.

.Net'te bu amaçla istisnalarımız var. Bu modeli takip etmek için hiçbir sebep olmamalıdır.

İstisna yönetiminde performansın etkileri olduğu açıktır. Belki de bununla bir ilgisi vardır. Ancak, bu kod snippet'inde zaten bir istisna var. Daha uygun bir yerde yakalanana kadar yığını yukarı hareket ettirmek daha temiz olurdu.

Kod pasajı göz önüne alındığında tamamen anlamsız görünüyor. Bana göre ilk kod deseni BazObject için null değerinin kabul edilebilir bir durum olacağını ve bool dönüşünün başarısız bir durumu güvenli bir şekilde belirlemenin bir ölçüsü olduğunu düşündürür. Aşağıdaki kod şuysa:

// 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
}

Bu benim bu şekilde yapmam daha anlamlı olur. Belki de bu, baz parametrelerinin aslında C # 'da nesne parametrelerinin nasıl çalıştığını anlamadan referansla iletildiğini garanti etmek için kullanmadan önce bir yöntemdir.

Bazen bu model, arayan kişi olarak, döndürülen türün bir başvuru veya değer türü olup olmadığına dikkat etmeniz gerekmediğinde yararlıdır. Bir değer türünü almak için böyle bir yöntem çağırıyorsanız, bu değer türünün yerleşik bir geçersiz değere (ör. Double.NaN) veya başarıyı belirlemenin başka bir yoluna ihtiyacınız olacaktır.

Fikir, işlemin başarılı olup olmadığını gösteren bir değer döndürmektir.

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

Nesne boş olamazsa (örneğinizde doğru görünür), aşağıdaki gibi daha iyi yapılır:

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

Nesne null olabilirse , istisnalar gidilecek yollardır:

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

İstisnaların olmadığı C'de kullanılan yaygın bir örüntüdür. Fonksiyonun bir hata koşulu döndürmesine izin verir. İstisnalar genellikle çok daha temiz bir çözümdür.