Tengo una DLL de C ++ de terceros a la que llamo desde C #.

Los métodos son estáticos.

Quiero abstraerlo para hacer algunas pruebas unitarias, así que creé una interfaz con los métodos estáticos, pero ahora mi programa tiene errores con:

El modificador 'estático' no es válido para este artículo

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

¿Cómo puedo lograr esta abstracción?

Mi código se ve así

private IInterfaceWithStaticMethods MyInterface;

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

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

No puede definir miembros estáticos en una interfaz en C #. Una interfaz es un contrato por instancias .

Recomendaría crear la interfaz como está actualmente, pero sin la palabra clave estática. Luego crea una clase StaticIInterfaceque implemente la interfaz y llame a los métodos estáticos de C ++. Para hacer pruebas unitarias, cree otra clase FakeIInterface, que también implemente la interfaz, pero haga lo que necesita para manejar sus pruebas unitarias.

Una vez que haya definido estas 2 clases, puede crear la que necesita para su entorno y pasarla al MyClassconstructor de.

Las interfaces no pueden tener miembros estáticos y los métodos estáticos no se pueden utilizar como implementación de métodos de interfaz.

Lo que puede hacer es utilizar una implementación de interfaz explícita:

public interface IMyInterface
{
    void MyMethod();
}

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

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

Alternativamente, puede simplemente usar métodos no estáticos, incluso si no acceden a ningún miembro específico de la instancia.

Los miembros estáticos son perfectamente legales en CLR, pero no C #.

Podría implementar algo de pegamento en IL para vincular los detalles de implementación.

Sin embargo, ¿no está seguro de si el compilador de C # permitiría llamarlos?

Consulte: 8.9.4 Definición del tipo de interfaz ECMA-335.

Los tipos de interfaz son necesariamente incompletos, ya que no dicen nada sobre la representación de los valores del tipo de interfaz. Por esta razón, una definición de tipo de interfaz no proporcionará definiciones de campo para valores del tipo de interfaz (es decir, campos de instancia), aunque puede declarar campos estáticos (véase §8.4.3).

De manera similar, una definición de tipo de interfaz no proporcionará implementaciones para ningún método sobre los valores de su tipo. Sin embargo, una definición de tipo de interfaz puede, y generalmente lo hace, definir contratos de método (nombre del método y firma del método) que se implementarán mediante tipos de soporte. Una definición de tipo de interfaz puede definir e implementar métodos estáticos (ver §8.4.3) ya que los métodos estáticos están asociados con el tipo de interfaz en sí en lugar de con cualquier valor del tipo.

Puede definir métodos estáticos en c # 8, pero debe declarar un cuerpo predeterminado para él.

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

o si no quieres tener ningún cuerpo predeterminado, simplemente lanza una excepción:

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

Podrías invocarlo con reflexión:

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

C # "Ten" permitirá miembros estáticos en interfaces , junto con roles. Es un gran paso adelante, también permitirá la sobrecarga de operadores genéricos, sin ningún uso de reflexión. Aquí hay un fragmento de ejemplo de cómo funciona, utilizando el ejemplo clásico de monoide, que es solo jerga para decir "algo que se puede agregar". Tomado directamente de Mads Torgersen: C # en el futuro :

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

Recursos adicionales:

Jeremy Bytes: miembros estáticos de la interfaz C # 8

EDITAR

Esta publicación declaró originalmente que los miembros estáticos de la interfaz se agregarán en C # 8.0 , lo cual no es cierto, malinterpreté las palabras de Mads Torgersen en el video. La guía oficial de C # 8.0 aún no habla de los miembros de la interfaz estática, pero está claro que han estado trabajando en ella durante bastante tiempo.

En cuanto a por qué no puede tener un método estático en una interfaz: ¿Por qué C # no permite que los métodos estáticos implementen una interfaz?

Sin embargo, sugeriría eliminar los métodos estáticos en favor de los métodos de instancia. Si eso no es posible, entonces puede envolver las llamadas al método estático dentro de un método de instancia, y luego puede crear una interfaz para eso y ejecutar sus pruebas unitarias a partir de eso.

es decir

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

public interface IStaticWrapper
{
    void MyMethod();
}

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

C # 8 permite miembros estáticos en interfaces

A partir de C # 8.0, una interfaz puede definir una implementación predeterminada para los miembros. También puede definir miembros estáticos para proporcionar una implementación única para una funcionalidad común.

interfaz (referencia de C #)

P.ej

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

var something = IGetSomething.Something;