Bir fonksiyonun bir parametreyi değiştirmesi uygun mudur?

Linq To SQL'i saran bir veri katmanımız var. Bu veri katmanında bu yöntem var (basitleştirilmiş)

int InsertReport(Report report)
{
    db.Reports.InsertOnSubmit(report);
    db.SubmitChanges();
    return report.ID; 
}

Gönderme değişikliklerinde, rapor kimliği daha sonra döndürdüğümüz veritabanındaki değerle güncellenir.

Arayan taraftan böyle görünüyor (basitleştirilmiş)

var report = new Report();
DataLayer.InsertReport(report);
// Do something with report.ID

Koda bakıldığında ID, InsertReport işlevinin içinde bir tür yan etki olarak ayarlandı ve sonra dönüş değerini yok sayıyoruz.

Sorum şu, yan etkiye güvenmeli ve bunun gibi bir şey yapmalıyım.

void InsertReport(Report report)
{
    db.Reports.InsertOnSubmit(report);
    db.SubmitChanges();
}

ya da bunu engellemeliyiz

int InsertReport(Report report)
{
    var newReport = report.Clone();
    db.Reports.InsertOnSubmit(newReport);
    db.SubmitChanges();
    return newReport.ID; 
}

hatta belki

Report InsertReport(Report report)
{
    var newReport = report.Clone();
    db.Reports.InsertOnSubmit(newReport);
    db.SubmitChanges();
    return newReport; 
}

Bu soru, bir birim testi oluşturduğumuzda ve rapor parametreleri ID özelliğinin güncellendiğini ve yan etki davranışını alay etmenin yanlış hissettiğini, eğer isterseniz bir kod kokusunun gerçekten net olmadığını tespit ettiğimizde ortaya çıktı.

Evet, sorun değil ve oldukça yaygın. Yine de, keşfettiğiniz gibi açık olmayabilir.

Genel olarak, kalıcılık türü yöntemleri nesnenin güncelleştirilmiş örneğini döndürme eğilimindedir. Yani:

Report InsertReport(Report report)
{        
    db.Reports.InsertOnSubmit(report);
    db.SubmitChanges();
    return report; 
}

Evet, ilettiğiniz nesnenin aynısını döndürüyorsunuz, ancak API'yi daha net hale getiriyor. Klonlamaya gerek yoktur - eğer orijinal kodunuzda olduğu gibi, arayan kişi geçtiği nesneyi kullanmaya devam ederse karışıklığa neden olacak bir şey varsa.

Başka bir seçenek de DTO kullanmaktır

Report InsertReport(ReportDTO dto)
{
    var newReport = Report.Create(dto);
    db.Reports.InsertOnSubmit(newReport);
    db.SubmitChanges();
    return newReport; 
}

Bu şekilde API çok açıktır ve arayan yanlışlıkla geçirilen / değiştirilmiş nesneyi kullanmayı deneyemez. Kodunuzun ne yaptığına bağlı olarak, biraz acı olabilir.

IMO bu, değişikliğin yan etkisinin arzu edildiği nadir bir durumdur - Rapor varlığınızın bir kimliği olduğundan, DTO'nun endişelerini zaten taşıdığı varsayılabilir ve tartışmalı olarak bellek içi Raporun sağlanması için ORM yükümlülüğü vardır . varlık, veritabanı temsil nesnesiyle eşzamanlı tutulur.

Sorun, dokümantasyon olmadan, yöntemin ne yaptığı ve özellikle neden bir tamsayı döndürdüğü açık değildir.

En kolay çözüm, yönteminiz için farklı bir ad kullanmak olacaktır. Gibi bir şey:

int GenerateIdAndInsert(Report report)

Yine de, bu yeterince açık değildir: eğer C # 'da olduğu gibi, reportnesnenin örneği referans olarak iletilirse, orijinal reportnesnenin değiştirilip değiştirilmediğini veya yöntemin onu klonlayıp değiştirip yalnızca klonu değiştirip değiştirmediğini bilmek zor olacaktır . Orijinal nesneyi değiştirmeyi seçerseniz, yöntemi adlandırmak daha iyi olur:

void ChangeIdAndInsert(Report report)

Daha karmaşık (ve belki de daha az optimal) bir çözüm, kodu büyük ölçüde yeniden düzenlemektir. Ne dersin:

using (var transaction = new TransactionScope())
{
    var id = this.Data.GenerateReportId(); // We need to find an available ID...
    this.Data.AddReportWithId(id, report); // ... and use this ID to insert a report.
    transaction.Complete();
}

Genellikle programcılar yalnızca bir nesnenin örnek yöntemlerinin durumunu değiştirmesini bekler. Başka bir deyişle, report.insert()raporun kimliğini değiştirdiğinde şaşırmadım ve kontrol edilmesi kolay. Raporun kimliğini değiştirip değiştirmediğini tüm uygulamadaki her yöntem için merak etmek kolay değildir.

Ayrıca belki IDde hiç ait olmaması gerektiğini savunuyorum Report. Bu kadar uzun bir süre geçerli bir kimlik içermediğinden, ekleme işleminden önce ve sonra iki farklı nesneniz var, farklı davranışlarla. "Önceki" nesnesi eklenebilir, ancak alınamaz, güncellenemez veya silinemez. "After" nesnesi tam tersidir. Birinin kimliği var, diğerinin yok. Görüntülenme şekilleri farklı olabilir. Göründükleri listeler farklı olabilir. İlişkili kullanıcı izinleri farklı olabilir. Her ikisi de kelimenin İngilizce anlamında "raporlardır", ancak çok farklıdırlar.

Öte yandan, kodunuz bir nesnenin yeterli olacağı kadar basit olabilir, ancak kodunuzun biberli olup olmadığı düşünülmelidir if (validId) {...} else {...}.

Hayır, sorun değil! Bir prosedürün, sadece başka bir yolun olmadığı prosedürel dillerde değiştirilmesi bir prosedür için uygundur; OOP dillerinde nesne üzerindeki değiştirme yöntemini, bu durumda raporda (report.generateNewId () gibi bir şey) çağırır.

Bu durumda yönteminiz 2 şey yapar, bu nedenle SRP'yi keser: db'ye bir kayıt ekler ve yeni bir kimlik oluşturur. Arayan, yönteminizin yeni bir kimlik oluşturduğunu bile bilmiyor çünkü basitçe insertRecord () olarak adlandırılıyor.