Defining operators for specific instances of a generic - c#

I am attempting to implement the generic Vector3 struct, and havethe operators for my struct that allows basic math when the type T is a numeric (int, float, double, long, short)
I had thought the way to do this was to just define the 4 basic operators for all each something like
public static Vector3<int> operator +(Vector3<int> left, Vector3<int> right)
but that gives me the error that at least one of the parameters must be of the containing type (which is Vector3 in this case)
I feel reasonably confident there is a way for me to define a Vector3 generic, and still have the convenience of the standard operators, but I can not seem to figure out what I need to write syntactically.


I believe you are trying to do something like this:
public class Vector3<T>
{
T x; T y; T z;
public static Vector3<int> operator + (Vector3<int> lhs, Vector3<int> rhs)
{
//Stuff
}
}
This is not allowed. Why not? Well imagine you wrote a method like this:
public static void Foo<T>()
{
var lhs = new Vector3<T>();
var rhs = new Vector3<T>();
var result = lhs + rhs;
}
Should the compiler allow this to compile or not? Because this would work:
Foo<int>();
But this would fail:
Foo<string>();
Because the compiler can't guarantee it'll work, it's not allowed.
If you have a burning desire to implement operator overloading for certain types of Vector3, you have to subclass it:
public class Vector3Int : Vector3<int>
{
public static Vector3Int operator + (Vector3Int lhs, Vector3Int rhs)
{
//Stuff
}
}
That would work. Note that I had to change struct to class as you can't inherit a struct.

Related

Call double "==" operator when used as generic parameter [duplicate]

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<T>(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<B>(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<T>(T a, T b) where T : A { Console.WriteLine(a == b); } }

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<T> - and if you have no more information, EqualityComparer<T>.Default is a good choice:
public bool Compare<T>(T x, T y)
{
return EqualityComparer<T>.Default.Equals(x, y);
}
Aside from anything else, this avoids boxing/casting.

"...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<T>(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<Test>(a, b);
}
static bool Compare<T>(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<T>(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.

In general, EqualityComparer<T>.Default.Equals should do the job with anything that implements IEquatable<T>, 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)

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.

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<T>(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<T>(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.

It appears that without the class constraint:
bool Compare<T> (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<T> (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<T> (T x, T y)
{
return x.Equals(y);
}

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:
/// <summary>
/// Gets the result of "a == b"
/// </summary>
public bool GetEqualityOperatorResult<T>(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<Func<T, T, bool>>(body, paramA, paramB).Compile();
// call it
return invokeEqualityOperator(a, b);
}
/// <summary>
/// Gets the result of "a =! b"
/// </summary>
public bool GetInequalityOperatorResult<T>(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<Func<T, T, bool>>(body, paramA, paramB).Compile();
// call it
return invokeInequalityOperator(a, b);
}

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.

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.

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) <= 0;
}

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 "==".

The .Equals() works for me while TKey is a generic type.
public virtual TOutputDto GetOne(TKey id)
{
var entity =
_unitOfWork.BaseRepository
.FindByCondition(x =>
!x.IsDelete &&
x.Id.Equals(id))
.SingleOrDefault();
// ...
}

I have 2 solutions and they're very simply.
Solution 1: Cast the generic typed variable to object and use == operator.
Example:
void Foo<T>(T t1, T t2)
{
object o1 = t1;
object o2 = t2;
if (o1 == o2)
{
// ...
// ..
// .
}
}
Solution 2: Use object.Equals(object, object) method.
Example:
void Foo<T>(T t1, T t2)
{
if (object.Equals(t1, t2)
{
// ...
// ..
// .
}
}

You can do this with C# 11 and .NET 7+:
static void Main()
{
Console.WriteLine(Compare(2, 2));
Console.WriteLine(Compare(2, 3));
}
static bool Compare<T>(T x, T y) where T : IEqualityOperators<T, T, bool>
{
return x == y;
}
(you may prefer to use where T : INumber<T>, which covers this scenario and a lot more, but it depends on your specific needs; not all equatable types are numbers)

C# operator '==' cannot be applied to operands of type 'TKey' and 'TKey' in generic classes [duplicate]

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<T>(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<B>(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<T>(T a, T b) where T : A { Console.WriteLine(a == b); } }

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<T> - and if you have no more information, EqualityComparer<T>.Default is a good choice:
public bool Compare<T>(T x, T y)
{
return EqualityComparer<T>.Default.Equals(x, y);
}
Aside from anything else, this avoids boxing/casting.

"...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<T>(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<Test>(a, b);
}
static bool Compare<T>(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<T>(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.

In general, EqualityComparer<T>.Default.Equals should do the job with anything that implements IEquatable<T>, 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)

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.

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<T>(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<T>(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.

It appears that without the class constraint:
bool Compare<T> (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<T> (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<T> (T x, T y)
{
return x.Equals(y);
}

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:
/// <summary>
/// Gets the result of "a == b"
/// </summary>
public bool GetEqualityOperatorResult<T>(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<Func<T, T, bool>>(body, paramA, paramB).Compile();
// call it
return invokeEqualityOperator(a, b);
}
/// <summary>
/// Gets the result of "a =! b"
/// </summary>
public bool GetInequalityOperatorResult<T>(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<Func<T, T, bool>>(body, paramA, paramB).Compile();
// call it
return invokeInequalityOperator(a, b);
}

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.

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.

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) <= 0;
}

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 "==".

The .Equals() works for me while TKey is a generic type.
public virtual TOutputDto GetOne(TKey id)
{
var entity =
_unitOfWork.BaseRepository
.FindByCondition(x =>
!x.IsDelete &&
x.Id.Equals(id))
.SingleOrDefault();
// ...
}

I have 2 solutions and they're very simply.
Solution 1: Cast the generic typed variable to object and use == operator.
Example:
void Foo<T>(T t1, T t2)
{
object o1 = t1;
object o2 = t2;
if (o1 == o2)
{
// ...
// ..
// .
}
}
Solution 2: Use object.Equals(object, object) method.
Example:
void Foo<T>(T t1, T t2)
{
if (object.Equals(t1, t2)
{
// ...
// ..
// .
}
}

You can do this with C# 11 and .NET 7+:
static void Main()
{
Console.WriteLine(Compare(2, 2));
Console.WriteLine(Compare(2, 3));
}
static bool Compare<T>(T x, T y) where T : IEqualityOperators<T, T, bool>
{
return x == y;
}
(you may prefer to use where T : INumber<T>, which covers this scenario and a lot more, but it depends on your specific needs; not all equatable types are numbers)

How do implicit conversions work with operator overloading?

If I were to, say, create a thin wrapper around the float type for whatever reason, like so:
public class WrappedFloat
{
private float value;
public WrappedFloat(float value)
{
this.value = value;
}
public static implicit operator float(WrappedFloat wrapped)
{
return wrapped.value;
}
public static implicit operator WrappedFloat(float value)
{
return new WrappedFloat(value);
}
}
This code is apparently perfectly valid:
new WrappedFloat(4.0F) + new WrappedFloat(3.0F)
Since WrappedFloat doesn't define any arithmetic operators, there must be something about it's implicit conversion to float allowing this. But operator overloading is just syntactic sugar for methods, right? It's not like I can call methods (i.e. CompareTo) on WrappedFloat just because float has them. So what's so special about operators here? What are the rules for allowing this?

Operators are, for the purposes of this discussion, just like static methods. Imagine you had an actual static method for each operator overload:
public static int Plus(int a, int b) { return a + b; }
public static float Plus(float a, float b) { return a + b; }
public static long Plus(long a, long b) { return a + b; }
public static string Plus(string a, string b) { return a + b; }
public static double Plus(double a, double b) { return a + b; }
//...
Now imagine you have:
Plus(new WrappedFloat(4.0F), new WrappedFloat(3.0F));
What would you expect to happen here? Overload resolution would run, it would see that there is an overload for which both of the parameters have an implicit conversion to, and that overload (accepting float values) becomes the unique best match.
The exact same thing happens with operators. It pulls together all of the overloads, sees which ones have argument lists for which the provided arguments can be implicitly converted to, and then chooses the best match among them if there are multiple.

But operator overloading is just syntactic sugar for methods, right?
It is not syntactic sugar for "methods", it is syntactic sugar for one kind of method implemented in a specific way. The typical method call on an object with . syntax is not applicable here. MS chose a design for programmer convenience. When I call
wrappedFloat.Method()
I dont expect it to look for every possibility on wrappedFloat, but when I do
wrappedFloat1 + wrappedFloat2
I expect it to. I agree with MS here. One difference here, is that in first case it is a call on the instance, the second one is a static method call where the formal parameter is passed as an argument.

How to make binary multiplication operator * available in a generic class?

abstract class Shape<T>
{
public abstract T Area();
}
class Square<T> : Shape<T>
{
T side;
public Square(T side)
{
this.side = side;
}
public override T Area()
{
return this.side * this.side;
}
}
Error 1 Operator '*' cannot be applied to operands of type 'T' and of type 'T'.
Compiler throws an error because there is no * for this.side*this.side. How to make the binary multiplication operator * available in a generic class?

You can't use the * operator itself, but you can work around it by generating an expression that uses this operator:
static class Operators
{
public static T Multiply<T>(T x, T y)
{
return OperatorCache<T>.Multiply(x, y);
}
static class OperatorCache<T>
{
static OperatorCache()
{
Multiply = MakeBinaryOperator(ExpressionType.Multiply);
}
static Func<T, T, T> MakeBinaryOperator(ExpressionType type)
{
var x = Expression.Parameter(typeof(T), "x");
var y = Expression.Parameter(typeof(T), "y");
var body = Expression.MakeBinary(type, x, y);
var expr = Expression.Lambda<Func<T, T, T>>(body, x, y);
return expr.Compile();
}
public readonly static Func<T, T, T> Multiply;
}
}
You can then use it like this:
public override T Area()
{
return Operators.Multiply(this.side, this.side);
}
Of course you can add other operators to the Operators class; just keep in mind that if the operator you're using is not defined for T, it will fail at runtime.

You can't do that. The multiplication operator is not defined for all types. But your generic has no constraints so the compiler has to assume that the consumers of your class can use any type, like string for example.
Unfortunately, generic constraints in .NET can't be used to express this kind of requirement, i.e. there is no way to constrain T to only types that define the multiplication operator.
Bottom line is: You can't use generics in your scenario. You need to go the same way as the .NET framework with its Size (for double) and SizeF (for float) types.
Note about the context of my answer:
If you want to provide your class for arbitrary classes you have control over, Alexey has the correct answer.
However, his answer does not apply if you want to use your Square class with types like double, float or int, because you can't add an interface to them.

You can substitute it with a method .Multiply(T a, T b)
And use it with interface
public interface IMultiplyable<T>
{
T Multiply(T a, T b);
}

Override operator c#

I would like to override operator * for my class. I know how to handle * for MyClass * MyClass but how can i implement this for having possibility to multiply for example:
7 * MyClass
7 is lets say double and MyClass is object of MyClass,
thanks for help

When you provide an operator for your class, the parameter types for the operator implementation control which situations you're handling.
To illustrate:
// Declare which operator to overload (+), the types
// that can be added (two Complex objects), and the
// return type (Complex):
public static Complex operator +(Complex c1, Complex c2)
{
return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);
}
This method defines what to do if you want to add two Complex numbers.
If you tried to use this with (say) a double and a Complex, compilation would fail.
In your case, you need just declare both versions:
public static MyClass operator *(MyClass c1, MyClass c2)
{
return ...
}
public static MyClass operator *(double n, MyClass c)
{
return ...
}

The appropriate signature in this case is:
public static MyClass operator *(double a, MyClass b)
This means it takes a double as the left side, a MyClass as the right, and returns a MyClass.

Categories

Resources