Genel yöntemimi sayısal türlerle sınırlayan bir kısıtlama var mı?

Herkes jenerikler ile genel bir tür argümanını Tsadece sınırlamak için bir yol olup olmadığını söyleyebilir :

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

whereAnahtar kelimenin farkındayım , ancak yalnızca bu türler için bir arayüz bulamıyorum ,

Gibi bir şey:

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

C # bunu desteklemiyor. Hejlsberg, Bruce Eckel ile bir röportajda bu özelliğin uygulanmamasının nedenlerini açıkladı :

Eklenen karmaşıklığın, elde ettiğiniz küçük verime değeceği açık değildir. Yapmak istediğiniz bir şey kısıtlama sisteminde doğrudan desteklenmiyorsa, bunu bir fabrika modeliyle yapabilirsiniz. Matrix<T>Örneğin, bir noktaya sahip olabilirsiniz ve bunun Matrixiçin bir nokta ürün yöntemi tanımlamak istersiniz. Yani sonuçta ne kadar çarpın iki anlamamız gerekir araçlarının elbette Ten azından değilse, bir kısıtlama olarak söyleyemeyiz ler, ancak Tolduğu int, doubleya da float. Ama yapabileceğiniz şey, Matrixargüman olarak a Calculator<T>ve in Calculator<T>adlı bir yönteme sahip olmaktır multiply. Sen onu uygulamaya git ve onu geç Matrix.

Ancak, bu, kullanıcının kullanmak istedikleri Calculator<T>her biri için kendi uygulamalarını sağlaması gereken oldukça kıvrımlı bir koda yol açar T. Genişletilebilir olması gerekmediği sürece, yani intve gibi sabit sayıda türü desteklemek doubleistiyorsanız, nispeten basit bir arayüzle kurtulabilirsiniz:

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

( Bir GitHub Gist'te minimum uygulama. )

Ancak, kullanıcının kendi özel türlerini sağlayabilmesini istediğiniz anda, kullanıcının kendi Calculatorörneklerini sağlayabilmesi için bu uygulamayı açmanız gerekir . Örneğin, özel ondalık kayan nokta uygulaması kullanan bir matris başlatmak için DFPşu kodu yazmanız gerekir:

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

... ve tüm üyeleri uygulamak DfpCalculator : ICalculator<DFP>.

Ne yazık ki aynı sınırlamaları paylaşan bir alternatif, Sergey Shandar'ın cevabında tartışıldığı gibi politika sınıflarıyla çalışmaktır .

Bu sorunun popülaritesi ve böyle bir fonksiyonun arkasındaki ilgi göz önüne alındığında, henüz T4 ile ilgili bir cevap olmadığını görmek beni şaşırttı.

Bu örnek kodda, derleyici jeneriklerle sahnelerin arkasında hemen hemen ne yaptığını yapmak için güçlü şablonlama motorunu nasıl kullanabileceğinize dair çok basit bir örnek göstereceğim.

Çemberlerden geçmek ve derleme zamanı kesinliğinden ödün vermek yerine, istediğiniz her tür için istediğiniz işlevi üretebilir ve buna göre kullanabilirsiniz (derleme zamanında!).

Bunu yapmak için:

• GenericNumberMethodTemplate.tt adlı yeni bir Metin Şablonu dosyası oluşturun .
• Otomatik oluşturulan kodu kaldırın (çoğunu koruyacaksınız, ancak bazılarına gerek yoktur).
• Aşağıdaki snippet'i ekleyin:

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

Bu kadar. Artık işiniz bitti.

Bu dosyayı kaydetmek otomatik olarak bu kaynak dosyaya derler:

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

Senin içinde mainyöntemle size derleme zamanı kesinlik olduğunu doğrulayabilirsiniz:

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

Bir açıklamadan öteye geçeceğim: hayır, bu KURU prensibinin ihlali değildir. NEM ALMA ilkesi, uygulamanın birden fazla yerde kod kopyalamasını engellemek için uygulamanın korunmasını zorlaştırır.

Burada durum böyle değil: Eğer bir değişiklik istiyorsanız, sadece şablonu değiştirebilirsiniz (tüm nesil için tek bir kaynak!) Ve bitti.

Kendi özel tanımlarınızla kullanmak için, oluşturulan kodunuza bir ad alanı bildirimi ekleyin (kendi uygulamanızı tanımlayacağınızla aynı olduğundan emin olun) ve sınıfı olarak işaretleyin partial. Daha sonra, bu derlemeyi şablon dosyanıza ekleyin, böylece nihai derlemeye dahil edilir:

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

Dürüst olalım: Bu çok güzel.

Feragatname: Bu örnek, .NET'te Metaprogramming'den Kevin Hazzard ve Manning Publications'dan Jason Bock tarafından büyük ölçüde etkilendi .

Bunun için bir kısıtlama yok. Sayısal hesaplamalar için jenerik kullanmak isteyen herkes için gerçek bir konudur.

Daha ileri gidip ihtiyacımız olduğunu söylerdim

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

Ya da

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

Maalesef yalnızca arabirimleriniz, temel sınıflarınız ve anahtar kelimeleriniz struct(değer türü classolmalıdır ), (başvuru türü new()olmalıdır ) ve (varsayılan oluşturucuya sahip olmalıdır)

Numarayı burada kod projesinde olduğuINullable<T> gibi başka bir şeye (benzeri ) sarabilirsiniz .

Kısıtlamayı çalışma zamanında uygulayabilirsiniz (işleçleri yansıtarak veya türleri denetleyerek), ancak genel olarak jenerik olma avantajını kaybetmez.

Politikaları kullanarak geçici çözüm:

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

Algoritmalar:

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

}

Kullanımı:

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.

Çözüm derleme zamanı güvenlidir. CityLizard Framework , .NET 4.0 için derlenmiş bir sürüm sağlar. Dosya lib / NETFramework4.0 / CityLizard.Policy.dll'dir.

Nuget'te de mevcuttur: https://www.nuget.org/packages/CityLizard/ . Bkz. CityLizard.Policy.I yapısı.

Bu soru biraz SSS sorusudur, bu yüzden bunu wiki olarak gönderiyorum (daha önce benzer yayınladığım için, ancak bu daha eski bir soru); Neyse ...

Hangi .NET sürümünü kullanıyorsunuz? .NET 3.5 kullanıyorsanız , MiscUtil'de genel bir işleçler uygulaması var (serbest vs).

Bu, T Add<T>(T x, T y)farklı türlerde aritmetik gibi yöntemler ve diğer varyantlara sahiptir (DateTime + TimeSpan ) .

Ayrıca, tüm dahili, kaldırılmış ve ısmarlama operatörler için çalışır ve delege performans için önbelleğe alınır.

Bunun neden zor olduğu konusunda bazı ek bilgiler burada .

dynamic(4.0) türünün bu sorunu dolaylı olarak da çözdüğünü bilmek isteyebilirsiniz - ör.

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

Maalesef, yalnızca bu örnekte where yan tümcesinde yapı belirtebilirsiniz. Özellikle Int16, Int32, vb.

Tek çözüm maalesef sorunun derleme zamanında alınmasını önleyen bir çalışma zamanı kontrolü yapmaktır sanırım. Bu şöyle bir şey olurdu: -

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

Bu biraz çirkin biliyorum, ama en azından gerekli kısıtlamaları sağlar.

Bu uygulama için olası performans etkilerini de inceleyeceğim, belki de daha hızlı bir yol var.

Muhtemelen yapabileceğiniz en yakın şey

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

Aşağıdakileri yapabileceğinizden emin değilim

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

Bu kadar özel bir şey için, neden her tip için aşırı yüklenmeler değil, liste çok kısa ve muhtemelen daha az bellek kaplaması olacak.

C # 7.3 ile başlayarak, daha yakın bir yaklaşımı kullanabilirsiniz - bir type parametresinin işaretçi olmayan, nullable olmayan yönetilmeyen bir tür olduğunu belirtmek için yönetilmeyen kısıtlama .

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

Yönetilmeyen kısıtlama, yapı kısıtlamasını ima eder ve struct veya new () kısıtlamaları ile birleştirilemez.

Aşağıdaki türlerden herhangi biri varsa, tür yönetilmeyen bir türdür:

• sbyte, bayt, kısa, kısa, int, uint, uzun, ulong, karakter, kayan nokta, çift, ondalık veya bool
• Herhangi bir numaralandırma türü
• Herhangi bir işaretçi türü
• Yalnızca yönetilmeyen türlerde alanlar içeren ve C # 7.3 ve önceki sürümlerde, kullanıcı tanımlı herhangi bir yapı türü yapılandırılmış bir tür değildir (en az bir tür bağımsız değişkeni içeren bir tür)

Daha da kısıtlamak ve ıcomparable eklenti uygulamak gerekmez işaretçi ve kullanıcı tanımlı türlerini ortadan kaldırmak için IComparable yüzden IEquatable <T> ekleyerek enum kısıtlamak, (ancak enum hala IComparable türetilmiştir, kendi koşullara bağlı ileri gidip ve ek arayüzleri ekleyebilirsiniz. yönetilmeyen bu listenin daha kısa tutulmasına izin verir):

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

Şablonları türlerle sınırlamanın bir yolu yoktur, ancak türe göre farklı eylemler tanımlayabilirsiniz. Genel bir sayısal paketin parçası olarak, iki değer eklemek için genel bir sınıfa ihtiyacım vardı.

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

Yazım hatalarının derleme zamanında değerlendirildiğini, bu nedenle if ifadelerinin derleyici tarafından kaldırılacağını unutmayın. Derleyici ayrıca sahte yayınları da kaldırır. Yani derleyici bir şey çözmek için

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

Bu sorunları çözmek için küçük bir kütüphane işlevi oluşturdum:

Onun yerine:

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.

Yazabilirsiniz:

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.

Kaynak kodu burada bulabilirsiniz: /codereview/26022/improvement-requested-for-generic-calculator-and-generic-number

Samjudson ile aynı şeyi merak ediyordum, neden sadece tamsayılara? ve durum böyleyse, istediğiniz tüm türleri tutmak için yardımcı bir sınıf veya bunun gibi bir şey oluşturmak isteyebilirsiniz.

Tüm istediğiniz tamsayılarsa, genel değil, genel değil; veya daha iyisi, türünü kontrol ederek başka herhangi bir türü reddedin.

Bunun için henüz 'iyi' bir çözüm yok. Bununla birlikte, Haacked'in yukarıda gösterdiği gibi hipotetik 'INumeric' kısıtlamanız için birçok missfits'i ekarte etmek için tür argümanını önemli ölçüde daraltabilirsiniz.

statik bool IntegerFunction <T> (T değeri) burada T: IComparable, IFormattable, IConvertible, IComparable <T>, IEquatable <T>, struct {...

.NET 4.0 ve sonraki bir sürümü kullanıyorsanız, dinamik olarak yöntem bağımsız değişkeni olarak kullanabilirsiniz ve çalışma zamanında geçirilen dinamik bağımsız değişken türünün sayısal / tamsayı türü olup olmadığını denetleyebilirsiniz .

Geçti türü ise dinamiği olduğunu değil sayısal / tamsayı tipi sonra istisna.

Fikri uygulayan örnek bir kısa kod şöyledir:

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

Tabii ki bu çözüm sadece çalışma zamanında çalışır ancak derleme zamanında asla çalışmaz.

Her zaman derleme zamanında çalışan ve asla çalışma zamanında çalışmayan bir çözüm istiyorsanız, dinamiği aşırı yüklenmiş genel kurucuları yalnızca istenen türdeki argümanları kabul eden ve yapı / sınıfa uygun ad veren bir genel yapı / sınıfla sarmanız gerekir .

Sarılmış dinamiğin her zaman sınıf / yapıya özel üye olması ve yapı / sınıfın tek üyesi olması ve yapı / sınıfın tek üyesinin adı "değer" olması mantıklıdır .

Ayrıca, gerekirse sınıfın / yapının özel dinamik üyesi için istenen türlerle çalışan genel yöntemleri ve / veya işleçleri tanımlamanız ve uygulamanız gerekir.

Ayrıca yapı / sınıf vardır mantıklı özel / benzersiz kabul yapıcı dinamiğini o "değer" olarak adlandırılan tek özel dinamik üyesi ama başlatır argüman olarak değiştirici bu yapıcı taşımaktadır özel tabii ki.

Class / struct hazır olduğunda, argümanın IntegerFunction türünü tanımlanan sınıf / struct olarak tanımlayın.

Fikri uygulayan örnek bir uzun kod şuna benzer:

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

Kodunuzda dinamik kullanmak için Microsoft.CSharp'a Başvuru Eklemeniz gerektiğini unutmayın

.NET çerçevesinin sürümü 4.0'ın altında / altında / altındaysa ve dinamik bu sürümde tanımlanmamışsa, bunun yerine nesneyi kullanmanız ve tamsayı türüne döküm yapmanız gerekir, bu da sorun olduğunu, en az .NET 4.0 veya daha yeniyse, nesne yerine dinamik kullanabilirsiniz .

Ne yazık ki .NET bunu yerel olarak yapmanın bir yolunu sunmuyor.

Bu sorunu gidermek için, aşağıdaki yerleşik sayısal türler ve nullable eşdeğerleri için diğer sayısal türler için destek ekleme özelliğine sahip en standart sayısal işlemleri sağlayan OSS kütüphanesi Genumerics'i oluşturdum .

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

Performans, verimli genel sayısal algoritmalar oluşturmanıza olanak tanıyan sayısal türe özgü bir çözümle eşdeğerdir.

İşte kod kullanımına bir örnek.

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

Egzersizin amacı nedir?

İnsanların zaten işaret ettiği gibi, en büyük öğeyi alan jenerik olmayan bir işleve sahip olabilirsiniz ve derleyici sizin için otomatik olarak daha küçük girişleri dönüştürür.

static bool IntegerFunction(Int64 value) { }

İşleviniz performans açısından kritik bir yoldaysa (çok düşük bir olasılıkla IMO), tüm gerekli işlevler için aşırı yükler sağlayabilirsiniz.

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

Ben dışsal ele verebilir genel bir kullanmak istiyorsunuz ...

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

Bu sınırlama, genel türler için işleçleri aşırı yüklemeye çalıştığımda beni etkiledi; "INumeric" kısıtlaması olmadığından ve diğer nedenlerden ötürü yığın akışı üzerindeki iyi insanlara sunmaktan mutluluk duyduklarından, işlemler genel türler üzerinde tanımlanamaz.

Gibi bir şey istedim

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

Bu sorun, .net4 dinamik çalışma zamanı yazarak kullanarak çalıştım.

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

Kullanmayla dynamicilgili iki şey

1. Verim. Tüm değer türleri kutucuklanır.
2. Çalışma zamanı hataları. Derleyiciyi "yenersiniz", ancak tip güvenliğini kaybedersiniz. Genel tipte işleç tanımlanmamışsa, yürütme sırasında bir istisna atılır.

.NET sayısal ilkel türleri, hesaplamalarda kullanılmasına izin verecek ortak bir arabirimi paylaşmaz. Kendi arayüzler (örneğin tanımlamak mümkün olacağını ISignedWholeNumber) bu tür işlemleri gerçekleştirmek hangi tek ihtiva yapılarını tanımlamak Int16, Int32vb ve bu arabirimleri uygulayan ve ardından kısıtlı jenerik türlerini kabul yöntemleri varISignedWholeNumber , fakat sayısal değerler dönüştürmek zorunda yapı türlerinize büyük olasılıkla bir sıkıntı olacaktır.

Alternatif bir yaklaşım, statik sınıfını tanımlamak olacaktır Int64Converter<T>statik özellik ile bool Available {get;};ve statik delegeleri Int64 GetInt64(T value), T FromInt64(Int64 value), bool TryStoreInt64(Int64 value, ref T dest). Sınıf yapıcısı, bilinen türler için delegeleri yüklemek için sabit kodlanmış olabilir ve muhtemelen türün Työntemleri doğru adlarla ve imzalarla uygulayıp uygulamadığını sınamak için (örneğin Int64, bir sayıyı içeren ve bir sayıyı içeren ancak özel bir ToString()yöntem). Bu yaklaşım, derleme zamanı tür denetlemesiyle ilişkili avantajları kaybeder, ancak yine de boks işlemlerinden kaçınmayı başarır ve her türün yalnızca bir kez "denetlenmesi" gerekir. Bundan sonra, bu türle ilişkili işlemler bir temsilci gönderimi ile değiştirilir.

Ben sayısal türleri ve dizeleri ele gerekiyordu benzer bir durum vardı; biraz tuhaf bir karışım gibi görünüyor ama işte böyle.

Yine, birçok insan gibi, kısıtlamalara baktım ve desteklemesi gereken bir grup arayüz buldum. Bununla birlikte, a)% 100 su geçirmez değildi ve b), bu uzun kısıtlama listesine bakan yeni herkes hemen çok karışık olurdu.

Bu yüzden benim yaklaşımım, tüm mantığımı herhangi bir kısıtlama olmaksızın genel bir yönteme koymak, ancak genel yöntemi özel yapmaktı. Sonra genel yöntemlerle maruz, bir açıkça ele almak istediğim türü işleme - aklımda, kod temiz ve açık, eg

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
}

İstediğiniz tek bir sayısal tür kullanmaksa , C ++ ile bir diğer ada benzer bir şey oluşturmayı düşünebilirsiniz using.

Yani çok genel bir

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

sahip olabilirsin

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