Ich habe eine C ++ - DLL eines Drittanbieters, die ich von C # aus aufrufe.

Die Methoden sind statisch.

Ich möchte es abstrahieren, um einige Unit-Tests durchzuführen, also habe ich eine Schnittstelle mit den darin enthaltenen statischen Methoden erstellt, aber jetzt sind meine Programmfehler mit:

Der Modifikator 'statisch' ist für dieses Element nicht gültig

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

Wie kann ich diese Abstraktion erreichen?

Mein Code sieht so aus

private IInterfaceWithStaticMethods MyInterface;

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

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

Sie können keine statischen Elemente auf einer Schnittstelle in C # definieren. Eine Schnittstelle ist ein Vertrag für Instanzen .

Ich würde empfehlen, die Benutzeroberfläche so zu erstellen, wie Sie sie derzeit sind, jedoch ohne das statische Schlüsselwort. Erstellen Sie dann eine Klasse StaticIInterface, die die Schnittstelle implementiert und die statischen C ++ - Methoden aufruft. Um Unit-Tests FakeIInterfacedurchzuführen , erstellen Sie eine weitere Klasse , die ebenfalls die Schnittstelle implementiert, aber das tut, was Sie für Ihre Unit-Tests benötigen.

Sobald Sie diese beiden Klassen definiert haben, können Sie die für Ihre Umgebung benötigte erstellen und an MyClassden Konstruktor übergeben.

Schnittstellen können keine statischen Elemente haben und statische Methoden können nicht als Implementierung von Schnittstellenmethoden verwendet werden.

Sie können eine explizite Schnittstellenimplementierung verwenden:

public interface IMyInterface
{
    void MyMethod();
}

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

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

Alternativ können Sie einfach nicht statische Methoden verwenden, auch wenn diese nicht auf instanzspezifische Mitglieder zugreifen.

Statische Mitglieder sind in der CLR vollkommen legal, nur nicht C #.

Sie können etwas Kleber in IL implementieren, um die Implementierungsdetails zu verknüpfen.

Sie sind sich nicht sicher, ob der C # -Compiler das Aufrufen zulassen würde?

Siehe: 8.9.4 Definition des Schnittstellentyps ECMA-335.

Schnittstellentypen sind notwendigerweise unvollständig, da sie nichts über die Darstellung der Werte des Schnittstellentyps aussagen. Aus diesem Grund darf eine Schnittstellentypdefinition keine Felddefinitionen für Werte des Schnittstellentyps (dh Instanzfelder) enthalten, obwohl sie statische Felder deklarieren kann (siehe §8.4.3).

Ebenso darf eine Schnittstellentypdefinition keine Implementierungen für Methoden zu den Werten ihres Typs bereitstellen. Eine Schnittstellentypdefinition kann jedoch Methodenverträge (Methodenname und Methodensignatur) definieren, die von unterstützenden Typen implementiert werden sollen. Eine Schnittstellentypdefinition kann statische Methoden definieren und implementieren (siehe §8.4.3), da statische Methoden eher dem Schnittstellentyp selbst als einem beliebigen Wert des Typs zugeordnet sind.

Sie können statische Methoden in c # 8 definieren, müssen jedoch einen Standardtext dafür deklarieren.

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

oder wenn Sie keinen Standardkörper haben möchten, lösen Sie einfach eine Ausnahme aus:

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

Sie könnten es mit Nachdenken aufrufen:

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

C # "Ten" ermöglicht neben Rollen auch statische Elemente auf Schnittstellen . Dies ist ein großer Fortschritt, da auch eine generische Überlastung des Bedieners ohne Reflexion möglich ist. Hier ist ein Beispielausschnitt, wie es funktioniert, unter Verwendung des klassischen Monoid-Beispiels, das nur Jargon ist, um "etwas zu sagen, das hinzugefügt werden kann". Direkt aus Mads Torgersen: C # in die Zukunft 45:30 :

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

Zusätzliche Ressourcen:

Jeremy Bytes: Statische Mitglieder der C # 8-Schnittstelle

BEARBEITEN

Dieser Beitrag, in dem ursprünglich angegeben wurde, dass statische Mitglieder der Benutzeroberfläche in C # 8.0 hinzugefügt werden , was nicht stimmt. Ich habe Mads Torgersens Worte im Video falsch interpretiert. Der offizielle C # 8.0-Leitfaden spricht noch nicht über statische Schnittstellenmitglieder, aber es ist klar, dass sie schon ziemlich lange daran arbeiten.

Warum Sie keine statische Methode für eine Schnittstelle haben können: Warum erlaubt C # statischen Methoden nicht, eine Schnittstelle zu implementieren?

Ich würde jedoch vorschlagen, die statischen Methoden zugunsten von Instanzmethoden zu entfernen. Wenn dies nicht möglich ist, können Sie die statischen Methodenaufrufe in eine Instanzmethode einbinden. Anschließend können Sie eine Schnittstelle dafür erstellen und daraus Ihre Komponententests ausführen.

dh

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

public interface IStaticWrapper
{
    void MyMethod();
}

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

C # 8 Ermöglicht statische Mitglieder auf Schnittstellen

Ab C # 8.0 kann eine Schnittstelle eine Standardimplementierung für Mitglieder definieren. Es kann auch statische Elemente definieren, um eine einzelne Implementierung für allgemeine Funktionen bereitzustellen.

Schnittstelle (C # Referenz)

Z.B

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

var something = IGetSomething.Something;