Determining if any elements in an IEnumerable could be cast to type U

Question

In newer versions of .net, there are a number of extensions methods which accept IEnumerable<T> or IEnumerable. One such method is OfType<TResult> which returns an enumerable that contains only elements of the original sequence which can be cast to the specified type T. This method perfectly happily chug away using a non-generic IEnumerable to process all the items of the original list, regardless of the type of the original list and the destination type. If the original list is an IEnumerable<int> and TResult is int, it will get each item of the original list as a non-generic object and then cast it, even though it could just use the original IEnumerator<int>. If the original list is an IEnumerable<int> and TResult is StringBuilder, it will likewise chug through boxing all the items in the original list even though none of them could possibly be cast to the destination type.

How difficult would it be to write a method which would take an IEnumerable<TSrc> and convert it to an IEnumerable<TResult>, handling efficiently the cases in which either all items in the original enumeration are guaranteed to appear in the latter, or in which the type of the source enumerator would imply that the latter would be empty (assuming that all variations of IEnumerable a type supports would return the same sequence of items)? To be sure, one wouldn't terribly often be trying to cast a sequence to the type it already holds, but it's not uncommon to have a generic class with multiple type parameters that will sometimes overlap and sometimes not.

Answer 1

IEquatable<T>.Equals should be consistent with the Object.Equals override. I'm not sure specifically using IEquatable<T> directly offers any value.

It sounds to me like you simply want to make sure boxed objects use the unboxed values for the equality test. You should be able to do most of what you want with an equals like this:

private static bool Equals<T1, T2>(T1 first, T2 second)
{
    // if either are boxed, try Equals with unboxed values (dynamic)
    if (typeof(T2) == typeof(object) && second.GetType().IsValueType)
    {
        dynamic dsec = second;
        if (typeof(T1) == typeof(object) && second.GetType().IsValueType)
        {
            dynamic dfir = first;
            return Equals(dfir, dsec);
        }
        return Equals(first, dsec);
    }
    if (typeof(T1) == typeof(object) && second.GetType().IsValueType)
    {
        dynamic dfir = first;
        Equals<dynamic, T2>(dfir, second);
    }
    // neither are boxed, just fall back to their Equals overrides...
    var t = Object.Equals(first, second);
    return t;
}

Enumerable.Intersect and Except work only with collections of the same type, so if the type was Object it should do what you want.

Update:

Value types cannot derive from a base class. Their only common base will always only be Object, which means you always have to box at least one value if you want to compare two different value types without specifically using a method that knows the two types you want to compare--which Enumerable.Intersect and Except don't accept anyway. So it's not possible without writing different methods.

Update 2:

It's a poor assumption to assume that if two types can't been converted between each other (or one to the other) that that means they can never be equal. For example:

public struct One
{
    public int Value;
    public override int GetHashCode()
    {
        return Value.GetHashCode();
    }
}

public struct Two
{
    public int Value;
    public override bool Equals(object obj)
    {
        if (obj is Two) return this == (Two)obj;
        if (obj is One) return this.Equals((One)obj);
        return base.Equals(obj);
    }

    public bool Equals(One one)
    {
        return one.Value == Value;
    }

    public static bool operator==(Two one, Two two)
    {
        return one.Value == two.Value;
    }

    public static bool operator !=(Two one, Two two)
    {
        return !(one == two);
    }
    public override int GetHashCode()
    {
        return Value.GetHashCode();
    }
}

// ...

    Console.WriteLine(two.Equals(one));
    Console.WriteLine(two.Equals((Object)one));
    Console.WriteLine(two.GetType().IsAssignableFrom(one.GetType()) || one.GetType().IsAssignableFrom(two.GetType()));

Results in True, True and False. So, clearly two objects can be "equal" while not being convertible between each other.