Интерфейсное соглашение о присвоении имен [закрывается]

Конвенции (и критика против них) у всех есть причина позади них, поэтому давайте бежать по некоторым причинам позади конвенций

• Интерфейсы снабжаются префиксом как я для дифференциации интерфейсных типов от реализаций - например, как упомянуто выше должен быть простой способ различать Thing и его интерфейс IThing таким образом, конвенция служит с этой целью.

• Интерфейсы снабжаются префиксом я для дифференциации его от абстрактных классов - существует неоднозначность, когда Вы видите следующий код:

  public class Apple: Fruit

  Без конвенции нельзя было бы знать если Apple наследовался другому названному классу Fruit, или если это была реализация названного интерфейса Fruit, тогда как IFruit сделает это очевидным:

  public class Apple: IFruit

  Принцип наименьшего количества удивления применяется.

• Не все использование венгерской записи порицается - Раннее использование Венгерской записи показало префикс, который указал на тип объекта и затем сопровождаемый именем переменной или иногда подчеркиванием перед именем переменной. Это было, для определенных сред программирования (думайте Visual Basic 4 - 6), полезный, но поскольку истинное объектно-ориентированное программирование стало еще популярнее, это стало непрактичным и избыточным для определения типа. Это стало особенно проблемой, когда она прибыла в intellisense.

  Сегодня венгерская запись приемлема для различения элементов UI от фактических данных и так же связала элементы UI, например, txtObject для текстового поля, lblObject для маркировки, которая связана с тем текстовым полем, в то время как данные для текстового поля просто Object.

  Я также должен указать, что исходное использование Венгерской записи не было для определения типов данных (названо Системной Венгерской записью), а скорее, указывая семантическое использование имени переменной (названный Венгерской записью Приложений). Читайте больше на нем на статье в Википедии о Венгерской записи.

Мне действительно не нравится эта конвенция. Я понимаю, что это выручает со случаем, когда у Вас есть интерфейс и реализация, которая имела бы то же имя, но я просто нахожу это ужасным. Я все еще следовал бы за ним, если бы это была конвенция, где я работаю, конечно. Непротиворечивость является точкой конвенций, и непротиворечивость является очень хорошей вещью.

Мне нравится иметь интерфейс, описывают то, что интерфейс выполняет в максимально универсальном пути, например, Validator. Определенная реализация, которая проверяет конкретную вещь, была бы a ThingValidator, и реализация с некоторой абстрактной функциональностью, совместно использованной Validators был бы AbstractValidator. Я сделал бы это даже если Thing единственное... хорошо... вещь, которую я проверяю, и Validator было бы универсально.

В случаях, где только один реальный класс имеет смысл для интерфейса, я все еще пытаюсь описать что-то определенное относительно той конкретной реализации вместо того, чтобы назвать интерфейс по-другому для предотвращения коллизии имен. В конце концов, я собираюсь быть вводящим имени интерфейса чаще, чем название реализации.

Факт вопроса - то, что все понимают это, и часть написания лучшего кода помогает читать и понять.

Это смотрит Hungarianish мне. Венгерский язык обычно считают угрозой на языках со строгим контролем типов.

Так как C# является продуктом Microsoft, и Венгерская запись была изобретением Microsoft, я вижу, где C# мог бы быть восприимчив к своему влиянию.

Я знаю, что инструкции Microsoft рекомендуют использовать 'меня' для описания этого как интерфейс. Но это прибывает из соглашений о присвоении имен IBM, если я не, помнят неправильно, инициирование 'я' для интерфейсов и следования *Impl для реализаций.

Однако, по-моему, Соглашения о присвоении имен Java являются лучшим выбором, чем соглашение о присвоении имен IBM (и не только в Java для C# также и любого языка программирования OO). Interfaces описывает то, что объект может смочь сделать, если он реализует интерфейс, и описание должно быть в глагольной форме. Т.е. Выполнимый, сериализуемый, Invoiceable, и т.д. По моему скромному мнению, это - идеальное описание того, что представляет интерфейс.

Я не знаю точно, почему они выбрали ту конвенцию, возможно, частично думая о воодушевлении класса с "I" как в "Я являюсь Счетным".

Соглашение о присвоении имен, которое было бы больше в строке остальной части платформы, будет состоять в том, чтобы включить тип в имя, что касается примера xxxAttribute и xxxException классы, делая ее xxxInterface. Это немного длинно, хотя, и после всех интерфейсов что-то отдельное, не только другой набор классов.

Разделить интерфейсы от классов.

Также (это - больше персонального наблюдения, чем продиктованный от на высокий), интерфейсы описывают то, что делает класс. 'Я' предоставляет себя этому (я уверен, что это - конструкция в грамматике, которая была бы большой выкрикнуть прямо сейчас); интерфейс, который описывает классы, которые проверяют, был бы "IValidate". Тот, который описывает поведение при сравнении, был бы "IMatch".

Поскольку у Вас обычно есть IThing и Вещь. Таким образом вместо того, чтобы позволить людям идти со своими собственными "конвенциями" для этой повторяющейся ситуации, универсальная единая конвенция была выбрана. Отзываясь эхом, что говорят другие, фактическая стандартность является причиной достаточно для использования его.

Действительно снабдите префиксом имена интерфейса букву I, чтобы указать, что тип является интерфейсом.

Инструкция не объясняет, почему необходимо использовать I префикс, но то, что это - теперь установленная конвенция, должен быть причиной достаточно.

Что необходимо получить путем отбрасывания I префикс?

Нет ничего неправильно с не использованием I конвенций для интерфейсов - просто быть последовательным и удостовериться, что это работает не только на Вас, но и на целую команду (если существует один).

Я думаю, что это лучше, чем добавление суффикса "Impl" на Вашем реальном классе. Это - одна буква, и эта конвенция хорошо устанавливается. Конечно, Вы свободны использовать любое именование, Вы желаете.

Ну, одно очевидное соображение было бы (очень распространено) IFoo и Foo пара (при абстракции Foo), но в более общем плане часто существенно знать, является ли что-то интерфейсом по сравнению с классом. Да это частично избыточно, но IMO, отличается от вещей как sCustomerName - здесь, само имя (customerName) должен быть достаточно для понимания переменной.

Но с CustomerRepository - это, что класс или абстрактный интерфейс?

Также: ожидание; факт, право или неправильно, именно это ожидают люди. Это - почти причина достаточно.

Это - просто конвенция, это полно решимости, должен предотвратить коллизии имени. C# не позволяет мне иметь класс и интерфейс под названием Клиент, даже если имена файлов являются Клиентом и IClient, соответственно. Я - удобное использование конвенции; если бы я должен был предложить другую конвенцию, то я предложил бы использовать "Контракт" в качестве суффикса, например, ClientContract.

Причина я делаю это, проста: потому что это - конвенция. Я просто следовал бы за ним, чем имел бы весь мой код, выглядят по-другому, мешая читать и учиться.

Вещь является более читаемым именем, чем IThing . Я придерживаюсь мнения, что мы должны программировать интерфейсы, а не конкретные реализации. Итак, вообще говоря, интерфейсы должны иметь приоритет над реализациями. Я предпочитаю давать более удобочитаемое имя интерфейсу, а не реализации (т. Е. Мои интерфейсы называются без префикса «I»).

На мой взгляд, это «я» - всего лишь визуальный шум. IDE должна по-разному отображать имена классов и интерфейсов. К счастью, стандартная библиотека Java не использует это соглашение.