Solução para restrição operador sobrecarregado em .NET genéricos
-
02-07-2019 - |
Pergunta
O que eu faria se eu quiser ter um método genérico que só aceita tipos que têm sobrecarregado um operador, por exemplo, o operador de subtração. Eu tentei usar uma interface como um constrangimento, mas interfaces não podem ter sobrecarga de operadores.
Qual é a melhor maneira de conseguir isso?
Solução
Não há uma resposta imediata; operadores são estáticos, e não pode ser expresso em restrições -. e os primatives existentes não implementar qualquer interface específica (contraste com IComparable [
No entanto; se você só quer que ele funcione, em seguida, em .NET 3.5 há algumas opções ...
Eu uni uma biblioteca aqui que permite eficiente e acesso simples aos operadores com genéricos -, tais como:
T result = Operator.Add(first, second); // implicit <T>; here
Ele pode ser baixado como parte do MiscUtil
Além disso, em C # 4.0, isso se torna possível através dynamic
:
static T Add<T>(T x, T y) {
dynamic dx = x, dy = y;
return dx + dy;
}
Me também (em um ponto) uma versão .NET 2.0, mas que é menos testado. A outra opção é criar uma interface como
interface ICalc<T>
{
T Add(T,T)()
T Subtract(T,T)()
}
etc, mas então você precisa passar um ICalc<T>;
através de todos os métodos, que fica confuso.
Outras dicas
Eu achei que a IL pode realmente lidar com isso muito bem. Ex.
ldarg.0
ldarg.1
add
ret
Compilado em um método genérico, o código será executado muito bem contanto que um tipo primitivo é especificado. Pode ser possível estender este para chamar funções de operador em tipos não-primitivos.
Consulte aqui .
Há um pedaço de código roubado dos internats que eu uso muito para isso. Ele procura ou constrói usando operadores aritméticos básicos IL
. Tudo é feito dentro de uma classe genérica Operation<T>
, e tudo que você tem a fazer é atribuir a operação necessária para um delegado. add = Operation<double>.Add
como.
É usado como este:
public struct MyPoint
{
public readonly double x, y;
public MyPoint(double x, double y) { this.x=x; this.y=y; }
// User types must have defined operators
public static MyPoint operator+(MyPoint a, MyPoint b)
{
return new MyPoint(a.x+b.x, a.y+b.y);
}
}
class Program
{
// Sample generic method using Operation<T>
public static T DoubleIt<T>(T a)
{
Func<T, T, T> add=Operation<T>.Add;
return add(a, a);
}
// Example of using generic math
static void Main(string[] args)
{
var x=DoubleIt(1); //add integers, x=2
var y=DoubleIt(Math.PI); //add doubles, y=6.2831853071795862
MyPoint P=new MyPoint(x, y);
var Q=DoubleIt(P); //add user types, Q=(4.0,12.566370614359172)
var s=DoubleIt("ABC"); //concatenate strings, s="ABCABC"
}
}
Operation<T>
código fonte cortesia da pasta bin: http://pastebin.com/nuqdeY8z
com a atribuição abaixo:
/* Copyright (C) 2007 The Trustees of Indiana University
*
* Use, modification and distribution is subject to the Boost Software
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
*
* Authors: Douglas Gregor
* Andrew Lumsdaine
*
* Url: http://www.osl.iu.edu/research/mpi.net/svn/
*
* This file provides the "Operations" class, which contains common
* reduction operations such as addition and multiplication for any
* type.
*
* This code was heavily influenced by Keith Farmer's
* Operator Overloading with Generics
* at http://www.codeproject.com/csharp/genericoperators.asp
*
* All MPI related code removed by ja72.
*/