Portando C++ a C# - plantillas

Question

Estoy portando una aplicación C++ a C#, y me he encontrado con plantillas. He leído un poco sobre esto, y entiendo que algunas plantillas son similares a los genéricos .Net. Leí el SO answer en este caso que lo resumió muy bien.

Sin embargo, algunos usos de la plantilla C++ no parecen estar directamente relacionados con los genéricos. En el siguiente ejemplo del artículo de Wikipedia Template metaprogramming, la plantilla parece aceptar un valor, en lugar de un tipo. No estoy muy seguro de cómo esto se transporta a C#?

template <int N> 
struct Factorial 
{ 
    enum { value = N * Factorial<N - 1>::value }; 
}; 

template <> 
struct Factorial<0> 
{ 
    enum { value = 1 }; 
}; 

// Factorial<4>::value == 24 
// Factorial<0>::value == 1 
void foo() 
{ 
    int x = Factorial<4>::value; // == 24 
    int y = Factorial<0>::value; // == 1 
} 

Es evidente que para este ejemplo que podía hacer:

public int Factorial(int N){ 
    if(N == 0) return 1; 
    return Factorial(N - 1); 
} 

pero esto me parece ser una refactorización a una función, en lugar de un puerto de código semánticamente similar.

Answer 1

genéricos Desafortunadamente .Net sólo pueden aceptar tipos. Las plantillas de C++ toman otros valores que el compilador considera expresiones constantes, porque en realidad son solo macros que se expanden a más código.

Esto significa que su idea de convertir el código en una llamada a método es la mejor opción. Se podría hacer la llamada al método devuelve un tipo con una propiedad .Value (siguiendo su ejemplo) manteniendo así el código portado similar a la plantilla:

return Factorial(N-1).Value; 

Answer 2

vistazo a este artículo para las diferencias entre los genéricos de C# y C++ plantillas:

creo que su ejemplo se incluye allí.

MSDN Link

Answer 3

La respuesta corta es que no todo lo que se puede hacer en C++ las plantillas se pueden hacer en C# generics. En el caso de plantillas que acepten valores que no sean de tipo, cada situación tendrá que ser manejada y refacturada apropiadamente caso por caso.

Answer 4

Esto es lo más cerca que podía pensar:

public class Factorial<T> 
    where T : IConvertible 
    { 
     public T GetFactorial(T t) 
     { 
      int int32 = Convert.ToInt32(t); 
      if (int32 == 0) 
       return (T) Convert.ChangeType(1, typeof(T)); 
      return GetFactorial((T) Convert.ChangeType(int32-1, typeof(T))); 
     } 
    } 

El problema es que no se puede definir genéricos y limitarlo a ValueTypes. Esto funcionará para byte, Int16 e Int32. También para valores pequeños de Int64.

Answer 5

En el siguiente ejemplo ... la plantilla parece aceptar un valor, en lugar de un tipo.

Este no es su mayor problema. De hecho, esto podría resolverse teóricamente en C# utilizando una representación de Church numeral o Peano basándose en tipos genéricos anidados.

Sin embargo, el problema es que C# no permite la especialización de plantilla . La especialización de plantillas es responsable en su ejemplo de definir que el factorial de 0 es 1, en lugar de lo mismo que para los demás números. C# no permite hacer eso.

Así que no hay forma de especificar un caso base en una definición de plantilla recursiva (genérica) y, por lo tanto, no hay recursividad. Los genéricos C# no están completos, mientras que las plantillas C++ sí lo están.

---

Algo como esto:

class Zero { } 

class Successor<T> : Zero where T : Zero { } 

// one: 
Successor<Zero> 
// two: 
Successor<Successor<Zero>> 
// etc. 

operaciones sobre estos números Implementar se deja como ejercicio para el lector.