Masalah penamaan: Haruskah "Sesuatu" diubah namanya menjadi "Sesuatu"? [Tutup]

Bab Paman Bob tentang nama dalam Kode Bersih merekomendasikan agar Anda menghindari penyandian nama, terutama yang berkaitan dengan notasi Hongaria. Dia juga secara spesifik menyebutkan menghapus Iawalan dari antarmuka, tetapi tidak menunjukkan contoh ini.

Mari kita asumsikan sebagai berikut:

• Penggunaan antarmuka terutama untuk mencapai testabilitas melalui injeksi ketergantungan
• Dalam banyak kasus, ini mengarah pada memiliki antarmuka tunggal dengan implementer tunggal

Jadi, misalnya, apa nama keduanya? Parserdan ConcreteParser? Parserdan ParserImplementation?

public interface IParser {
    string Parse(string content);
    string Parse(FileInfo path);
}

public class Parser : IParser {
     // Implementations
}

Atau haruskah saya mengabaikan saran ini dalam kasus implementasi tunggal seperti ini?

Sementara banyak, termasuk "Paman Bob", menyarankan untuk tidak menggunakan Iawalan untuk antarmuka, melakukannya adalah tradisi mapan dengan C #. Secara umum, itu harus dihindari. Tetapi jika Anda menulis C #, Anda harus benar-benar mengikuti konvensi bahasa itu dan menggunakannya. Tidak melakukannya akan menyebabkan kebingungan besar dengan orang lain yang akrab dengan C # yang mencoba membaca kode Anda.

Antarmuka adalah konsep logis yang penting, oleh karena itu, antarmuka harus membawa nama generik. Jadi, saya lebih suka

interface Something
class DefaultSomething : Something
class MockSomething : Something

dari

interface ISomething
class Something : ISomething
class MockSomething : ISomething

Yang terakhir memiliki beberapa isue:

1. Sesuatu hanyalah satu implementasi dari ISomething, namun itu adalah sesuatu dengan nama generik, seolah-olah itu entah bagaimana istimewa.
2. MockSomething tampaknya berasal dari Sesuatu, namun mengimplementasikan ISomething. Mungkin harus diberi nama MockISomething, tapi aku belum pernah melihatnya di alam liar.
3. Refactoring lebih sulit. Jika Sesuatu adalah kelas sekarang, dan Anda hanya tahu nanti bahwa Anda harus memperkenalkan antarmuka, antarmuka itu harus dinamai sama, karena itu harus transparan kepada klien apakah jenisnya adalah kelas beton, kelas abstrak atau antarmuka . Tidak ada yang memecahkannya.

Ini bukan hanya tentang konvensi penamaan. C # tidak mendukung multiple inheritance sehingga penggunaan notasi Hungaria yang lama ini memiliki sedikit manfaat meskipun Anda mewarisi dari kelas dasar dan mengimplementasikan satu atau lebih antarmuka. Jadi ini...

class Foo : BarB, IBarA
{
    // Better...
}

... lebih disukai daripada ini ...

class Foo : BarB, BarA
{
    // Dafuq?
}

IMO

Tidak tidak Tidak.

Konvensi penamaan bukan merupakan fungsi fandom Paman Bob Anda. Mereka bukan fungsi dari bahasa, c # atau sebaliknya.

Mereka adalah fungsi dari basis kode Anda. Untuk tingkat yang jauh lebih rendah dari toko Anda. Dengan kata lain yang pertama dalam basis kode menetapkan standar.

Hanya dengan begitu Anda bisa memutuskan. Setelah itu konsisten saja. Jika seseorang mulai tidak konsisten mengambil senjata nerf mereka dan membuat mereka memperbarui dokumentasi sampai mereka bertobat.

Saat membaca basis kode baru jika saya tidak pernah melihat Iawalan saya baik-baik saja, terlepas dari bahasa. Jika saya melihat satu di setiap antarmuka saya baik-baik saja. Jika saya terkadang melihatnya, seseorang akan membayar.

Jika Anda menemukan diri Anda dalam konteks yang jarang dijumpai dalam menetapkan preseden ini untuk basis kode Anda, saya mendorong Anda untuk mempertimbangkan ini:

Sebagai kelas klien saya berhak untuk tidak peduli dengan apa yang saya bicarakan. Yang saya butuhkan hanyalah nama dan daftar hal yang bisa saya panggil terhadap nama itu. Itu mungkin tidak akan berubah kecuali jika saya mengatakannya. SAYA SENDIRI bagian itu. Apa yang saya bicarakan, antarmuka atau tidak, bukan departemen saya.

Jika Anda menyelinap Idalam nama itu, klien tidak peduli. Jika tidak ada I, klien tidak peduli. Apa yang dibicarakannya mungkin konkret. Mungkin tidak. Karena tidak memanggilnya new, tidak ada bedanya. Sebagai klien, saya tidak tahu. Saya tidak ingin tahu.

Sekarang sebagai monyet kode melihat kode itu, bahkan di java, ini mungkin penting. Lagi pula, jika saya harus mengubah implementasi ke antarmuka saya bisa melakukannya tanpa memberi tahu klien. Jika tidak ada Itradisi saya mungkin tidak akan mengganti namanya. Yang mungkin menjadi masalah karena sekarang kita harus mengkompilasi ulang klien karena meskipun sumbernya tidak peduli biner melakukannya. Sesuatu yang mudah dilewatkan jika Anda tidak pernah mengubah namanya.

Mungkin itu bukan masalah bagi Anda. Mungkin tidak. Jika ya, itu alasan yang bagus untuk peduli. Tapi untuk cinta mainan meja jangan mengklaim kita harus membabi buta melakukan ini karena itu cara yang dilakukan di beberapa bahasa. Entah memiliki alasan yang kuat atau tidak peduli.

Ini bukan tentang hidup dengannya selamanya. Ini tentang tidak memberi saya omong kosong tentang basis kode yang tidak sesuai dengan mentalitas khusus Anda kecuali jika Anda siap untuk memperbaiki 'masalah' di mana-mana. Kecuali Anda memiliki alasan yang kuat saya tidak seharusnya mengambil jalan yang paling tidak menentang keseragaman, jangan datang kepada saya untuk mengkhotbahkan konformitas. Aku punya hal yang lebih baik untuk dilakukan.

Ada satu perbedaan kecil antara Java dan C # yang relevan di sini. Di Jawa, setiap anggota adalah virtual secara default. Dalam C #, setiap anggota disegel secara default - kecuali untuk anggota antarmuka.

Asumsi yang sesuai dengan pedoman ini memengaruhi - di Jawa, setiap tipe publik harus dianggap non-final, sesuai dengan Prinsip Pergantian Liskov [1]. Jika Anda hanya memiliki satu implementasi, Anda akan memberi nama kelas Parser; jika Anda membutuhkan beberapa implementasi, Anda hanya akan mengubah kelas menjadi antarmuka dengan nama yang sama, dan mengganti nama implementasi konkret menjadi sesuatu yang deskriptif.

Dalam C #, asumsi utama adalah bahwa ketika Anda mendapatkan kelas (nama tidak dimulai dengan I), itulah kelas yang Anda inginkan. Pikiran Anda, ini tidak mendekati 100% akurat - contoh-contoh khas akan menjadi kelas seperti Stream(yang seharusnya merupakan antarmuka, atau beberapa antarmuka), dan setiap orang memiliki panduan dan latar belakang mereka sendiri dari bahasa lain. Ada juga pengecualian lain seperti Basesufiks yang cukup banyak digunakan untuk menunjukkan kelas abstrak - seperti halnya dengan antarmuka, Anda tahu jenisnya seharusnya polimorfik.

Ada juga fitur kegunaan yang bagus dalam membiarkan nama non-I-awalan untuk fungsi yang berhubungan dengan antarmuka itu tanpa harus menggunakan membuat antarmuka kelas abstrak (yang akan merugikan karena kurangnya kelas multiple-inheritance di C #). Ini dipopulerkan oleh LINQ, yang digunakan IEnumerable<T>sebagai antarmuka, dan Enumerablesebagai tempat penyimpanan metode yang berlaku untuk antarmuka itu. Ini tidak perlu di Java, di mana antarmuka dapat berisi implementasi metode juga.

Pada akhirnya, Iawalan secara luas digunakan di dunia C #, dan dengan ekstensi, dunia .NET (karena sejauh ini sebagian besar. Kode NET ditulis dalam C #, masuk akal untuk mengikuti pedoman C # untuk sebagian besar antarmuka publik). Ini berarti Anda hampir pasti akan bekerja dengan perpustakaan dan kode yang mengikuti notasi ini, dan masuk akal untuk mengadopsi tradisi untuk mencegah kebingungan yang tidak perlu - tidak seperti menghilangkan awalan akan membuat kode Anda lebih baik :)

Saya berasumsi bahwa alasan Paman Bob adalah sesuatu seperti ini:

IBananaadalah gagasan abstrak pisang. Jika ada kelas pelaksana yang tidak memiliki nama yang lebih baik dari itu Banana, abstraksi sama sekali tidak berarti, dan Anda harus meninggalkan antarmuka dan hanya menggunakan kelas. Jika ada nama yang lebih baik (katakanlah, LongBananaatau AppleBanana), tidak ada alasan untuk tidak menggunakan Banananama antarmuka. Oleh karena itu, menggunakan Iawalan menandakan bahwa Anda memiliki abstraksi yang tidak berguna, yang membuat kode lebih sulit untuk dipahami tanpa manfaat. Dan karena OOP yang ketat akan membuat Anda selalu kode terhadap antarmuka, satu-satunya tempat di mana Anda tidak akan melihat Iawalan pada suatu jenis akan berada di konstruktor - kebisingan yang tidak ada gunanya.

Jika Anda menerapkan ini pada IParserantarmuka sampel Anda, Anda dapat dengan jelas melihat bahwa abstraksi sepenuhnya berada di wilayah "tidak berarti". Entah ada sesuatu yang spesifik tentang implementasi konkret dari parser (misalnya JsonParser, XmlParser, ...), atau Anda hanya harus menggunakan kelas. Tidak ada yang namanya "implementasi default" (meskipun di beberapa lingkungan, ini memang masuk akal - terutama, COM), baik ada implementasi spesifik, atau Anda ingin kelas abstrak atau metode ekstensi untuk "default". Namun, dalam C #, kecuali basis kode Anda sudah menghapus I-prefix, simpan. Buat catatan mental setiap kali Anda melihat kode class Something: ISomething- artinya seseorang tidak pandai mengikuti YAGNI dan membangun abstraksi yang masuk akal.

[1] - Secara teknis, ini tidak secara khusus disebutkan dalam makalah Liskov, tetapi ini adalah salah satu dasar dari kertas OOP asli dan dalam pembacaan saya tentang Liskov, dia tidak menentang ini. Dalam interpretasi yang kurang ketat (yang diambil oleh sebagian besar bahasa OOP), ini berarti bahwa setiap kode yang menggunakan tipe publik yang dimaksudkan untuk substitusi (yaitu non-final / disegel) harus bekerja dengan implementasi yang sesuai dari tipe tersebut.

Jadi, misalnya, apa nama keduanya? Parser dan ConcreteParser? Parser dan ParserImplementation?

Dalam dunia yang ideal, Anda tidak harus mengawali nama Anda dengan tulisan tangan pendek ("Saya ...") tetapi cukup biarkan nama tersebut mengekspresikan sebuah konsep.

Saya membaca di suatu tempat (dan tidak bisa sumbernya) pendapat bahwa konvensi ISomething ini menuntun Anda untuk mendefinisikan konsep "IDollar" ketika Anda membutuhkan kelas "Dolar", tetapi solusi yang benar adalah konsep yang disebut hanya "Mata Uang".

Dengan kata lain, konvensi ini memberikan jalan keluar yang mudah untuk kesulitan menyebutkan nama dan yang mudah secara halus salah .

Di dunia nyata, klien kode Anda (yang mungkin hanya "Anda dari masa depan") harus dapat membacanya nanti dan terbiasa dengannya secepat mungkin (atau dengan sedikit usaha) mungkin (berikan klien kode Anda apa yang mereka harapkan dapatkan).

Konvensi ISomething, memperkenalkan nama cruft / bad. Yang mengatakan, cruft bukan cruft nyata *), kecuali konvensi dan praktik yang digunakan dalam penulisan kode tidak lagi aktual; jika konvensi mengatakan "gunakan sesuatu", maka yang terbaik adalah menggunakannya, untuk menyesuaikan (dan bekerja lebih baik) dengan pengembang lainnya.

*) Saya bisa lolos dengan mengatakan ini karena "cruft" bukan konsep yang pasti :)

Seperti jawaban lain menyebutkan, awalan nama antarmuka Anda dengan Iadalah bagian dari pedoman pengkodean untuk .NET framework. Karena kelas konkret lebih sering berinteraksi dengan daripada antarmuka generik dalam C # dan VB.NET, mereka adalah kelas pertama dalam skema penamaan dan dengan demikian harus memiliki nama paling sederhana - karenanya, IParseruntuk antarmuka dan Parseruntuk implementasi default.

Tetapi dalam kasus Java dan bahasa yang serupa, di mana antarmuka lebih disukai daripada kelas konkret, Paman Bob benar bahwa Iharus dihapus dan antarmuka harus memiliki nama yang paling sederhana - Parseruntuk antarmuka parser Anda, misalnya. Tetapi alih-alih nama berbasis peran seperti ParserDefault, kelas harus memiliki nama yang menjelaskan bagaimana parser diimplementasikan :

public interface Parser{
}

public class RegexParser implements Parser {
    // parses using regular expressions
}

public class RecursiveParser implements Parser {
    // parses using a recursive call structure
}

public class MockParser implements Parser {
    // BSes the parsing methods so you can get your tests working
}

Hal ini, misalnya, bagaimana Set<T>, HashSet<T>dan TreeSet<T>diberi nama.

Anda benar karena konvensi antarmuka I = antarmuka ini melanggar aturan (baru)

Di masa lalu Anda akan mengawali semuanya dengan jenisnya intCounter boolFlag dll.

Jika Anda ingin memberi nama sesuatu tanpa awalan, tetapi juga menghindari 'ConcreteParser' Anda bisa menggunakan ruang nama

namespace myapp.Interfaces
{
    public interface Parser {...
}


namespace myapp.Parsers
{
    public class Parser : myapp.Interfaces.Parser {...
}