Понимание интерфейсов

Я приведу вам пример ниже, но позвольте мне начать с одного из ваших утверждений. «Я не знаю, как определить, когда его использовать». поставить на край. Вам не нужно определять, когда его использовать, а когда нет. Любой параметр (по крайней мере, для общедоступных методов), любое (общедоступное) свойство (и лично я бы фактически расширил список до всего остального) должен быть объявлен как нечто вроде интерфейса, а не определенного класса. Единственный раз, когда я когда-либо объявлял что-то определенного типа, это когда не было подходящего интерфейса.

Я бы пошел

IEnumerable<T> sequence;

, когда смогу, и почти никогда (единственный случай, о котором я могу подумать, - это действительно ли я нужен метод ForEach)

List<T> sequence;

а теперь пример. Допустим, вы создаете систему, которая может сравнивать цены на автомобили и компьютеры. Каждый отображается в списке.

Цены на автомобили получены с набора веб-сайтов, а цены на компьютеры - с набора услуг.

решением может быть: создать одну веб-страницу, скажем, с сеткой данных и инъекцией зависимостей IDataRetriever если вы используете внедрение и интерфейсы, вы можете легко заменить производственный класс на тестирующий класс при тестировании. (Это снова может быть переключение хранилищ данных или принудительное выполнение ошибки, которую может быть очень сложно создать в коде выпуска, например, состояние гонки)

Возможно, лучший способ получить хорошее представление об интерфейсах - это использовать пример из .NET framework.

Рассмотрим следующую функцию:

void printValues(IEnumerable sequence)
{
    foreach (var value in sequence)
        Console.WriteLine(value);
}

Теперь я мог бы написать эту функцию принять List , объект [] или любой другой тип конкретной последовательности. Но поскольку я написал эту функцию, чтобы принимать параметр типа IEnumerable , это означает, что я могу передать любой конкретный тип в эту функцию, которая реализует интерфейс IEnumerable .

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

Хорошо, мне тоже сначала было трудно понять, так что не беспокойтесь об этом.

Подумайте об этом, если у вас есть класс, который, скажем, является персонажем видеоигры.

public class Character
{
}

Теперь предположим, что я хочу, чтобы у персонажа было оружие. Я мог бы использовать интерфейс для определения методов, необходимых для оружия:

interface IWeapon
{
    public Use();
}

Итак, давайте дадим персонажу оружие:

public class Character
{
    IWeapon weapon;

    public void GiveWeapon(IWeapon weapon)
    {
        this.weapon = weapon;
    }

    public void UseWeapon()
    {
        weapon.Use();
    }
}

Теперь мы можем создавать оружие, использующее интерфейс IWeapon, и мы можем передать его любому классу персонажа, и этот класс может использовать этот предмет.

public class Gun : IWeapon
{
    public void Use()
    {
        Console.Writeline("Weapon Fired");
    }
}

Затем вы можете склеить его вместе:

Character bob = new character();
Gun pistol = new Gun();
bob.GiveWeapon(pistol);
bob.UseWeapon();

Теперь это общий пример, но дает много силы. Вы можете прочитать об этом больше, если посмотрите Стратегический паттерн.

Я понял это следующим образом:

Деривация - это отношение «есть-есть», например, Собака - это животное, Корова - это животное, но интерфейс никогда не выводится, это реализовано.

Итак, интерфейс - это отношения «возможного», например, собака может быть собакой-шпионом, собака может быть цирковой собакой и т. Д. Но для этого собака должна научиться некоторым определенным вещам. Что в терминологии объектно-ориентированного программирования означает, что ваш класс должен иметь возможность делать некоторые определенные вещи (контракт, как они его называют), если он реализует интерфейс. например, если ваш класс реализует IEnumerable, это явно означает, что ваш класс имеет (должен иметь) такую ​​функциональность, чтобы его объекты можно было перечислить.

Таким образом, по сути, посредством реализации интерфейса класс предоставляет своим пользователям функциональность, которую он может что-то делать, но это НЕ наследование.

Мы используем интерфейсы (или абстрактные базовые классы), чтобы разрешить полиморфизм, который является очень центральной концепцией в объектно-ориентированном программировании. . Это позволяет нам очень гибко составлять поведение. Если вы еще этого не сделали, вам следует прочитать Шаблоны проектирования - он содержит множество примеров использования интерфейсов.

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

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

Веб-служба позволит вам кэшировать данные, уменьшая нагрузку на базу данных. Это также упростит предоставление данных из вашей системы другим системам. Еще одна вещь - гибкость - с веб-службой в качестве другого уровня вы можете изменить строку подключения / изменения схемы для всех клиентов в одном месте, вам не придется перераспределять клиента.
Вам когда-нибудь понадобится что-нибудь из этого? Я обычно не использую парадигмы, как вы говорите, но я думаю, что веб-сервис может иметь смысл. Тем не менее, только вы знаете, как устроено ваше приложение: сколько людей будет использовать этот клиент? Требуется ли для подключения к серверу MySQL какое-либо специальное программное обеспечение / конфигурация на клиентском компьютере? (Oracle делает, например).

Методы обычно считаются чем-то, что может делать объект; приведенный выше пример подразумевает, что класс, в котором определен метод, работает с числа

Тело метода точно описывает (в коде), как объект выполняет действие, описанное в имени метода. В приведенном выше примере метод добавления работает, применяя к параметрам оператор сложения и возвращая результат.

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

Другими словами, интерфейс может описывать действия (методы) класса, но он никогда не должен описывать, как должно выполняться действие.

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

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

public class Plugin
{
public void Run (PluginHost browser)
{
//do stuff here....
}
}

public interface IPlugin
{
void Run(PluginHost browser);
}

public class PluginHost
{
public void RunPlugins (IPlugin[] plugins)
{
foreach plugin in plugins
{
plugin.Run(this);
}
}
}