将LINQ（OrderBy / ThenBy）代码转换为CompareTo

Question

I have written a generic sort funciton to sort list and dicitonary. But LINQ doesnt works on Unity due to JIT errors. I want to have the same generics and convert it into myList.Sort() which uses CompraeTo. But Im unable to figure out how to accomplish this as generic as this.

    public static List<T> MySort<T>(this List<T> source, Type typeOfObject, bool isAscending = false, params string[] param) 
{
    if(param.Length == 0)
        return source;

    if (isAscending)
    {
        var temp = source.OrderBy (a => (typeOfObject.GetProperty (param [0])).GetValue (a, null));

        for (int i=1; i<param.Length; i++)
        {
            var myVar = i;
            temp = temp.ThenBy((a => (typeOfObject.GetProperty(param[myVar])).GetValue (a, null)));
        }
        return temp.ToList();
    }
    else
    {
        var temp = source.OrderByDescending (a => (typeOfObject.GetProperty (param [0])).GetValue (a, null));
        for (int i=1; i<param.Length; i++)
        {
            var myVar = i;
            temp.ThenByDescending((a => (typeOfObject.GetProperty(param[myVar])).GetValue (a, null)));
        }
        return temp.ToList();
    }
}

USage of this function

RealEstateItems.MySort(typeof(mIsoObjectExt), true, "UnlockLevel", "Coins", "Diamonds");

My current CompareTo Approac

myList.Sort ((a,b) => {
int result = ((a.Value) as mIsoObjectExt).UnlockLevel.CompareTo(((b.Value) as mIsoObjectExt).UnlockLevel);
//  result == 0 ? result = a.Value.Coins.CompareTo(a.Value.Coins);
if(result == 0)
{
    result = ((a.Value) as mIsoObjectExt).Coins.CompareTo(((b.Value) as mIsoObjectExt).Coins);
}
else
{
    return result;
}
if(result == 0)
{
    return ((a.Value) as mIsoObjectExt).Diamonds.CompareTo(((b.Value) as mIsoObjectExt).Diamonds);
}
return result;
});

But Im not satisfied with this i have to do this every time i have to sort even on the same properties. Basically i want to make something like above that i tell the function the type its properties to sort on and it sorts. How can i do this with Compare/CompareTo?

Answer 1

So we're going to need a few different building blocks to begin with. First off, what you're really doing here is sorting each item on a collection of values, as is seen in this other question . We can pull the solution from there to have a comparer for sorting items based on a collection of values:

public class SequenceComparer<T> : IComparer<IEnumerable<T>>
{
    private IComparer<T> comparer;
    public SequenceComparer(IComparer<T> compareer = null)
    {
        this.comparer = comparer ?? Comparer<T>.Default;
    }

    public int Compare(IEnumerable<T> x, IEnumerable<T> y)
    {
        using (var first = x.GetEnumerator())
        using (var second = x.GetEnumerator())
        {
            while (true)
            {
                var firstHasMore = first.MoveNext();
                var secondHasMore = second.MoveNext();
                if (!firstHasMore && !secondHasMore)
                    return 0;
                var lengthComparison = firstHasMore.CompareTo(secondHasMore);
                if (lengthComparison != 0)
                    return lengthComparison;
                var nextComparison = comparer.Compare(first.Current, second.Current);
                if (nextComparison != 0)
                    return nextComparison;
            }
        }
    }
}

We also want a way of creating a Comparison<T> delegate (which List.Sort accepts) from a projection delegate. This method is simple enough to write:

public static Comparison<T> CreateComparison<T, TKey>(Func<T, TKey> selector,
    IComparer<TKey> comparer = null)
{
    comparer = comparer ?? Comparer<TKey>.Default;
    return (a, b) => comparer.Compare(selector(a), selector(b));
}

It'll also be useful for us to be able to reverse a Comparison<T> (to handle descending ordering):

public static Comparison<T> Reverse<T>(this Comparison<T> comparison)
{
    return (a, b) => comparison(b, a);
}

Now to pull all of the pieces together. We can create a comparison that, for the projection, projects each item into a sequence of values that represent fetching each of the property names from the item using reflection. We can then reverse the comparer if we need a descending sort.

public static void MySort<T>(this List<T> source,
    bool isAscending = false,
    params string[] properties)
{
    var type = typeof(T);
    var comparison = CreateComparison((T item) =>
        properties.Select(prop => type.GetProperty(prop).GetValue(item)),
        new SequenceComparer<object>());
    if (!isAscending)
        comparison = comparison.Reverse();
    source.Sort(comparison);
}

---

Note that if you can also use the sequence comparer to simplify the LINQ approach:

public static IEnumerable<T> MyOrdering<T>(this IEnumerable<T> source,
    bool isAscending = false,
    params string[] properties)
{
    var type = typeof(T);

    Func<T, IEnumerable<object>> selector = item =>
        properties.Select(prop => type.GetProperty(prop).GetValue(item))
        .ToList();

    if (isAscending)
        return source.OrderBy(selector, new SequenceComparer<object>());
    else
        return source.OrderByDescending(selector, new SequenceComparer<object>());
}

Answer 2

You can use Servy's approach with reflection. If you decide against reflection, you can use the below approach, but it still needs the comparison to be provided from the caller.

public class MultiValueComparer<T> : IComparer<T>
{
   private IEnumerable<Comparison<T>> _comparisons;

   public MultiValueComparer(IEnumerable<Comparison<T>> comparisons)
   {
      _comparisons = comparisons;
   }

   public int Compare(T x, T y)
   {
     foreach (var comparison in _comparisons)
     {
        var result = comparison(x, y);
        if (result != 0)
           return result;
     }
     return 0;
   }
}

An extension method which takes a variable number of parameters

public static void Sort<T>(List<T> source, params Comparison<T>[] comparisons)
{
   if (comparisons.Count() == 0)
      return;

   source.Sort(new MultiValueComparer<T>(comparisons));
}

Usage:

Ascending Order:

Sort(samples, (x, y) => x.Name.CompareTo(y.Name), (x, y) => x.Test.CompareTo(y.Test));

Descending Order:

Sort(samples, (x, y) => y.Name.CompareTo(x.Name), (x, y) => y.Test.CompareTo(x.Test));