У мене є стороння бібліотека C ++ DLL, яку я телефоную з C #.

Методи статичні.

Я хочу абстрагувати це, щоб виконати певне модульне тестування, тому я створив інтерфейс зі статичними методами в ньому, але тепер мої помилки програми:

Модифікатор 'static' недійсний для цього елемента

MyMethod cannot be accessed with an instance reference; qualify it with a type name instead

Як я можу досягти цієї абстракції?

Мій код виглядає так

private IInterfaceWithStaticMethods MyInterface;

public MyClass(IInterfaceWithStaticMethods myInterface)
{
  this.MyInterface = myInterface;
}

public void MyMethod()
{
  MyInterface.StaticMethod();
}

Ви не можете визначити статичні члени інтерфейсу в C #. Інтерфейс - це контракт для екземплярів .

Я б порекомендував створити такий інтерфейс, як ви зараз, але без ключового слова static. Потім створіть клас, StaticIInterfaceякий реалізує інтерфейс і викликає статичні методи C ++. Щоб виконати модульне тестування, створіть інший клас FakeIInterface, який також реалізує інтерфейс, але робить те, що потрібно для обробки ваших модульних тестів.

Після того, як ви визначили ці 2 класи, ви можете створити той, який вам потрібен для вашого середовища, і передати його MyClassконструктору.

Інтерфейси не можуть мати статичних членів, а статичні методи не можуть використовуватися як реалізація методів інтерфейсу.

Що ви можете зробити, це використовувати явну реалізацію інтерфейсу:

public interface IMyInterface
{
    void MyMethod();
}

public class MyClass : IMyInterface
{
    static void MyMethod()
    {
    }

    void IMyInterface.MyMethod()
    {
        MyClass.MyMethod();
    }
}

Крім того, ви можете просто використовувати нестатичні методи, навіть якщо вони не мають доступу до жодних конкретних примірників.

Статичні члени абсолютно законні в CLR, тільки не C #.

Ви можете застосувати трохи клею в IL, щоб зв’язати деталі реалізації.

Не впевнені, чи зможе компілятор C # дозволити їх викликати?

Див .: 8.9.4 Визначення типу інтерфейсу ECMA-335.

Типи інтерфейсів неодмінно неповні, оскільки вони нічого не говорять про представлення значень типу інтерфейсу. З цієї причини визначення типу інтерфейсу не повинно надавати визначень полів для значень типу інтерфейсу (тобто полів екземпляра), хоча воно може оголошувати статичні поля (див. §8.4.3).

Аналогічним чином, визначення типу інтерфейсу не повинно забезпечувати реалізації будь-яких методів на значеннях свого типу. Однак визначення типу інтерфейсу може - і зазвичай робить - визначати контракти методів (ім'я методу та підпис методу), які повинні бути реалізовані за допомогою підтримуючих типів. Визначення типу інтерфейсу може визначати та реалізовувати статичні методи (див. П. 8.4.3), оскільки статичні методи пов'язані з самим типом інтерфейсу, а не з будь-яким значенням типу.

Ви можете визначити статичні методи в c # 8, але для цього потрібно оголосити тіло за замовчуванням.

    public interface IMyInterface
    {
          static string GetHello() =>  "Default Hello from interface" ;
          static void WriteWorld() => Console.WriteLine("Writing World from interface");
    }

або якщо ви не хочете мати тіло за замовчуванням, просто викиньте виняток:

    public interface IMyInterface
    {
          static string GetHello() =>  throw new NotImplementedException() ;
          static void WriteWorld() => throw new NotImplementedException();
    }

Ви можете викликати це з роздумом:

MyInterface.GetType().InvokeMember("StaticMethod", BindingFlags.Static | BindingFlags.Public | BindingFlags.InvokeMethod, null, null, null);

C # "Десять" дозволить статичним членам на інтерфейсах , поряд з ролями. Це величезний крок вперед, він також дозволить перевантажити загальний оператор, не використовуючи жодного відображення. Ось приклад фрагмента, як це працює, з використанням класичного прикладу моноїдів, який є просто жаргоном для того, щоб сказати "те, що можна додати". Взято безпосередньо від Мадса Торгерсена: C # у майбутнє :

interface IMonoid<T>
{
    static T Zero { get; }
    static T operator +(T t1, T t2);
}

public static T AddAll<T>(T[] ts) where T : IMonoid<T>
{
    T result = T.Zero;
    foreach (T t in ts) { result += t; }
    return result;
}

role IntAddMonoid extends int : IMonoid<int>
{
    public static int Zero => 0;
}

IntAddMonoid[] values = new int[] {1, 2, 4, 8, 16, 32};
int sixtyThree = AddAll<IntAddMonoid>(values); // == 63

Додаткові ресурси:

Джеремі Байтс: Статичні члени інтерфейсу C # 8

РЕДАГУВАТИ

Цей спочатку заявлений статичний член інтерфейсу буде доданий до C # 8.0 , що не відповідає дійсності, я неправильно інтерпретував слова Мадса Торгерсена у відео. В офіційному посібнику C # 8.0 ще не йдеться про статичних членів інтерфейсу, але зрозуміло, що вони працюють над цим вже досить довго.

Щодо того, чому у вас не може бути статичного методу на інтерфейсі: Чому C # не дозволяє статичним методам реалізовувати інтерфейс?

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

тобто

public static class MyStaticClass
{
    public static void MyStaticMethod()
    {...}
}

public interface IStaticWrapper
{
    void MyMethod();
}

public class MyClass : IStaticWrapper
{
    public void MyMethod()
    {
        MyStaticClass.MyStaticMethod();
    }
}

C # 8 Дозволяє статичним членам інтерфейсів

Починаючи з C # 8.0, інтерфейс може визначати реалізацію за замовчуванням для членів. Він також може визначати статичні члени, щоб забезпечити єдину реалізацію для загальної функціональності.

інтерфейс (посилання на C #)

Напр

public interface IGetSomething
{
    public static string Something = "something";
}

var something = IGetSomething.Something;