Визначення питань: Чи слід "ISomething" перейменувати на "Щось"? [зачинено]

Глава дядька Боба про імена в Чистому кодексі рекомендує уникати кодування імен, головним чином щодо угорських позначень. Він також конкретно згадує про видалення Iпрефікса з інтерфейсів, але не показує прикладів цього.

Припустимо наступне:

• Використання інтерфейсу полягає в основному для досягнення простежуваності шляхом введення залежності
• У багатьох випадках це призводить до наявності єдиного інтерфейсу з одним реалізатором

Так, наприклад, як слід назвати цих двох? Parserі ConcreteParser? Parserі ParserImplementation?

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

public class Parser : IParser {
     // Implementations
}

Або я повинен ігнорувати цю пропозицію в таких випадках, як реалізація?

Хоча багато хто, включаючи «дядька Боба», радять не використовувати Iв якості префікса інтерфейси, але це є усталеною традицією для C #. Загалом кажучи, цього слід уникати. Але якщо ви пишете C #, ви дійсно повинні слідувати умовам цієї мови та користуватися нею. Якщо цього не зробити, це призведе до великої плутанини у всіх, хто знайомий із C #, хто намагається прочитати ваш код.

Інтерфейс є важливою логічною концепцією, отже, інтерфейс повинен носити загальну назву. Отже, я вважаю за краще

interface Something
class DefaultSomething : Something
class MockSomething : Something

ніж

interface ISomething
class Something : ISomething
class MockSomething : ISomething

Останній має кілька питань:

1. Щось є лише однією реалізацією ISomething, але це те, що має загальну назву, ніби це якось особливе.
2. MockSomething, схоже, походить від чогось, але реалізує ISomething. Можливо, його слід назвати MockISomething, але я ніколи цього не бачив у дикій природі.
3. Рефакторинг складніше. Якщо щось зараз є класом, і ви лише пізніше дізнаєтесь, що вам потрібно ввести інтерфейс, цей інтерфейс повинен бути названий однаковим, тому що він повинен бути прозорим для клієнтів, чи є тип конкретним класом, абстрактним класом або інтерфейсом . Щось порушує це.

Мова йде не тільки про іменування конвенцій. C # не підтримує багатократне успадкування, тому це спадкове використання угорської нотації має невелику, хоча й корисну перевагу, коли ви успадковуєте з базового класу та реалізуєте один або кілька інтерфейсів. Так це ...

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

... є кращим перед цим ...

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

ІМО

Ні-ні-ні.

Конвенції про іменування не є функцією фандуму вашого дядька Боба. Вони не є функцією мови, c # чи іншим чином.

Вони є функцією вашої кодової бази. У значно меншій мірі ваш магазин. Іншими словами, перший у кодовій базі встановлює стандарт.

Тільки тоді ви приймаєте рішення. Після цього просто будьте послідовними. Якщо хтось починає непослідовно, забирайте у нього пістолет-нерв і змушуйте його оновлювати документацію, поки вони не покаяться.

Читаючи нову базу коду, якщо я ніколи не бачу Iпрефікса, я добре, незалежно від мови. Якщо я бачу його на кожному інтерфейсі, я добре. Якщо я іноді бачу його, хтось збирається платити.

Якщо ви опинитесь у розрідженому контексті встановлення цього прецеденту для вашої кодової бази, я закликаю вас врахувати це:

Як клас клієнта, я залишаю за собою право не давати прокляття, про що я говорю. Все, що мені потрібно, - це ім’я та перелік речей, які я можу викликати проти цього імені. Вони можуть не змінитися, якщо я цього не скажу. Я ВЛАСНУЮ цю частину. Те, з чим я розмовляю, інтерфейс чи ні, - це не мій відділ.

Якщо ви підкрадетеся до Iцього імені, клієнту все одно. Якщо немає I, клієнту все одно. Те, про що йдеться, може бути конкретним. Це не може. Оскільки він не закликає newдо нього жодним чином, це не має ніякого значення. Як клієнт, я не знаю. Я не хочу знати.

Тепер як мавпа з кодом дивиться на цей код, навіть у Java, це може бути важливим. Зрештою, якщо мені доведеться змінити реалізацію на інтерфейс, я можу це зробити, не повідомляючи клієнта. Якщо немає Iтрадиції, я можу навіть не перейменувати її. Що може бути проблемою, тому що тепер нам доведеться перекомпілювати клієнта, тому що, хоча джерело не дбає про двійкові. Щось легко пропустити, якщо ти ніколи не змінив ім’я.

Можливо, це для вас не проблема. Можливо, не. Якщо це так, це вагомий привід для турботи. Але для любові до настільних іграшок не стверджую, що ми повинні робити це наосліп, тому що це робиться на деяких мовах. Або мати чортово обгрунтовану причину, або не байдуже.

Справа не в тому, щоб жити з цим вічно. Йдеться про те, щоб не лаяти базу коду, що не відповідає вашому конкретному менталітету, якщо ви не готові вирішити "проблему" скрізь. Якщо у вас немає вагомих причин, я не повинен стати на шлях найменшого опору рівномірності, не приходьте до мене, щоб проповідувати відповідність. У мене є кращі справи.

Тут є одна крихітна різниця між Java та C #, яка є актуальною. У Java кожен член за замовчуванням віртуальний. У C # кожен член за замовчуванням опечатується, за винятком членів інтерфейсу.

Припущення, що впливають на це, керуються принципом - на Яві кожен публічний тип слід вважати не остаточним, відповідно до принципу заміни Ліскова [1]. Якщо у вас є лише одна реалізація, ви назвете клас Parser; якщо ви виявите, що вам потрібно кілька реалізацій, ви просто поміняєте клас на інтерфейс з тим самим іменем і перейменовуєте конкретну реалізацію на щось описове.

У C # головне припущення полягає в тому, що коли ви отримуєте клас (ім'я не починається з I), це клас, який ви хочете. Зауважте, це ніде не є на 100% точним - типовим зустрічним прикладом можуть бути класи типу Stream(які насправді мали бути інтерфейсом або парою інтерфейсів), і кожен має свої вказівки та фони з інших мов. Існують також інші винятки, такі як досить широко використовуваний Baseсуфікс для позначення абстрактного класу - як і в інтерфейсі, ви знаєте, що тип повинен бути поліморфним.

Існує також приємна зручність використання в тому, щоб залишити не-I-префікс ім'я для функціональності, що стосується цього інтерфейсу, не вдаючись до того, щоб зробити інтерфейс абстрактним класом (що зашкодить через відсутність багатократного успадкування класу в C #). Це було популяризовано LINQ, який використовує IEnumerable<T>як інтерфейс, так і Enumerableяк сховище методів, що застосовуються до цього інтерфейсу. Це не потрібно в Java, де інтерфейси можуть містити також реалізацію методів.

Зрештою, Iпрефікс широко використовується у світі C #, а в розширенні - у світі .NET (оскільки на сьогоднішній день більшість коду .NET написано на C #, є сенс дотримуватися рекомендацій C # для більшості публічних інтерфейсів). Це означає, що ви майже напевно будете працювати з бібліотеками та кодом, що слідує за цим позначенням, і є сенс прийняти традицію, щоб запобігти зайвій плутанині - це не так, як якщо опущення префікса зробить ваш код краще :)

Я припускаю, що міркування дядька Боба були приблизно таким:

IBananaє абстрактним поняттям банан. Якщо може бути будь-який клас-реалізатор, який би не мав кращої назви, ніж Bananaабстракція абсолютно безглузда, і вам слід кинути інтерфейс і просто скористатися класом. Якщо є краща назва (скажімо, LongBananaабо AppleBanana), немає причин не використовувати Bananaяк ім'я інтерфейсу. Тому використання Iпрефікса означає, що у вас є марна абстракція, що робить код важче зрозуміти без користі. І оскільки суворий OOP завжди буде вам кодувати проти інтерфейсів, єдине місце, де ви б не побачили Iпрефікс типу, було б на конструкторі - досить безглуздий шум.

Якщо застосувати це до зразкового IParserінтерфейсу, ви можете чітко бачити, що абстракція повністю знаходиться на "безглуздій" території. Або є що - то конкретне про конкретну реалізацію синтаксичного аналізатора (наприклад JsonParser, XmlParser...), або ви повинні просто використовувати клас. Не існує такого поняття, як "реалізація за замовчуванням" (хоча в деяких середовищах це дійсно має сенс - особливо, COM), або існує конкретна реалізація, або ви хочете абстрактний клас або методи розширення для "за замовчуванням". Однак у C #, якщо ваша кодова база вже не містить I-префікса, зберігайте її. Просто робіть class Something: ISomethingміркування щоразу, коли побачите код на зразок - це означає, що хтось не дуже добре стежить за YAGNI та будує розумні абстракції.

[1] - Технічно це не конкретно згадується в роботі Ліскова, але це одна з основ оригінальної статті OOP, і в моєму читанні Ліскова вона цього не оскаржувала. У менш суворій інтерпретації (той, який бере більшість мов OOP), це означає, що будь-який код, що використовує загальнодоступний тип, призначений для заміни (тобто не остаточний / запечатаний), повинен працювати з будь-якою відповідною реалізацією цього типу.

Так, наприклад, як слід назвати цих двох? Парсер і ConcreteParser? Парсер і парсер втілення?

В ідеальному світі вам не слід префіксувати своє ім’я короткою рукою ("Я ..."), а просто дозволити ім'я виражати поняття.

Я десь прочитав (і не можу отримати джерело) думки, що ця конвенція ISomething приводить вас до визначення поняття "IDollar", коли вам потрібен клас "Долар", але правильним рішенням буде концепція, яка називається просто "Валюта".

Іншими словами, конвенція дозволяє легко усунути труднощі з називанням речей, а простого - абсолютно невірним .

У реальному світі клієнти вашого коду (який може бути просто "ви з майбутнього") повинні мати можливість прочитати його пізніше і бути знайомим з ним якнайшвидше (або якнайменше зусиль) (дайте клієнтам вашого коду, що вони очікують отримати).

Конвенція ISomething вводить жорстокі / погані імена. Однак це означає, що сутність не є справжньою суттю *), за винятком випадків, коли конвенції та практики, що застосовуються при написанні коду, вже не є актуальними; якщо в конвенції сказано "використовувати ISomething", то найкраще використовувати його, щоб відповідати (і працювати краще) з іншими розробниками.

*) Я можу втекти, сказавши, що це "суворе" все одно не є точною концепцією :)

В інших відповідях згадується, що префіксація імен вашого інтерфейсу Iє частиною керівних принципів кодування для .NET-бази. Оскільки конкретні класи частіше взаємодіють із загальними інтерфейсами у C # та VB.NET, вони є першокласними у схемах іменування і, таким чином, повинні мати найпростіші імена - отже, IParserдля інтерфейсу та Parserдля реалізації за замовчуванням.

Але у випадку з Java та подібними мовами, де інтерфейси віддані перевагу замість конкретних класів, дядько Боб має рацію в тому, що його Iслід видалити, а інтерфейси повинні мати найпростіші імена - наприклад, Parserдля вашого інтерфейсу парсера. Але замість імені на основі ролей , як ParserDefault, клас повинен мати ім'я , яке описує , як це аналізатор реалізований :

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
}

Це, наприклад, як Set<T>, HashSet<T>і TreeSet<T>названі.

Ви правильні, що ця конвенція I = інтерфейсу порушує (нові) правила

За старих часів ви б додавали все до свого типу intCounter boolFlag тощо.

Якщо ви хочете назвати речі без префікса, але також уникати "ConcreteParser", ви можете використовувати простори імен

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


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