Pasando un operador junto con otros parámetros

Question

Tengo un código MUY ineficiente en el que muchas líneas aparecen 4 veces a medida que paso por permutaciones con operaciones "<" y ">" y una variedad de variables y constantes. Parecería que hay una forma de escribir la función una vez y pasar los operadores junto con los valores necesariamente cambiantes y las variables "ref". ¿Qué técnica debo aprender? Se han sugerido "delegados" pero no veo cómo usarlos de esta manera. Esto está en C# 2.0, VS2005, pero si la técnica es genérica y también se puede usar con C++, sería genial.

Solicitud de algo de código: El siguiente aparece en muchas formas, con diferentes "<" signos y ">", así como una mezcla de "+" y "-" signos:

if (move[check].Ypos - move[check].height/200.0D < LayoutManager.VISIO_HEIGHT - lcac_c.top) 
{ 
    move[check].Ypos = move[check].Ypos + adjust; 
. 
. 
. 

Answer 1

En C++, utilice las std::less y std::greater funtores. Ambos métodos heredan std::binary_function, por lo que su función genérica debería aceptar instancias de este tipo.

En .NET, el equivalente a std::binary_function es Func<T, U, R>. No hay equivalentes en std::less y std::greater, pero es bastante trivial crearlos. Vea el siguiente ejemplo.

static class Functor 
{ 
    static Func<T, T, bool> Greater<T>() 
     where T : IComparable<T> 
    { 
     return delegate(T lhs, T rhs) { return lhs.CompareTo(rhs) > 0; }; 
    } 

    static Func<T, T, bool> Less<T>() 
     where T : IComparable<T> 
    { 
     return delegate(T lhs, T rhs) { return lhs.CompareTo(rhs) < 0; }; 
    } 
} 

Nota, el código anterior utiliza la clase Func<> de .NET 3.5. Si esto no es aceptable, considere definir su propio delegado.

C++ ejemplo invocación:

void DoWork(const std::binary_function<int, int, bool>& myOperator, 
      int arg1, int arg2) 
{ 
    if (myOperator(arg1, arg2)) { /* perform rest of work */ } 
} 

void main() 
{ 
    DoWork(std::less<int>(), 100, 200); 
    DoWork(std::greater<int>(), 100, 200); 
} 

C Ejemplo # invocación:

void DoWork(Func<int, int, bool> myOperator, int arg1, int arg2) 
{ 
    if (myOperator(arg1, arg2)) { /* perform rest of work */ } 
} 

void main() 
{ 
    DoWork(Functor.Less<int>(), 100, 200); 
    DoWork(Functor.Greater<int>(), 100, 200); 
} 

EDITAR: corregí el ejemplo de la clase funtor como la aplicación < o> operadores a un tipo genérico doesn' t trabajo (de la misma manera que lo hace con las plantillas de C++).

Answer 2

en C# utilice delegados para pasar la operación "<" y ">" al código que está haciendo el trabajo.

C# Ejemplo:

public delegate bool BooleanOperatorDelegate(int a, int b) 

class OperatorsImplementer { 
    public bool OperatorLess(int a, int b) { 
     return a < b; 
    } 
} 

class AnotherOperatorsImplementer { 
    public bool OperatorLess(int a, int b) { 
     return (a + 1) < (b - 1); 
    } 
} 

class OperatorUser { 
    int DoSomethingObscene(int a, int b, BooleanOperatorDelegate operator) { 
     if (operator(a, b)) { 
      return 5; 
     } 
     else { 
      return -5; 
     } 
    } 
} 

También debe comprobar que el delegado que se obtiene como un parámetro de no es NULL.

Este es el método C para hacerlo:

bool (*operator_func)(float a, float b) 

Answer 3

Puede pasar operadores definiéndolos de manera similar al operador Enum en esta clase Comparer; y luego llamar a la función como esta:

if (IsTrue(var1, Operator.GreaterThanOrEqual, var2)) 
    Console.WriteLine("var1 is greater than var2"); 
else 
    Console 
     .WriteLine("Unfortunately var1 is not greater than or equal var2. Sorry about that."); 

---

 public static class Comparer 
{ 
    public static bool IsTrue<T, U>(T value1, Operator comparisonOperator, U value2) 
       where T : U 
       where U : IComparable 
    { 
     switch (comparisonOperator) 
     { 
      case Operator.GreaterThan: 
       return value1.CompareTo(value2) > 0; 
      case Operator.GreaterThanOrEqual: 
       return value1.CompareTo(value2) >= 0; 
      case Operator.LessThan: 
       return value1.CompareTo(value2) < 0; 
      case Operator.LessThanOrEqual: 
       return value1.CompareTo(value2) <= 0; 
      case Operator.Equal: 
       return value1.CompareTo(value2) == 0; 
      default: 
       return false; 
     } 
    } 

    public enum Operator 
    { 
     GreaterThan = 1, 
     GreaterThanOrEqual = 2, 
     LessThan = 3, 
     LessThanOrEqual = 4, 
     Equal = 5 
    } 
}