Can t operator be applied to generic types in C

Question

According to the documentation of the    operator in MSDN       For predefined value types  the   equality operator      returns true if   the values of its operands are equal    false otherwise  For reference types   other than string     returns true if   its two operands refer to the same   object  For the string type       compares the values of the strings    User-defined value types can overload   the    operator  see operator   So can   user-defined reference types  although   by default    behaves as described   above for both predefined and   user-defined reference types    So why does this code snippet fail to compile   bool Compare lt T gt  T x  T y    return x    y      I get the error Operator      cannot be applied to operands of type  T  and  T   I wonder why  since as far as I understand the    operator is predefined for all types   Edit  Thanks  everybody  I didn t notice at first that the statement was about reference types only  I also thought that bit-by-bit comparison is provided for all value types  which I now know is not correct   But  in case I m using a reference type  would the    operator use the predefined reference comparison  or would it use the overloaded version of the operator if a type defined one   Edit 2  Through trial and error  we learned that the    operator will use the predefined reference comparison when using an unrestricted generic type  Actually  the compiler will use the best method it can find for the restricted type argument  but will look no further  For example  the code below will always print true  even when Test test lt B gt  new B    new B    is called   class A   public static bool operator   A x  A y    return true      class B   A   public static bool operator   B x  B y    return false      class Test   void test lt T gt  T a  T b  where T   A   Console WriteLine a    b

User · Answer

I wrote the following function looking at the latest msdn  It can easily compare two objects x and y   static bool IsLessThan T x  T y         return   IComparable  x   CompareTo y   lt   0

User · Answer

by default    behaves as described above for both predefined and user-defined reference types    Type T is not necessarily a reference type  so the compiler can t make that assumption   However  this will compile because it is more explicit       bool Compare lt T gt  T x  T y  where T   class               return x    y          Follow up to additional question   But  in case I m using a reference type  would the the    operator use the predefined reference comparison  or would it use the overloaded version of the operator if a type defined one    I would have thought that    on the Generics would use the overloaded version  but the following test demonstrates otherwise   Interesting    I d love to know why   If someone knows please share   namespace TestProject    class Program        static void Main string   args                Test a   new Test            Test b   new Test             Console WriteLine  Inline             bool x   a    b          Console WriteLine  Generic             Compare lt Test gt  a  b                static bool Compare lt T gt  T x  T y  where T   class               return x    y             class Test        public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b              public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b                 Output  Inline  Overloaded    called  Generic   Press any key to continue        Follow Up 2  I do want to point out that changing my compare method to       static bool Compare lt T gt  T x  T y  where T   Test               return x    y          causes the overloaded    operator to be called   I guess without specifying the type  as a where   the compiler can t infer that it should use the overloaded operator    though I d think that it would have enough information to make that decision even without specifying the type

User · Answer

In general  EqualityComparer lt T gt  Default Equals should do the job with anything that implements IEquatable lt T gt   or that has a sensible Equals implementation   If  however     and Equals are implemented differently for some reason  then my work on generic operators should be useful  it supports the operator versions of  among others     Equal T value1  T value2  NotEqual T value1  T value2  GreaterThan T value1  T value2  LessThan T value1  T value2  GreaterThanOrEqual T value1  T value2  LessThanOrEqual T value1  T value2

User · Answer

The compile can t know T couldn t be a struct  value type   So you have to tell it it can only be of reference type i think   bool Compare lt T gt  T x  T y  where T   class   return x    y      It s because if T could be a value type  there could be cases where x    y would be ill formed - in cases when a type doesn t have an operator    defined  The same will happen for this which is more obvious   void CallFoo lt T gt  T x    x foo        That fails too  because you could pass a type T that wouldn t have a function foo  C  forces you to make sure all possible types always have a function foo  That s done by the where clause

User · Answer

bool Compare T x  T y  where T   class   return x    y       The above will work because    is taken care of in case of user-defined reference types  In case of value types     can be overridden  In which case       should also be defined   I think that could be the reason  it disallows generic comparison using

User · Answer

In general  EqualityComparer lt T gt  Default Equals should do the job with anything that implements IEquatable lt T gt   or that has a sensible Equals implementation   If  however     and Equals are implemented differently for some reason  then my work on generic operators should be useful  it supports the operator versions of  among others     Equal T value1  T value2  NotEqual T value1  T value2  GreaterThan T value1  T value2  LessThan T value1  T value2  GreaterThanOrEqual T value1  T value2  LessThanOrEqual T value1  T value2

User · Answer

As others have said  it will only work when T is constrained to be a reference type  Without any constraints  you can compare with null  but only null - and that comparison will always be false for non-nullable value types   Instead of calling Equals  it s better to use an IComparer lt T gt  - and if you have no more information  EqualityComparer lt T gt  Default is a good choice   public bool Compare lt T gt  T x  T y        return EqualityComparer lt T gt  Default Equals x  y       Aside from anything else  this avoids boxing casting

User · Answer

by default    behaves as described above for both predefined and user-defined reference types    Type T is not necessarily a reference type  so the compiler can t make that assumption   However  this will compile because it is more explicit       bool Compare lt T gt  T x  T y  where T   class               return x    y          Follow up to additional question   But  in case I m using a reference type  would the the    operator use the predefined reference comparison  or would it use the overloaded version of the operator if a type defined one    I would have thought that    on the Generics would use the overloaded version  but the following test demonstrates otherwise   Interesting    I d love to know why   If someone knows please share   namespace TestProject    class Program        static void Main string   args                Test a   new Test            Test b   new Test             Console WriteLine  Inline             bool x   a    b          Console WriteLine  Generic             Compare lt Test gt  a  b                static bool Compare lt T gt  T x  T y  where T   class               return x    y             class Test        public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b              public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b                 Output  Inline  Overloaded    called  Generic   Press any key to continue        Follow Up 2  I do want to point out that changing my compare method to       static bool Compare lt T gt  T x  T y  where T   Test               return x    y          causes the overloaded    operator to be called   I guess without specifying the type  as a where   the compiler can t infer that it should use the overloaded operator    though I d think that it would have enough information to make that decision even without specifying the type

User · Answer

The compile can t know T couldn t be a struct  value type   So you have to tell it it can only be of reference type i think   bool Compare lt T gt  T x  T y  where T   class   return x    y      It s because if T could be a value type  there could be cases where x    y would be ill formed - in cases when a type doesn t have an operator    defined  The same will happen for this which is more obvious   void CallFoo lt T gt  T x    x foo        That fails too  because you could pass a type T that wouldn t have a function foo  C  forces you to make sure all possible types always have a function foo  That s done by the where clause

User · Answer

It appears that without the class constraint   bool Compare lt T gt   T x  T y  where T  class       return x    y      One should realize that while class constrained Equals in the    operator inherits from Object Equals  while that of a struct overrides ValueType Equals   Note that   bool Compare lt T gt   T x  T y  where T  struct       return x    y      also gives out the same compiler error   As yet I do not understand why having a value type equality operator comparison is rejected by the compiler  I do know for a fact though  that this works   bool Compare lt T gt   T x  T y        return x Equals y

User · Answer

Well in my case I wanted to unit-test the equality operator  I needed call the code under the equality operators without explicitly setting the generic type  Advises for EqualityComparer were not helpful as EqualityComparer called Equals method but not the equality operator    Here is how I ve got this working with generic types by building a LINQ  It calls the right code for    and    operators        lt summary gt      Gets the result of  a    b       lt  summary gt  public bool GetEqualityOperatorResult lt T gt  T a  T b           declare the parameters     var paramA   Expression Parameter typeof T   nameof a        var paramB   Expression Parameter typeof T   nameof b           get equality expression for the parameters     var body   Expression Equal paramA  paramB          compile it     var invokeEqualityOperator   Expression Lambda lt Func lt T  T  bool gt  gt  body  paramA  paramB  Compile           call it     return invokeEqualityOperator a  b           lt summary gt      Gets the result of  a    b       lt  summary gt  public bool GetInequalityOperatorResult lt T gt  T a  T b           declare the parameters     var paramA   Expression Parameter typeof T   nameof a        var paramB   Expression Parameter typeof T   nameof b           get equality expression for the parameters     var body   Expression NotEqual paramA  paramB          compile it     var invokeInequalityOperator   Expression Lambda lt Func lt T  T  bool gt  gt  body  paramA  paramB  Compile           call it     return invokeInequalityOperator a  b

User · Answer

There is an MSDN Connect entry for this here  Alex Turner s reply starts with      Unfortunately  this behavior is by   design and there is not an easy   solution to enable use of    with type   parameters that may contain value   types

User · Answer

As others have said  it will only work when T is constrained to be a reference type  Without any constraints  you can compare with null  but only null - and that comparison will always be false for non-nullable value types   Instead of calling Equals  it s better to use an IComparer lt T gt  - and if you have no more information  EqualityComparer lt T gt  Default is a good choice   public bool Compare lt T gt  T x  T y        return EqualityComparer lt T gt  Default Equals x  y       Aside from anything else  this avoids boxing casting

User · Answer

bool Compare T x  T y  where T   class   return x    y       The above will work because    is taken care of in case of user-defined reference types  In case of value types     can be overridden  In which case       should also be defined   I think that could be the reason  it disallows generic comparison using

User · Answer

bool Compare T x  T y  where T   class   return x    y       The above will work because    is taken care of in case of user-defined reference types  In case of value types     can be overridden  In which case       should also be defined   I think that could be the reason  it disallows generic comparison using

User · Answer

If you want to make sure the operators of your custom type are called you can do so via reflection  Just get the type using your generic parameter and retrieve the MethodInfo for the desired operator  e g  op Equality  op Inequality  op LessThan       var methodInfo   typeof  T  GetMethod  op Equality                                 BindingFlags Static   BindingFlags Public         Then execute the operator using the MethodInfo s Invoke method and pass in the objects as the parameters   var result    bool  methodInfo Invoke null  new object     object1  object2      This will invoke your overloaded operator and not the one defined by the constraints applied on the generic parameter  Might not be practical  but could come in handy for unit testing your operators when using a generic base class that contains a couple of tests

User · Answer

The  Equals   works for me while TKey is a generic type   public virtual TOutputDto GetOne TKey id        var entity            unitOfWork BaseRepository              FindByCondition x   gt                    x IsDelete  amp  amp                   x Id Equals id                SingleOrDefault

User · Answer

So many answers  and not a single one explains the WHY   which Giovanni explicitly asked       NET generics do not act like C   templates   In C   templates  overload resolution occurs after the actual template parameters are known   In  NET generics  including C    overload resolution occurs without knowing the actual generic parameters   The only information the compiler can use to choose the function to call comes from type constraints on the generic parameters

User · Answer

Well in my case I wanted to unit-test the equality operator  I needed call the code under the equality operators without explicitly setting the generic type  Advises for EqualityComparer were not helpful as EqualityComparer called Equals method but not the equality operator    Here is how I ve got this working with generic types by building a LINQ  It calls the right code for    and    operators        lt summary gt      Gets the result of  a    b       lt  summary gt  public bool GetEqualityOperatorResult lt T gt  T a  T b           declare the parameters     var paramA   Expression Parameter typeof T   nameof a        var paramB   Expression Parameter typeof T   nameof b           get equality expression for the parameters     var body   Expression Equal paramA  paramB          compile it     var invokeEqualityOperator   Expression Lambda lt Func lt T  T  bool gt  gt  body  paramA  paramB  Compile           call it     return invokeEqualityOperator a  b           lt summary gt      Gets the result of  a    b       lt  summary gt  public bool GetInequalityOperatorResult lt T gt  T a  T b           declare the parameters     var paramA   Expression Parameter typeof T   nameof a        var paramB   Expression Parameter typeof T   nameof b           get equality expression for the parameters     var body   Expression NotEqual paramA  paramB          compile it     var invokeInequalityOperator   Expression Lambda lt Func lt T  T  bool gt  gt  body  paramA  paramB  Compile           call it     return invokeInequalityOperator a  b

User · Answer

by default    behaves as described above for both predefined and user-defined reference types    Type T is not necessarily a reference type  so the compiler can t make that assumption   However  this will compile because it is more explicit       bool Compare lt T gt  T x  T y  where T   class               return x    y          Follow up to additional question   But  in case I m using a reference type  would the the    operator use the predefined reference comparison  or would it use the overloaded version of the operator if a type defined one    I would have thought that    on the Generics would use the overloaded version  but the following test demonstrates otherwise   Interesting    I d love to know why   If someone knows please share   namespace TestProject    class Program        static void Main string   args                Test a   new Test            Test b   new Test             Console WriteLine  Inline             bool x   a    b          Console WriteLine  Generic             Compare lt Test gt  a  b                static bool Compare lt T gt  T x  T y  where T   class               return x    y             class Test        public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b              public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b                 Output  Inline  Overloaded    called  Generic   Press any key to continue        Follow Up 2  I do want to point out that changing my compare method to       static bool Compare lt T gt  T x  T y  where T   Test               return x    y          causes the overloaded    operator to be called   I guess without specifying the type  as a where   the compiler can t infer that it should use the overloaded operator    though I d think that it would have enough information to make that decision even without specifying the type

User · Answer

As others have said  it will only work when T is constrained to be a reference type  Without any constraints  you can compare with null  but only null - and that comparison will always be false for non-nullable value types   Instead of calling Equals  it s better to use an IComparer lt T gt  - and if you have no more information  EqualityComparer lt T gt  Default is a good choice   public bool Compare lt T gt  T x  T y        return EqualityComparer lt T gt  Default Equals x  y       Aside from anything else  this avoids boxing casting

User · Answer

In general  EqualityComparer lt T gt  Default Equals should do the job with anything that implements IEquatable lt T gt   or that has a sensible Equals implementation   If  however     and Equals are implemented differently for some reason  then my work on generic operators should be useful  it supports the operator versions of  among others     Equal T value1  T value2  NotEqual T value1  T value2  GreaterThan T value1  T value2  LessThan T value1  T value2  GreaterThanOrEqual T value1  T value2  LessThanOrEqual T value1  T value2

User · Answer

I wrote the following function looking at the latest msdn  It can easily compare two objects x and y   static bool IsLessThan T x  T y         return   IComparable  x   CompareTo y   lt   0

User · Answer

So many answers  and not a single one explains the WHY   which Giovanni explicitly asked       NET generics do not act like C   templates   In C   templates  overload resolution occurs after the actual template parameters are known   In  NET generics  including C    overload resolution occurs without knowing the actual generic parameters   The only information the compiler can use to choose the function to call comes from type constraints on the generic parameters

User · Answer

It appears that without the class constraint   bool Compare lt T gt   T x  T y  where T  class       return x    y      One should realize that while class constrained Equals in the    operator inherits from Object Equals  while that of a struct overrides ValueType Equals   Note that   bool Compare lt T gt   T x  T y  where T  struct       return x    y      also gives out the same compiler error   As yet I do not understand why having a value type equality operator comparison is rejected by the compiler  I do know for a fact though  that this works   bool Compare lt T gt   T x  T y        return x Equals y

User · Answer

by default    behaves as described above for both predefined and user-defined reference types    Type T is not necessarily a reference type  so the compiler can t make that assumption   However  this will compile because it is more explicit       bool Compare lt T gt  T x  T y  where T   class               return x    y          Follow up to additional question   But  in case I m using a reference type  would the the    operator use the predefined reference comparison  or would it use the overloaded version of the operator if a type defined one    I would have thought that    on the Generics would use the overloaded version  but the following test demonstrates otherwise   Interesting    I d love to know why   If someone knows please share   namespace TestProject    class Program        static void Main string   args                Test a   new Test            Test b   new Test             Console WriteLine  Inline             bool x   a    b          Console WriteLine  Generic             Compare lt Test gt  a  b                static bool Compare lt T gt  T x  T y  where T   class               return x    y             class Test        public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b              public static bool operator    Test a  Test b                Console WriteLine  Overloaded    called            return a Equals b                 Output  Inline  Overloaded    called  Generic   Press any key to continue        Follow Up 2  I do want to point out that changing my compare method to       static bool Compare lt T gt  T x  T y  where T   Test               return x    y          causes the overloaded    operator to be called   I guess without specifying the type  as a where   the compiler can t infer that it should use the overloaded operator    though I d think that it would have enough information to make that decision even without specifying the type

User · Answer

If you want to make sure the operators of your custom type are called you can do so via reflection  Just get the type using your generic parameter and retrieve the MethodInfo for the desired operator  e g  op Equality  op Inequality  op LessThan       var methodInfo   typeof  T  GetMethod  op Equality                                 BindingFlags Static   BindingFlags Public         Then execute the operator using the MethodInfo s Invoke method and pass in the objects as the parameters   var result    bool  methodInfo Invoke null  new object     object1  object2      This will invoke your overloaded operator and not the one defined by the constraints applied on the generic parameter  Might not be practical  but could come in handy for unit testing your operators when using a generic base class that contains a couple of tests

User · Answer

It appears that without the class constraint   bool Compare lt T gt   T x  T y  where T  class       return x    y      One should realize that while class constrained Equals in the    operator inherits from Object Equals  while that of a struct overrides ValueType Equals   Note that   bool Compare lt T gt   T x  T y  where T  struct       return x    y      also gives out the same compiler error   As yet I do not understand why having a value type equality operator comparison is rejected by the compiler  I do know for a fact though  that this works   bool Compare lt T gt   T x  T y        return x Equals y

User · Answer

The compile can t know T couldn t be a struct  value type   So you have to tell it it can only be of reference type i think   bool Compare lt T gt  T x  T y  where T   class   return x    y      It s because if T could be a value type  there could be cases where x    y would be ill formed - in cases when a type doesn t have an operator    defined  The same will happen for this which is more obvious   void CallFoo lt T gt  T x    x foo        That fails too  because you could pass a type T that wouldn t have a function foo  C  forces you to make sure all possible types always have a function foo  That s done by the where clause

User · Answer

The compile can t know T couldn t be a struct  value type   So you have to tell it it can only be of reference type i think   bool Compare lt T gt  T x  T y  where T   class   return x    y      It s because if T could be a value type  there could be cases where x    y would be ill formed - in cases when a type doesn t have an operator    defined  The same will happen for this which is more obvious   void CallFoo lt T gt  T x    x foo        That fails too  because you could pass a type T that wouldn t have a function foo  C  forces you to make sure all possible types always have a function foo  That s done by the where clause

User · Answer

The  Equals   works for me while TKey is a generic type   public virtual TOutputDto GetOne TKey id        var entity            unitOfWork BaseRepository              FindByCondition x   gt                    x IsDelete  amp  amp                   x Id Equals id                SingleOrDefault

User · Answer

It appears that without the class constraint   bool Compare lt T gt   T x  T y  where T  class       return x    y      One should realize that while class constrained Equals in the    operator inherits from Object Equals  while that of a struct overrides ValueType Equals   Note that   bool Compare lt T gt   T x  T y  where T  struct       return x    y      also gives out the same compiler error   As yet I do not understand why having a value type equality operator comparison is rejected by the compiler  I do know for a fact though  that this works   bool Compare lt T gt   T x  T y        return x Equals y

User · Answer

In general  EqualityComparer lt T gt  Default Equals should do the job with anything that implements IEquatable lt T gt   or that has a sensible Equals implementation   If  however     and Equals are implemented differently for some reason  then my work on generic operators should be useful  it supports the operator versions of  among others     Equal T value1  T value2  NotEqual T value1  T value2  GreaterThan T value1  T value2  LessThan T value1  T value2  GreaterThanOrEqual T value1  T value2  LessThanOrEqual T value1  T value2

User · Answer

bool Compare T x  T y  where T   class   return x    y       The above will work because    is taken care of in case of user-defined reference types  In case of value types     can be overridden  In which case       should also be defined   I think that could be the reason  it disallows generic comparison using

User · Answer

There is an MSDN Connect entry for this here  Alex Turner s reply starts with      Unfortunately  this behavior is by   design and there is not an easy   solution to enable use of    with type   parameters that may contain value   types

User · Answer

As others have said  it will only work when T is constrained to be a reference type  Without any constraints  you can compare with null  but only null - and that comparison will always be false for non-nullable value types   Instead of calling Equals  it s better to use an IComparer lt T gt  - and if you have no more information  EqualityComparer lt T gt  Default is a good choice   public bool Compare lt T gt  T x  T y        return EqualityComparer lt T gt  Default Equals x  y       Aside from anything else  this avoids boxing casting

[c#] Can't operator == be applied to generic types in C#?

Examples related to c#

Examples related to generics

Examples related to operators

Examples related to equals-operator