C # 'dan çağırdığım bir 3. parti C ++ DLL var.

Yöntemler statiktir.

Bazı birim testleri yapmak için onu soyutlamak istiyorum, bu yüzden içindeki statik yöntemlerle bir arayüz oluşturdum, ancak şimdi program hatalarım:

'Statik' değiştiricisi bu öğe için geçerli değil

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

Bu soyutlamayı nasıl başarabilirim?

Kodum buna benziyor

private IInterfaceWithStaticMethods MyInterface;

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

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

C # 'da bir arabirimde statik üyeler tanımlayamazsınız. Arayüz, örnekler için bir sözleşmedir .

Arayüzü şu anda olduğu gibi, ancak static anahtar sözcüğü olmadan oluşturmanızı tavsiye ederim. Ardından StaticIInterface, arabirimi uygulayan ve statik C ++ yöntemlerini çağıran bir sınıf oluşturun . Birim testi yapmak için FakeIInterface, arayüzü de uygulayan ancak birim testlerinizi işlemek için ihtiyacınız olanı yapan başka bir sınıf oluşturun .

Bu 2 sınıfı tanımladıktan sonra, ortamınız için ihtiyacınız olanı oluşturabilir ve bunu MyClassyapıcısına aktarabilirsiniz .

Arabirimlerin statik üyeleri olamaz ve statik yöntemler arabirim yöntemlerinin uygulanması olarak kullanılamaz.

Yapabilecekleriniz, açık bir arayüz uygulaması kullanmaktır:

public interface IMyInterface
{
    void MyMethod();
}

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

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

Alternatif olarak, herhangi bir örneğe özel üyeye erişmeseler bile statik olmayan yöntemleri kullanabilirsiniz.

Statik üyeler CLR'de tamamen yasaldır, sadece C # değil.

Uygulama ayrıntılarını bağlamak için IL'de biraz yapıştırıcı uygulayabilirsiniz.

C # derleyicisinin onları aramaya izin verip vermeyeceğinden emin değil misiniz?

Bakınız: 8.9.4 Arayüz tipi tanımı ECMA-335.

Arabirim türleri, arabirim türünün değerlerinin gösterimi hakkında hiçbir şey söylemediklerinden, zorunlu olarak eksiktir. Bu nedenle, bir arabirim türü tanımı, statik alanları bildirebilmesine rağmen arabirim türünün değerleri (yani örnek alanları) için alan tanımları sağlamamalıdır (bkz. §8.4.3).

Benzer şekilde, bir arayüz türü tanımı, türünün değerleri üzerinde herhangi bir yöntem için uygulamalar sağlamayacaktır. Ancak, bir arayüz tipi tanımı, destekleyici tipler tarafından uygulanması gereken yöntem sözleşmelerini (yöntem adı ve yöntem imzası) tanımlayabilir ve genellikle yapar. Bir arabirim türü tanımı, statik yöntemler tanımlayabilir ve uygulayabilir (bkz. §8.4.3), çünkü statik yöntemler, türün herhangi bir değeri yerine arabirim türünün kendisiyle ilişkilendirilir.

Statik yöntemleri c # 8'de tanımlayabilirsiniz, ancak bunun için varsayılan bir gövde belirtmelisiniz.

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

veya herhangi bir varsayılan gövdeye sahip olmak istemiyorsanız, sadece bir istisna atabilirsiniz:

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

Bunu derinlemesine düşünerek çağırabilirsiniz:

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

C # "Ten", rollerin yanı sıra arayüzlerde statik üyelere izin verecek . Bu ileriye doğru büyük bir adımdır, herhangi bir yansıma kullanmadan genel operatör aşırı yüklemesine de izin verecektir. Burada, sadece "eklenebilecek bir şey" demek için kullanılan bir jargon olan klasik monoid örneği kullanan bir örnek pasaj bulunmaktadır. Doğrudan Mads Torgersen'den alınmıştır: C # Geleceğe :

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

Ek kaynaklar:

Jeremy Bytes: C # 8 arabirim statik üyeleri

DÜZENLE

Bu gönderi başlangıçta belirtilen arayüz statik üyeleri C # 8.0'a eklenecek , bu doğru değil, Mads Torgersen'in videodaki sözlerini yanlış yorumladım. Resmi C # 8.0 kılavuzu henüz statik arayüz üyelerinden bahsetmiyor, ancak oldukça uzun süredir üzerinde çalıştıkları açık.

Neden bir arabirimde statik bir yönteme sahip olamayacağınıza gelince: C # Statik Yöntemlerin Arabirimi Uygulamasına Neden İzin Vermiyor?

Ancak, örnek yöntemler lehine statik yöntemlerin kaldırılmasını öneririm. Bu mümkün değilse, statik yöntem çağrılarını bir örnek yöntemin içine sarabilir ve ardından bunun için bir arabirim oluşturabilir ve bundan birim testlerinizi çalıştırabilirsiniz.

yani

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

public interface IStaticWrapper
{
    void MyMethod();
}

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

C # 8 Arayüzlerde Statik Üyelere İzin Verir

C # 8.0 ile başlayarak, bir arayüz, üyeler için varsayılan bir uygulama tanımlayabilir. Ortak işlevsellik için tek bir uygulama sağlamak için statik üyeleri de tanımlayabilir.

arayüz (C # Referansı)

Örneğin

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

var something = IGetSomething.Something;