Comparando campos genéricos

Question

Eu tenho alguns tipos genéricos, como o seguinte:

public struct Tuple<T1, T2> { ... }
public struct Tuple<T1, T2, T3> { ... }
etc.

Estes devem, em teoria, ser capaz de comparar-se contra os outros valores do mesmo tipo, para que eu possa escrever o seguinte tipo de código:

List<Tuple<Type, String>> l = new List<Tuple<Type, String>>();
l.Add(new Tuple<Type, String>(typeof(ISomeInterface), "123"));
if (l.Contains(new Tuple<Type, String>(typeof(ISomeOtherInterface), "123"))
    ...

Infelizmente, houve um erro no meu código, e a questão torna-se então como fazer isso corretamente.

O bug tinha a ver com minha implementação do CompareTo>, que basicamente se parece com isso:

Int32 result = HelperMethods.CompareTwoFields<T1>(_Value1, other._Value1);
if (result != 0)
    return result;

Int32 result = HelperMethods.CompareTwoFields<T2>(_Value2, other._Value2);
if (result != 0)
    return result;

return 0;

HelperMethods.CompareTwoFields esta aparência:

internal static Int32 CompareTwoFields<T>(T field1, T field2)
{
    Int32 result = 0;
    if (ReferenceEquals(field1, null) != ReferenceEquals(field2, null))
        result = ReferenceEquals(field1, null) ? -1 : +1;
    else if (!ReferenceEquals(field1, null) && field1 is IComparable<T>)
        result = ((IComparable<T>)field1).CompareTo(field2);
    else if (!typeof(T).IsValueType)
    {
        if (Object.ReferenceEquals(field1, field2))
            return 0;
        else
            return field1.ToString().CompareTo(field2.ToString());
    }
    return result;
}

A última instrução if há algo que eu dobrado agora para corrigir o bug, mas isso é correto?

Basicamente, como faço para comparar dois objetos Type? Existe uma comparação significativa para eles, salvo apenas para convertê-los em uma string e comparar?

Answer 1

Você quer dizer:

bool equal = EqualityComparer<T>.Default.Equals(val1,val2);

Isso funciona com IEquatable<T> (para T : IEquatable<T>), o resto cai de volta para object.Equals.

Há também Comparer<T>.Default para comparações de desigualdade (maior / menor):

int delta = Comparer<T>.Default.Compare(val1,val2);

Esta usos T : IComparable<T>, ou T : IComparable contrário.

A propósito, Type deve apenas usar a referência regulares comparar fornecido pelo object.Equals, por isso deve apenas multa trabalho com o acima.