Неявная и явная реализация интерфейсов в C#: когда и какую использовать?

В чём разница между неявной и явной реализацией интерфейса?

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

Неявная реализация (Implicit)

Это стандартный способ, который вы уже использовали. Метод объявляется как public и его сигнатура совпадает с сигнатурой интерфейса:

public interface IWorker
{
    void Work();
}

public class Employee : IWorker
{
    public void Work() { Console.WriteLine("Employee works"); }
}

// Использование:
Employee emp = new Employee();
emp.Work(); // Работает

IWorker worker = emp;
worker.Work(); // Тоже работает

Плюсы: простота, интуитивность, метод доступен и через класс, и через интерфейс.

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

Явная реализация (Explicit)

При явной реализации вы указываете имя интерфейса перед методом (void IWorker.Work()). Такой метод не является частью публичного API класса:

public class Manager : IWorker
{
    void IWorker.Work() { Console.WriteLine("Manager works"); }
}

// Использование:
Manager mgr = new Manager();
// mgr.Work(); // ОШИБКА: метод не виден

IWorker worker = mgr;
worker.Work(); // Работает! Вызывается через интерфейс

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

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

Когда применять явную реализацию?

• Конфликт имён. Если класс реализует два интерфейса с одинаковыми методами:

public interface IReader { void Read(); }
public interface IWriter { void Read(); } // Да, так бывает

public class FileProcessor : IReader, IWriter
{
    void IReader.Read() { Console.WriteLine("Reading"); }
    void IWriter.Read() { Console.WriteLine("Writing"); }
    // public void Read() — если сделать так, то оба интерфейса вызовут один метод
}

• Сокрытие "внутренних" методов. Интерфейс может содержать методы, не предназначенные для прямого вызова пользователем класса, но нужные для работы с интерфейсом (например, IDisposable.Dispose()).
• Уменьшение публичного API. Если класс должен реализовать интерфейс, но вы не хотите, чтобы его методы были видны в Intellisense для экземпляра класса.

Практический пример: интерфейс IDisposable

public class ResourceHolder : IDisposable
{
    public void DoWork() { /* ... */ }
    
    // Явная реализация — пользователь не вызывает Dispose напрямую
    void IDisposable.Dispose()
    {
        Console.WriteLine("Ресурсы освобождены");
        // Логика освобождения
    }
}

// Использование:
ResourceHolder holder = new ResourceHolder();
holder.DoWork(); // ОК
// holder.Dispose(); // Ошибка — метод скрыт

// Но в using-блоке работает:
using (ResourceHolder r = new ResourceHolder())
{
    r.DoWork();
} // Здесь автоматически вызван Dispose через интерфейс

Выводы

Используйте неявную реализацию как основную — она проще и естественнее. Явную реализацию применяйте, когда нужно:

• Разрешить конфликт имён нескольких интерфейсов.
• Скрыть метод от прямого вызова, оставив доступ только через интерфейс.
• Реализовать интерфейс, не расширяя публичное API класса.

На практике явная реализация встречается реже, но в определённых сценариях (например, при работе с COM-интерфейсами или паттерном "Адаптер") она незаменима.

public interface IWorker { void Work(); }

public class Base : IWorker
{
    void IWorker.Work() { Console.WriteLine("Base"); }
}

public class Derived : Base, IWorker
{
    void IWorker.Work() { Console.WriteLine("Derived"); }
}