C#：通过 SortedSet 中的多个属性比较两个对象

Question

I'd like to compare two objects by multiple properties.

Let's say I have a class called Student, and every student has name and score. My wish is to create a SortedSet( implement a Comparer here ), so whenever I add a Student into the collection they will be sorted by their score, and if they have the same score they will be sorted by their name alphabetically.

Java 8 equivalent of this would be:

TreeSet<Student> students = new TreeSet<>(
    Comparator.comparing(Student::getScore).thenComparing(Student::getName)
);

Is this possible using Comparer<Student>.Create() or in any other way?

Answer 1

You can use SortedSet with a custom comparer. Implementation is a little trickier:

var s = new SortedSet<Student>(
    Comparer<Student>.Create((a, b) => {
        // This code implements comparison by score first
        var res= a.Score.CompareTo(b.Score);
        // Ties are resolved by name in alphabetic order
        return res != 0 ? res : a.Name.CompareTo(b.Name);
    })
);

Answer 2

Two quick examples I put together, you could use an IComparer<> of type Student . You would then give it the comparisons in the order required, as such:

class Program
{
    static void Main(string[] args)
    {
        var set = new SortedSet<Student>(new StudentComparer());

        set.Add(new Student {Name = "Test", Score = 10});
        set.Add(new Student { Name = "Tom", Score = 5 });
        set.Add(new Student { Name = "Adam", Score = 90 });
        set.Add(new Student { Name = "Adam", Score = 85 });

        foreach (var setItem in set)
        {
            Debug.WriteLine($@"{setItem.Name} - {setItem.Score}");
        }

        /*  outputs:
            Tom - 5
            Test - 10
            Adam - 85
            Adam - 90
        */
    }

}

class Student
{
    public string Name { get; set; }
    public int Score { get; set; }
}

class StudentComparer : IComparer<Student>
{
    public int Compare(Student x, Student y)
    {
        var result = x.Score.CompareTo(y.Score); 

        if (result == 0)
        {
            result = x.Name.CompareTo(y.Name);
        }
        return result;
    }
}

You could also use a normal List, and use Linq:

        var students = new List<Student>
        {
            new Student {Name = "Test", Score = 10},
            new Student {Name = "Tom", Score = 5},
            new Student {Name = "Adam", Score = 90},
            new Student {Name = "Adam", Score = 85}
        };


        var orderedList = students.OrderByDescending(s => s.Score)
            .ThenBy(s => s.Name);

        foreach (var student in orderedList)
        {
            Debug.WriteLine($@"{student.Name} - {student.Score}");
        }

        /*  outputs:
            Adam - 90
            Adam - 85
            Test - 10
            Tom - 5
        */

Answer 3

You can use SortedSet generic and provide it with an IComparer<Student> that does the comparison based on the order you want, ie, first the scores are compared and if they are the same you compare the names.

class Program
{
    static void Main(string[] args)
    {
        var students = new List<Student>()
        {
            new Student()
            {
                Score = 10,
                Name = "David"
            },
            new Student()
            {
                Score = 4,
                Name = "Nik"
            },
            new Student()
            {
                Score = 10,
                Name = "Randy"
            }
        };


        SortedSet<Student> sortedStudents = new SortedSet<Student>(new StudentMultiCriteria());
        foreach (var student in students)
        {
            sortedStudents.Add(student);
        }

        foreach (var sortedStudent in sortedStudents)
        {
            Console.WriteLine(sortedStudent);
        }

    }

}

class Student
{
    public int Score { get; set; }
    public string Name { get; set; }

    public override string ToString()
    {
        return $"Score {Score}, Name {Name}";
    }

}

class StudentMultiCriteria : IComparer<Student>
{
    public int Compare(Student x, Student y)
    {
        // You do the comparison based on different fields here
        return x.Score.CompareTo(y.Score) == 0 ? x.Name.CompareTo(y.Name) : x.Score.CompareTo(y.Score);
    }
}

Answer 4

My bad, in my comment I should of said Icomparable<Student> . This will allow the sorted collection to use a default comparer. Also It seems to me that when sorting like this, generally the scores will be sorted descending but the names ascending. Therefore your class could look like this:

class Student : IComparable<Student>
{
    public int score = 0;
    public string name = "";

    public int CompareTo(Student other)
    {
        if (score == other.score)
        {
            return name.CompareTo(other.name);
        }
        else
        {
            return other.score.CompareTo(score);
        }
    }
}

static void Main()
{
    SortedSet<Student> students = new SortedSet<Student>();
    students.Add(new Student { score = 20, name = "abcd" });
    students.Add(new Student { score = 10, name = "bcde" });
    students.Add(new Student { score = 10, name = "acde" });
    students.Add(new Student { score = 30, name = "cdef" });
    students.Add(new Student { score = 10, name = "abce" });
}

The result would look something like this:

30,"cdef"

20,"abcd"

10,"abce"

10,"acde"

10,"bcde"

Answer 5

You could write a generic comparer to mimic that API:

public class Comparator<T> : Comparer<T>
{
    readonly List<Func<T, T, int>> m_comparisons = new List<Func<T, T, int>>();

    Comparator()
    {
    }

    public static Comparator<T> Comparing<TProp>(Func<T, TProp> property)
        where TProp : IComparable<TProp>
    {
        return new Comparator<T>().ThenComparing(property);
    }

    public static Comparator<T> ComparingDescending<TProp>(Func<T, TProp> property)
        where TProp : IComparable<TProp>
    {
        return new Comparator<T>().ThenComparingDescending(property);
    }

    public static Comparator<T> Comparing<TProp>(Func<T, TProp> property, IComparer<TProp> propertyComparer)
    {
        return new Comparator<T>().ThenComparing(property, propertyComparer);
    }

    public static Comparator<T> ComparingDescending<TProp>(Func<T, TProp> property, IComparer<TProp> propertyComparer)
    {
        return new Comparator<T>().ThenComparingDescending(property, propertyComparer);
    }

    public Comparator<T> ThenComparing<TProp>(Func<T, TProp> property)
        where TProp : IComparable<TProp>
    {
        return ThenComparing(property, Comparer<TProp>.Default);
    }

    public Comparator<T> ThenComparingDescending<TProp>(Func<T, TProp> property)
        where TProp : IComparable<TProp>
    {
        return ThenComparingDescending(property, Comparer<TProp>.Default);
    }

    public Comparator<T> ThenComparing<TProp>(Func<T, TProp> property, IComparer<TProp> propertyComparer)
    {
        m_comparisons.Add((t1, t2) => propertyComparer.Compare(property(t1), property(t2)));
        return this;
    }

    public Comparator<T> ThenComparingDescending<TProp>(Func<T, TProp> property, IComparer<TProp> propertyComparer)
    {
        m_comparisons.Add((t1, t2) => propertyComparer.Compare(property(t2), property(t1)));
        return this;
    }

    public override int Compare(T x, T y)
    {
        foreach (Func<T, T, int> comparison in m_comparisons)
        {
            int result = comparison(x, y);
            if (result != 0)
            {
                return result;
            }
        }

        // They are equal.
        return 0;
    }
}

---

Usage:

SortedSet<Student> students = new SortedSet<Student>(Comparator
    .Comparing(x => Score)
    .ThenComparing(x => x.Name)); // etc.

I find this much more readable and safer than building up a big lambda using Comparer<Student>.Create .