일반 방법을 숫자 유형으로 제한하는 제약 조건이 있습니까?

제네릭을 사용하여 제네릭 형식 인수 T를 제한하는 방법이 있는지 아는 사람이 있습니까?

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

where키워드를 알고 있지만 이러한 유형 에 대해서만 인터페이스를 찾을 수 없습니다 .

다음과 같은 것 :

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

C #은이를 지원하지 않습니다. Hejlsberg는 Bruce Eckel과의 인터뷰에서이 기능 을 구현하지 않은 이유를 설명했습니다 .

그리고 추가 된 복잡성이 적은 양의 수익을 거둘 가치가 있다는 것은 확실하지 않습니다. 구속 조건 시스템에서 수행하려는 작업이 직접 지원되지 않는 경우 팩토리 패턴으로 수행 할 수 있습니다. Matrix<T>예를 들어을 가질 수 있으며 Matrix내적 방법을 정의하려고합니다. 당신이 궁극적으로 어떻게 곱하기 2 개 이해하는 데 필요한 수단은 물론 T적어도하지 않을 경우, 당신이 제약 조건으로 그런 말을 할 수의, 그러나 T이다 int, double또는 float. 그러나 당신이 할 수있는 일은 Matrix인수 a로 가져 와서 Calculator<T>in Calculator<T>이라는 메소드를 갖는 것 multiply입니다. 당신은 그것을 구현하고 그것을 전달합니다 Matrix.

그러나 이로 인해 사용자는 사용하고자하는 Calculator<T>각각에 대해 자체 구현 을 제공해야하는 상당히 복잡한 코드가 생성됩니다 T. 확장 할 필요가없는 한, 예를 들어 intand와 같은 고정 된 유형의 유형을 지원하려는 경우 double비교적 간단한 인터페이스를 사용하여 벗어날 수 있습니다.

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

( GitHub Gist에서 최소 구현 )

그러나 사용자가 고유 한 사용자 정의 유형을 제공 할 수있게하려면 사용자가 자신의 Calculator인스턴스를 제공 할 수 있도록이 구현을 열어야 합니다. 예를 들어, 사용자 정의 10 진수 부동 소수점 구현을 사용하는 행렬을 인스턴스화 DFP하려면이 코드를 작성해야합니다.

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

…에 대한 모든 멤버를 구현하십시오 DfpCalculator : ICalculator<DFP>.

불행히도 동일한 제한을 공유하는 대안 은 Sergey Shandar의 답변에서 논의 된 것처럼 정책 클래스를 사용 하는 것 입니다.

이 질문의 인기와 그러한 기능에 대한 관심을 고려할 때 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();
        }
    }
}

한 가지 언급을 할 것입니다. 아니요, 이것은 DRY 원칙을 위반하지 않습니다. DRY 원칙은 사람들이 여러 위치에서 코드를 복제하여 응용 프로그램을 유지 관리하기 어렵게 만드는 것을 방지하기위한 것입니다.

여기에 모든 경우가있는 것은 아닙니다. 변경을 원한다면 템플릿 (모든 세대를위한 단일 소스) 만 변경하면됩니다.

고유 한 사용자 정의 정의와 함께 사용하려면 생성 된 코드에 네임 스페이스 선언을 추가하고 (자체 구현을 정의 할 이름과 동일한 지 확인) 클래스를로 표시하십시오 partial. 그런 다음 템플릿 파일에 다음 줄을 추가하면 최종 컴파일에 포함됩니다.

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

솔직하게 말하자 : 이것은 꽤 멋지다.

면책 조항 :이 샘플은 Kevin Hazzard와 Manning Publications의 Jason Bock에 의해 .NET의 Metaprogramming에 크게 영향을 받았습니다 .

이에 대한 제약은 없습니다. 숫자 계산에 제네릭을 사용하려는 사람에게는 실제 문제입니다.

더 나아가서 우리가 필요하다고 말해

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

또는

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

불행히도 인터페이스, 기본 클래스 및 키워드 struct(값 유형 class이어야 함 ), (참조 유형이어야 함) 및 new()(기본 생성자가 있어야 함) 만 있습니다.

codeproject에서INullable<T> 와 같이 다른 것과 비슷한 것으로 숫자를 감쌀 수 있습니다 .

런타임에 연산자를 반영하거나 형식을 확인하여 제한을 적용 할 수 있지만 처음에는 제네릭을 사용하는 이점이 없습니다.

정책을 사용하는 해결 방법 :

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를 참조하십시오 . 구조를 .

이 질문은 약간의 FAQ이므로 wiki로 게시하고 있습니다. 어쨌든...

사용중인 .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 절에서만 struct를 지정할 수 있습니다. 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을 시작으로, 당신은 가까이 사용할 수있는 근사치를 - 관리되지 않는 제약은 유형 매개 변수가 아닌 포인터, 비 - 널 (NULL)로 지정 관리되지 않는 유형입니다.

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

관리되지 않는 제약 조건은 struct 제약 조건을 의미하며 struct 또는 new () 제약 조건과 결합 할 수 없습니다.

다음 유형 중 하나 인 유형은 관리되지 않는 유형입니다.

• sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal 또는 bool
• 모든 열거 형
• 모든 포인터 유형
• 관리되지 않는 형식의 필드 만 포함하고 C # 7.3 이하의 필드를 포함하는 사용자 정의 구조체 형식은 생성 된 형식이 아닙니다 (적어도 하나의 형식 인수를 포함하는 형식).

더 제한하고에서 IComparable 추가 구현하지 않는 포인터와 사용자 정의 형식 제거하기 에서 IComparable을 너무 IEquatable <T>를 추가하여 열거 제한 (만 열거 여전히에서 IComparable에서 파생, 당신은 당신의 상황에 따라 더 나아가 추가 인터페이스를 추가 할 수 있습니다. 관리되지 않으면이 목록을 더 짧게 유지할 수 있습니다.)

    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 에서 찾을 수 있습니다.

samjudson과 같은 것이 궁금합니다. 왜 정수 만입니까? 이 경우 도우미 클래스 또는 원하는 모든 유형을 보유 할 수있는 클래스를 만들 수 있습니다.

정수만 원하는 경우 제네릭을 사용하지 마십시오. 제네릭이 아닙니다. 또는 더 나은 방법으로 유형을 확인하여 다른 유형을 거부하십시오.

아직 '좋은'해결책은 없습니다. 그러나 Haacked가 위에서 보여준 것처럼 당신의 가정적인 '수치 적'제약에 대한 많은 미스 핏을 배제하기 위해 타입 인수를 크게 좁힐 수 있습니다.

static bool IntegerFunction <T> (T value) 여기서 T : IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T>, struct {...

.NET 4.0 이상을 사용하는 경우 dynamic 을 메소드 인수로 사용 하고 런타임 에서 전달 된 동적 인수 유형이 숫자 / 정수 유형인지 확인할 수 있습니다.

전달 된 동적 유형이 숫자 / 정수 유형 이 아닌 경우 예외를 처리하십시오.

아이디어를 구현하는 간단한 코드 예 는 다음과 같습니다.

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.
    }

물론이 솔루션은 런타임에서만 작동하지만 컴파일 시간에는 작동하지 않습니다.

당신은 항상 결코 런타임에 컴파일 시간에 작동하는 솔루션을 원하는 경우에 당신은 포장해야합니다 동적 누구의 과부하 공용 구조체 / 클래스 공개 생성자가 원하는 유형의 인수 만 허용하고 struct / class에 적절한 이름을 지정 .

랩핑 된 다이나믹 은 항상 클래스 / struct의 개인 멤버이며 구조체 / 클래스의 유일한 멤버이고 구조체 / 클래스의 유일한 멤버 이름은 "value"입니다.

필요한 경우 클래스 / 구조의 개인 동적 멤버에 대해 원하는 유형으로 작동 하는 공용 메소드 및 / 또는 연산자 를 정의하고 구현 해야합니다.

또한 구조체 / 클래스에는 "값"이라는 개인 동적 멤버 만 초기화하는 인수로 동적 을 허용하는 특수 / 고유 생성자가 있지만 이 생성자 의 수정자는 개인입니다. 물론 입니다.

클래스 / 구조가 준비되면 인수의 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 프레임 워크의 버전이 4.0 미만 / 미만 / 미만이고 동적 이 해당 버전에서 정의되지 않은 경우 대신 객체 를 사용 하고 정수 유형으로 캐스팅해야하므로 문제가 발생하므로 at을 사용하는 것이 좋습니다. 가능한 경우 .NET 4.0 이상을 사용하면 object 대신 동적 을 사용할 수 있습니다 .

불행히도 .NET은 기본적으로 그렇게 할 수있는 방법을 제공하지 않습니다.

이 문제를 해결하기 위해 OSS 라이브러리 Genumerics 를 만들었습니다.이 라이브러리 는 다음과 같은 내장 숫자 형식에 대한 대부분의 표준 숫자 연산과 다른 숫자 형식에 대한 지원을 추가 할 수있는 Null 허용 기능을 제공합니다.

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;
}

이 제한은 제네릭 형식에 대해 연산자를 오버로드하려고 할 때 영향을 미쳤습니다. "단수"제약이 없었고, 다른 이유 때문에 스택 오버 플로우에 능숙한 사람들이 기꺼이 제공 할 수 있기 때문에, 일반 유형에 대해서는 오퍼레이션을 정의 할 수 없습니다.

나는 같은 것을 원했다

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()방법). 이 접근 방식은 컴파일 타임 유형 검사와 관련된 이점을 잃어 버릴 수 있지만 여전히 권투 작업을 피하고 각 유형을 한 번만 "확인"해야합니다. 그 후에는 해당 유형과 관련된 작업이 대리자 파견으로 대체됩니다.

숫자 유형과 문자열을 처리해야하는 비슷한 상황이있었습니다. 약간 기괴한 믹스처럼 보이지만 거기에 있습니다.

다시 말하지만, 많은 사람들처럼 제약 조건을 살펴보고 지원해야 할 많은 인터페이스를 생각해 냈습니다. 그러나 a) 100 % 수밀이 아니었다. b)이 긴 제약 목록을보고있는 사람이라면 누구나 매우 혼란 스러울 것이다.

그래서 내 접근 방식은 모든 논리를 제약 조건없이 일반 메서드에 넣는 것이 아니라 해당 일반 메서드를 비공개로 만드는 것이 었습니다. 그런 다음 처리하려는 유형을 명시 적으로 처리하는 공개 메소드로 노출했습니다. 내 마음에 코드는 깨끗하고 명시 적입니다.

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 { ... }