运算符“==”不能应用于“T”和“int”类型的操作数

Question

what I should do here?

On node.Item == target the following error occurs: Operator '==' cannot be applied to operands of type 'T' and 'T'

so I need it all as generic

public class Node<T>
    {
       

        public T  Item  { get; set; }
        public Node<T> Left { get; set; }
        public Node<T> Right { get; set; }
        public Node(T item)
        {
                    Item = item;
        }

        public override string ToString()
        {
            return $"{Item,-15}";
        }
    }

public bool Ancestors(Node<T> node, T target)
{
    if (node == null)
    {
        return false;
    }

    if (node.Item == target)
    {
        return true;
    }

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

    return false;
}

Answer 1

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

Answer 2

Let's focus on this line:

if (node.Item == target)

In order to compare two items, they must be of the same type (some exceptions apply to this rule, but that's irrelevant for your situation).

So let's confirm that the two things we're comparing are of the same type.

target is easy, because your method parameter clearly states int target .

So what is node.Item ? Well, first, let's look at what node is in the method declaration:

Node<T> node

You also posted your Node<T> class definition:

public class Node<T> 
{ 
    public T Item { get; set; } 
}

Therefore, the Item property of your Node<T> node is of type T . But wait, result is an int . We can't compare that!

Hence the error you're getting:

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

I hope the error makes more sense now.

---

So how do we solve it? Well, one of the operands must change type to match the other operand. So we could make both of them int :

public bool Ancestors(Node<int> node, int target)
{
    if (node.Item == target)
    {
        return true;
    }
}

or we can make both operands to be of type T :

public bool Ancestors(Node<T> node, T target)
{
    if (node.Item.Equals(target))
    {
        return true;
    }
}

Note that I'm using Equals here, instead of == , because == doesn't work for all types (and the compiler needs to account for all possible types T could represent).

The correct solution depends on precisely what you need here.