¿Cómo sumar números genéricos en C#?

Question

Duplicar posible:
C# generic constraint for only integers

Como se puede ver en el siguiente código, necesito para calcular la suma de dos números genéricos.

public class NumberContainer<T> 
{ 
    public T ValueA { get; private set; } 
    public T ValueB { get; private set; } 
    public T Total { get { return ValueA + ValueB; } } 
} 

Sin embargo, no es posible hacer una adición directa de los dos valores de T, que resulta en el error de compilador a continuación: no se puede aplicar a operandos de tipo

operador '+' 'T' y 'T'

Dado que no tengo la intención de usar T para nada más que tipos de valores que representan números (short, ushort, int, uint, etc.), ¿cómo podría realizar el ¿suma? (la eficiencia es un factor a considerar)

Answer 1

Puede hacerlo con "poco de magia" de LINQ:

private static readonly Func<T, T, T> adder; 
static NumberContainer() { 
    var p1 = Expression.Parameter(typeof (T)); 
    var p2 = Expression.Parameter(typeof (T)); 
    adder = (Func<T, T, T>)Expression 
     .Lambda(Expression.Add(p1, p2), p1, p2) 
     .Compile(); 
} 
public T Total { get { return adder(ValueA, ValueB); } } 

El único inconveniente es que este código se compilar incluso si NumberContainer se crea una instancia de un tipo T que no admite la adición; por supuesto lanzará una excepción en tiempo de ejecución. Una ventaja adicional es que este debería funcionar con operadores definidos por el usuario +.

Answer 2

Puede especificar una restricción para T que debe ser una estructura, y quizás que implementa IConvertable, y luego use Convert.

public class NumberContainer<T> 
     where T : struct, IConvertible 
    { 
     public T ValueA { get; private set; } 
     public T ValueB { get; private set; } 
     public T Total { 
      get 
      { 
       // do type checking here, then: 

       return (T)Convert.ChangeType(
        Convert.ToDouble((object)ValueA) + 
        Convert.ToDouble((object)ValueB), typeof(T)); 
      } 
     } 
    } 

Sin embargo, no hay ninguna manera con los genéricos para garantizar que T es un entero o de tipo flotante en tiempo de compilación. Sin embargo, puedes verificarlo en tiempo de ejecución y lanzar una excepción.

Answer 3

Además de utilizar LINQ, si estás en .NET 4 esto es posible usando dynamic:

static T Add<T>(T x, T y) 
{ 
    dynamic dx = x, dy = y; 
    return dx + dy; 
} 

En el ejemplo de código esto se convierte en:

public class NumberContainer<T> where T: struct 
{ 
    public T ValueA { get; private set; } 
    public T ValueB { get; private set; } 
    public T Total { get { return ((dynamic)ValueA) + ((dynamic)ValueB); } } 
} 

Este enfoque doesn' t garantizar la seguridad sin embargo. Si T es una estructura aleatoria que no admite +, terminará con una excepción (creo).

Answer 4

Se podría tratar esto sólo como una clase base abstracta y derivar clases específicas que especifican el valor T y proporcionaron la aplicación para Total

public abstract class NumberContainer<T> 
    where T: struct 
{ 
    public T ValueA { get; private set; } 
    public T ValueB { get; private set; } 
    public abstract T Total(); 
} 

public class IntContainer : NumberContainer<int> 
{ 
    public override int Total() 
    { 
     return ValueA + ValueB; 
    } 
}