Comparing values of generic types

Hi all!

Consider the following sample:

Code:

public abstract class SomeClass
{
    // checks equality of each member in two arrays.
    public static bool ArrayEquals<T>(T[] a, T[] b)
    {
        if (a.Length != b.Length) {
            return false;
        }

        for (int i = 0; i < a.Length; i++) {
            if ( a[i] != b[i] ) {
                return false;
            }

        }
        return true;
    }
}

Now, this function doesn't work, and I quess it's because <T> COULD be a reference type, or a value type. Is there a way to allow only value-types as <T>?

Or, alternately, is there another way of checking the value(not reference) of each entity in a and b?
object.Equals(a[i], b[i]) does not work because it checks the ref.

Thanks!

In my opinion, Equals is the correct way to write this function. Each class can override Equals to check the actual value of the class if it makes sense. However, instead of using the static object.Equals, you should use a[i].Equals(b[i]). If you want to restrict to value types, I think you can use the struct generic type constraint. However, the Equals method is better because then you can use it on both value types and atomic reference types.

Originally Posted by pianorain

In my opinion, Equals is the correct way to write this function. Each class can override Equals to check the actual value of the class if it makes sense. However, instead of using the static object.Equals, you should use a[i].Equals(b[i]). If you want to restrict to value types, I think you can use the struct generic type constraint. However, the Equals method is better because then you can use it on both value types and atomic reference types.

I know, but consider this:

Code:

bool someMethod<T>(T a, T b)
{
    if ( a.Equals(b) )
    {
        Console.Writeline("Hooray!");
        return true;
    }
    return false;
}

This will not work so long as your dealing with generic types.
I do belive it's because with gens it always checks the ref instead of the potential value, even thou it's a value type.

It's not a big dealie, cus I've overridden the method to support the datatypes I need it to, without generics, but I just found the topic interesting.

So how does the List<T> class do it? Does it use obj.Equals as well?

Originally Posted by MisterT

This will not work so long as your dealing with generic types.

Please define what you mean by "this will not work," because this appears to work just fine:

Code:

class A : IEquatable<A>
{
	int m_int;

	public A(int a) { m_int = a; }

	public override bool Equals(object obj)
	{
		A other = obj as A;

		if (other == null)
			return false;

		return Equals(other);
	}

	public bool Equals(A other)
	{
		return m_int == other.m_int;
	}
}

static bool someMethod<T>(T a, T b)
{
	if (a.Equals(b))
	{
		Console.WriteLine("Hooray!");
		return true;
	}

	Console.WriteLine("Whoops!");
	return false;
}

[STAThread]
static void Main(string[] args)
{
	A a = new A(3);
	A b = new A(4);
	A a2 = new A(3);

	someMethod(a, b);
	someMethod(a, a2);
	someMethod(a2, b);
	
	Console.WriteLine("Finished");
	Console.ReadLine();
}

Output:

Code:

Whoops!
Hooray!
Whoops!
Finished

Ok so I'm guessing that List<T> does use object.Equals. Also for types like int, float, string are they checked for there value rather than there reference?

Yes, I'm sure any of the built-in data types that require some sort of equality functionality uses object.Equals. For value types and string, the default Equals will automatically do a value comparison.

Okay thanks.