Sorting Custom Objects with Parameter in .NET?

Question

Let's say I have a custom object of Foo

Is there anyway I can sort through a list of these objects, like

list<of foo>.sort()

and also be able to sort this list with a passable parameter. which will influence the sort?

list<of foo>.sort(pValue)

I'm guessing I'll need to define two separate sorts, but I am not sure.

EDIT: using built-in list. How objects are sorted depends on whether or not a parameter is passed. I could use a global variable and use that for sorting, but that makes bad bac code :p

Answer 1

If you're the one defining the Sort() method, then yes.

It's easy enough to overload the Sort() method in C# (or using an optional parameter in VB.NET).

If you're talking about List.Sort() that is baked into the framework...then I'm not sure what you want to do and you'll need to provide some more details.

Answer 2

declaration (as an extension method):

public static void Sort(this List<Foo> list, Bar param)
{
   // your sorting algorithm
}

usage:

var list = new List<Foo>();
list.Add(new Foo());
list.Sort(); // standard algorithm
list.Sort(new Bar()); // your own algorithm

Answer 3

Take a look at IComparer and IComparable

Answer 4

This is fairly easy in C#. Just create lambda functions for both, and you can specify the parameter right in the lambda function. I know VB supports extension methods, but I'm not sure about lambda functions.

// Sorting ints based on natural order:
List<Int32> ints = GetInts();
ints.Sort((lhs, rhs) => lhs.Compare(rhs));

// Sorting Foo objects based on some computation:
List<Foo> foos = GetFoos();
foos.Sort((lhs, rhs) => lhs.Compute(pValue).Compare(rhs.Compute(pValue)));

Answer 5

You have three choices:

• Your class being sorted can implement IComparable
• You can implement an IComparer<of foo> and use an instance of it when calling sort().
• You can create a function that compares two foo objects and use that function when calling sort().

The advantage of the comparer is you can parametrize it more easily since you create an instance and can set any property in it prior to use. The disadvantage is you have to create a separate class.

The delegate is simpler to use but a little less clean if you want to parametrize the compare.

Answer 6

You should try

list<of foo>.OrderBy( .... )

where inside OrderBy you can use lamda expressions to control your sort algorithm by parameters and the order of sort

Answer 7

As has already been stated, you should have a look at implementing an IComparable interface on your object. You can then create a new class implementing IComparer which will be used to control the sorting you want to apply. There are a couple of good articles here and here that should get you started.