Есть ли ограничение, которое ограничивает мой универсальный метод числовыми типами?

Может кто-нибудь сказать мне, есть ли способ с обобщениями ограничить аргумент универсального типа Tтолько:

• Int16
• Int32
• Int64
• UInt16
• UInt32
• UInt64

Я знаю whereключевое слово, но не могу найти интерфейс только для этих типов,

Что-то вроде:

static bool IntegerFunction<T>(T value) where T : INumeric 

C # не поддерживает это. Хейлсберг описал причины неиспользования этой функции в интервью с Брюсом Эккелем :

И не ясно, что дополнительная сложность стоит того небольшого дохода, который вы получаете. Если что-то, что вы хотите сделать, не поддерживается напрямую в системе ограничений, вы можете сделать это с помощью фабричного шаблона. Вы можете иметь Matrix<T>, например, и в этом Matrixвы хотели бы определить метод точечного произведения. Это, конечно, означает , что вы в конечном счете , необходимо понять , как умножить два Ts, но вы не можете сказать , что в качестве ограничения, по крайней мере, если Tесть int, doubleили float. Но то, что вы могли бы сделать, - это Matrixпринять в качестве аргумента a Calculator<T>и Calculator<T>вызвать метод multiply. Вы идете реализовать это, и вы передаете это Matrix.

Однако это приводит к довольно запутанному коду, в котором пользователь должен предоставить свою собственную Calculator<T>реализацию для каждого, Tкоторый он хочет использовать. Пока он не должен быть расширяемым, т.е. если вы просто хотите поддерживать фиксированное количество типов, таких как intи double, вы можете обойтись без относительно простого интерфейса:

var mat = new Matrix<int>(w, h);

( Минимальная реализация в GitHub Gist. )

Однако, как только вы захотите, чтобы пользователь мог предоставлять свои собственные, пользовательские типы, вам нужно открыть эту реализацию, чтобы пользователь мог предоставить свои собственные Calculatorэкземпляры. Например, чтобы создать экземпляр матрицы, использующей пользовательскую реализацию с десятичной плавающей запятой DFP, вам нужно написать следующий код:

var mat = new Matrix<DFP>(DfpCalculator.Instance, w, h);

... и внедрить всех членов для DfpCalculator : ICalculator<DFP>.

Альтернатива, которая, к сожалению, имеет те же ограничения, - это работать с классами политики, как обсуждалось в ответе Сергея Шандара .

Учитывая популярность этого вопроса и интерес к такой функции, я с удивлением вижу, что пока нет ответа, связанного с T4.

В этом примере кода я продемонстрирую очень простой пример того, как вы можете использовать мощный шаблонизатор, чтобы делать то, что компилятор в значительной степени делает за кулисами с обобщениями.

Вместо того, чтобы идти по кругу и жертвовать определенностью времени компиляции, вы можете просто сгенерировать нужную функцию для каждого типа, который вам нравится, и использовать ее соответствующим образом (во время компиляции!).

Для этого:

• Создайте новый файл текстового шаблона с именем GenericNumberMethodTemplate.tt .
• Удалите автоматически сгенерированный код (вы сохраните большую его часть, но некоторые не нужны).
• Добавьте следующий фрагмент:

<#@ template language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>

<# Type[] types = new[] {
    typeof(Int16), typeof(Int32), typeof(Int64),
    typeof(UInt16), typeof(UInt32), typeof(UInt64)
    };
#>

using System;
public static class MaxMath {
    <# foreach (var type in types) { 
    #>
        public static <#= type.Name #> Max (<#= type.Name #> val1, <#= type.Name #> val2) {
            return val1 > val2 ? val1 : val2;
        }
    <#
    } #>
}

Вот и все. Вы сделали сейчас.

Сохранение этого файла автоматически скомпилирует его в этот исходный файл:

using System;
public static class MaxMath {
    public static Int16 Max (Int16 val1, Int16 val2) {
        return val1 > val2 ? val1 : val2;
    }
    public static Int32 Max (Int32 val1, Int32 val2) {
        return val1 > val2 ? val1 : val2;
    }
    public static Int64 Max (Int64 val1, Int64 val2) {
        return val1 > val2 ? val1 : val2;
    }
    public static UInt16 Max (UInt16 val1, UInt16 val2) {
        return val1 > val2 ? val1 : val2;
    }
    public static UInt32 Max (UInt32 val1, UInt32 val2) {
        return val1 > val2 ? val1 : val2;
    }
    public static UInt64 Max (UInt64 val1, UInt64 val2) {
        return val1 > val2 ? val1 : val2;
    }
}

В вашем mainметоде вы можете проверить, что у вас есть уверенность во время компиляции:

namespace TTTTTest
{
    class Program
    {
        static void Main(string[] args)
        {
            long val1 = 5L;
            long val2 = 10L;
            Console.WriteLine(MaxMath.Max(val1, val2));
            Console.Read();
        }
    }
}

Я опередил одно замечание: нет, это не нарушение принципа СУХОЙ. Принцип СУХОГО заключается в том, чтобы не допустить дублирования кода людьми в нескольких местах, что может затруднить сопровождение приложения.

Это совсем не так: если вы хотите изменить, вы можете просто изменить шаблон (единый источник для всего вашего поколения!), И все готово.

Чтобы использовать его с вашими собственными пользовательскими определениями, добавьте объявление пространства имен (убедитесь, что оно совпадает с тем, в котором вы определите свою собственную реализацию) к вашему сгенерированному коду и пометьте класс как partial. Затем добавьте эти строки в файл шаблона, чтобы он был включен в возможную компиляцию:

<#@ import namespace="TheNameSpaceYouWillUse" #>
<#@ assembly name="$(TargetPath)" #>

Давайте будем честными: это довольно круто.

Отказ от ответственности: этот образец находился под сильным влиянием метапрограммирования в .NET Кевина Хаззарда и Джейсона Бока, Manning Publications .

Там нет никаких ограничений для этого. Это реальная проблема для тех, кто хочет использовать дженерики для численных расчетов.

Я бы пошел дальше и сказал, что нам нужно

static bool GenericFunction<T>(T value) 
    where T : operators( +, -, /, * )

Или даже

static bool GenericFunction<T>(T value) 
    where T : Add, Subtract

К сожалению, у вас есть только интерфейсы, базовые классы и ключевые слова struct(должен быть тип-значение), class(должен быть ссылочный тип) и new()(должен иметь конструктор по умолчанию)

Вы можете заключить число во что-то еще (подобное INullable<T>), как здесь, в codeproject .

Вы можете применить ограничение во время выполнения (отражая для операторов или проверяя типы), но это теряет преимущество наличия универсального во-первых.

Обходной путь с использованием политик:

interface INumericPolicy<T>
{
    T Zero();
    T Add(T a, T b);
    // add more functions here, such as multiplication etc.
}

struct NumericPolicies:
    INumericPolicy<int>,
    INumericPolicy<long>
    // add more INumericPolicy<> for different numeric types.
{
    int INumericPolicy<int>.Zero() { return 0; }
    long INumericPolicy<long>.Zero() { return 0; }
    int INumericPolicy<int>.Add(int a, int b) { return a + b; }
    long INumericPolicy<long>.Add(long a, long b) { return a + b; }
    // implement all functions from INumericPolicy<> interfaces.

    public static NumericPolicies Instance = new NumericPolicies();
}

Алгоритмы:

static class Algorithms
{
    public static T Sum<P, T>(this P p, params T[] a)
        where P: INumericPolicy<T>
    {
        var r = p.Zero();
        foreach(var i in a)
        {
            r = p.Add(r, i);
        }
        return r;
    }

}

Применение:

int i = NumericPolicies.Instance.Sum(1, 2, 3, 4, 5);
long l = NumericPolicies.Instance.Sum(1L, 2, 3, 4, 5);
NumericPolicies.Instance.Sum("www", "") // compile-time error.

Решение безопасно во время компиляции. CityLizard Framework предоставляет скомпилированную версию для .NET 4.0. Это файл lib / NETFramework4.0 / CityLizard.Policy.dll.

Это также доступно в Nuget: https://www.nuget.org/packages/CityLizard/ . См. Структуру CityLizard.Policy.I .

Этот вопрос является чем-то вроде часто задаваемых вопросов, поэтому я публикую его как вики (поскольку я уже публиковал подобное ранее, но это более старый вопрос); тем не мение...

Какую версию .NET вы используете? Если вы используете .NET 3.5, то у меня есть универсальная реализация операторов в MiscUtil (бесплатно и т. Д.).

У этого есть методы как T Add<T>(T x, T y), и другие варианты для арифметики на различных типах (как DateTime + TimeSpan).

Кроме того, это работает для всех встроенных, поднятых и сделанных на заказ операторов и кэширует делегата для производительности.

Некоторые дополнительные сведения о том, почему это сложно, здесь .

Возможно, вы также захотите узнать, что dynamic(4.0) решение этой проблемы тоже косвенно - т.е.

dynamic x = ..., y = ...
dynamic result = x + y; // does what you expect

К сожалению, вы можете указать структуру только в предложении where в этом случае. Кажется странным, что вы не можете конкретно указать Int16, Int32 и т. Д., Но я уверен, что есть некоторая глубокая причина реализации, лежащая в основе решения не разрешать типы значений в предложении where.

Я полагаю, что единственным решением является проверка во время выполнения, которая, к сожалению, предотвращает обнаружение проблемы во время компиляции. Это будет что-то вроде: -

static bool IntegerFunction<T>(T value) where T : struct {
  if (typeof(T) != typeof(Int16)  &&
      typeof(T) != typeof(Int32)  &&
      typeof(T) != typeof(Int64)  &&
      typeof(T) != typeof(UInt16) &&
      typeof(T) != typeof(UInt32) &&
      typeof(T) != typeof(UInt64)) {
    throw new ArgumentException(
      string.Format("Type '{0}' is not valid.", typeof(T).ToString()));
  }

  // Rest of code...
}

Что немного некрасиво, я знаю, но, по крайней мере, обеспечивает необходимые ограничения.

Я также рассмотрю возможные последствия для производительности для этой реализации, возможно, есть более быстрый выход.

Вероятно, самое близкое, что вы можете сделать, это

static bool IntegerFunction<T>(T value) where T: struct

Не уверен, что вы могли бы сделать следующее

static bool IntegerFunction<T>(T value) where T: struct, IComparable
, IFormattable, IConvertible, IComparable<T>, IEquatable<T>

Для чего-то такого особенного, почему бы просто не иметь перегрузки для каждого типа, список такой короткий, и, возможно, он будет занимать меньше памяти.

Начиная с C # 7.3, вы можете использовать более близкое приближение - неуправляемое ограничение, чтобы указать, что параметр типа является не указателем, не обнуляемым неуправляемым типом.

class SomeGeneric<T> where T : unmanaged
{
//...
}

Неуправляемое ограничение подразумевает ограничение структуры и не может быть объединено ни с ограничениями структуры, ни с новыми ().

Тип - это неуправляемый тип, если он является одним из следующих типов:

• sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal или bool
• Любой тип перечисления
• Любой тип указателя
• Любой определяемый пользователем тип структуры, который содержит поля только неуправляемых типов и, в C # 7.3 и более ранних версиях, не является составным типом (тип, который включает хотя бы один аргумент типа)

Для дальнейшего ограничения и исключения указателей и пользовательских типов, которые не реализуют IComparable, добавьте IComparable (но enum по-прежнему является производным от IComparable, поэтому ограничьте enum, добавив IEquatable <T>, вы можете пойти дальше в зависимости от ваших обстоятельств и добавить дополнительные интерфейсы. unmanaged позволяет сохранить этот список короче):

    class SomeGeneric<T> where T : unmanaged, IComparable, IEquatable<T>
    {
    //...
    }

Не существует способа ограничить шаблоны типами, но вы можете определять различные действия в зависимости от типа. Как часть универсального числового пакета, мне нужен универсальный класс, чтобы добавить два значения.

    class Something<TCell>
    {
        internal static TCell Sum(TCell first, TCell second)
        {
            if (typeof(TCell) == typeof(int))
                return (TCell)((object)(((int)((object)first)) + ((int)((object)second))));

            if (typeof(TCell) == typeof(double))
                return (TCell)((object)(((double)((object)first)) + ((double)((object)second))));

            return second;
        }
    }

Обратите внимание, что typeofs оцениваются во время компиляции, поэтому операторы if будут удалены компилятором. Компилятор также удаляет ложные приведения. Так что-то будет разрешено в компиляторе

        internal static int Sum(int first, int second)
        {
            return first + second;
        }

Я создал небольшую библиотечную функциональность для решения этих проблем:

Вместо:

public T DifficultCalculation<T>(T a, T b)
{
    T result = a * b + a; // <== WILL NOT COMPILE!
    return result;
}
Console.WriteLine(DifficultCalculation(2, 3)); // Should result in 8.

Вы могли бы написать:

public T DifficultCalculation<T>(Number<T> a, Number<T> b)
{
    Number<T> result = a * b + a;
    return (T)result;
}
Console.WriteLine(DifficultCalculation(2, 3)); // Results in 8.

Вы можете найти исходный код здесь: /codereview/26022/improvement-requested-for-generic-calculator-and-generic-number

Мне было так же интересно, как Самудсону, почему только целым числам? и если это так, вы можете создать вспомогательный класс или что-то подобное для хранения всех типов, которые вы хотите.

Если все, что вы хотите, это целые числа, не используйте универсальный, который не является универсальным; или еще лучше, отклоните любой другой тип, проверив его тип.

Для этого пока нет «хорошего» решения. Однако вы можете значительно сузить аргумент типа, чтобы исключить множество ошибок для вашего гипотетического ограничения «INumeric», как показано выше в Haacked.

static bool IntegerFunction <T> (значение T), где T: IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T>, struct {...

Если вы используете .NET 4.0 и более поздние версии, вы можете просто использовать динамический как аргумент метода и проверить во время выполнения, что переданный динамический тип аргумента является числовым / целочисленным типом.

Если тип переданной динамической переменной не является числовым / целочисленным типом, тогда генерируется исключение.

Пример короткого кода, который реализует идею, выглядит примерно так:

using System;
public class InvalidArgumentException : Exception
{
    public InvalidArgumentException(string message) : base(message) {}
}
public class InvalidArgumentTypeException : InvalidArgumentException
{
    public InvalidArgumentTypeException(string message) : base(message) {}
}
public class ArgumentTypeNotIntegerException : InvalidArgumentTypeException
{
    public ArgumentTypeNotIntegerException(string message) : base(message) {}
}
public static class Program
{
    private static bool IntegerFunction(dynamic n)
    {
        if (n.GetType() != typeof(Int16) &&
            n.GetType() != typeof(Int32) &&
            n.GetType() != typeof(Int64) &&
            n.GetType() != typeof(UInt16) &&
            n.GetType() != typeof(UInt32) &&
            n.GetType() != typeof(UInt64))
            throw new ArgumentTypeNotIntegerException("argument type is not integer type");
        //code that implements IntegerFunction goes here
    }
    private static void Main()
    {
         Console.WriteLine("{0}",IntegerFunction(0)); //Compiles, no run time error and first line of output buffer is either "True" or "False" depends on the code that implements "Program.IntegerFunction" static method.
         Console.WriteLine("{0}",IntegerFunction("string")); //Also compiles but it is run time error and exception of type "ArgumentTypeNotIntegerException" is thrown here.
         Console.WriteLine("This is the last Console.WriteLine output"); //Never reached and executed due the run time error and the exception thrown on the second line of Program.Main static method.
    }

Конечно, это решение работает только во время выполнения, но никогда во время компиляции.

Если вам нужно решение, которое всегда работает во время компиляции, а не во время выполнения, вам придется обернуть динамическую переменную с помощью общедоступной структуры / класса, перегруженный public конструкторы принимают аргументы только нужных типов и дают подходящее имя для структуры / класса.

Имеет смысл, что динамическая оболочка всегда является закрытым членом класса / структуры и является единственным членом структуры / класса, а именем единственного члена структуры / класса является «значение».

Вы также должны будете определить и реализовать открытые методы и / или операторы, которые работают с желаемыми типами для частного динамического члена класса / структуры, если это необходимо.

Также имеет смысл, что структура / класс имеет специальный / уникальный конструктор, который принимает динамический в качестве аргумента, который инициализирует только свой закрытый динамический член, называемый «значением», но модификатор этого конструктора является приватным разумеется, .

Как только класс / структура будет готова, определите тип аргумента IntegerFunction, который будет тем классом / структурой, который был определен.

Пример длинного кода, который реализует идею, выглядит примерно так:

using System;
public struct Integer
{
    private dynamic value;
    private Integer(dynamic n) { this.value = n; }
    public Integer(Int16 n) { this.value = n; }
    public Integer(Int32 n) { this.value = n; }
    public Integer(Int64 n) { this.value = n; }
    public Integer(UInt16 n) { this.value = n; }
    public Integer(UInt32 n) { this.value = n; }
    public Integer(UInt64 n) { this.value = n; }
    public Integer(Integer n) { this.value = n.value; }
    public static implicit operator Int16(Integer n) { return n.value; }
    public static implicit operator Int32(Integer n) { return n.value; }
    public static implicit operator Int64(Integer n) { return n.value; }
    public static implicit operator UInt16(Integer n) { return n.value; }
    public static implicit operator UInt32(Integer n) { return n.value; }
    public static implicit operator UInt64(Integer n) { return n.value; }
    public static Integer operator +(Integer x, Int16 y) { return new Integer(x.value + y); }
    public static Integer operator +(Integer x, Int32 y) { return new Integer(x.value + y); }
    public static Integer operator +(Integer x, Int64 y) { return new Integer(x.value + y); }
    public static Integer operator +(Integer x, UInt16 y) { return new Integer(x.value + y); }
    public static Integer operator +(Integer x, UInt32 y) { return new Integer(x.value + y); }
    public static Integer operator +(Integer x, UInt64 y) { return new Integer(x.value + y); }
    public static Integer operator -(Integer x, Int16 y) { return new Integer(x.value - y); }
    public static Integer operator -(Integer x, Int32 y) { return new Integer(x.value - y); }
    public static Integer operator -(Integer x, Int64 y) { return new Integer(x.value - y); }
    public static Integer operator -(Integer x, UInt16 y) { return new Integer(x.value - y); }
    public static Integer operator -(Integer x, UInt32 y) { return new Integer(x.value - y); }
    public static Integer operator -(Integer x, UInt64 y) { return new Integer(x.value - y); }
    public static Integer operator *(Integer x, Int16 y) { return new Integer(x.value * y); }
    public static Integer operator *(Integer x, Int32 y) { return new Integer(x.value * y); }
    public static Integer operator *(Integer x, Int64 y) { return new Integer(x.value * y); }
    public static Integer operator *(Integer x, UInt16 y) { return new Integer(x.value * y); }
    public static Integer operator *(Integer x, UInt32 y) { return new Integer(x.value * y); }
    public static Integer operator *(Integer x, UInt64 y) { return new Integer(x.value * y); }
    public static Integer operator /(Integer x, Int16 y) { return new Integer(x.value / y); }
    public static Integer operator /(Integer x, Int32 y) { return new Integer(x.value / y); }
    public static Integer operator /(Integer x, Int64 y) { return new Integer(x.value / y); }
    public static Integer operator /(Integer x, UInt16 y) { return new Integer(x.value / y); }
    public static Integer operator /(Integer x, UInt32 y) { return new Integer(x.value / y); }
    public static Integer operator /(Integer x, UInt64 y) { return new Integer(x.value / y); }
    public static Integer operator %(Integer x, Int16 y) { return new Integer(x.value % y); }
    public static Integer operator %(Integer x, Int32 y) { return new Integer(x.value % y); }
    public static Integer operator %(Integer x, Int64 y) { return new Integer(x.value % y); }
    public static Integer operator %(Integer x, UInt16 y) { return new Integer(x.value % y); }
    public static Integer operator %(Integer x, UInt32 y) { return new Integer(x.value % y); }
    public static Integer operator %(Integer x, UInt64 y) { return new Integer(x.value % y); }
    public static Integer operator +(Integer x, Integer y) { return new Integer(x.value + y.value); }
    public static Integer operator -(Integer x, Integer y) { return new Integer(x.value - y.value); }
    public static Integer operator *(Integer x, Integer y) { return new Integer(x.value * y.value); }
    public static Integer operator /(Integer x, Integer y) { return new Integer(x.value / y.value); }
    public static Integer operator %(Integer x, Integer y) { return new Integer(x.value % y.value); }
    public static bool operator ==(Integer x, Int16 y) { return x.value == y; }
    public static bool operator !=(Integer x, Int16 y) { return x.value != y; }
    public static bool operator ==(Integer x, Int32 y) { return x.value == y; }
    public static bool operator !=(Integer x, Int32 y) { return x.value != y; }
    public static bool operator ==(Integer x, Int64 y) { return x.value == y; }
    public static bool operator !=(Integer x, Int64 y) { return x.value != y; }
    public static bool operator ==(Integer x, UInt16 y) { return x.value == y; }
    public static bool operator !=(Integer x, UInt16 y) { return x.value != y; }
    public static bool operator ==(Integer x, UInt32 y) { return x.value == y; }
    public static bool operator !=(Integer x, UInt32 y) { return x.value != y; }
    public static bool operator ==(Integer x, UInt64 y) { return x.value == y; }
    public static bool operator !=(Integer x, UInt64 y) { return x.value != y; }
    public static bool operator ==(Integer x, Integer y) { return x.value == y.value; }
    public static bool operator !=(Integer x, Integer y) { return x.value != y.value; }
    public override bool Equals(object obj) { return this == (Integer)obj; }
    public override int GetHashCode() { return this.value.GetHashCode(); }
    public override string ToString() { return this.value.ToString(); }
    public static bool operator >(Integer x, Int16 y) { return x.value > y; }
    public static bool operator <(Integer x, Int16 y) { return x.value < y; }
    public static bool operator >(Integer x, Int32 y) { return x.value > y; }
    public static bool operator <(Integer x, Int32 y) { return x.value < y; }
    public static bool operator >(Integer x, Int64 y) { return x.value > y; }
    public static bool operator <(Integer x, Int64 y) { return x.value < y; }
    public static bool operator >(Integer x, UInt16 y) { return x.value > y; }
    public static bool operator <(Integer x, UInt16 y) { return x.value < y; }
    public static bool operator >(Integer x, UInt32 y) { return x.value > y; }
    public static bool operator <(Integer x, UInt32 y) { return x.value < y; }
    public static bool operator >(Integer x, UInt64 y) { return x.value > y; }
    public static bool operator <(Integer x, UInt64 y) { return x.value < y; }
    public static bool operator >(Integer x, Integer y) { return x.value > y.value; }
    public static bool operator <(Integer x, Integer y) { return x.value < y.value; }
    public static bool operator >=(Integer x, Int16 y) { return x.value >= y; }
    public static bool operator <=(Integer x, Int16 y) { return x.value <= y; }
    public static bool operator >=(Integer x, Int32 y) { return x.value >= y; }
    public static bool operator <=(Integer x, Int32 y) { return x.value <= y; }
    public static bool operator >=(Integer x, Int64 y) { return x.value >= y; }
    public static bool operator <=(Integer x, Int64 y) { return x.value <= y; }
    public static bool operator >=(Integer x, UInt16 y) { return x.value >= y; }
    public static bool operator <=(Integer x, UInt16 y) { return x.value <= y; }
    public static bool operator >=(Integer x, UInt32 y) { return x.value >= y; }
    public static bool operator <=(Integer x, UInt32 y) { return x.value <= y; }
    public static bool operator >=(Integer x, UInt64 y) { return x.value >= y; }
    public static bool operator <=(Integer x, UInt64 y) { return x.value <= y; }
    public static bool operator >=(Integer x, Integer y) { return x.value >= y.value; }
    public static bool operator <=(Integer x, Integer y) { return x.value <= y.value; }
    public static Integer operator +(Int16 x, Integer y) { return new Integer(x + y.value); }
    public static Integer operator +(Int32 x, Integer y) { return new Integer(x + y.value); }
    public static Integer operator +(Int64 x, Integer y) { return new Integer(x + y.value); }
    public static Integer operator +(UInt16 x, Integer y) { return new Integer(x + y.value); }
    public static Integer operator +(UInt32 x, Integer y) { return new Integer(x + y.value); }
    public static Integer operator +(UInt64 x, Integer y) { return new Integer(x + y.value); }
    public static Integer operator -(Int16 x, Integer y) { return new Integer(x - y.value); }
    public static Integer operator -(Int32 x, Integer y) { return new Integer(x - y.value); }
    public static Integer operator -(Int64 x, Integer y) { return new Integer(x - y.value); }
    public static Integer operator -(UInt16 x, Integer y) { return new Integer(x - y.value); }
    public static Integer operator -(UInt32 x, Integer y) { return new Integer(x - y.value); }
    public static Integer operator -(UInt64 x, Integer y) { return new Integer(x - y.value); }
    public static Integer operator *(Int16 x, Integer y) { return new Integer(x * y.value); }
    public static Integer operator *(Int32 x, Integer y) { return new Integer(x * y.value); }
    public static Integer operator *(Int64 x, Integer y) { return new Integer(x * y.value); }
    public static Integer operator *(UInt16 x, Integer y) { return new Integer(x * y.value); }
    public static Integer operator *(UInt32 x, Integer y) { return new Integer(x * y.value); }
    public static Integer operator *(UInt64 x, Integer y) { return new Integer(x * y.value); }
    public static Integer operator /(Int16 x, Integer y) { return new Integer(x / y.value); }
    public static Integer operator /(Int32 x, Integer y) { return new Integer(x / y.value); }
    public static Integer operator /(Int64 x, Integer y) { return new Integer(x / y.value); }
    public static Integer operator /(UInt16 x, Integer y) { return new Integer(x / y.value); }
    public static Integer operator /(UInt32 x, Integer y) { return new Integer(x / y.value); }
    public static Integer operator /(UInt64 x, Integer y) { return new Integer(x / y.value); }
    public static Integer operator %(Int16 x, Integer y) { return new Integer(x % y.value); }
    public static Integer operator %(Int32 x, Integer y) { return new Integer(x % y.value); }
    public static Integer operator %(Int64 x, Integer y) { return new Integer(x % y.value); }
    public static Integer operator %(UInt16 x, Integer y) { return new Integer(x % y.value); }
    public static Integer operator %(UInt32 x, Integer y) { return new Integer(x % y.value); }
    public static Integer operator %(UInt64 x, Integer y) { return new Integer(x % y.value); }
    public static bool operator ==(Int16 x, Integer y) { return x == y.value; }
    public static bool operator !=(Int16 x, Integer y) { return x != y.value; }
    public static bool operator ==(Int32 x, Integer y) { return x == y.value; }
    public static bool operator !=(Int32 x, Integer y) { return x != y.value; }
    public static bool operator ==(Int64 x, Integer y) { return x == y.value; }
    public static bool operator !=(Int64 x, Integer y) { return x != y.value; }
    public static bool operator ==(UInt16 x, Integer y) { return x == y.value; }
    public static bool operator !=(UInt16 x, Integer y) { return x != y.value; }
    public static bool operator ==(UInt32 x, Integer y) { return x == y.value; }
    public static bool operator !=(UInt32 x, Integer y) { return x != y.value; }
    public static bool operator ==(UInt64 x, Integer y) { return x == y.value; }
    public static bool operator !=(UInt64 x, Integer y) { return x != y.value; }
    public static bool operator >(Int16 x, Integer y) { return x > y.value; }
    public static bool operator <(Int16 x, Integer y) { return x < y.value; }
    public static bool operator >(Int32 x, Integer y) { return x > y.value; }
    public static bool operator <(Int32 x, Integer y) { return x < y.value; }
    public static bool operator >(Int64 x, Integer y) { return x > y.value; }
    public static bool operator <(Int64 x, Integer y) { return x < y.value; }
    public static bool operator >(UInt16 x, Integer y) { return x > y.value; }
    public static bool operator <(UInt16 x, Integer y) { return x < y.value; }
    public static bool operator >(UInt32 x, Integer y) { return x > y.value; }
    public static bool operator <(UInt32 x, Integer y) { return x < y.value; }
    public static bool operator >(UInt64 x, Integer y) { return x > y.value; }
    public static bool operator <(UInt64 x, Integer y) { return x < y.value; }
    public static bool operator >=(Int16 x, Integer y) { return x >= y.value; }
    public static bool operator <=(Int16 x, Integer y) { return x <= y.value; }
    public static bool operator >=(Int32 x, Integer y) { return x >= y.value; }
    public static bool operator <=(Int32 x, Integer y) { return x <= y.value; }
    public static bool operator >=(Int64 x, Integer y) { return x >= y.value; }
    public static bool operator <=(Int64 x, Integer y) { return x <= y.value; }
    public static bool operator >=(UInt16 x, Integer y) { return x >= y.value; }
    public static bool operator <=(UInt16 x, Integer y) { return x <= y.value; }
    public static bool operator >=(UInt32 x, Integer y) { return x >= y.value; }
    public static bool operator <=(UInt32 x, Integer y) { return x <= y.value; }
    public static bool operator >=(UInt64 x, Integer y) { return x >= y.value; }
    public static bool operator <=(UInt64 x, Integer y) { return x <= y.value; }
}
public static class Program
{
    private static bool IntegerFunction(Integer n)
    {
        //code that implements IntegerFunction goes here
        //note that there is NO code that checks the type of n in rum time, because it is NOT needed anymore 
    }
    private static void Main()
    {
        Console.WriteLine("{0}",IntegerFunction(0)); //compile error: there is no overloaded METHOD for objects of type "int" and no implicit conversion from any object, including "int", to "Integer" is known.
        Console.WriteLine("{0}",IntegerFunction(new Integer(0))); //both compiles and no run time error
        Console.WriteLine("{0}",IntegerFunction("string")); //compile error: there is no overloaded METHOD for objects of type "string" and no implicit conversion from any object, including "string", to "Integer" is known.
        Console.WriteLine("{0}",IntegerFunction(new Integer("string"))); //compile error: there is no overloaded CONSTRUCTOR for objects of type "string"
    }
}

Обратите внимание, что для использования динамического в вашем коде вы должны добавить ссылку на Microsoft.CSharp

Если версия .NET Framework ниже / ниже / меньше 4.0 и динамический не определен в этой версии, вам придется использовать вместо него объект и выполнять приведение к целочисленному типу, что является проблемой, поэтому я рекомендую использовать по адресу по крайней мере .NET 4.0 или новее, если вы можете, так что вы можете использовать динамический вместо объекта .

К сожалению, .NET не предоставляет способ сделать это изначально.

Чтобы решить эту проблему, я создал библиотеку OSS Genumerics, которая предоставляет большинство стандартных числовых операций для следующих встроенных числовых типов и их обнуляемых эквивалентов с возможностью добавления поддержки других числовых типов.

sbyte, byte, short,ushort ,int , uint, long, ulong, float, double, decimal, ИBigInteger

Производительность эквивалентна конкретному числовому типу решения, позволяющего создавать эффективные универсальные числовые алгоритмы.

Вот пример использования кода.

public static T Sum(T[] items)
{
    T sum = Number.Zero<T>();
    foreach (T item in items)
    {
        sum = Number.Add(sum, item);
    }
    return sum;
}

public static T SumAlt(T[] items)
{
    // implicit conversion to Number<T>
    Number<T> sum = Number.Zero<T>();
    foreach (T item in items)
    {
        // operator support
        sum += item;
    }
    // implicit conversion to T
    return sum;
}

Какой смысл упражнения?

Как уже указывали люди, у вас может быть неуниверсальная функция, берущая самый большой элемент, и компилятор автоматически преобразует меньшие целые для вас.

static bool IntegerFunction(Int64 value) { }

Если ваша функция находится на критическом для производительности пути (очень маловероятно, IMO), вы можете обеспечить перегрузки для всех необходимых функций.

static bool IntegerFunction(Int64 value) { }
...
static bool IntegerFunction(Int16 value) { }

Я бы использовал общий, который вы могли бы обработать извне ...

/// <summary>
/// Generic object copy of the same type
/// </summary>
/// <typeparam name="T">The type of object to copy</typeparam>
/// <param name="ObjectSource">The source object to copy</param>
public T CopyObject<T>(T ObjectSource)
{
    T NewObject = System.Activator.CreateInstance<T>();

    foreach (PropertyInfo p in ObjectSource.GetType().GetProperties())
        NewObject.GetType().GetProperty(p.Name).SetValue(NewObject, p.GetValue(ObjectSource, null), null);

    return NewObject;
}

Это ограничение затронуло меня, когда я попытался перегрузить операторы для универсальных типов; поскольку не было никакого ограничения «INumeric», и по множеству других причин хорошие люди в stackoverflow рады предоставить, операции не могут быть определены на универсальных типах.

Я хотел что-то вроде

public struct Foo<T>
{
    public T Value{ get; private set; }

    public static Foo<T> operator +(Foo<T> LHS, Foo<T> RHS)
    {
        return new Foo<T> { Value = LHS.Value + RHS.Value; };
    }
}

Я работал над этой проблемой, используя динамическую типизацию .net4.

public struct Foo<T>
{
    public T Value { get; private set; }

    public static Foo<T> operator +(Foo<T> LHS, Foo<T> RHS)
    {
        return new Foo<T> { Value = LHS.Value + (dynamic)RHS.Value };
    }
}

Две вещи об использовании dynamic:

1. Представление. Все типы значений упакованы.
2. Ошибки во время выполнения. Вы «бьете» компилятор, но теряете безопасность типов. Если универсальный тип не имеет определенного оператора, во время выполнения будет выдано исключение.

Числовые примитивные типы .NET не имеют общего интерфейса, который позволял бы использовать их для расчетов. Можно было бы определить свои собственные интерфейсы (например ISignedWholeNumber) , которые будут выполнять такие операции, определяют структуры , которые содержат один Int16, Int32и т.д. , и реализуют эти интерфейсы, а затем имеют методы , которые принимают общие типы ограниченных к ISignedWholeNumber, но имеющая для преобразования числовых значений к вашим типам структуры, скорее всего, будет неприятность.

Альтернативный подход состоит в определение статического класса Int64Converter<T>со статическим свойством bool Available {get;};и статическими делегатами Int64 GetInt64(T value), T FromInt64(Int64 value), bool TryStoreInt64(Int64 value, ref T dest). Конструктор класса может быть жестко запрограммирован для загрузки делегатов для известных типов и, возможно, использовать Reflection для проверки того, Tреализует ли тип методы с правильными именами и сигнатурами (в случае, если это что-то вроде структуры, которая содержит Int64и представляет число, но имеет пользовательский ToString()метод). Этот подход утратил бы преимущества, связанные с проверкой типов во время компиляции, но все же смог бы избежать операций упаковки, и каждый тип должен был бы быть "проверен" только один раз. После этого операции, связанные с этим типом, будут заменены отправкой делегата.

У меня была похожая ситуация, когда мне нужно было обрабатывать числовые типы и строки; кажется немного странной смесью, но вы идете.

Опять же, как и многие люди, я посмотрел на ограничения и придумал кучу интерфейсов, которые он должен был поддерживать. Тем не менее, а) это не было на 100% водонепроницаемо и б), любой новичок, взглянувший на этот длинный список ограничений, сразу же был бы очень сбит с толку.

Итак, мой подход состоял в том, чтобы поместить всю мою логику в универсальный метод без ограничений, но сделать этот универсальный метод закрытым. Затем я раскрыл его с помощью открытых методов, один из которых явно обрабатывал тип, который я хотел обработать - на мой взгляд, код чистый и явный, например

public static string DoSomething(this int input, ...) => DoSomethingHelper(input, ...);
public static string DoSomething(this decimal input, ...) => DoSomethingHelper(input, ...);
public static string DoSomething(this double input, ...) => DoSomethingHelper(input, ...);
public static string DoSomething(this string input, ...) => DoSomethingHelper(input, ...);

private static string DoSomethingHelper<T>(this T input, ....)
{
    // complex logic
}

Если все, что вам нужно, это использовать один числовой тип , вы можете создать нечто похожее на псевдоним в C ++ с помощью using.

Таким образом, вместо того, чтобы иметь очень общий

T ComputeSomething<T>(T value1, T value2) where T : INumeric { ... }

ты мог бы иметь

using MyNumType = System.Double;
T ComputeSomething<MyNumType>(MyNumType value1, MyNumType value2) { ... }