Is there a constraint that restricts my generic method to numeric types

Question

Can anyone tell me if there is a way with generics to limit a generic type argument T to only    Int16 Int32 Int64 UInt16 UInt32 UInt64   I m aware of the where keyword  but can t find an interface for only these types   Something like   static bool IntegerFunction lt T gt  T value  where T   INumeric

User · Answer

There is no way to restrict templates to types, but you can define different actions based on the type. As part of a generic numeric package, I needed a generic class to add two values.

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

Note that the typeofs are evaluated at compile time, so the if statements would be removed by the compiler. The compiler also removes spurious casts. So Something would resolve in the compiler to

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

User · Answer

I had a similar situation where I needed to handle numeric types and strings  seems a bit of a bizarre mix but there you go   Again  like many people I looked at constraints and came up with a bunch of interfaces that it had to support   However  a  it wasn t 100  watertight and b   anyone new looking at this long list of constraints would be immediately very confused   So  my approach was to put all my logic into a generic method with no constraints  but to make that generic method private   I then exposed it with public methods  one explicitly handling the type I wanted to handle - to my mind  the code is clean and explicit  e g   public static string DoSomething this int input         gt  DoSomethingHelper input        public static string DoSomething this decimal input         gt  DoSomethingHelper input        public static string DoSomething this double input         gt  DoSomethingHelper input        public static string DoSomething this string input         gt  DoSomethingHelper input         private static string DoSomethingHelper lt T gt  this T input                 complex logic

User · Answer

What is the point of the exercise   As people pointed out already  you could have a non-generic function taking the largest item  and compiler will automatically convert up smaller ints for you    static bool IntegerFunction Int64 value        If your function is on performance-critical path  very unlikely  IMO   you could provide overloads for all needed functions   static bool IntegerFunction Int64 value          static bool IntegerFunction Int16 value

User · Answer

Considering the popularity of this question and the interest behind such a function I am surprised to see that there is no answer involving T4 yet   In this sample code I will demonstrate a very simple example of how you can use the powerful templating engine to do what the compiler pretty much does behind the scenes with generics   Instead of going through hoops and sacrificing compile-time certainty you can simply generate the function you want for every type you like and use that accordingly  at compile time     In order to do this     Create a new Text Template file called GenericNumberMethodTemplate tt   Remove the auto-generated code  you ll keep most of it  but some isn t needed   Add the following snippet     lt    template language  C     gt   lt    output extension   cs    gt   lt    assembly name  System Core    gt    lt   Type   types   new         typeof Int16   typeof Int32   typeof Int64       typeof UInt16   typeof UInt32   typeof UInt64           gt   using System  public static class MaxMath        lt   foreach  var type in types           gt          public static  lt    type Name   gt  Max   lt    type Name   gt  val1   lt    type Name   gt  val2                return val1  gt  val2   val1   val2                 lt           gt      That s it  You re done now   Saving this file will automatically compile it to this source file   using System  public static class MaxMath       public static Int16 Max  Int16 val1  Int16 val2            return val1  gt  val2   val1   val2            public static Int32 Max  Int32 val1  Int32 val2            return val1  gt  val2   val1   val2            public static Int64 Max  Int64 val1  Int64 val2            return val1  gt  val2   val1   val2            public static UInt16 Max  UInt16 val1  UInt16 val2            return val1  gt  val2   val1   val2            public static UInt32 Max  UInt32 val1  UInt32 val2            return val1  gt  val2   val1   val2            public static UInt64 Max  UInt64 val1  UInt64 val2            return val1  gt  val2   val1   val2            In your main method you can verify that you have compile-time certainty   namespace TTTTTest       class Program               static void Main string   args                        long val1   5L              long val2   10L              Console WriteLine MaxMath Max val1  val2                Console Read                          I ll get ahead of one remark  no  this is not a violation of the DRY principle  The DRY principle is there to prevent people from duplicating code in multiple places that would cause the application to become hard to maintain   This is not at all the case here  if you want a change then you can just change the template  a single source for all your generation   and it s done   In order to use it with your own custom definitions  add a namespace declaration  make sure it s the same one as the one where you ll define your own implementation  to your generated code and mark the class as partial  Afterwards  add these lines to your template file so it will be included in the eventual compilation    lt    import namespace  TheNameSpaceYouWillUse    gt   lt    assembly name    TargetPath     gt    Let s be honest  This is pretty cool   Disclaimer  this sample has been heavily influenced by Metaprogramming in  NET by Kevin Hazzard and Jason Bock  Manning Publications

User · Answer

Beginning with C  7 3  you can use closer approximation - the unmanaged constraint to specify that a type parameter is a non-pointer  non-nullable unmanaged type  class SomeGeneric lt T gt  where T   unmanaged            The unmanaged constraint implies the struct constraint and can t be combined with either the struct or new   constraints  A type is an unmanaged type if it s any of the following types   sbyte  byte  short  ushort  int  uint  long  ulong  char  float  double  decimal  or bool Any enum type Any pointer type Any user-defined struct type that contains fields of unmanaged types only and  in C  7 3 and earlier  is not a constructed type  a type that includes at least one type argument   To restrict further and eliminate pointer and user-defined types that do not implement IComparable add IComparable  but enum is still derived from IComparable  so restrict enum by adding IEquatable  lt  T  gt   you can go further depending on your circumstances and add additional interfaces  unmanaged allows to keep this list shorter       class SomeGeneric lt T gt  where T   unmanaged  IComparable  IEquatable lt T gt                         But this doesn t prevent from DateTime instantiation

User · Answer

I was wondering the same as samjudson  why only to integers  and if that is the case  you might want to create a helper class or something like that to hold all the types you want   If all you want are integers  don t use a generic  that is not generic  or better yet  reject any other type by checking its type

User · Answer

Unfortunately you are only able to specify struct in the where clause in this instance  It does seem strange you can t specify Int16  Int32  etc  specifically but I m sure there s some deep implementation reason underlying the decision to not permit value types in a where clause   I guess the only solution is to do a runtime check which unfortunately prevents the problem being picked up at compile time  That d go something like -  static bool IntegerFunction lt T gt  T value  where T   struct     if  typeof T     typeof Int16    amp  amp        typeof T     typeof Int32    amp  amp        typeof T     typeof Int64    amp  amp        typeof T     typeof UInt16   amp  amp        typeof T     typeof UInt32   amp  amp        typeof T     typeof UInt64         throw new ArgumentException        string Format  Type   0   is not valid    typeof T  ToString                Rest of code        Which is a little bit ugly I know  but at least provides the required constraints   I d also look into possible performance implications for this implementation  perhaps there s a faster way out there

User · Answer

If all you want is use one numeric type  you could consider creating something similar to an alias in C   with using   So instead of having the very generic  T ComputeSomething lt T gt  T value1  T value2  where T   INumeric           you could have  using MyNumType   System Double  T ComputeSomething lt MyNumType gt  MyNumType value1  MyNumType value2            That might allow you to easily go from double to int or others if needed  but you wouldn t be able to use ComputeSomething with double and int in the same program   But why not replace all double to int then  Because your method may want to use a double whether the input is double or int  The alias allows you to know exactly which variable uses the dynamic type

User · Answer

Probably the closest you can do is   static bool IntegerFunction lt T gt  T value  where T  struct   Not sure if you could do the following  static bool IntegerFunction lt T gt  T value  where T  struct  IComparable   IFormattable  IConvertible  IComparable lt T gt   IEquatable lt T gt    For something so specific  why not just have overloads for each type  the list is so short and it would possibly have less memory footprint

User · Answer

Topic is old but for future readers   This feature is tightly related to Discriminated Unions which is not implemented in C  so far  I found its issue here   https   github com dotnet csharplang issues 113  This issue is still open and feature has been planned for C  10  So still we have to wait a bit more  but after releasing you can do it this way   static bool IntegerFunction lt T gt  T value  where T   Int16   Int32   Int64

User · Answer

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   An alternative approach would be to define static class Int64Converter lt T gt  with a static property bool Available  get    and static delegates for Int64 GetInt64 T value   T FromInt64 Int64 value   bool TryStoreInt64 Int64 value  ref T dest    The class constructor could use be hard-coded to load delegates for known types  and possibly use Reflection to test whether type T implements methods with the proper names and signatures  in case it s something like a struct which contains an Int64 and represents a number  but has a custom ToString   method    This approach would lose the advantages associated with compile-time type-checking  but would still manage to avoid boxing operations and each type would only have to be  checked  once   After that  operations associated with that type would be replaced with a delegate dispatch

User · Answer

This limitation affected me when I tried to overload operators for generic types  since there was no  INumeric  constraint  and for a bevy of other reasons the good people on stackoverflow are happy to provide  operations cannot be defined on generic types   I wanted something like  public struct Foo lt T gt        public T Value  get  private set         public static Foo lt T gt  operator   Foo lt T gt  LHS  Foo lt T gt  RHS                return new Foo lt T gt    Value   LHS Value   RHS Value               I have worked around this issue using  net4 dynamic runtime typing     public struct Foo lt T gt        public T Value   get  private set         public static Foo lt T gt  operator   Foo lt T gt  LHS  Foo lt T gt  RHS                return new Foo lt T gt    Value   LHS Value    dynamic RHS Value              The two things about using dynamic are    Performance   All value types get boxed  Runtime errors   You  beat  the compiler  but lose type safety   If the generic type doesn t have the operator defined  an exception will be thrown during execution

User · Answer

If you are using  NET 4 0 and later then you can just use dynamic as method argument and check in runtime that the passed dynamic argument type is numeric integer type   If the type of the passed dynamic is not numeric integer type then throw exception   An example short code that implements the idea is something like   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   amp  amp              n GetType      typeof Int32   amp  amp              n GetType      typeof Int64   amp  amp              n GetType      typeof UInt16   amp  amp              n GetType      typeof UInt32   amp  amp              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          Of course that this solution works in run time only but never in compile time   If you want a solution that always works in compile time and never in run time then you will have to wrap the dynamic with a public struct class whose overloaded public constructors accept arguments of the desired types only and give the struct class appropriate name   It makes sense that the wrapped dynamic is always private member of the class struct and it is the only member of the struct class and the name of the only member of the struct class is  value    You will also have to define and implement public methods and or operators that work with the desired types for the private dynamic member of the class struct if necessary   It also makes sense that the struct class has special unique constructor that accepts dynamic as argument that initializes it s only private dynamic member called  value  but the modifier of this constructor is private of course   Once the class struct is ready define the argument s type of IntegerFunction to be that class struct that has been defined   An example long code that implements the idea is something like   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  gt  Integer x  Int16 y    return x value  gt  y        public static bool operator  lt  Integer x  Int16 y    return x value  lt  y        public static bool operator  gt  Integer x  Int32 y    return x value  gt  y        public static bool operator  lt  Integer x  Int32 y    return x value  lt  y        public static bool operator  gt  Integer x  Int64 y    return x value  gt  y        public static bool operator  lt  Integer x  Int64 y    return x value  lt  y        public static bool operator  gt  Integer x  UInt16 y    return x value  gt  y        public static bool operator  lt  Integer x  UInt16 y    return x value  lt  y        public static bool operator  gt  Integer x  UInt32 y    return x value  gt  y        public static bool operator  lt  Integer x  UInt32 y    return x value  lt  y        public static bool operator  gt  Integer x  UInt64 y    return x value  gt  y        public static bool operator  lt  Integer x  UInt64 y    return x value  lt  y        public static bool operator  gt  Integer x  Integer y    return x value  gt  y value        public static bool operator  lt  Integer x  Integer y    return x value  lt  y value        public static bool operator  gt   Integer x  Int16 y    return x value  gt   y        public static bool operator  lt   Integer x  Int16 y    return x value  lt   y        public static bool operator  gt   Integer x  Int32 y    return x value  gt   y        public static bool operator  lt   Integer x  Int32 y    return x value  lt   y        public static bool operator  gt   Integer x  Int64 y    return x value  gt   y        public static bool operator  lt   Integer x  Int64 y    return x value  lt   y        public static bool operator  gt   Integer x  UInt16 y    return x value  gt   y        public static bool operator  lt   Integer x  UInt16 y    return x value  lt   y        public static bool operator  gt   Integer x  UInt32 y    return x value  gt   y        public static bool operator  lt   Integer x  UInt32 y    return x value  lt   y        public static bool operator  gt   Integer x  UInt64 y    return x value  gt   y        public static bool operator  lt   Integer x  UInt64 y    return x value  lt   y        public static bool operator  gt   Integer x  Integer y    return x value  gt   y value        public static bool operator  lt   Integer x  Integer y    return x value  lt   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  gt  Int16 x  Integer y    return x  gt  y value        public static bool operator  lt  Int16 x  Integer y    return x  lt  y value        public static bool operator  gt  Int32 x  Integer y    return x  gt  y value        public static bool operator  lt  Int32 x  Integer y    return x  lt  y value        public static bool operator  gt  Int64 x  Integer y    return x  gt  y value        public static bool operator  lt  Int64 x  Integer y    return x  lt  y value        public static bool operator  gt  UInt16 x  Integer y    return x  gt  y value        public static bool operator  lt  UInt16 x  Integer y    return x  lt  y value        public static bool operator  gt  UInt32 x  Integer y    return x  gt  y value        public static bool operator  lt  UInt32 x  Integer y    return x  lt  y value        public static bool operator  gt  UInt64 x  Integer y    return x  gt  y value        public static bool operator  lt  UInt64 x  Integer y    return x  lt  y value        public static bool operator  gt   Int16 x  Integer y    return x  gt   y value        public static bool operator  lt   Int16 x  Integer y    return x  lt   y value        public static bool operator  gt   Int32 x  Integer y    return x  gt   y value        public static bool operator  lt   Int32 x  Integer y    return x  lt   y value        public static bool operator  gt   Int64 x  Integer y    return x  gt   y value        public static bool operator  lt   Int64 x  Integer y    return x  lt   y value        public static bool operator  gt   UInt16 x  Integer y    return x  gt   y value        public static bool operator  lt   UInt16 x  Integer y    return x  lt   y value        public static bool operator  gt   UInt32 x  Integer y    return x  gt   y value        public static bool operator  lt   UInt32 x  Integer y    return x  lt   y value        public static bool operator  gt   UInt64 x  Integer y    return x  gt   y value        public static bool operator  lt   UInt64 x  Integer y    return x  lt   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            Note that in order to use dynamic in your code you must Add Reference to Microsoft CSharp  If the version of the  NET framework is below under lesser than 4 0 and dynamic is undefined in that version then you will have to use object instead and do casting to the integer type  which is trouble  so I recommend that you use at least  NET 4 0 or newer if you can so you can use dynamic instead of object

User · Answer

There s no constraint for this  It s a real issue for anyone wanting to use generics for numeric calculations   I d go further and say we need  static bool GenericFunction lt T gt  T value       where T   operators     -           Or even  static bool GenericFunction lt T gt  T value       where T   Add  Subtract   Unfortunately you only have interfaces  base classes and the keywords struct  must be value-type   class  must be reference type  and new    must have default constructor   You could wrap the number in something else  similar to INullable lt T gt   like here on codeproject     You could apply the restriction at runtime  by reflecting for the operators or checking for types  but that does lose the advantage of having the generic in the first place

User · Answer

Workaround using policies   interface INumericPolicy lt T gt        T Zero        T Add T a  T b          add more functions here  such as multiplication etc     struct NumericPolicies      INumericPolicy lt int gt       INumericPolicy lt long gt         add more INumericPolicy lt  gt  for different numeric types        int INumericPolicy lt int gt  Zero     return 0        long INumericPolicy lt long gt  Zero     return 0        int INumericPolicy lt int gt  Add int a  int b    return a   b        long INumericPolicy lt long gt  Add long a  long b    return a   b           implement all functions from INumericPolicy lt  gt  interfaces       public static NumericPolicies Instance   new NumericPolicies        Algorithms   static class Algorithms       public static T Sum lt P  T gt  this P p  params T   a          where P  INumericPolicy lt T gt                var r   p Zero            foreach var i in a                        r   p Add r  i                     return r             Usage   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    The solution is compile-time safe  CityLizard Framework provides compiled version for  NET 4 0  The file is lib NETFramework4 0 CityLizard Policy dll   It s also available in Nuget  https   www nuget org packages CityLizard   See CityLizard Policy I structure

User · Answer

This question is a bit of a FAQ one  so I m posting this as wiki  since I ve posted similar before  but this is an older one   anyway    What version of  NET are you using  If you are using  NET 3 5  then I have a generic operators implementation in MiscUtil  free etc   This has methods like T Add lt T gt  T x  T y   and other variants for arithmetic on different types  like DateTime   TimeSpan   Additionally  this works for all the inbuilt  lifted and bespoke operators  and caches the delegate for performance  Some additional background on why this is tricky is here  You may also want to know that dynamic  4 0  sort-of solves this issue indirectly too - i e  dynamic x        y       dynamic result   x   y     does what you expect

User · Answer

Unfortunately  NET doesn t provide a way to do that natively   To address this issue I created the OSS library Genumerics which provides most standard numeric operations for the following built-in numeric types and their nullable equivalents with the ability to add support for other numeric types   sbyte  byte  short  ushort  int  uint  long  ulong  float  double  decimal  and BigInteger  The performance is equivalent to a numeric type specific solution allowing you to create efficient generic numeric algorithms   Here s an example of the code usage   public static T Sum T   items        T sum   Number Zero lt T gt         foreach  T item in items                sum   Number Add sum  item             return sum      public static T SumAlt T   items           implicit conversion to Number lt T gt      Number lt T gt  sum   Number Zero lt T gt         foreach  T item in items                   operator support         sum    item               implicit conversion to T     return sum

User · Answer

I created a little library functionality to solve these problems   Instead of   public T DifficultCalculation lt T gt  T a  T b        T result   a   b   a      lt    WILL NOT COMPILE      return result    Console WriteLine DifficultCalculation 2  3       Should result in 8    You could write   public T DifficultCalculation lt T gt  Number lt T gt  a  Number lt T gt  b        Number lt T gt  result   a   b   a      return  T result    Console WriteLine DifficultCalculation 2  3       Results in 8    You can find the source code here  https   codereview stackexchange com questions 26022 improvement-requested-for-generic-calculator-and-generic-number

User · Answer

There is no  good  solution for this yet  However you can narrow the type argument significantly to rule out many missfits for your hypotetical  INumeric  constraint as Haacked has shown above   static bool IntegerFunction lt T gt  T value  where T  IComparable  IFormattable  IConvertible  IComparable lt T gt   IEquatable lt T gt   struct

User · Answer

C  does not support this  Hejlsberg has described the reasons for not implementing the feature in an interview with Bruce Eckel      And it s not clear that the added complexity is worth the small yield that you get  If something you want to do is not directly supported in the constraint system  you can do it with a factory pattern  You could have a Matrix lt T gt   for example  and in that Matrix you would like to define a dot product method  That of course that means you ultimately need to understand how to multiply two Ts  but you can t say that as a constraint  at least not if T is int  double  or float  But what you could do is have your Matrix take as an argument a Calculator lt T gt   and in Calculator lt T gt   have a method called multiply  You go implement that and you pass it to the Matrix    However  this leads to fairly convoluted code  where the user has to supply their own Calculator lt T gt  implementation  for each T that they want to use  As long as it doesn   t have to be extensible  i e  if you just want to support a fixed number of types  such as int and double  you can get away with a relatively simple interface   var mat   new Matrix lt int gt  w  h      Minimal implementation in a GitHub Gist    However  as soon as you want the user to be able to supply their own  custom types  you need to open up this implementation so that the user can supply their own Calculator instances  For instance  to instantiate a matrix that uses a custom decimal floating point implementation  DFP  you   d have to write this code   var mat   new Matrix lt DFP gt  DfpCalculator Instance  w  h         and implement all the members for DfpCalculator   ICalculator lt DFP gt    An alternative  which unfortunately shares the same limitations  is to work with policy classes  as discussed in Sergey Shandar   s answer

User · Answer

I would use a generic one which you could handle externaly          lt summary gt      Generic object copy of the same type      lt  summary gt       lt typeparam name  T  gt The type of object to copy lt  typeparam gt       lt param name  ObjectSource  gt The source object to copy lt  param gt  public T CopyObject lt T gt  T ObjectSource        T NewObject   System Activator CreateInstance lt T gt          foreach  PropertyInfo p in ObjectSource GetType   GetProperties            NewObject GetType   GetProperty p Name  SetValue NewObject  p GetValue ObjectSource  null   null        return NewObject

[c#] Is there a constraint that restricts my generic method to numeric types?

Examples related to c#

Examples related to generics

Examples related to constraints