How to Solve Operator '!=' Cannot Be Applied to Operands of Type 'T' and 'T'

Operator '==' cannot be applied to operands of type 'T' and 'T'

I'm not looking for a replacement for the == operator, I'm looking for an explanation why the compiler can't figure out that both generic properties are of the same type.

There is no explanation that explains a falsehood. The compiler can and does figure out that both generic properties are of the same compile-time type, which you could illustrate with something like:

x.Id = reference.Id;

The compiler would allow that assignment no problem because it knows that there is an identity conversion between two identical at compile time types.

So you must be looking for an explanation of some other thing. I think what you are really looking for is a justification for why operator overload resolution fails to find a best operator for equality on a type parameter.

The answer is: C# generic types are not C++ templates. In C++, if you have ex1 OP ex2 then the resolution of the operator that determines its semantics is performed once per construction of the template. In C#, we don't do that; we perform overload resolution on operators once and must find an operator that works for all possible substitutions of type arguments.

We cannot do that for equality operators on unconstrained types; if TId is object then reference equality must be performed; if it is string then string equality must be performed, if it is int then int equality must be performed, if it is "nullable Guid", then lifted-to-nullable Guid equality must be performed, and so on. There is no generalized equality operator in C#, only a collection of specific equality operators, and since there is no generalized operator, there's no single operator for operator overload resolution to choose. Thus you get an error.

That's why in order to do this you would typically constrain the type to implement some interface that can be used; we can generically call interface methods on generic types.

You've rejected that correct solution to the problem, and so there's not much we can do to help you here without knowing more about why you've rejected the standard, safe, efficient solution.

Now, you might note that the compiler could generate code which determines at runtime what the resolution of the overload resolution algorithm is, based on the runtime types. C# cannot do that without excessive performance cost; if you are willing to pay that cost, then cast your operands to dynamic. That tells the compiler that you are willing to accept overload resolution failures at runtime in exchange for not getting them at compile time; be careful! When you turn off a safety system, you are responsible for ensuring the type safety of your program.

Operator '??' cannot be applied to operands of type 'T' and 'T'

You should add class constraint:

public static T Method<T>(T model) where T : class, new()
{
    var m = model ?? new T();

    return m;
}

And you should return m too!

Note: As @KristofDegrave mentioned in his comment, the reason that we have to add class constraint is because T can be a value type, like int and since ?? operator (null-coalescing) check on types that can be null, so we have to add class constraint to exclude value types.

Edit: Alvin Wong's answer covered the case for nullable types too; which are structs actually, but can be operands of ?? operator. Just be aware that Method would return null without Alvin's overloaded version, for nullable types.

Operator '==' cannot be applied to operands of type 'T' and 'int'

I assume that you intend for target to have the same generic type as T in Node<T>. In that case, you should change your method signature to:

public bool Ancestors<T>(Node<T> node, T target) where T : IEquatable<T>

You would then compare node.Item to target using:

if (node.Item.Equals(target))

The complete method could look like this:

public bool Ancestors<T>(Node<T> node, T target) where T : IEquatable<T>
{
    if (node?.Item == null)
        return false;

    if (node.Item.Equals(target))
        return true;

    if (Ancestors(node.Left, target) ||
        Ancestors(node.Right, target))
    {
        Console.Write(node.Item + " ");
        return true;
    }

    return false;
}

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

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

Operator '?' cannot be applied to operand of type 'T'

Since not everything can be null, you have to narrow down T to be something nullable (aka an object). Structs can't be null, and neither can enums.

Adding a where on class does fix the issue:

public abstract class Feature<T> where T : class

So why doesn't it just work?

Invoke() yields T. If GetValue is null, the ? operator sets the return value of type T to null, which it can't. If T is int for example, it can't make it nullable (int?) since the actual type required (T = int) isn't.

If you change T to be int in your code, you will see the problem very clearly. The end result of what you ask is this:

get
{
    int? x = GetValue?.Invoke();
    return x.GetValueOrDefault(0);
}

This is not something the null-propagation operator will do for you. If you revert to the use of default(T) it does know exactly what to do and you avoid the 'problematic' null-propagation.

C# Gives CS0019 Error: Operator cannot be applied to operands of type 'T' and 'T'

Edit: somehow I managed to cut out a code snippet before I posted this.

First of all, the generic type in the Node class needs to implement the ICompareable interface to do this.

 public class Node<T> where T : ICompareable
 {
     public T data { get; set; }
     public Node<T> left { get; set; }
     public Node<T> right { get; set; }
     public Node<T>(T data)
     {
         this.data = data;
     }
 }

Second of all, ICompareable doesn't overload the '<' and '>' operators. You need to do something like this instead

else if (n.data.CompareTo(current.data) < 0) {
    current.left = RecursiveInsert(current.left, n);
    current = balance_tree(current);
}