Sempre di più nella mie applicazioni per rappressentare le mie entity non uso i dataset ma delle Collection Tipizzate come avevo già avuto modo di parlare nel post sulla CollectionBase.
Quindi mi sono creato una classe base per le collection che implementa le interfaccie, per creare collection e utilizzare il binding ovvero ICollection,IList e IEnumerable e attraverso un'arraylist carico la collection.

Fin qui niente di particolarmente difficile, invece diventa un pò più complicato quando bisogna implementare il metodo Sort dell'arraylist per poter ordinare la collection.
Per implementare il metodo Sort dell'arraylist dobbiamo implementare o l'interfaccia IComparable o l'interfaccia IComparer. Implementare queste interfaccie non è complicatissimo però dobbiamo sempre compare una singola proprietà che implementi IComparable, tutti i tipi primitivi implementano IComparable con il metodo CompareTo.
Bene visto che la mia collection è una classe di base dovevo farlo per tutte le proprietà(importante che implementino IComparable) e senza dover usare uno switch che è poco scalabile, quindi in questo caso mi è venuta ancora una volta in aiuto la Reflection.

Quindi mi sono creato una classe base che implementa l'interfaccia IComparer e che nel costruttore acetta il nome della proprietà e l'ogetto da ordinare e quindi nel metodo Compare ho fatto la comparazione dell'oggetto.
La classe è cosi fatta

[Serializable()]
public class BaseClassCompare : IComparer
{
#region Private Fields
PropertyInfo propInfo;
#endregion
#region Costructor
/// <summary>
/// Imposta la proprietà 
/// </summary>
/// <param name="key">la proprietà da ordinare</param>
/// <param name="item">l'oggetto da ordinare</param>
public BaseClassCompare(string key, object item)
{
//recupero la proprietà
Type _type = item.GetType();
propInfo = _type.GetProperty(key);
if (propInfo == null)
{
throw new ArgumentException("La proprietà non esiste",key);
}

}
#endregion
#region Comparer
/// <summary>
/// Implementazione dell'interfaccia IComparer
/// </summary>
/// <param name="x">primo oggetto</param>
/// <param name="y">secondo oggetto</param>
/// <returns></returns>
public int Compare(object x, object y)
{
   IComparable a = (IComparable)propInfo.GetValue(x,null);
   return a.CompareTo(propInfo.GetValue(y,null));
}
 

}
#endregion
} // end class - BaseClassCompare


E poi nella mia Collection Base nel metodo Sort faccio
/// <summary>
/// Ordina la collection
/// </summary>
/// <param name="key">la proprietà da ordinare</param>
public void Sort(string key)
{
IComparer icomp = new BaseClassCompare(key, myList[0],ascending);
this.myList.Sort(icomp);
}

dove myList è il mio ArrayList.
Forse con la reflection si perde un pò in prestazioni però se pensate che magari le vostre entità possano cambiare spesso direi che questo è la via migliore.