Вопрос об интерфейсе

Question

Мы определяем интерфейс, как показано ниже:

interface IMyInterface
{
    void MethodToImplement();
}

И последствия, как показано ниже:

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

вместо создания интерфейса, почему мы можем использовать функцию напрямую, как показано ниже: -)

class InterfaceImplementer
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

Есть мысли?

Answer 1

Вы не реализуете интерфейс в нижнем примере, вы просто создаете объект InterfaceImplementer

РЕДАКТИРОВАТЬ: в этом примере интерфейс не требуется.Однако они чрезвычайно полезны при попытке написать слабосвязанный код, когда вам не нужно зависеть от конкретных объектов.Они также используются для определения контрактов, в которых что-либо, реализующее их, должно также реализовывать каждый метод, который он определяет.

Существует множество информации, вот лишь краткое введение http://www.csharp -станция.ru / Tutorials / Lesson13.aspx

Если вы действительно хотите больше узнать об интерфейсах и о том, как они могут помочь в написании хорошего кода, я бы порекомендовал книгу Head First Design Patterns. Amazon Link

Answer 2

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

Вы спрашиваете, в чем смысл интерфейса?

Создание интерфейсапозволяет отделить вашу программу от определенного класса и вместо этого кодировать против абстракции .

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

Answer 3

Назначение интерфейсов не в экземплярах объектов, а в ссылках на них.Подумайте, изменился ли ваш пример на это:

static void Main()
{
    IMyInterface iImp = new InterfaceImplementer();
    iImp.MethodToImplement();
}

Теперь объект iTmp имеет тип IMyInterface.Его конкретная реализация - InterfaceImplementer, но могут быть случаи, когда реализация не важна (или нежелательна).Рассмотрим что-то вроде этого:

interface IVehicle
{
    void MoveForward();
}
class Car : IVehicle
{
    public void MoveForward()
    {
        ApplyGasPedal();
    }
    private void ApplyGasPedal()
    {
        // some stuff
    }
}
class Bike : IVehicle
{
    public void MoveForward()
    {
        CrankPedals();
    }
    private void CrankPedals()
    {
        // some stuff
    }
}

Теперь предположим, что у вас где-то есть такой метод:

void DoSomething(IVehicle)
{
    IVehicle.MoveForward();
}

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

Answer 4

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

Однако есть и преимущества:

• Множественное наследование - класс может расширять только один родительский класс, но можетреализовать любое количество интерфейсов.
• Свобода использования классов - если ваш код написан так, что он заботится только о том, чтобы он имел экземпляр SomethingI, вы не привязаны к определенному классу Something.Если завтра вы решите, что ваш метод должен возвращать класс, который работает по-другому, он может вернуть SomethingA, и любой вызывающий код менять не нужно.

Answer 5

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

public class SomeOtherClass
{
     public void DoSomething(IMyInterface something)
     {
          something.MethodToImplement();
     }
}

public class Program
{
     public static void Main(string[] args)
     {
          if(args != null)
              new SomeOtherClass().DoSomething(new ImplementationOne());
          else
              new SomeOtherClass().DoSomething(new ImplementationTwo());
     }
}

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

Подвести итог: оба предоставленных вами фрагмента кода являются допустимыми параметрами кода.Нам нужен контекст, чтобы определить, что является «лучшим» решением.

Answer 6

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

Это позволяет вам программировать в спецификации, а не в реализации.

Представьте, что у нас есть следующее:

public class Dog
{
    public string Speak()
    {
        return "woof!";
    }
}

И хотим посмотреть, что он говорит:

public string MakeSomeNoise(Dog dog)
{
    return dog.Speak();
}

Мы действительно не извлекаем выгоду из Интерфейса, однако, если бы мы также хотели видеть, какого родаИз-за шума, производимого Cat, нам понадобится другая перегрузка MakeSomeNoise (), которая может принять Cat, однако с интерфейсом мы можем иметь следующее:

public interface IAnimal
{
    public string Speak();
}

public class Dog : IAnimal
{
    public string Speak()
    {
        return "woof!";
    }
}

public class Cat : IAnimal
{
    public string Speak()
    {
        return "meow!";
    }
}

И выполнить их оба через:

public string MakeSomeNoise(IAnimal animal)
{
    return animal.Speak();
}

Answer 7

Интерфейсы позволяют объекту работать с различными объектами, у которых нет общего базового типа , но есть определенные общие способности. Если несколько классов реализуют IDoSomething, метод может принять параметр типа IDoSomething, и объект любого из этих классов может быть передан ему. Затем метод может использовать все методы и свойства, применимые к IDoSomething, не беспокоясь о действительном базовом типе объекта.