Develop Reference

In C#, I would love to define the > and < operators for string [duplicate]

This question already has answers here:
C# String Operator Overloading
(7 answers)
Closed 1 year ago.
Personally, I find the string.CompareTo() annoying to use and read.
I would love to read and write like: if (string1 > string2)
Currently, I can do this, using ExtensionMethods:
string a = "ABC";
string b = "BBC";
if ( a.IsGreaterThan(b) )
{
Console.WriteLine("a is greater than b");
}
else if ( a.IsLessThan(b) )
{
Console.WriteLine("a is less than b");
}
public static class StringExtensions
{
public static bool IsGreaterThan(this string i, string value)
{
return (i.CompareTo(value) > 0);
}
public static bool IsLessThan(this string i, string value)
{
return (i.CompareTo(value) < 0);
}
}
This is much better, but I'd still like to define the < and > operators. I found an OLD post explaining why this is NOT possible:
Currently this is not supported because Extension methods are defined in separate static class and static classes cannot have operator overloading definitions.
Has anything changed in C# to now allow defining the < and > operators for string class?

I'd still like to define the < and > operators
But why [.gifv]?
What does it mean to you that a string is "greater than" another? Its length? Or the first Unicode codepoint within it that's higher than the codepoint at the same location in the first string?
What about combined characters? Is ñ (U+00F1) greater or smaller than n and ~ combined (U+006E and U+0303), or perhaps equal? What about i + j and ij? Would the current culture matter?
Be happy that there's such a "clumsy" method to do comparisons, so you can call an overload on it to specify what kind of comparison you actually want. There is no one size fits all in string comparisons, and you definitely shouldn't be able to override it for all strings.
Besides, already compiled code doesn't care about extension methods (or extension operators, if that were a thing). Consider you're running library code in which you can definitely read that there's a if (foo < bar) and in your code it's true, but in the compiled code it's false, because it does a different comparison for the same operator.
So no, C# doesn't allow overriding operators for built-in types.

Construct AndAlso/OrElse LINQ expression with custom method

I'm trying to pass in a custom MethodInfo to the Expression.AndAlso and OrElse factory methods (which are for the && and || operators, respectively). These operators use short circuiting, which makes this difficult, but normally the & and | operators (along with the true and false operators) are used. However, the MSDN documentation for Expression.AndAlso/OrElse doesn't mention the true or false operators.
For testing, I've declared a method that uses a normal & operator on two ints:
public static int And(int a, int b) {
return a & b;
}
Note that the return type must be int rather than bool to avoid an exception.
I then construct the expression:
var expr = Expression.AndAlso(
Expression.Constant(0),
Expression.Constant(5),
new Func<int, int, int>(And).Method
);
This results in an exception:
The user-defined operator method 'And' for operator 'AndAlso' must have associated boolean True and False operators.
Strangely, the error is also thrown if I use a custom struct that has the true and false operators. I can avoid it if the struct overloads the & operator and I pass in that overload, but not if I pass in a different method. Other non-short-circuiting operators work with custom methods though.
The problem is that I don't know how to pass methods for the true and false operators in. I first thought I could maybe combine them as delegates, but the different methods have incompatible signatures. Is there any way to pass these methods in?
The bigger picture
I'm building a system for interpreting expressions to support ahead-of-time compilation. It supports using a custom method for the AndAlso/OrElse operators, currently by taking a custom Func<InterpretedExpression, InterpretedExpression, object> (which works as the expressions are interpreted rather than compiled). This could easily be changed if it causes problems (which would be due to it not having accessible true and false methods).
Note: I'm using Visual Studio's C# Interactive window for testing, but ultimately need to support .NET 3.5 (though information for newer versions is still helpful and appreciated).

The problem is that I don't know how to pass methods for the true and false operators in. I first thought I could maybe combine them as delegates, but the different methods have incompatible signatures. Is there any way to pass these methods in?
The short answer is no, you can't.
Looking at the reference source implementation (unfortunately, it should really be in the documentation), looks like the passed method has the following constraints:
(1) It should be a static non generic method with signature
static T Method(T arg0, T arg1);
where T cannot be an open generic type.
(2) The declaring type of the method must have operators true and false defined.
Since operators true and false require the argument type to be the same as the declaring type, this combined with (1) really constraints the usage to class/struct T declaring the static method and true and false operators.
In other words, a method with bitwise & / | operator semantics without actually overloading those operators.
So it can be used only for types like this:
public struct IntWrapper
{
public readonly int Value;
public IntWrapper(int value) { Value = value; }
public static IntWrapper And(IntWrapper a, IntWrapper b) { return new IntWrapper(a.Value & b.Value); }
public static bool operator true(IntWrapper x) { return x.Value != 0; }
public static bool operator false(IntWrapper x) { return x.Value == 0; }
}
with usage:
var expr = Expression.AndAlso(
Expression.Constant(new IntWrapper(0)),
Expression.Constant(new IntWrapper(5)),
new Func<IntWrapper, IntWrapper, IntWrapper>(IntWrapper.And).Method
);
This I guess limits more general usage you are after.

C# How to hack/fix 'this' keyword into a struct? [duplicate]

This question already has an answer here:
Why do I have to copy "this" when using LINQ in a struct (and is it OK if I do)?
(1 answer)
Closed 7 years ago.
Apparently you cannot use the keyword "this" in a method in a struct.
Note that in the below example I do not explicitly type "this" but it is implied when I reference the properties "X" or "Y".
My struct:
public struct Coord
{
public int X;
public int Y;
public Coord(int x, int y)
{
X = x;
Y = y;
}
// some other methods omitted
public List<int> GetPossibles()
{
return LaurenceAI.Values.Where(n => LaurenceAI.Possibilities[X, Y, n]).ToList();
}
}
usage example:
foreach(int numeral in targetCoord.GetPossibles())
{
//do stuff
}
Error:
Error 1 Anonymous methods, lambda expressions, and query expressions inside structs cannot access instance members of 'this'. Consider copying 'this' to a local variable outside the anonymous method, lambda expression or query expression and using the local instead. C:\Projects\Sodoku\SodokuSolver\Sodoku\LaurenceAI.cs 367 74 Sodoku
Questions:
What is the technical reason that a method in a struct cannot use keyword "this"?
Is there an elegant way to fix this so that I don't have to type out the reflection code longhand every time I want a list of possible numerals for a given Coord?

The reason is that structs are passed by value, not by reference. Using this in this context results in typically not what you want - it'll access the this pointer of the copy, not the outer object, and it'll be really confusing when any assignments you make aren't showing in the outer call. It's annoying in this specific circumstance, but in general it's stopping more weird errors.
The error message actually gives you a fairly reasonable solution - copy the values first. Do something like:
public List<int> GetPossibles()
{
var localX = X;
var localY = Y;
return LaurenceAI.Values.Where(n => LaurenceAI.Possibilities[localX, localY, n]).ToList();
}

Operator '&' cannot be applied to operands of type 'T' and 'T' [duplicate]

This question already has answers here:
C#, Flags Enum, Generic function to look for a flag
(11 answers)
Closed 6 years ago.
My application defines several enums that include the [Flags] attribute.
I wanted to write a small utility method to check if a flag was set for any of those enums and I came up with the following.
protected static bool IsFlagSet<T>(ref T value, ref T flags)
{
return ((value & flags) == flags);
}
But this gives me the error "Operator '&' cannot be applied to operands of type 'T' and 'T'".
Can this be made to work?

The Enum class already has a utility function: Enum.HasFlag(Flag f), see the example on MSDN
if (petsInFamily.HasFlag(Pet.Dog))
familiesWithDog++;
Note: This was introduced in C# 4.
And while it's very readable it may have some performance issues.

I understand that my answer is too late, but I found really amazing solution of this problem.
Starting from .Net 4 we can use dynamic types in C#. You method can be rewritten:
protected static bool IsFlagSet<T>(T value, T flags)
{
dynamic a = value;
dynamic b = flags;
return ((a & b) == flags);
}
Idea behind that dynamic allows you postpone to runtime if method/operator supported by type T. So if & is defined for T then runtime is success.

& is an operator on a class type. Which means that the class T has to have a method that overloads the operator &.
.Net can't expect that every class will have it. So it fails.
What you can do, is make a base class, that declares the operator overload as a method.
Then use Constraints to declare that T uses that base class:
protected static bool IsFlagSet<T> where T: BaseclassWithAnd (ref T value, ref T flags)
{
return ((value & flags) == flags);
}

You must type-cast it to a type that defines the & operation.
protected static bool IsFlagSet<T>(ref T value, ref T flags)
{
return ((Convert.ToInt32(value) & Convert.ToInt32(flags)) == Convert.ToInt32(flags));
}

The reason of the error is that you can't restric generic type as "have operator X defined for T,T". As result C# has to assume that there is no operator X defined for T,T and shows an error.
This is behavior often discussed in relation to == operator - i.e. Can't operator == be applied to generic types in C#?, but applies to all operators.
For full list of possible constrints see - http://msdn.microsoft.com/en-us/library/d5x73970(v=VS.100).aspx, note that there is no constraint for Enum (that would be useful for your scenario specifically) nor for types with operator X defined.

Why must C# operator overloads be static?

Why does C# require operator overloads to be static methods rather than member functions (like C++)? (Perhaps more specifically: what was the design motivation for this decision?)

This has been answered in excruciating detail by Eric Lippert in a blog post that has since been removed. Here is the archived version.
There is also another subtler point about value types and instance operators. Static operators make this kind of code possible:
class Blah {
int m_iVal;
public static Blah operator+ (Blah l, int intVal)
{
if(l == null)
l = new Blah();
l.m_iVal += intVal;
return l;
}
}
//main
Blah b = null;
b = b + 5;
So you can invoke the operator, even though the reference is null. This wouldn't be the case for instance operators.

Take a look at this post.
A couple of reasons, the primary seeming to be to preserve operator symmetry (such that the left hand side of a binary operation does not get special treatment, as being responsible for dispatching the operation).

Perhaps its best to think why should the methods not be static. There is no need for state and hence this.