Confrontando i campi generici
-
21-08-2019 - |
Domanda
Ho alcuni tipi generici, come il seguente:
public struct Tuple<T1, T2> { ... }
public struct Tuple<T1, T2, T3> { ... }
etc.
Si dovrebbe in teoria essere in grado di confrontarsi contro altri valori dello stesso tipo, in modo che io possa scrivere il seguente tipo di codice:
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"))
...
purtroppo, c'era un bug nel mio codice, e la questione diventa allora come fare questo in modo corretto.
Il bug aveva a che fare con la mia implementazione di CompareTo>, che appare sostanzialmente in questo modo:
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 assomiglia a questo:
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;
}
L'ultima se-dichiarazione c'è qualcosa ho infilato adesso per risolvere il bug, ma è corretto?
In sostanza, come faccio a confrontare due oggetti di tipo? C'è un confronto significativo per questi, ad eccezione solo per convertirli in una stringa e confrontare?
Soluzione
Vuoi dire:
bool equal = EqualityComparer<T>.Default.Equals(val1,val2);
Questo funziona con IEquatable<T>
(per T : IEquatable<T>
), il resto cade di nuovo a object.Equals
.
C'è Comparer<T>.Default
anche per i confronti di disuguaglianza (superiore / inferiore):
int delta = Comparer<T>.Default.Compare(val1,val2);
Questo utilizza T : IComparable<T>
o T : IComparable
altrimenti.
A proposito, Type
dovrebbe usare il riferimento normale comparazione fornito da <=>, quindi dovrebbe funzionare bene con quanto sopra.