C # Agregar dos valores generics

¿Alguien puede explicar por qué esto no funcionará? Intentaba poder agregar dos valores independientemente del tipo numérico.

public static T Add (T number1, T number2) { return number1 + number2; } 

Cuando compilo esto, aparece el siguiente error:

 Operator '+' cannot be applied to operands of type 'T' and 'T' 

No existe una restricción genérica que le permita aplicar una sobrecarga al operador. Puede echar un vistazo a la siguiente biblioteca . Alternativamente, si usa .NET 4.0, podría usar la palabra clave dynamic :

 public static T Add(T number1, T number2) { dynamic a = number1; dynamic b = number2; return a + b; } 

Obviamente, esto no aplica ningún tiempo de comstackción de seguridad, que es lo que generics están destinados a. La única forma de aplicar seguridad en tiempo de comstackción es aplicar restricciones genéricas. Y para su escenario no hay restricción disponible. Es solo un truco para engañar al comstackdor. Si la persona que llama del método Agregar no pasa los tipos que funcionan con el operador +, el código arrojará una excepción en el tiempo de ejecución.

Las soluciones dadas aquí funcionan bien, pero pensé que agregaría otra que use expresiones

 public static T Add(T a, T b) { // Declare the parameters var paramA = Expression.Parameter(typeof(T), "a"); var paramB = Expression.Parameter(typeof(T), "b"); // Add the parameters together BinaryExpression body = Expression.Add(paramA, paramB); // Compile it Func add = Expression.Lambda>(body, paramA, paramB).Compile(); // Call it return add(a, b); } 

De esta forma estás creando un Func que realiza la adición. La explicación completa se puede encontrar en este artículo .

El comstackdor no conoce el tipo T, por lo que no puede encontrar un operador + sobrecargado definido en cualquier lugar …

Lo mejor que puede hacer actualmente es declarar su método como tal (dado que todos los tipos numéricos son convertibles en dobles):

 public static double Add (double number1, double number2) { return number1 + number2; } 

o si está seguro de que se definirá un operador + adecuado:

 public static T Add(T number1, T number2) { dynamic dynamic1 = number1; dynamic dynamic2 = number2; return dynamic1 + dynamic2; } 

Actualizado

O una combinación de los dos:

 public static T Add(T in1, T in2) { var d1 = Convert.ToDouble(in1); var d2 = Convert.ToDouble(in2); return (T)(dynamic)(d1 + d2); } 

Este es un problema que tuve cuando quería un método genérico que podría funcionar en listas arbitrarias de números, por ejemplo:

 public T Calculate(IEnumerable numbers); 

La solución que encontré fue usar una expresión lambda:

 public T Calculate(Func add, IEnumerable numbers); 

Que llamarías luego por

 var sum = this.Calculate((a, b) => a + b, someListOfNumbers); 

Obviamente, en algunos casos, también puede tener + dentro del código en lugar de expresiones lambda, pero si necesita realizar operaciones matemáticas de una manera genérica, esto fue lo más fácil que se me ocurrió que es comstackr seguro.

 Since this is generic type without a constraint compiler has no knowledge if the types involved will have '+' overloaded hence the compiler error These are some workarounds public static TResult Add(T1 left, T2 right, Func AddMethod) { return AddMethod(left, right); } var finalLabel = Add("something", 3,(a,b) => a + b.ToString()); Below code could let you build same but evaluated at run time so not run time safe public static T AddExpression(T left, T right) { ParameterExpression leftOperand = Expression.Parameter(typeof(T), "left"); ParameterExpression rightOperand = Expression.Parameter(typeof(T), "right"); BinaryExpression body = Expression.Add(leftOperand, rightOperand); Expression> adder = Expression.Lambda>( body, leftOperand, rightOperand); Func theDelegate = adder.Compile(); return theDelegate(left, right); } 
  public class generic { T result; public generic(T eval1, T eval2) { dynamic a = eval1; dynamic b = eval2; result = a + b; Console.WriteLine(result); Console.ReadLine(); } 

  static void Main(string[] args) { generic genobj = new generic(20,30); } 

Esto evita que los desarrolladores escriban código defectuoso. Pocas preguntas para explicar mejor la pregunta:

1> ¿El comstackdor conoce el tipo [No, porque es un tipo genérico]? 2> ¿Puede aceptar objetos como parámetro? [Sí, puede y debido a esto no sabrá qué hacer con ellos -> código con errores]

Como quiere evitar que su código tenga errores, C # no le permite tener ‘+’ ‘-‘ y otros operadores.

Solución: puede usar el tipo “dynamic”, “var” y puede devolver la sum de ellos, si es necesario.

Porque nadie respondió proporcionando una solución usando el objeto. Por lo tanto, estoy agregando mi solución. En esto, debes convertir tus valores generics a objeto.

Este es el código de trabajo:

 public static T Add(T number1, T number2) { object a = number1; object b = number2; return (T)(object)((int)a * (int)b).ToString(); } 

Pruebe este código. Este es un código genérico para agregar.

 public static dynamic AddAllType(dynamic x, dynamic y) { return x + y; } 

Como puede ver en el mensaje de error, el operador ‘+’ no puede aplicarse. Esto ocurre porque el comstackdor no sabe nada sobre el tipo T. No sabe si esta es una clase o no.