Статичні члени в інтерфейсах

1. Вступ

Раніше інтерфейси були суворими: лише сигнатури — без полів, реалізації й статичних членів. Але .NET розвивається, а мова програмування — жива система: щоб відповідати на нові виклики, вона еволюціонує.

З новими версіями C# інтерфейси опанували нові можливості. Одна з найпомітніших — статичні члени в інтерфейсах. Тепер інтерфейси можуть містити статичні методи, властивості та події. У нових версіях C# (починаючи з C# 11) зʼявилася навіть можливість оголошувати статичні абстрактні методи, які вимагають реалізації у типів, що реалізують цей інтерфейс.

Це — великий зсув у парадигмі, який змінює підхід до дженериків і обʼєктно-орієнтованого програмування.

Якщо пояснювати простими словами: статичний член інтерфейсу — це «загальний» член, доступ до якого здійснюється через сам тип інтерфейсу (або через реалізуючий тип), а не через екземпляр обʼєкта.

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

Як це виглядає? Приклад синтаксису

public interface IMyMath
{
    static int Add(int a, int b) => a + b; // Статичний метод (реалізація за замовчуванням)

    static abstract int Multiply(int a, int b); // Вимагає реалізації у реалізуючого типу 
}

• static — член доступний на рівні типу, а не в екземпляра.
• static abstract — контракт «вимагає» реалізувати статичний метод у реалізуючому типі.
• В інтерфейсах (як і в класах) тепер можна оголошувати статичні методи, властивості та події. Також можна створювати константи. Проте інтерфейси, як і раніше, не можуть мати полів екземпляра або статичних полів (крім констант).

Ключова ідея статичних членів в інтерфейсах — дати можливість оголошувати універсальні «операції». Наприклад, якщо у вас є колекція обʼєктів і ви хочете виконати для них «порівняння», не знаючи, який тип реалізує інтерфейс, це можна зробити за допомогою статичних абстрактних членів.

2. Статичні методи з реалізацією в інтерфейсі

Навіщо це узагалі потрібно?

Класична проблема: ви хочете описувати не лише «екземплярні» методи (наприклад, уміти щось робити з обʼєктом), а й «статичні» (наприклад, створювати новий обʼєкт з рядка або порівнювати два обʼєкти статичним методом). Раніше це доводилося вирішувати через патерни (Factory, Comparer, Helper), але тепер це можна виразити безпосередньо через інтерфейс.

Особливо важливо це стало для дженериків і алгоритмів, які працюють із довільними типами:

• Реалізація універсальних операторів (наприклад, додавання, порівняння).
• Обмеження для дженерик-коду: «Будь-які типи, у яких є статичний метод або оператор…»
• Серіалізація/десеріалізація: коли потрібно створити обʼєкт з рядка без знання типу під час написання коду.

Статичні методи з тілом

Починаючи з C# 8 в інтерфейсах дозволено статичні методи з тілом. Вони схожі на звичайні статичні методи в класі.

public interface IUtility
{
    static void PrintHello()
    {
        Console.WriteLine("Привіт з інтерфейсу!");
    }
}

Такий метод можна викликати так: IUtility.PrintHello();

Це зручно для допоміжних функцій, які логічно належать інтерфейсу, але не стосуються конкретної реалізації. Наприклад: статистика для всіх обʼєктів типу, фабричні методи (CreateDefault), загальні допоміжні перевірки (скажімо, на допустимі значення).

Особливість: статичні члени інтерфейсу не «перевизначаються» у класах

Якщо ви оголосили в інтерфейсі static void Method() { ... }, то реалізуючий клас може оголосити такий самий статичний метод із тією ж сигнатурою — але це не перевизначення! Це просто два незалежні методи: імʼя збігається, але це не «віртуальний статичний метод».

3. Статичні абстрактні члени

Починаючи з C# 11, в інтерфейсах дозволено оголошувати static abstract методи. Це означає: «кожен клас або структура, що реалізує цей інтерфейс, зобовʼязаний оголосити статичний член із такою ж сигнатурою».

Приклад:

public interface IParsable<T>
{
    static abstract T Parse(string s);
}

Будь-який тип, що реалізує цей інтерфейс, повинен оголосити статичний метод Parse(string s).

Реалізація такого інтерфейсу на класі

public class Temperature : IParsable<Temperature>
{
    public int Value { get; set; }

    // Статична реалізація!
    public static Temperature Parse(string s)
    {
        var temp = new Temperature();
        temp.Value = int.Parse(s);
        return temp;
    }
}

Як це працює?

Це стає особливо цікаво в дженерик-коді:

public static T ParseFromString<T>(string s) where T : IParsable<T>
{
    return T.Parse(s);
}

// Використання:
var temp = ParseFromString<Temperature>("42");

Тепер можна писати по-справжньому універсальний код, який працює з будь-якими типами, що реалізують «статичну» поведінку!

4. Статичні члени в інтерфейсах vs. звичайні статичні члени класів

7. Приклади з реального світу

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

Нехай у нас є інтерфейс «IPrintable»:

public interface IPrintable
{
    void Print();
    static void PrintAll(IEnumerable<IPrintable> items)
    {
        foreach (var item in items)
        {
            item.Print();
        }
    }
}

Тепер можна зручно викликати:

var documents = new List<IPrintable>
{
    new Invoice { Number = "INV-001" },
    new Receipt { Number = "RC-007" }
};
IPrintable.PrintAll(documents); // статичний метод інтерфейсу!

Така архітектура чудово підходить для «групових» операцій над усіма реалізаціями інтерфейсу.

Складніший приклад: дженерик-додавання числових типів

Нехай у нас є інтерфейс:

public interface IAddable<T>
{
    static abstract T Add(T left, T right);
}

Реалізація для цілих чисел (клас-обгортка):

public struct MyInt : IAddable<MyInt>
{
    public int Value { get; }
    public MyInt(int val) => Value = val;
    public static MyInt Add(MyInt left, MyInt right) => new MyInt(left.Value + right.Value);
}

І нарешті, універсальна функція для додавання двох чисел типу T:

public static T Sum<T>(T a, T b) where T : IAddable<T>
{
    return T.Add(a, b);
}

// Використовуємо:
var x = new MyInt(5);
var y = new MyInt(6);
var z = Sum(x, y); // z.Value == 11

Саме заради такої універсальності й додали підтримку статичних членів в інтерфейсах!

8. Типові помилки та особливості

Робота з новими можливостями не завжди така проста, як здається з прикладів. Ось кілька моментів, які можуть збентежити початківця:

Статичні методи інтерфейсу не «успадковуються» класом, що його реалізує. Якщо оголосити в інтерфейсі static void Foo(), то MyClass.Foo() і IMyInterface.Foo() — це два абсолютно різні методи.

Static abstract — обовʼязковий для реалізації. Якщо забули — компілятор скаже, що клас не повністю реалізує інтерфейс.

Обмеження дженериків: щоб використовувати статичні абстрактні члени, потрібно вказати обмеження за інтерфейсом у параметрах дженерика (where T : IMyInterface).

Не всі інструменти поки що підтримують нові можливості. Наприклад, Rider, VS Code або застарілі Roslyn-аналізатори не завжди коректно показують статичні абстрактні члени в інтерфейсах, якщо версія .NET не підтримує C# 11+.

Не плутайте з методами-розширеннями інтерфейсів: їх оголошують окремо, і вони не працюють як статичні члени.