C# espressioni lambda e icomparer
-
28-10-2019 - |
Domanda
Sto usando le espressioni Lambda per ordinare e cercare un array in C#. Non voglio implementare l'interfaccia ICOMparer nella mia classe, perché devo ordinare e cercare su più campi dei membri.
class Widget
{
public int foo;
public void Bar()
{
Widget[] widgets;
Array.Sort(widgets, (a, b) => a.foo.CompareTo(b.foo));
Widget x = new Widget();
x.foo = 5;
int index = Array.BinarySearch(widgets, x,
(a, b) => a.foo.CompareTo(b.foo));
}
}
Mentre l'ordinamento funziona bene, la ricerca binaria fornisce un errore di compilazione Impossibile convertire l'espressione di lambda in digitare 'system.collections.icompareru003CWidget> 'Perché non è un tipo delegato. Per qualche ragione, Ording ha sovraccarico sia per ICOMparer che per il confronto, ma BinarySearch supporta solo ICOMparer. Dopo alcune ricerche, ho scoperto il goffo ComparisonComparer<T>
Per convertire il confronto con un icomparer:
public class ComparisonComparer<T> : IComparer<T>
{
private readonly Comparison<T> comparison;
public ComparisonComparer(Comparison<T> comparison)
{
this.comparison = comparison;
}
int IComparer<T>.Compare(T x, T y)
{
return comparison(x, y);
}
}
Ciò consente alla ricerca binaria di funzionare come segue:
int index = Array.BinarySearch(
widgets,
x,
new ComparisonComparer<Widget>((a, b) => a.foo.CompareTo(b.foo)));
Che schifo. C'è un modo più pulito?
Soluzione
Bene, un'opzione è quella di creare qualcosa di simile ProjectionComparer
invece. Ne ho una versione Morbutil - Fondamentalmente crea un IComparer<T>
da una proiezione.
Quindi il tuo esempio sarebbe:
int index = Array.BinarySearch(widgets, x,
ProjectionComparer<Widget>.Create(x => x.foo));
Oppure potresti implementare i tuoi metodi di estensione su T[]
fare lo stesso genere di cose:
public static int BinarySearchBy<TSource, TKey>(
this TSource[] array,
TSource value,
Func<TSource, TKey> keySelector)
{
return Array.BinarySearch(array, value,
ProjectionComparer.Create(array, keySelector));
}
Altri suggerimenti
Puoi usare il mio ValueComparer<T>
classe:
int index = Array.BinarySearch(
widgets, x,
new ValueComparer<Widget>(x => x.Foo)
);
È possibile confrontare per più proprietà passando più espressioni Lambda.
Prova questo:
public static class ComparisonEx
{
public static IComparer<T> AsComparer<T>(this Comparison<T> @this)
{
if (@this == null)
throw new System.ArgumentNullException("Comparison<T> @this");
return new ComparisonComparer<T>(@this);
}
public static IComparer<T> AsComparer<T>(this Func<T, T, int> @this)
{
if (@this == null)
throw new System.ArgumentNullException("Func<T, T, int> @this");
return new ComparisonComparer<T>((x, y) => @this(x, y));
}
private class ComparisonComparer<T> : IComparer<T>
{
public ComparisonComparer(Comparison<T> comparison)
{
if (comparison == null)
throw new System.ArgumentNullException("comparison");
this.Comparison = comparison;
}
public int Compare(T x, T y)
{
return this.Comparison(x, y);
}
public Comparison<T> Comparison { get; private set; }
}
}
Ti consente di utilizzare questo codice:
Comparison<int> c = (x, y) => x == y ? 0 : (x <= y ? -1 : 1);
IComparer<int> icc = c.AsComparer();
Func<int, int, int> f = (x, y) => x == y ? 0 : (x <= y ? -1 : 1);
IComparer<int> icf = f.AsComparer();