development

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

big-blog 2020. 3. 2. 13:10
반응형

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

제네릭을 사용하여 제네릭 형식 인수 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.Policy.I 구조를 참조하십시오 .

이 질문은 약간의 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>

특정 유형의 경우 각 유형마다 과부하가 발생하지 않는 이유는 목록이 너무 짧고 메모리 사용량이 적을 수 있습니다.

템플릿을 유형으로 제한하는 방법은 없지만 유형에 따라 다른 동작을 정의 할 수 있습니다. 일반 숫자 패키지의 일부로 두 값을 추가하려면 일반 클래스가 필요했습니다.

    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.

https://codereview.stackexchange.com/questions/26022/improvement-requested-for-generic-calculator-and-generic-number 에서 소스 코드를 찾을 수 있습니다.

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

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

.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에 적절한 이름을 지정 하는 public 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 대신 dynamic 을 사용할 수 있습니다 .

운동의 요점은 무엇입니까?

사람들이 이미 지적했듯이 가장 일반적인 항목을 사용하는 비 제네릭 함수를 사용할 수 있으며 컴파일러는 자동으로 작은 정수를 변환합니다. 

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. 런타임 오류. 컴파일러를 "이길"그러나 형식 안전성이 손실됩니다. 제네릭 형식에 연산자가 정의되어 있지 않으면 실행 중에 예외가 발생합니다.

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

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

The .NET numeric primitive types do not share any common interface that would allow them to be used for calculations. It would be possible to define your own interfaces (e.g. ISignedWholeNumber) which would perform such operations, define structures which contain a single Int16, Int32, etc. and implement those interfaces, and then have methods which accept generic types constrained to ISignedWholeNumber, but having to convert numeric values to your structure types would likely be a nuisance.

다른 방법은 Int64Converter<T>정적 속성 bool Available {get;};과 Int64 GetInt64(T value),, T FromInt64(Int64 value)에 대한 정적 대리자를 사용하여 정적 클래스를 정의하는 것 bool TryStoreInt64(Int64 value, ref T dest)입니다. 클래스 생성자는 알려진 형식의 델리게이트를로드하기 위해 하드 코딩을 사용할 수 있으며 Reflection을 사용하여 형식 T이 올바른 이름과 서명을 사용하여 메서드를 구현 하는지 테스트 할 수 있습니다 ( Int64그리고 숫자 를 포함 하고 숫자를 나타내는 구조체와 같은 것이지만 사용자 정의 ToString()방법). 이 접근 방식은 컴파일 타임 유형 검사와 관련된 이점을 잃어 버릴 수 있지만 여전히 권투 작업을 피하고 각 유형을 한 번만 "확인"해야합니다. 그 후에는 해당 유형과 관련된 작업이 대리자 파견으로 대체됩니다.

원하는 것이 하나의 숫자 유형을 사용하는 경우 C ++에서와 함께 별명과 비슷한 것을 만드는 것을 고려할 수 using있습니다.

따라서 매우 일반적인 대신

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

당신은 할 수 있었다

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

그것은 당신이 쉽게에서 이동 할 수 있습니다 double에 int또는 다른 필요한 경우,하지만 당신은 사용할 수 없을 것 ComputeSomething와 double와 int같은 프로그램에서.

그렇다면 왜 모든 double것을 대체하지 int않습니까? 귀하의 방법은 double입력이 double또는 인지 여부 를 사용하려고 할 수 있습니다 int. 별명을 사용하면 동적 유형을 사용하는 변수를 정확하게 알 수 있습니다 .

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

다시 말하지만, 많은 사람들처럼 제약 조건을 살펴보고 지원해야 할 많은 인터페이스를 생각해 냈습니다. 그러나 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
}

모두 상속하는 단일 인터페이스 또는 기본 클래스가 없으므로 (다른 클래스에서도 상속되지 않음) 간단한 대답은 아니요입니다.

나는 이것이 왜 문제인지 궁금합니다. IntegerFunction 클래스 내에서 정수로만 수행 할 수있는 작업은 무엇입니까?

나는 당신이 제네릭을 오해하고 있다고 생각합니다. 수행하려는 작업이 특정 데이터 유형에만 적합하면 "일반적인"작업을 수행하지 않는 것입니다.

또한 함수가 int 데이터 유형에서만 작동하도록하려는 경우 특정 크기마다 별도의 함수가 필요하지 않습니다. 가장 큰 특정 유형의 매개 변수를 사용하면 프로그램에서 더 작은 데이터 유형을 자동으로 업 캐스트 할 수 있습니다. (즉, Int16을 전달하면 호출 할 때 Int64로 자동 변환됩니다).

함수에 전달되는 int의 실제 크기에 따라 다른 작업을 수행하는 경우 수행중인 작업을 수행하려고 시도하더라도 심각하게 재고해야한다고 생각합니다. 언어를 속 여야하는 경우 원하는 것을하는 방법보다는 성취하려는 것에 대해 조금 더 생각해야합니다.

그렇지 않으면 Object 유형의 매개 변수를 사용할 수 있으므로 매개 변수 유형을 확인하고 적절한 조치를 취하거나 예외를 처리해야합니다.

참고 URL : https://stackoverflow.com/questions/32664/is-there-a-constraint-that-restricts-my-generic-method-to-numeric-types



반응형

'development' 카테고리의 다른 글

UITableView에서 빈 셀을 제거하는 방법은 무엇입니까?  (0) 2020.03.02
선행 및 후행 공백을 자르는 방법?  (0) 2020.03.02
복사 제거 및 반환 값 최적화 란 무엇입니까?  (0) 2020.03.02
MySQL에서 하나를 제외한 모든 열을 선택 하시겠습니까?  (0) 2020.03.02
objectForKey와 valueForKey의 차이점은 무엇입니까?  (0) 2020.03.02

'development'의 다른글

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

관련글

댓글

티스토리툴바