Saya memiliki C ++ DLL pihak ketiga yang saya panggil dari C #.

Metodenya statis.

Saya ingin mengabstraksikannya untuk melakukan beberapa pengujian unit jadi saya membuat antarmuka dengan metode statis di dalamnya tetapi sekarang program saya mengalami kesalahan dengan:

Pengubah 'statis' tidak valid untuk item ini

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

Bagaimana saya bisa mencapai abstraksi ini?

Kode saya terlihat seperti ini

private IInterfaceWithStaticMethods MyInterface;

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

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

Anda tidak dapat menentukan anggota statis pada antarmuka di C #. Antarmuka adalah kontrak untuk contoh .

Saya akan merekomendasikan membuat antarmuka seperti Anda saat ini, tetapi tanpa kata kunci statis. Kemudian buat kelas StaticIInterfaceyang mengimplementasikan antarmuka dan memanggil metode C ++ statis. Untuk melakukan pengujian unit, buat kelas lain FakeIInterface, yang juga mengimplementasikan antarmuka, tetapi melakukan apa yang Anda perlukan untuk menangani pengujian unit Anda.

Setelah Anda menentukan 2 kelas ini, Anda dapat membuat kelas yang Anda perlukan untuk lingkungan Anda, dan meneruskannya ke MyClasskonstruktor.

Antarmuka tidak boleh memiliki anggota statis dan metode statis tidak dapat digunakan sebagai implementasi metode antarmuka.

Yang dapat Anda lakukan adalah menggunakan implementasi antarmuka eksplisit:

public interface IMyInterface
{
    void MyMethod();
}

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

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

Alternatifnya, Anda dapat dengan mudah menggunakan metode non-statis, bahkan jika mereka tidak mengakses anggota khusus instance.

Anggota statis benar-benar legal di CLR, hanya saja bukan C #.

Anda dapat menerapkan beberapa perekat di IL untuk menghubungkan detail implementasi.

Tidak yakin apakah kompilator C # akan mengizinkan pemanggilan mereka?

Lihat: 8.9.4 Definisi tipe antarmuka ECMA-335.

Jenis antarmuka harus tidak lengkap karena mereka tidak mengatakan apa-apa tentang representasi nilai dari jenis antarmuka. Untuk alasan ini, definisi tipe antarmuka tidak boleh memberikan definisi field untuk nilai tipe antarmuka (misalnya field instance), meskipun ia dapat mendeklarasikan field statis (lihat §8.4.3).

Demikian pula, definisi tipe antarmuka tidak boleh menyediakan implementasi untuk metode apa pun pada nilai tipenya. Namun, definisi tipe antarmuka dapat — dan biasanya memang — menentukan kontrak metode (nama metode dan tanda tangan metode) yang akan diimplementasikan oleh tipe pendukung. Definisi tipe antarmuka dapat mendefinisikan dan mengimplementasikan metode statis (lihat §8.4.3) karena metode statis dikaitkan dengan tipe antarmuka itu sendiri daripada dengan nilai tipe apa pun.

Anda dapat mendefinisikan metode statis di c # 8 tetapi Anda harus mendeklarasikan isi default untuk itu.

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

atau jika Anda tidak ingin memiliki isi default, cukup berikan pengecualian:

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

Anda bisa memintanya dengan refleksi:

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

C # "Sepuluh" akan mengizinkan anggota statis pada antarmuka , bersama dengan peran. Ini adalah langkah maju yang besar, ini akan memungkinkan operator generik kelebihan beban juga, tanpa menggunakan refleksi. Berikut ini cuplikan contoh cara kerjanya, menggunakan contoh monoid klasik, yang hanya jargon untuk mengatakan "sesuatu yang bisa ditambahkan". Diambil langsung dari Mads Torgersen: C # into the Future :

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

Sumber daya tambahan:

Jeremy Bytes: C # 8 antarmuka anggota statis

EDIT

Posting ini awalnya menyatakan antarmuka anggota statis akan ditambahkan di C # 8.0 , yang tidak benar, saya salah menafsirkan kata-kata Mads Torgersen dalam video. Panduan resmi C # 8.0 belum berbicara tentang anggota antarmuka statis, tetapi jelas mereka telah mengerjakannya cukup lama sekarang.

Tentang mengapa Anda tidak dapat memiliki metode statis pada antarmuka: Mengapa C # Tidak Mengizinkan Metode Statis untuk Menerapkan Antarmuka?

Namun, saya menyarankan untuk menghapus metode statis demi metode instance. Jika itu tidak memungkinkan, Anda dapat menggabungkan panggilan metode statis di dalam metode instance, lalu Anda dapat membuat antarmuka untuk itu dan menjalankan pengujian unit dari itu.

yaitu

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

public interface IStaticWrapper
{
    void MyMethod();
}

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

C # 8 Memungkinkan Anggota Statis di Antarmuka

Dimulai dengan C # 8.0, sebuah antarmuka dapat menentukan implementasi default untuk anggota. Ini juga dapat menentukan anggota statis untuk menyediakan implementasi tunggal untuk fungsionalitas umum.

antarmuka (Referensi C #)

Misalnya

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

var something = IGetSomething.Something;