Необходимость интерфейсов в c #

Question

Зачем нужны интерфейсы в c #? как мы пишем абстрактный метод в интерфейсах. вместо этого мы можем напрямую реализовать эти методы в классе.

Answer 1

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

Answer 2

Вам не нужно для использования интерфейсов в C #. Они полезны и уместны в некоторых обстоятельствах, но не в всех обстоятельствах. Удобное практическое правило, которое я использую, заключается в том, что если в вашем проекте у вас есть только один класс, реализующий интерфейс, вам не нужен этот интерфейс.

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

Answer 3

Возможно, вы захотите прочитать о полиморфизме .

Answer 4

Интерфейс необходим точно так, как описано в книгах: для определения договора между компонентами. Они являются одним из лучших способов предоставления определенной функциональности другим модулям при сохранении инкапсуляции.

Например:

1) попытаться, без интерфейса, раскрыть часть функциональности, реализованной в сборке «A», сборке «B», без фактической реализации, видимой для сборки «A».

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

Answer 5

Для себя я нахожу много использования интерфейсов, когда у меня есть похожие объекты, но совершенно разные реализации тех же методов.

Кроме того, вы можете реализовать несколько интерфейсов, но наследовать только один абстрактный класс. Я считаю это очень полезным, потому что мои бизнес-объекты имеют лучшее представление.

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

Answer 6

Согласно первому принципу GoF: программа для интерфейса не является реализацией

Это помогает во многих отношениях. Проще изменить реализацию, проще сделать код тестируемым и т. Д.

Надеется, что это поможет.

Answer 7

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

Пример, если класс Реализация интерфейса «Idisposable», что означает, что он имеет функциональность для освобождения неуправляемых Ресурсы. Теперь внешние объекты, использующие этот класс, знают, что у него есть контракт, по которому он может распоряжаться неиспользуемые неуправляемые объекты.

Answer 8

Интерфейсы используются для определения поведения / свойств классов без указания реализации. Если вы начинаете думать о классах как о выполняющих роли, а не просто как о наборе методов и свойств, тогда вы можете начать присваивать классам несколько ролей с использованием интерфейсов, что невозможно при использовании прямого наследования в C #, поскольку вы можете наследовать только от одного класса. Заставляя клиентов классов зависеть от интерфейсов (ролей), а не от самого класса, ваш код будет более слабо связан и, вероятно, лучше спроектирован.

Еще одним преимуществом этого является то, что если вы пишете модульные тесты, они, скорее всего, будут сосредоточены на поведении, а не на состоянии. Кодирование на основе интерфейсов позволяет очень легко создавать реализации макетов / заглушек для этого типа тестирования.

Не всем понадобятся интерфейсы - но, вероятно, большинство вещей с поведением (т.е. больше, чем просто набор данных) должны иметь их ИМХО, поскольку у вас всегда будет две реализации: реальная в вашем приложении и одна или несколько фальшивых в ваших тестах.

Answer 9

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

Answer 10

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

Другой способ состоит в том, чтобы все они были производными от одного базового класса. Таким образом, любой код, использующий классы, должен знать только о базовом классе - он может рассматривать любой из производных классов как базовый класс и использовать те методы, которые определены в базовом классе, для настройки. Это не так уж плохо, но у него есть главный недостаток - поскольку C # не поддерживает множественное наследование - ограничение вашей цепочки наследования. Если вы хотите, чтобы у некоторых классов была одинаковая способность, но не у всех для различного набора поведения, вы все равно застряли в реализации этого для всех. Не хорошо.

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