public enum SortDirection
{
   Ascending, Descending
}

public class ListSorter where T : class
{
  public static List Sort
(
              List listToSort,
              string propertyName,
              SortDirection direction) where P : IComparable
  {
    Type propertyType = typeof (P);
    Type comparableInterface = propertyType.GetInterface("IComparable");

    if (comparableInterface == null)
        throw new Exception("Properties to sort by must be IComparable");

    listToSort.Sort(
        delegate(T x, T y)
            {
              PropertyInfo p1 = x.GetType().GetProperty(propertyName, propertyType);
              PropertyInfo p2 = y.GetType().GetProperty(propertyName, propertyType);

              object p1objvalue = p1.GetValue(x, null);
              object p2objvalue = p2.GetValue(y, null);

              P p1value = (P)p1objvalue;
              P p2value = (P)p2objvalue;

              if (direction == SortDirection.Ascending)
                  return p1value.CompareTo(p2value);
              else
                  return p2value.CompareTo(p1value);
          });

    return listToSort;
  }
}

To sort a list of Person objects by the string property FirstName do the following:

List myUnsortedList = GetPersonsInRandomOrder();
List sortedList =  ListSorter
                                     .Sort(
                                     myUnsortedList,
                                     "FirstName",
                                     SortDirection.Ascending);

To sort a list of Person objects by the int property Age do the following:

List myUnsortedList = GetPersonsInRandomOrder();
List sortedList =  ListSorter
                                     .Sort(
                                     myUnsortedList,
                                     "Age",
                                     SortDirection.Ascending);

If you have the luxury of using .NET Framework 3.0 or 3.5 you can use Linq to solve the problem really quick:

var sortedPersonList = from p in unsortedPersonList
                               orderby p.FirstName
                               select p;

foreach (var person in sortedPersonList)
{
    Console.WriteLine(person.FirstName + " " + person.LastName);
}

Leave a comment to this post if you have any thoughts.

Most of the problems you can brute force in resonable time, but the challenge is more of a personal level in trying to solve them elegant or in as few lines as possible.

I quickly found that the magic of yield return and Linq was well suited to solve several of the problems I’ve encountered yet. So I decided to write a blog post about them and share my new-found knowlege of Linq.

Problem 1: Add all the natural numbers below one thousand that are multiples of 3 or 5

The Enumerable pattern is quite extraordinary when used in Linq like this. So I decided to use the same pattern on other problems as well.

[code lang="csharp"]
return Enumerable.Range(1, 999)
.Where(x => x % 5 == 0 || x % 3 == 0)
.Sum();
[/code]

Problem 2: Find the sum of all the even-valued terms in the Fibonacci sequence which do not exceed four million

First I made a sequence generator for Fibonacci numbers:

[code lang="csharp"]
internal static IEnumerableFibonacciSequence()
{
  long last1 = 1;
  yield return 1;

  long last2 = 2;
  yield return 2;

  while (true)
  {
    long next = last1 + last2;
    last1 = last2;
    last2 = next;
    yield return next;
  }
}
[/code]

Problem 3: What is the largest prime factor of the number 600851475143 ?

Again I start with creating a sequence generator. This one returns the sequence of factors for any number.

[code lang="csharp"]
internal static IEnumerable GetFactors(long x)
{
    for (long factor = 1; factor * factor <= x; factor++)
    {
        if (x % factor == 0)
        {
            yield return factor;
            if (factor * factor != x)
                yield return x / factor;
        }
    }
}
[/code]

We also need a small helper function to check if a number if a prime number:

[code lang="csharp"]
private static bool IsPrime(long num)
{
  long limit = (long)Math.Sqrt(num);

  for (long d = 2; d <= limit; d++)
  {
      if (num % d == 0)
          return false;
  }

  return true;
}
[/code]

Finally the actual Linq query to find the largest prime factor of the number 600851475143 :

[code lang="csharp"]
var primeFactors = from factor in GetFactors(600851475143)
                          where IsPrime(factor)
                          select factor;

return primeFactors.Max();
[/code]

I also have use the same pattern on several of the other problems like nr 10: Find the sum of all prime numbers below 2 000 000:

[code lang="csharp"]
return PrimeNumbers()
         .TakeWhile(x => x < 2000000)
         .Sum();
[/code]

This seems a simple enough task, but once when the service was down for a long time the number of files waiting to be processed was huge (in the several hundred thousand range). Scanning a folder with that many files in C# and then determining the oldest one takes quite a long time.

So I took a look at three different methods for solving this simple task.

1. Using the DirectoryInfo.GetFiles function
2. Using the Directoty.GetFiles and then Directory.GetLastWriteTime on each file
3. Using plain old DOS dir command

For 50.000 files the first two options takes about 7 seconds each on my development machine. While using dir takes only 0.7 seconds. Thats 10 times the performance difference.

This is how I managed to tweak dir to do the work:

static string ScanFilesUsingDir(string filePath)
{
   string cmd = @"c:\Windows\System32\cmd.exe";
   string args = @"/C \"dir " + filePath + " /B /O:D /T:W\"";

   Process proc = new System.Diagnostics.Process();
   proc.EnableRaisingEvents = false;
   proc.StartInfo.CreateNoWindow = false;
   proc.StartInfo.FileName = cmd;
   proc.StartInfo.Arguments = args;
   proc.StartInfo.RedirectStandardOutput = true;
   proc.StartInfo.UseShellExecute = false;
   proc.Start();

   // Display returned console information if any
   StreamReader dirOutput = proc.StandardOutput;
   string oldestFile = dirOutput.ReadLine();
   dirOutput.Close();

   proc.Kill();
   return oldestFile;
}

Oldest file found: f9e41b18-efa8-49ee-9a51-a89f7ef514ee.tmp
Activity ‘Using DirectgoryInfo’ took 00:00:07.0810000

Oldest file found: f9e41b18-efa8-49ee-9a51-a89f7ef514ee.tmp
Activity ‘Using FileInfo’ took 00:00:07.2710000

Oldest file found: f9e41b18-efa8-49ee-9a51-a89f7ef514ee.tmp
Activity ‘Using Shell Dir’ took 00:00:00.7030000

Just goes to show that POD (Plain Old Dos) still is good for something

Complete source code: FileGenerator.rar