Comment puis-je faire un Tri avec une dynamique de paramètre de chaîne?

Si vous utilisez de la plaine de LINQ-to-objets et ne veulent pas prendre une dépendance sur une bibliothèque externe, il n'est pas difficile d'obtenir ce que vous voulez.

La OrderBy() clause accepte un Func<TSource, TKey> qui obtient une sorte de clé à partir d'un élément source. Vous pouvez définir la fonction à l'extérieur de la OrderBy() clause:

Func<Item, Object> orderByFunc = null;

Vous pouvez attribuer des valeurs différentes selon les critères de tri:

if (sortOrder == SortOrder.SortByName)
  orderByFunc = item => item.Name;
else if (sortOrder == SortOrder.SortByRank)
  orderByFunc = item => item.Rank;

Alors vous pouvez trier:

var sortedItems = items.OrderBy(orderByFunc);

Cet exemple suppose que le type de source est Item qui ont des propriétés Name et Rank.

Notez que dans cet exemple TKey est Object de ne pas contraindre les types de biens qui peuvent être triés sur. Si la fonction renvoie une valeur de type (comme Int32), elle obtiendra la boîte lors du tri et qui est quelque peu inefficace. Si vous pouvez contraindre TKey à un type de valeur spécifique, vous pouvez contourner ce problème.

Vous n'avez pas besoin d'une bibliothèque externe pour cela. Le code ci-dessous fonctionne pour LINQ to SQL/entités.

    ///<summary>
    ///Sorts the elements of a sequence according to a key and the sort order.
    ///</summary>
    ///<typeparam name="TSource">The type of the elements of <paramref name="query" />.</typeparam>
    ///<param name="query">A sequence of values to order.</param>
    ///<param name="key">Name of the property of <see cref="TSource"/> by which to sort the elements.</param>
    ///<param name="ascending">True for ascending order, false for descending order.</param>
    ///<returns>An <see cref="T:System.Linq.IOrderedQueryable`1" /> whose elements are sorted according to a key and sort order.</returns>
    public static IQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> query, string key, bool ascending = true)
    {
        if (string.IsNullOrWhiteSpace(key))
        {
            return query;
        }

        var lambda = (dynamic)CreateExpression(typeof(TSource), key);

        return ascending 
            ? Queryable.OrderBy(query, lambda) 
            : Queryable.OrderByDescending(query, lambda);
    }

    private static LambdaExpression CreateExpression(Type type, string propertyName)
    {
        var param = Expression.Parameter(type, "x");

        Expression body = param;
        foreach (var member in propertyName.Split('.'))
        {
            body = Expression.PropertyOrField(body, member);
        }

        return Expression.Lambda(body, param);
    }

(CreateExpression copié à partir de https://stackoverflow.com/a/16208620/111438)

Oeil à ce blog ici. Il décrit une façon de le faire, par la définition d'un EntitySorter<T>.

Il vous permet de passer dans un IEntitySorter<T> à votre service des méthodes et de l'utiliser comme ceci:

public static Person[] GetAllPersons(IEntitySorter<Person> sorter)
{
    using (var db = ContextFactory.CreateContext())
    {
        IOrderedQueryable<Person> sortedList = sorter.Sort(db.Persons);

        return sortedList.ToArray();
    }
}

Et vous pouvez créer un EntitiySorter comme ceci:

IEntitySorter<Person> sorter = EntitySorter<Person>
    .OrderBy(p => p.Name)
    .ThenByDescending(p => p.Id);

Ou comme ceci:

var sorter = EntitySorter<Person>
     .OrderByDescending("Address.City")
     .ThenBy("Id");

Vous avez besoin d'utiliser LINQ Dynamique Requête de la Bibliothèque afin de passer des paramètres au moment de l'exécution,

Cela permettra linq des déclarations comme

string orderedBy = "Description";
var query = (from p in products
orderby(orderedBy)
select p);