C#类与接口排序问题：IComparer实现逻辑修正需求

Let's break down what's going wrong with your current SortedTypeComparer and fix it to match your expected ordering.

The Core Problem in Your Current Code #

Your current logic has the priority reversed for unrelated interfaces and classes. When you have an interface (like IRunnable) and a class that doesn't implement it (like Animal), your code returns 1 when comparing the interface to the class. In IComparer<T> terms, this means the interface is considered "greater than" the class, so it gets sorted after the class—exactly the opposite of what you want.

Expected Order Recap #

To make it clear, here's the priority we need to enforce:

1. Unrelated interfaces (e.g., IAnimal, IRunnable) come first (all have equal priority among themselves)
2. Classes that don't implement any of the preceding interfaces (e.g., Animal) come next
3. Related interfaces and their implementing classes (e.g., ICat followed by Cat), with interfaces always preceding the classes that implement them

Fixed SortedTypeComparer Code #

Here's the corrected implementation that adheres to these rules:

public class SortedTypeComparer : IComparer<Type>
{
    /// <summary>
    /// Compares types to match the desired interface/class priority rules
    /// </summary>
    public int Compare(Type x, Type y)
    {
        // First handle inheritance/implementation relationships
        if (y.IsAssignableFrom(x))
        {
            // x is a subtype of y (e.g., Cat is a subtype of Animal, or Cat implements IAnimal)
            // We want parent/interface first, so x should come after y → return 1
            return 1;
        }
        else if (x.IsAssignableFrom(y))
        {
            // y is a subtype of x (e.g., Animal is parent of Cat, or IAnimal is implemented by Cat)
            // We want x (parent/interface) first → return -1
            return -1;
        }
        // Now handle unrelated types
        else if (x.IsInterface && y.IsClass)
        {
            // Unrelated interface and class: interface comes first → x is "less than" y
            return -1;
        }
        else if (x.IsClass && y.IsInterface)
        {
            // Unrelated class and interface: interface comes first → x is "greater than" y
            return 1;
        }
        // All other cases: same priority (unrelated interfaces, unrelated classes)
        else
        {
            return 0;
        }
    }
}

Key Changes & Explanations #

1. Removed redundant conditions: We don't need to recheck !y.IsAssignableFrom(x) && !x.IsAssignableFrom(y) for the unrelated case—we already handled the related cases in the first two if blocks. This simplifies the code and makes it easier to read.
2. Reversed the interface/class priority:
   • When comparing an unrelated interface (x) to a class (y), return -1—this tells the sorter to place the interface before the class.
   • When comparing an unrelated class (x) to an interface (y), return 1—this places the class after the interface.
3. Preserved correct related-type ordering: The first two if blocks still ensure that:
   • Interfaces come before the classes that implement them
   • Parent classes/interfaces come before their subtypes

Testing the Fix #

With this corrected comparer, your example list will now sort to:
IAnimal, IRunnable, Animal, ICat, Cat
...regardless of the initial order of the items. Unrelated interfaces will always stay at the front, followed by non-implementing classes, then related interfaces and their implementations.

内容的提问来源于stack exchange，提问作者Dilshod K