1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

List<Daten> wertList = new List<daten>();
wertList.Add(new Daten{ wert = "test5"});
wertList.Add(new Daten{ wert = "test3"});
wertList.Add(new Daten{ wert = "test2"});
wertList.Add(new Daten{ wert = "test7"});

var x = wertList.OrderBy("wert", true);

foreach (var c in x)
{
    System.Diagnostics.Debug.WriteLine(c.wert);
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:

public static class DynamicEnumerable
{
    public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> query, string propertyName, bool ascending)
    {
        ParameterExpression prm = System.Linq.Expressions.Expression.Parameter(typeof(T), "it");

        System.Linq.Expressions.Expression property = System.Linq.Expressions.Expression.Property(prm, propertyName);

        Type propertyType = property.Type;

        MethodInfo method = typeof(DynamicEnumerable).GetMethod("OrderByProperty", BindingFlags.Static | BindingFlags.NonPublic)
            .MakeGenericMethod(typeof(T), propertyType);

        return (IEnumerable<T>)method.Invoke(null, new object[] { query, prm, property, ascending });
    }

    private static IEnumerable<T> OrderByProperty<T, P>(this IEnumerable<T> query, ParameterExpression prm, System.Linq.Expressions.Expression property, bool ascending)
    {
        Func<IEnumerable<T>, Func<T, P>, IEnumerable<T>> orderBy = (q, p) => ascending ? q.OrderBy(p) : q.OrderByDescending(p);
        return orderBy(query, System.Linq.Expressions.Expression.Lambda<Func<T, P>>(property, prm).Compile());
    }
}

class Daten
{
    public string wert
    {
        get;
        set;
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:

// Compiliert, wirft aber zur Laufzeit Exception beim Aufruf variante1.OrderBy("wert", true)
var variante1 = _List.Cast<object>();  

// Bei variante2.OrderBy("wert", true) wird beim compilieren OrderBy nicht gefunden.
IEnumerable variante2 = _List as IEnumerable;

// Compiliert nicht
IEnumerable<object> variante2 = _List as IEnumerable<object>;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

class Sorthelper
{
public Sorthelper(Object object, String column)
{
// Wert mittels Reflection ermitteln object.column und der Property Wert zuweisen

}
public String Wert
{
get;
set;
}
}                    

1:
2:
3:
4:
5:
6:

public static IEnumerable OrderByProperty(this IEnumerable self, string propertyName)
{
  return
    self.Cast<object>()
    .OrderBy(o => o.GetType().GetProperty(propertyName).GetValue(o, null));
}