J'ai une DLL C ++ tierce que j'appelle à partir de C #.

Les méthodes sont statiques.

Je veux l'abstraire pour faire des tests unitaires, j'ai donc créé une interface avec les méthodes statiques, mais maintenant mes erreurs de programme avec:

Le modificateur «statique» n'est pas valide pour cet article

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

Comment puis-je réaliser cette abstraction?

Mon code ressemble à ceci

private IInterfaceWithStaticMethods MyInterface;

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

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

Vous ne pouvez pas définir de membres statiques sur une interface en C #. Une interface est un contrat pour les instances .

Je recommanderais de créer l'interface telle que vous l'êtes actuellement, mais sans le mot-clé static. Créez ensuite une classe StaticIInterfacequi implémente l'interface et appelle les méthodes C ++ statiques. Pour faire des tests unitaires, créez une autre classe FakeIInterface, qui implémente également l'interface, mais fait ce dont vous avez besoin pour gérer vos tests unitaires.

Une fois ces 2 classes définies, vous pouvez créer celle dont vous avez besoin pour votre environnement et la transmettre au MyClassconstructeur de.

Les interfaces ne peuvent pas avoir de membres statiques et les méthodes statiques ne peuvent pas être utilisées comme implémentation de méthodes d'interface.

Ce que vous pouvez faire, c'est utiliser une implémentation d'interface explicite:

public interface IMyInterface
{
    void MyMethod();
}

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

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

Sinon, vous pouvez simplement utiliser des méthodes non statiques, même si elles n'accèdent à aucun membre spécifique à une instance.

Les membres statiques sont parfaitement légaux dans le CLR, mais pas C #.

Vous pouvez implémenter un peu de glue dans IL pour relier les détails d'implémentation.

Vous ne savez pas si le compilateur C # permettrait de les appeler?

Voir: 8.9.4 Définition du type d'interface ECMA-335.

Les types d'interface sont forcément incomplets puisqu'ils ne disent rien sur la représentation des valeurs du type d'interface. Pour cette raison, une définition de type d'interface ne doit pas fournir de définitions de champ pour les valeurs du type d'interface (c'est-à-dire des champs d'instance), bien qu'elle puisse déclarer des champs statiques (voir le §8.4.3).

De même, une définition de type d'interface ne doit pas fournir d'implémentations pour aucune méthode sur les valeurs de son type. Cependant, une définition de type d'interface peut - et fait généralement - définir des contrats de méthode (nom de méthode et signature de méthode) qui doivent être implémentés par les types de prise en charge. Une définition de type d'interface peut définir et implémenter des méthodes statiques (voir §8.4.3) puisque les méthodes statiques sont associées au type d'interface lui-même plutôt qu'à n'importe quelle valeur du type.

Vous pouvez définir des méthodes statiques en c # 8 mais vous devez déclarer un corps par défaut pour cela.

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

ou si vous ne voulez pas de corps par défaut, lancez simplement une exception:

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

Vous pouvez l'invoquer avec réflexion:

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

C # "Ten" va autoriser les membres statiques sur les interfaces , avec les rôles. C'est un énorme pas en avant, cela permettra également une surcharge des opérateurs génériques, sans aucune réflexion. Voici un extrait d'exemple de son fonctionnement, en utilisant l'exemple classique du monoïde, qui n'est qu'un jargon pour dire "quelque chose qui peut être ajouté". Tiré directement de 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

Ressources additionnelles:

Jeremy Bytes: membres statiques de l'interface C # 8

ÉDITER

Ce message a initialement déclaré que les membres statiques de l'interface seront ajoutés dans C # 8.0 , ce qui n'est pas vrai, j'ai mal interprété les mots de Mads Torgersen dans la vidéo. Le guide officiel C # 8.0 ne parle pas encore des membres de l'interface statique, mais il est clair qu'ils y travaillent depuis assez longtemps.

Quant à savoir pourquoi vous ne pouvez pas avoir de méthode statique sur une interface: Pourquoi C # n'autorise-t-il pas les méthodes statiques à implémenter une interface?

Cependant, je suggérerais de supprimer les méthodes statiques au profit des méthodes d'instance. Si cela n'est pas possible, vous pouvez encapsuler les appels de méthode statique à l'intérieur d'une méthode d'instance, puis créer une interface pour cela et exécuter vos tests unitaires à partir de cela.

c'est à dire

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

public interface IStaticWrapper
{
    void MyMethod();
}

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

C # 8 autorise les membres statiques sur les interfaces

À partir de C # 8.0, une interface peut définir une implémentation par défaut pour les membres. Il peut également définir des membres statiques afin de fournir une seule implémentation pour une fonctionnalité commune.

interface (référence C #)

Par exemple

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

var something = IGetSomething.Something;