Price<\/code>:<\/p>\npublic int CompareTo(Product? other)\r\n{\r\n if (ReferenceEquals(this, other)) return 0;\r\n if (other is null) return 1;\r\n\r\n var nameComparison = string.Compare(ProductName, other.ProductName,\r\n StringComparison.OrdinalIgnoreCase);\r\n\r\n return nameComparison != 0 ? nameComparison : Price.CompareTo(other.Price);\r\n}<\/pre>\nThe first thing we do on line #3 is to perform a reference comparison to check if we are comparing the same object with itself. If that is the case, we return 0<\/code>, indicating that the objects occur in the same position within the sort order. Note<\/strong> that we did not say that a return value of 0<\/code> indicates equality, only their relative positioning within the sort order. Equal objects must return 0<\/code>, but it is possible, based on how we are sorting, to have two unequal objects that still share the same position in relation to their sort order.<\/p>\nSecond, on line #4 we check whether other<\/code> is null<\/code>. In the case of it being null<\/code>, we return 1<\/code> indicating that our current object is larger than the null<\/code> object.<\/p>\nThird, on line #6 we compare the ProductName<\/code> of the two objects. Since we have already verified that they are not the same object and that other<\/code> is not null, we can safely make this comparison.<\/p>\nThis leads us to the last line, #8, where we check to see if the ProductName<\/code> has the same sort-order positioning. If it does, then we compare the Price<\/code> as a way of determining which object should be first in the sort order.<\/p>\nIComparable<T> Implementation In Action<\/h3>\n
Now let’s see what happens when we sort our Product<\/code> collection:<\/p>\nvar productList = new List<Product?>(products);\r\nproductList.Sort();<\/pre>\nLet’s inspect the result:<\/p>\n
NULL NULL $0.00 00000000-0000-0000-0000-000000000000\r\nGeneric Car Games $75.18 c65100fd-e49f-f5e0-0e71-052d7eefe9b3\r\nGorgeous Fish Games $103.07 f0569e86-bfad-6f3a-b74d-2555175dcc6e\r\nHandcrafted Hat Books $38.09 c7b30b28-db07-f2ae-70dc-9505096e676b\r\nPractical Chicken Electronics $126.06 d6fee4b9-8767-851a-b386-a8af727663a7\r\nTasty Cheese Clothing $134.74 4af80b60-3e17-1dfd-8462-c009ca918154<\/pre>\nIComparer<T> Interface for Sorting a List in C#<\/h2>\n
Sometimes when we are sorting, we do not want to follow the default sort defined for a given type T<\/code>. The IComparer<T><\/code> interface is one of the techniques we can use for sorting a list according to our own desired sort order. It allows an implementing type to define a Compare()<\/code> method that can be used to sort objects of type T<\/code>. The Compare()<\/code> method signature is very similar to the CompareTo()<\/code> method that we looked at with the IComparable<T><\/code> interface:<\/p>\npublic int Compare (T? a, T? b)<\/code><\/p>\nJust like the CompareTo()<\/code> method, the value returned indicates the relative positioning of the two objects within the desired sort order:<\/p>\n\n< 0<\/code> – a<\/code> precedes b<\/code> in the sort order<\/li>\n0<\/code> – a<\/code> is in the same position as b<\/code> in the sort order<\/li>\n> 0<\/code> – a<\/code> follows b<\/code> in the sort order<\/li>\n<\/ul>\nA common use case for the IComparer<T><\/code> is to define a custom comparer to use for sorting a collection differently than the default ordering defined by the object. For example, the default sort ordering of our Product<\/code> object is based on the natural ordering of the ProductName<\/code>. We can override that behavior when sorting a collection by defining an IComparer<Product><\/code> that sorts based on the price.<\/p>\nImplementing IComparer<T> for Custom Sorting<\/h3>\n
Let’s take a look at it in action. We’ll start with our class definition:<\/p>\n
public sealed class ProductPriceIComparer : IComparer<Product?><\/code><\/p>\nThe only thing left to do is to implement the Compare(Product? x, Product? y)<\/code> method:<\/p>\npublic int Compare(Product? a, Product? b)\r\n{\r\n if (ReferenceEquals(a, b)) return 0;\r\n if (a is null) return -1;\r\n if (b is null) return 1;\r\n\r\n var priceComparison = a.Price.CompareTo(b.Price);\r\n\r\n return priceComparison != 0 ? priceComparison :\r\n string.Compare(a.ProductName, b.ProductName, StringComparison.OrdinalIgnoreCase);\r\n}<\/pre>\nThe code looks very similar to the CompareTo()<\/code> method that we defined earlier, with one very notable difference, the number of arguments. CompareTo()<\/code> is a member of the Product<\/code> class and so only takes a single argument, namely the other Product<\/code> to compare with the current Product<\/code>. When we implement the ICompare<T><\/code> interface, the Compare()<\/code> method performs the comparison with two provided Product<\/code> objects.\u00a0<\/p>\nFirst, on line #3, we check whether the two objects are the same object. In that case, we just return 0<\/code>. Next, on line #4, we check to see if a<\/code> is null<\/code>. If it is, then we return -1<\/code> indicating that a<\/code> comes before b<\/code> in the sorting order. On line #5 we also check whether b<\/code> is null<\/code> and if it is, we return 1<\/code> to indicate that b<\/code> comes before a<\/code> in the sorting order.<\/p>\nThe major difference between our earlier CompareTo()<\/code> and this Compare()<\/code> is found on lines 7 and 9. In our CompareTo()<\/code> method, we first performed a comparison on the ProductName<\/code> and then, only if the ProductName<\/code> was equal regarding sort order, did we compare the Price<\/code>. In this case, we are checking the Price<\/code> first, as our goal is to order Products<\/code> according to Price<\/code> rather than ProductName<\/code>.\u00a0<\/p>\nIComparer<T> Implementation in Action<\/h3>\n
Let’s see our collection when we sort it using the ProductPriceIComparer<\/code>:<\/p>\nvar productList = new List<Product?>(products);\r\nproductList.Sort(new ProductPriceIComparer());<\/pre>\nAnd, let’s check the result:<\/p>\n
NULL NULL $0.00 00000000-0000-0000-0000-000000000000\r\nHandcrafted Hat Books $38.09 c7b30b28-db07-f2ae-70dc-9505096e676b\r\nGeneric Car Games $75.18 c65100fd-e49f-f5e0-0e71-052d7eefe9b3\r\nGorgeous Fish Games $103.07 f0569e86-bfad-6f3a-b74d-2555175dcc6e\r\nPractical Chicken Electronics $126.06 d6fee4b9-8767-851a-b386-a8af727663a7\r\nTasty Cheese Clothing $134.74 4af80b60-3e17-1dfd-8462-c009ca918154<\/pre>\nThe Comparer<T> Abstract Class<\/h2>\n
We have already looked at the IComparer<T><\/code> interface, so now let’s take a look at the abstract class Comparer<T><\/code> which is an abstract base class that implements the IComparer<T><\/code> interface.<\/p>\nGiven the choice between implementing the interface and deriving from the base class, deriving from Comparer<T><\/code> is the recommended approach by Microsoft<\/strong>. The remarks<\/a> section of the documentation for IComparer<T><\/code> explains why we should prefer deriving from Comparer<T><\/code> over implementing the interface.<\/p>\nDeriving from Comparer<T><\/h3>\n
So let’s take a look at creating a custom comparer to sort our Product<\/code> items by Id<\/code> via the Comparer<T><\/code>:<\/p>\npublic sealed class ProductIdComparer : Comparer<Product?><\/code><\/p>\nSince we are looking to implement a comparer for the Product<\/code> class, we derive from the generic Comparer<T><\/code> class passing in Product<\/code> for our generic type argument.<\/p>\nNext, we need to implement Compare()<\/code>, just like we did when implementing the IComparer<T><\/code> interface:<\/p>\npublic override int Compare(Product? a, Product? b)\r\n{\r\n \/\/ removed for brevity\r\n return a.Id.CompareTo(b.Id);\r\n}<\/pre>\nFor brevity, we have omitted the first three lines of the method, as they are identical to lines 3-5 in the IComparer<T><\/code> implementation. In our case, we are defining a comparison based on the Id<\/code> of the Product<\/code>. With this as our goal, all we need to do is return the result of the Id<\/code> comparison.<\/p>\nOne important<\/strong> difference to note between implementing the IComparer<T><\/code> interface and deriving from Comparer<T><\/code> is the signature of the Compare()<\/code> method. When implementing the interface, we simply define a public Compare()<\/code> method. When deriving from the base class, we have to override<\/strong> the Compare()<\/code> method.<\/p>\nComparer<T> Implementation in Action<\/h3>\n
Let’s take a look at our Id<\/code> comparer in action:<\/p>\nvar productList = new List<Product?>(products);\r\nproductList.Sort(new ProductIdComparer());<\/pre>\nThe result:<\/p>\n
NULL NULL $0.00 00000000-0000-0000-0000-000000000000\r\nTasty Cheese Clothing $134.74 4af80b60-3e17-1dfd-8462-c009ca918154\r\nGeneric Car Games $75.18 c65100fd-e49f-f5e0-0e71-052d7eefe9b3\r\nHandcrafted Hat Books $38.09 c7b30b28-db07-f2ae-70dc-9505096e676b\r\nPractical Chicken Electronics $126.06 d6fee4b9-8767-851a-b386-a8af727663a7\r\nGorgeous Fish Games $103.07 f0569e86-bfad-6f3a-b74d-2555175dcc6e<\/pre>\nSorting With The Comparison<T> Delegate<\/h2>\n
Now, let’s take a look at the Comparison<T><\/code> delegate. This delegate is one of the techniques we can employ when sorting a list. The following signature defines it:<\/p>\npublic delegate int Comparison<in T>(T a, T b);<\/code><\/p>\nJust like our other comparison methods (CompareTo()<\/code> and Compare()<\/code>), the Comparison<T><\/code> delegate returns an int<\/code> based on the sort order of compared objects:<\/p>\n\n< 0<\/code> – a<\/code> precedes b<\/code> in the sort order<\/li>\n0<\/code> – a<\/code> is in the same position as b<\/code> in the sort order<\/li>\n> 0<\/code> – a<\/code> follows b<\/code> in the sort order<\/li>\n<\/ul>\nTo use the Comparison<T><\/code> delegate, we simply invoke the Sort()<\/code> overload that accepts the delegate. We can accomplish this either by passing in a lambda function directly or by defining a method that matches the delegate signature. Let’s look at both options.<\/p>\nDefining Comparison<T> Delegate via a Lambda<\/h3>\n
Here we’ll invoke Sort()<\/code> with a lambda that orders our Product<\/code> items by Category<\/code>:<\/p>\nvar productList = new List<Product?>(products);\r\nproductList.Sort((a, b) =>\r\n{\r\n \/\/ object and null checks removed for brevity\r\n var result = string.Compare(a.Category, b.Category, StringComparison.OrdinalIgnoreCase);\r\n\r\n return result != 0 ? result : a.CompareTo(b);\r\n});<\/pre>\nOnce again for brevity, we removed the object and null checks from the code listing, as they are identical to our earlier example. Following those checks, we perform a comparison of the Category<\/code> property. If the Product<\/code> instance a<\/code> and b<\/code> compare share the same category, we fall back to calling the default comparison (Name<\/code>, followed by Price<\/code>).<\/p>\nNow let’s take a look at the result:<\/p>\n
NULL NULL $0.00 00000000-0000-0000-0000-000000000000\r\nHandcrafted Hat Books $38.09 c7b30b28-db07-f2ae-70dc-9505096e676b\r\nTasty Cheese Clothing $134.74 4af80b60-3e17-1dfd-8462-c009ca918154\r\nPractical Chicken Electronics $126.06 d6fee4b9-8767-851a-b386-a8af727663a7\r\nGeneric Car Games $75.18 c65100fd-e49f-f5e0-0e71-052d7eefe9b3\r\nGorgeous Fish Games $103.07 f0569e86-bfad-6f3a-b74d-2555175dcc6e<\/pre>\nDefining Comparison<T> Delegate via a Method<\/h3>\n
As we mentioned earlier, we can also define a method that matches the Comparison<T><\/code> delegate signature and pass that as the argument to the Sort()<\/code> overload, which takes a Comparison<T><\/code>. Let’s see how this works by defining a new static DescendingCompare()<\/code> method in our Product<\/code> class:<\/p>\npublic static int DescendingCompare(Product? a, Product? b) => b?.CompareTo(a) ?? -1;<\/code><\/p>\nThis method is pretty straightforward. Our goal is to sort Products<\/code> in descending order, so all we need to do is “reverse” the comparison result of the current CompareTo()<\/code> implementation. We accomplish this by reversing the operands when performing the comparison. That is, instead of comparing a<\/code> to b<\/code>, we compare b<\/code> to a<\/code>. One thing to note<\/strong> is the return value when b<\/code> is null<\/code>. Because we are sorting in