¿Hay alguna forma en C# para forzar la sobrecarga del operador en clases derivadas?

Question

Necesito definir una interfaz que debe imponer ciertas sobrecargas al operador a los tipos que lo implementan. No parece una forma obvia de hacerlo, ya que la sobrecarga del operador debe hacerse usando métodos estáticos en clase. ¿Hay alguna forma de lograr el mismo efecto (usando clases abstractas o cualquier otra cosa)?

Answer 1

poco de un truco, pero ...

Usted puede proporcionar sobrecargas de operadores en su clase base que luego llamar a algunos métodos abstractos publicados en una de las clases para hacer el trabajo allí.

public abstract class MyClass 
{ 
    public static MyClass operator +(MyClass c1, MyClass c2) 
    { 
     return c1.__DoAddition(c2); 
    } 

    protected abstract MyClass __DoAddition(MyClass c2); 
} 

Answer 2

No. La única forma sensata de hacer esto sería hacer que un test de prueba de unidad use la reflexión para encontrar todas las implementaciones concretas, y luego verificar esta condición. Puede también hacer algo en el tiempo de ejecución re lo mismo a través de un constructor estático, pero entonces la pregunta es que constructor estático?

Otro enfoque es abandonar los operadores y utilizar un enfoque basado en interfaz; por ejemplo, si necesita T para tener +(T,T), en lugar de que los operadores tengan una interfaz con un método Add(T). Otra ventaja aquí es que las interfaces se pueden usar desde genéricos (generalmente a través de restricciones), donde-como el uso de operadores de código genérico requiere un poco de esfuerzo.

Answer 3

Puede implementar la sobrecarga en una clase base abstracta, pero delegue los detalles de la operación real en un método abstracto. Entonces esto tendrá que implementarse y la sobrecarga se aplicará con su implementación.

public abstract class OverLoadingBase 
{ 
    public abstract OverLoadingBase DoAdd(OverLoadingBase y); 

    public static OverLoadingBase operator +(OverLoadingBase x, OverLoadingBase y) 
    { 
     return x.DoAdd(y); 
    }  
} 

Aunque no estoy seguro de si esto está completo.

Answer 4

Como su operador solo se puede sobrecargar y no anular, es bastante difícil. La mejor solución que puedo pensar es utilizar una clase abstracta y sobrecargarla así.

public abstract class MyBase 
{ 
    public abstract MyBase Add(MyBase right); 
    public abstract MyBase Subtract(MyBase right); 

    public static MyBase operator +(MyBase x, MyBase y) 
    { 
     //validation here 
     return x.Add(y); 
    } 

    public static MyBase operator -(MyBase x, MyBase y) 
    { 
     //validation here 
     return x.Subtract(y); 
    } 
} 

Answer 5

he hecho esto en el pasado ...

public abstract class BaseClass<TClass> where TClass : BaseClass 
{ 
    public static TClass operator +(TClass c1, TClass c2) 
    { 
     return c1.DoAddition(c2); 
    } 

    protected abstract TClass DoAddition(TClass c2); 
} 

Y luego implementado de la siguiente manera:

public class ConcreteClass : BaseClass<ConcreteClass> 
{ 
    protected ConcreteClass DoAddition(ConcreteClass c2) 
    { 
     ... 
    } 
}