Pola Desain - DLL per Strategi

Saya biasanya mendapati diri saya merancang aplikasi saya dengan cara berikut:

1. Satu DLL yang berisi antarmuka untuk subsistem yang diinginkan. Sebagai contoh Company.Framework.Persistence.dll,.
2. Satu DLL baru per setiap strategi (atau implementasi ) dari subsistem tersebut. Sebagai contoh:
   • Company.Framework.Persistence.MSSQL.dll
   • Company.Framework.Persistence.MySQL.dll
   • Company.Framework.Persistence.FileSystem.dll

Ini akan menghasilkan solusi yang sangat besar dengan banyak proyek, tetapi di sisi lain, akan memberikan konsumen kesempatan untuk memilih DLL yang tepat untuk kebutuhannya.

Jika kami memiliki satu panggilan DLL Company.Framework.Persistence.dll, konsumen harus memuat banyak strategi yang mungkin tidak pernah ia gunakan. Memiliki DLL termodulasi akan menyelesaikan masalah ini.

Apakah ini latihan yang bagus? Apakah ada kerugian dengan desain ini?

Saya pikir kelebihan pendekatan ini jauh, jauh melebihi kerugiannya.

Apa yang Anda mencapai di sini lebih bijih kurang sempurna "implementasi" dari Idalam SOLIDdengan cara dari Stairwaypola - yang mengatakan, aplikasi Anda tergantung "down" pada sebuah antarmuka yang didefinisikan dalam Company.Framework.Persistence.dlldan implementasi individu itu sendiri juga tergantung "up" pada abstraksi ini.

Ini berarti aplikasi Anda sangat terpisah dari setiap detail implementasi (tentu saja Anda biasanya ingin membuat grafik runtime aktual menggunakan IOC Container dari beberapa jenis). Saya tanpa malu-malu menghubungkan ke gambar yang ada dari pola ini dari jawaban lain pada subjek. pada Stack Overflow:

Dalam buku Adaptive Code via C # , penulis berbicara tentang pendekatan ini dan secara khusus menyebutnya sebagai sesuatu yang harus selalu dilakukan karena menyediakan tingkat tinggi decoupling. ( contoh )

Keuntungan lain yang mungkin adalah mampu menambal implementasi individu tanpa khawatir bahwa Anda mungkin telah mempengaruhi orang lain, meskipun ini cukup kecil begitu Anda rajin dengan tes regresi Anda; juga dapat menggunakan implementasi individu dalam sub-folder yang juga dapat berisi versi spesifik dari setiap dependensi pihak ke-3 yang mungkin mereka butuhkan mungkin akan membantu menjaga semuanya terorganisir dengan baik.

Satu-satunya kelemahan nyata yang dapat saya pikirkan dengan pendekatan ini adalah bahwa secara teori dimungkinkan untuk mengubah antarmuka Company.Framework.Persistence.dll(bersama dengan binari aplikasi Anda) dan lalai untuk memperbarui implementasi dll yang terkait yang akan menyebabkan kesalahan runtime untuk pengguna Anda.

Setelah bersalah melakukan hal ini di masa lalu, saya dapat mengatakan bahwa ini benar-benar hanya sesuatu yang dapat terjadi jika Anda sangat ceroboh :)

Saya melakukannya juga.

Proyek / dll pada dasarnya gratis dan membuat kode lebih mudah dibaca dan lebih mudah digunakan.

Saya tahu orang menggunakan DLL besar tunggal dan membedakan dengan spasi nama. Tetapi seperti yang Anda katakan mereka harus menggunakan kode yang tidak digunakan, saya tidak melihat manfaat apa pun untuk praktik ini dan banyak kelemahannya

• perubahan ke satu implementasi membutuhkan kompilasi dari yang lain
• kode yang tidak digunakan digunakan untuk hidup (risiko bug)
• kode uji digunakan langsung (mengolok-olok dll, risiko bug, kesalahan konfigurasi)
• kode usang memerlukan refactoring untuk dihapus, (misalkan kita tidak menggunakan MySQL lagi)
• harus menguji kode yang tidak digunakan sebelum digunakan (kami sedang menguji kan?)
• refactoring dapat menyebabkan kesalahan kompilasi pada komponen yang tidak digunakan (misalkan kita mengubah antarmuka)

Saya mungkin mengambil jalan pintas dan meletakkan implementasi konkret dengan antarmuka untuk aplikasi kecil jika itu menghindari proyek yang hanya berisi satu antarmuka. Tapi biasanya saya menemukan antarmuka sesuai dengan model. Jadi saya akan melakukannya

• Company.Framework.Models.dll (termasuk antarmuka untuk kegigihan)
• Company.Framework.Persistence.MySQL.dll (model ref, tetapi perlu tetap)
• Company.Framework.Persistence.Mock.dll (model ref, tetapi perlu tetap)

atau (jalan pintas yang buruk!)

• Company.Framework.Models.dll (tidak termasuk antarmuka)
• Company.Framework.Persistence.MySQL.dll (termasuk antarmuka persistensi, model ref)
• Company.Framework.Persistence.Mock.dll (model ref dan sql, tetapi tidak digunakan untuk hidup)

Obvs, cukup sederhana untuk memperbaiki antarmuka jika aplikasi bertambah besar / rumit

Keuntungan dari strategi dua adalah untuk meminimalkan neraka dll.

Biasanya Company.Framework.Persistence.MySQL.dll akan bergantung pada beberapa dll untuk berinteraksi dengan MySql. Jika saya tidak tertarik pada MySql, Mengapa saya harus mengunduh dll dari MySql?

Katakanlah kerangka kerja Anda mendukung 20 penyedia penyimpanan yang berbeda. Sebagian besar pengguna hanya menggunakan satu. Jadi semua pengguna harus pergi dan mendapatkan 19 dll yang tidak akan mereka gunakan hanya untuk mengkompilasi kerangka kerja Anda.

Dengan mengikuti strategi dua Anda memungkinkan pengguna Anda untuk hanya menginstal dll yang akan mereka gunakan dan dengan demikian meminimalkan dll neraka.