Tek Sorumluluk İlkesi - Kod Parçalanmasından Nasıl Kaçının?


56

Takım liderinin SOLID geliştirme ilkelerinin kötü niyetli bir savunucusu olduğu bir ekip üzerinde çalışıyorum. Bununla birlikte, karmaşık yazılımları kapıdan çıkarma konusunda çok fazla deneyimi yoktur.

SRP'yi hali hazırda oldukça karmaşık bir kod temeli olan, şimdi çok yüksek derecede parçalanmış ve anlaşılması ve hata ayıklaması zor hale getirdiği bir duruma sahibiz.

Artık sadece kod parçalama ile değil aynı zamanda kapsülleme konusunda da bir sorunumuz var, çünkü özel veya korunan bir sınıf içindeki yöntemlerin bir 'değişim nedenini' temsil ettiği ve kamuya açık ya da iç sınıflara ve arayüzlere çıkarıldığı düşünüldü. başvurunun kapsülleme hedeflerine uygun değildir.

20'den fazla arayüz parametresi alan bazı sınıf kurucularımız var, bu nedenle IoC kaydı ve çözünürlüğümüz kendi başına bir canavar oluyor.

Bu sorunların bazılarının düzeltilmesine yardımcı olmak için kullanabileceğimiz herhangi bir 'SRP'den uzakta bir refaktör' yaklaşımı olup olmadığını bilmek istiyorum. İşlevselliklerinin toplamına tek bir noktadan erişim sağlamak için bir dizi birbiriyle yakından ilişkili sınıfları 'sardıran' boş kaba taneli sınıflar oluşturduğumda SOLID’i ihlal etmediğini okudum ( aşırı SRP'd sınıf uygulaması).

Bunun dışında, herkesi mutlu tutarken, gelişim çabalarımızla pragmatik olarak devam etmemizi sağlayacak bir çözüm düşünemiyorum.

Baska öneri ?


18
Bu sadece benim görüşüm, ancak çeşitli kısaltmalar yığını altında unutulan bir kural daha olduğunu düşünüyorum - "Ortak Anlam Anlaşması". Bir 'çözüm' gerçekte çözdüğü daha fazla sorun yarattığında, bir şeyler yanlış olur. Benim düşüncem, eğer bir problem karmaşıksa, ancak karmaşıklıklarına dikkat eden ve hala hata ayıklaması kolay olan bir sınıfa dahil edilmişse - onu yalnız bırakıyorum. Genel olarak 'sarmalayıcı' fikriniz bana sağlam geliyor, ancak cevabı daha bilgili birine bırakacağım.
Patryk Ćwiek

6
'Değişim nedeni' ile ilgili olarak - tüm nedenleri önceden spekülasyona gerek yoktur. Bunu gerçekten değiştirmek zorunda kalana kadar bekleyin ve daha sonra böyle bir değişikliği kolaylaştırmak için neler yapılabileceğini görün.

62
20 yapıcı parametresi olan bir sınıf bana çok SRP gelmiyor!
MattDavey

1
"... IoC kaydı ve çözünürlüğü ..." yazıyorsunuz; bu sizin (veya takım liderinizin) "IoC" ve "bağımlılık enjeksiyonunun" (DI) aynı şey olduğunu düşünüyor, ki bu doğru değil. DI, IoC'ye ulaşmanın bir aracıdır, ancak kesinlikle tek değil. Neden IoC yapmak istediğinizi dikkatlice analiz etmelisiniz ; ünite testleri yazmak istediğinizden dolayı servis belirleme düzenini veya sadece arabirim sınıflarını ( ISomething) kullanmayı da deneyebilirsiniz . IMHO, bu yaklaşımların kullanımı bağımlılık enjeksiyonundan çok daha kolaydır ve daha okunabilir kodlarla sonuçlanır.

2
Burada verilen herhangi bir cevap bir boşlukta olacaktır; Özel bir cevap vermek için kodu görmemiz gerekir. Yapıcıda 20 parametre? peki, bir nesneyi kaçırıyor olabilirsiniz ... ya da hepsi geçerli olabilir; ya da bir config dosyasına ait olabilirler, ya da bir DI sınıfına ait olabilirler ya da ... Semptomlar şüpheli geliyor, ama CS'deki çoğu şey gibi, "buna bağlı" ...
Steven A. Lowe

Yanıtlar:


84

Sınıfınızın yapıcıda 20 parametresi varsa, ekibiniz SRP'nin ne olduğunu tam olarak biliyor gibi görünmüyor. Sadece bir şeyi yapan bir sınıfınız varsa, 20 bağımlılığı nasıl olur? Bu, bir balığa çıkmak ve bir olta takımı, sandık kutusu, kapitone malzemeleri, bowling topu, mızrakböcekleri, alev fırlatıcısı, vb. Gibi şeyleri getirmek gibidir.

Bununla birlikte, SRP, oradaki çoğu ilke gibi, aşırı uygulanabilir. Tamsayıları arttırmak için yeni bir sınıf oluşturursanız, evet, bu tek bir sorumluluk olabilir, ama hadi. Saçma. SOLID ilkeleri gibi şeylerin bir amaç için orada olduğunu unutma eğilimindeyiz. SOLID, kendi başına bir amaç değil, bir amaç için bir araçtır. Son sürdürülebilirliktir . Tek Sorumluluk İlkesi ile bu ayrıntıya girecekseniz, bu, SOLID için büyük bir çabanın, takımı SOLID hedefine kör ettiğini gösteren bir göstergedir.

Yani, söylediğim şey sanırım ... SRP senin sorunun değil. SRP'nin yanlış anlaşılması veya inanılmaz derecede ayrıntılı bir uygulamasıdır. Takımını ana şeyi ana şey olarak tutmaya çalış. Ve asıl şey, sürdürülebilirlik.

DÜZENLE

İnsanları modülleri, kullanım kolaylığını teşvik edecek şekilde tasarlamalarını sağlayın. Her sınıfı mini bir API olarak düşünün. Önce, "Bu sınıfı nasıl kullanmak isterdim" düşünün ve uygulayın. Sadece, "Bu sınıfın ne yapması gerekiyor?" Deme. SRP, kullanımı zor sınıfları yapmak için büyük bir eğilimi var ise sen kullanılabilirlik içine çok düşündüm koymayın.

EDIT 2

Yeniden düzenleme ile ilgili ipuçları arıyorsanız, önerdiğiniz şeyi yapmaya başlayabilirsiniz - birkaç tanesini sarmak için daha kaba taneli sınıflar oluşturun. Büyük taneli sınıfın hala SRP'ye bağlı olduğundan , ancak daha yüksek bir seviyede olduğundan emin olun . O zaman iki seçeneğin var:

  1. İnce taneli sınıflar artık sistemin başka bir yerinde kullanılmıyorsa, uygulamalarını kademeli olarak kaba taneli sınıfa çekebilir ve silebilirsiniz.
  2. İnce taneli sınıfları yalnız bırakın. Belki de iyi tasarlanmışlardır ve kullanımlarını kolaylaştırmak için paketleyiciye ihtiyacınız vardı. Projenizin çoğu için durumun bu olduğundan şüpheleniyorum.

Yeniden düzenlemeyi tamamladığınızda (ancak havuza başlamadan önce), çalışmanızı gözden geçirin ve kendinize yeniden düzenlemenin gerçekten de sürdürülebilirlik ve kullanım kolaylığı için bir gelişme olup olmadığını sorun.


2
İnsanların sınıf tasarlamayı düşünmelerini sağlamanın alternatif yolu: CRC kartları yazmalarına izin verin (Sınıf Adı, Sorumluluk, İşbirliği Yapanlar) . Bir sınıfta çok fazla ortak çalışan veya sorumluluk varsa, büyük olasılıkla SRP-ish yeterli değildir. Başka bir deyişle, tüm metinler dizin kartına sığmalıdır, aksi halde çok fazla şey yapıyordur.
Spoike

18
Alev makinesinin ne için olduğunu biliyorum, ama nasıl bir sırıkla balık avlıyorsun?
R. Martinho Fernandes

13
+1 SOLID, kendi başına bir amaç değil, bir amaç için bir araçtır.
B Yedi

1
+1: Daha önce “Demeter Yasası” gibi şeylerin yanlış isimlendirildiğini, “Demeter'in Kılavuz çizgisi” olması gerektiğini savundum. Bu işler sizin için çalışmalı, onlar için çalışmamalısınız.
Binary Worrier

2
@EmmadKareem: DAO nesnelerinin birkaç özelliğe sahip olması gerektiği doğrudur. Fakat yine de, bir Customersınıf kadar basit bir şeyde bir arada gruplayabileceğiniz ve daha fazla korunabilir bir koda sahip olabileceğiniz çeşitli şeyler var. Buradaki örneklere bakın: codemonkeyism.com/…
Spoike

32

Martin Fowler’in Refactoring’inde SRP’ye karşı bir kural okuduğumu düşünüyorum. "Her sınıfın değişmek için tek bir nedeni var mı?" Kadar önemli olan ikinci bir soru var. ve "Her değişiklik sadece bir sınıfı etkiliyor mu?"

İlk sorunun cevabı her durumda "evet" ise, ikinci soru "yakın bile değil" ise, SRP'yi nasıl uyguladığınızı tekrar gözden geçirmeniz gerekir.

Örneğin, bir tabloya bir alan eklemek, bir DTO ve bir validator sınıfı ve bir kalıcılık sınıfı ile bir görünüm modeli nesnesini değiştirmeniz gerektiği anlamına gelir ve bu durumda bir sorun yaratırsınız. Belki de SRP'yi nasıl uyguladığınızı yeniden düşünmelisiniz.

Belki de alan eklemenin Müşteri nesnesini değiştirmenin nedeni olduğunu söylediniz, ancak kalıcılık katmanını değiştirmenin (bir XML dosyasından veritabanına diyorsunuz) Müşteri nesnesini değiştirmek için başka bir neden olduğunu söylediniz. Böylece bir CustomerPersistence nesnesi de yaratmaya karar veriyorsunuz. Ancak, STILL alanına bir alan eklemek, CustomerPersisitence nesnesinde bir değişiklik yapılmasını gerektiriyorsa, amaç ne? Hala değişmesi gereken iki nedenden dolayı bir nesneniz var - artık Müşteri değil.

Bununla birlikte, bir ORM tanıtırsanız, sınıfları DTO'ya bir alan eklerseniz, bu verileri okumak için kullanılan SQL'i otomatik olarak değiştirecek şekilde çalıştırabilirsiniz. O zaman iki endişeyi ayırmak için iyi bir nedeniniz var.

Özetle, işte benim yapmaya meyilli olduğum şey: "hayır, bu nesneyi değiştirmek için birden fazla neden var" ile "hayır, bu değişimin yapacağı" sayısı arasında kaba bir denge varsa birden fazla nesneyi etkileyebilir, "sanırım SRP ve parçalanma arasında bir denge hakkım var. Fakat eğer ikisi de hala yüksekse, endişeleri birbirinden ayırabileceğim farklı bir yol olup olmadığını merak etmeye başlıyorum.


+1 "her değişiklik yalnızca bir sınıfı etkiler mi?"
dj18

Tartışmadığım bir konu, bir mantıksal varlığa bağlı görevlerin farklı sınıflar arasında bölünmesi durumunda, kodun aynı varlığa bağlı birden fazla farklı nesneye referans tutması gerekebileceğidir. Örneğin, "SetHeaterOutput" ve "MeasureTem Temperature" işlevlerine sahip bir fırın düşünün. Eğer fırın bağımsız HeaterControl ve TemperatureSensor ile temsil edilmişse, nesneler, hiçbir şey bir TemperatureFeedbackSystem nesnesinin bir fırının ısıtıcısına ve farklı bir fırının sıcaklık sensörüne referans vermesini engelleyemez.
supercat

1
Bunun yerine, bu işlevler bir Kiln nesnesi tarafından uygulanan bir IKiln arabiriminde birleştirildiyse, TemperatureFeedbackSystem'in yalnızca tek bir IKiln referansı tutması gerekirdi. Bağımsız bir satış sonrası sıcaklık sensörüne sahip bir fırının kullanılması gerekliyse, yapıcısı bir IHeaterControl ve ITem TemperatureSensor'ı kabul eden ve bunları IKiln'i uygulamak için kullanmış bir KompozitKiln nesnesi kullanabilirdi, ancak bu tür kasıtlı gevşek kompozisyon kodda kolayca tanınabilirdi.
supercat

23

Sadece bir sistemin karmaşık olması, onu karmaşık hale getirmeniz gerektiği anlamına gelmez . Bunun gibi çok fazla bağımlılığa (veya Ortak çalışanlara) sahip bir sınıfınız varsa:

public class MyAwesomeClass {
    public class MyAwesomeClass(IDependency1 _d1, IDependency2 _d2, ... , IDependency20 _d20) {
      // Assign it all
    }
}

... o zaman çok karmaşık hale geldi ve gerçekten SRP'yi izlemiyorsun , değil mi? Bahse girerim MyAwesomeClass, bir CRC kartında bir indeks kartına sığmayacak ne yazdığını ya da gerçekten okunaksız küçük harflerle yazmak zorunda kaldığınızı söylersiniz.

Burada sahip olduğun şey, adamlarının yerine Arayüz Ayrıştırma İlkesini takip etmeleriydi ve onu aşırı uç noktaya götürmüş olabilirdi, ama bu başka bir hikaye. Bağımlılıkların etki alanı nesneleri olduğunu söyleyebiliriz (ki bu da), ancak aynı zamanda 20 etki alanı nesnesini işleyen bir sınıfa sahip olmak onu biraz fazla uzatıyor.

TDD size bir sınıfın ne kadarının yapıldığının iyi bir göstergesi olacaktır. Açıkça koymak; Bir test yönteminin yazması sonsuza kadar sürecek bir kurulum koduna sahipse (testleri yeniden yerleştirseniz bile) MyAwesomeClassmuhtemelen yapacak çok şeyiniz olur.

Peki bu bilmeceyi nasıl çözersiniz? Sorumlulukları diğer sınıflara taşırsınız. Bu sorunu olan bir sınıfa atabileceğiniz bazı adımlar vardır:

  1. Sınıfınızın bağımlılıklarıyla yaptığı tüm eylemleri (veya sorumlulukları) tanımlayın.
  2. Eylemleri yakından ilişkili bağımlılıklara göre gruplayın.
  3. Redelegate! Yani, tanımlanmış eylemlerin her birini yeni sınıflara (veya daha önemlisi) başka sınıflara yönlendirmek.

Sorumlulukların yeniden düzenlenmesi üzerine soyut bir örnek

Let Cbirkaç bağımlılıkları olan bir sınıf olmak D1, D2, D3, D4daha az kullanmak gözden geçirmeniz gerekebilir söyledi. CBağımlılıkları hangi yöntemlerle çağıracağımızı belirlediğimizde, bunun basit bir listesini yapabiliriz:

  • D1- performA(D2),performB()
  • D2 - performD(D1)
  • D3 - performE()
  • D4 - performF(D3)

Listeye baktığımızda bunu görebiliriz D1ve D2sınıf bir şekilde birlikte ihtiyaç duydukları için birbirleriyle ilişkilidir. Bu D4ihtiyaçları da görebiliriz D3. Yani iki grubumuz var:

  • Group 1- D1<->D2
  • Group 2- D4->D3

Gruplamalar, sınıfın şimdi iki sorumluluğu olduğunun göstergesidir.

  1. Group 1- Biri birbirine ihtiyaç duyan çağıran iki nesneyi kullanmak için. Belki de sınıfınızın Cher iki bağımlılığı da kullanma ihtiyacını ortadan kaldırabilir ve bunun yerine bu aramaları yapmalarından birini bırakabilirsiniz. Bu gruplandırmada D1referans alabileceği açıktır D2.
  2. Group 2- Diğer sorumluluğun diğerini çağırmak için bir nesneye ihtiyacı var. Can not D4işlemek D3sınıfın yerine? Öyleyse muhtemelen aramaları yapmasına izin vererek D3sınıftan Cuzaklaşabiliriz D4.

Cevabımı, çok soyut olduğu ve çok fazla varsayımda bulunduğu gibi, taştan olduğu gibi almayın. Bunu yeniden alevlendirmenin daha fazla yolu olduğundan eminim, ama en azından adımlar, sınıfları bölmek yerine sorumlulukları yerine getirme konusunda bir çeşit süreç edinmenize yardımcı olabilir.


Düzenle:

Yorumlarından @Emmad Karem diyor ki:

"Sınıfınızda yapıcıda 20 parametre varsa, ekibiniz SRP'nin ne olduğunu tam olarak biliyor gibi görünmüyor. Sadece bir şeyi yapan bir sınıfınız varsa, 20 bağımlılığı nasıl olur?" - Bence Müşteri sınıfına sahipseniz, yapıcıda 20 parametreye sahip olmak garip değildir.

DAO nesnelerinin kurucunuzda ayarlamanız gereken birçok parametreye sahip olduğu ve parametrelerin genellikle dizge gibi basit tipler olduğu doğrudur. Ancak bir Customersınıf örneğinde, işleri daha basit hale getirmek için özelliklerini diğer sınıfların içinde gruplandırabilirsiniz. AddressSokakları olan bir sınıf ve Zipcodeposta kodunu içeren bir sınıf olması ve veri doğrulama gibi iş mantığını yönetmesi gibi:

public class Address {
    private String street1;
    //...

    private Zipcode zipcode;

    // easy to extend
    public bool isValid() {
        return zipcode.isValid();
    }
}

public class Zipcode {
    private string zipcode;
    public bool isValid() {
        // return regex match that zipcode contains numbers
    }
}

Bu şey blog post olmasını sağlamanın yanı sıra "Asla, asla, (en az sık ya) Java Dize kullanmak asla" . Alt nesneleri oluşturmayı kolaylaştırmak için yapıcılar veya statik yöntemler kullanmanın bir alternatifi olarak, bir sıvı oluşturucu paterni kullanabilirsiniz .


+1: Harika cevap! Gruplandırma IMO çok güçlü bir mekanizmadır, çünkü gruplamayı yinelemeli olarak uygulayabilirsiniz. Çok kaba konuşursak, n soyutlama katmanıyla 2 ^ n öğeyi düzenleyebilirsiniz.
Giorgio

+1: İlk birkaç paragrafınız, ekibimin karşı karşıya olduğu şeyleri tam olarak özetliyor. Aslında hizmet nesneleri olan "İş Nesneleri" ve yazmayı uyuşturmak için birim test kurulum kodu. Servis katmanımızın bir satır kod içereceği konusunda bir sorunumuz olduğunu biliyordum; iş katmanı yöntemine yapılan bir çağrı.
Erkek

3

SRP ile ilgili tüm cevaplara ve bunun nasıl ileri götürülebileceğine katılıyorum. Yazınızda, SRP'ye bağlı "aşırı yeniden düzenleme" nedeniyle kapsülleme kırıldığını veya değiştirildiğini belirttiniz. Benim için çalışmış olan tek şey her zaman temel konulara bağlı kalmak ve tam olarak bir son bulması için gerekenleri yapmaktır.

Legacy sistemleri ile çalışırken, her şeyi daha iyi hale getirmek için düzeltmek için "coşku", Team Leads'ta, özellikle de bu rol için yeni olanlarda oldukça yüksektir. SOLID, sadece SRP'ye sahip değil - bu sadece S'dir. SOLID'i takip ediyorsanız, OLID'yi de unutmadığınızdan emin olun.

Şu anda bir Legacy sistemi üzerinde çalışıyorum ve başlangıçta benzer bir yolda ilerlemeye başladık. Bizim için çalışan şey , her iki dünyanın da en iyisini yapmak için kolektif bir ekip kararıydı - SOLID ve KISS (Basit Aptalca Tutun). Kod yapısındaki büyük değişiklikleri toplu olarak tartıştık ve çeşitli gelişim ilkelerini uygulamada sağduyulu davrandık. "S / W Geliştirme Yasaları" değil, kılavuz olarak mükemmeldirler. Takım sadece Takım Lideri ile ilgili değil - takımdaki tüm geliştiricilerle ilgili. Benim için her zaman işe yarayan şey, herkesi bir odaya sokmak ve tüm ekibinizin uymayı kabul ettiği ortak bir kılavuz seti bulmaktır.

Mevcut durumunuzu nasıl düzelteceğinize ilişkin olarak, bir VCS kullanıyorsanız ve uygulamanıza çok fazla yeni özellik eklememişseniz, tüm ekibin anlaşılabilir, okunabilir ve bakım yapılabilir olduğunu düşündüğü bir kod sürümüne her zaman geri dönebilirsiniz. Evet! Senden işi atıp, sıfırdan başlamanı istiyorum. Bu, kırılmış bir şeyi "düzeltmeye" çalışmaktan ve onu zaten var olan bir şeye geri götürmekten daha iyidir.


3

Cevap, her şeyden önce kodun sürdürülebilirliği ve açıklığıdır. Benim için bu, daha az kod yazmanın anlamı değil, daha fazla kod yazmanızdır . Daha az soyutlama, daha az arayüz, daha az seçenek, daha az parametre.

Bir kod yapılandırmasını değerlendirdiğimde veya yeni bir özellik eklediğimde, gerçek mantığa kıyasla ne kadar kazan plakası gerektiğine inanıyorum. Cevap% 50'den fazlaysa, bu muhtemelen üzerinde düşüneceğim anlamına gelir.

SRP'nin üstünde, başka birçok geliştirme stili var. Senin durumunda YAGNI gibi sesler kesinlikle yoksundur.


3

Buradaki cevapların birçoğu gerçekten iyi ancak bu konunun teknik yönüne odaklanıyor. Geliştiricinin, SRP'yi fiilen ihlal ettiği gibi SRP sesini izlemeye kalkar gibi göründüğünü de ekleyeceğim.

Bob'un blogunu bu durumda burada görebilirsiniz , ancak birden fazla sınıfa bir sorumluluk atılırsa, SRP'nin ihlal edildiğini, çünkü bu sınıfların paralel olarak değiştiğini savunuyor. Sanırım, dev'in Bob'un blogunun tepesindeki tasarımdan gerçekten hoşlanacağını ve parçalandığını görmek biraz hayal kırıklığına uğrayabilir. Özellikle “Ortak Kapanış İlkesi” ni ihlal ettiği için - birlikte değişen şeyler birlikte kalır.

SRP'nin “bir değişiklik yapmama” ve “bir şey yapmama” anlamına geldiğini ve bir değişiklik meydana gelinceye kadar bu değişim için kendinizle ilgilenmenize gerek olmadığını unutmayın. İkinci adam soyutlama için para ödüyor.

Şimdi ikinci sorun var - "SOLID geliştirmenin bakir savunucusu". Bu geliştirici ile çok iyi bir ilişkiniz olduğu kesin gibi görünmüyor, bu yüzden kodbazındaki problemleri ikna etme girişimlerinde bulunuluyor. İlişkileri onarmanız gerekecek, böylece konular hakkında gerçek bir tartışma yapabilirsiniz. Tavsiye edeceğim şey bira.

Cidden hayır - kafeye gitmezseniz. Ofisten çıkın ve rahat bir yere gidin, bu konular hakkında gayrı resmi olarak konuşabilirsiniz. Bir toplantıda tartışmaya girmeye çalışmak yerine, eğlenceli bir yerde tartışmayacağınız bir toplantıda. Seni deli eden bu devin, "kapıdan dışarı" yazılımı almaya çalışan ve işini yapmak istemeyen gerçek işleyen bir insan olduğunu anlamaya çalış. Bu ortak temeli muhtemelen paylaştığınızdan, hala SRP'ye uygunken tasarımın nasıl geliştirileceğini tartışmaya başlayabilirsiniz.

Her ikisi de, SRP'nin iyi bir şey olduğunu kabul edebilir, sadece farklı yönleri yorumladığınızı kabul ederseniz, muhtemelen verimli konuşmalar yapmaya başlayabilirsiniz.


-1

SRP'nin genel olarak iyi bir düşünce olduğu konusunda takım lideri kararınıza [güncelleme = 2012.05.31] katılıyorum. Ancak @ Spoike -s yorumuna 20 arabirim argümanına sahip bir kurucunun çok uzak olduğunu kesinlikle kabul ediyorum. [/ Update]:

IoP ile SRP'nin tanıtılması, karmaşıklığı bir "çok sorumlu sınıftan" bir çok srp sınıfına ve çok daha karmaşık bir başlangıç durumuna getirme

  • daha kolay test edilebilirlik / tdd (bir seferde bir srp sınıfı test edilir)
  • ama pahasına
    • çok daha zor bir kod başlatma ve entegrasyon
    • daha zor hata ayıklama
    • parçalanma (= kodun birkaç dosya / dizin üzerinden dağıtılması)

Korkarım, srp'yi feda etmeden kodlama işlemlerini azaltamazsınız.

Ancak, bir kurucuda başlatmanın karmaşıklığını gizleyen sözdizimsel bir şeker sınıfı uygulayarak kod başlatma işleminin "acısını hafifletebilirsiniz".

   class MySrpClass {
      MySrpClass(Interface1 parm1, Interface2 param2, .... Interface20 param2) {
      }
   } 

   class MySyntaxSugarClass : MySrpClass {
      MySyntaxSugarClass() {
         super(new MyInterface1Implementation(), new MyImpl2(), ....)
      }
   }

2
20 arayüzün, sınıfın yapacak çok şeyinin bir göstergesi olduğuna inanıyorum. Yani, değişmesi için 20 neden var, bu da neredeyse bir SRP ihlalidir. Sadece sistemin karmaşık olması, onun karmaşık olması gerektiği anlamına gelmez.
Spoike
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.