dotnet .net core 2 OrderBy/OrderByDescending avec le paramètre générique

Question

Je veux créer une manière dynamique de renvoyer une liste triée par le paramètre xy. La liste peut être triée par ordre décroissant, ascendant, par identifiant, nom d'utilisateur, courrier électronique et bien d'autres choses encore.

Je reçois ce paramètre sous forme de chaîne. Ainsi par exemple sort=-username

Le moins indique que la liste est descendante. Et le paramètre de tri est nom d'utilisateur.

Je reviens donc user.OrderByDescending(o => o.Username).ToList();

Au moment, avec l'aide d'une longue construction si-bien je perçois que le tri est nécessaire. Mon espoir est que je peux remplacer le paramètre de chaîne de tri avec l'aide d'une fonction au paramètre d'objet.

pseudocode

//input for example: sort=-username 
Boolean isAscending = isAscending(sort) //return true or false 
var parameter = isSortStringInsideObject(sort) // 
if (isAscending) { 
    user.OrderBy(o => o.parameter).ToList(); 
} else { 
    user.OrderByDescending(o => o.parameter).ToList(); 
} 

Donc paramètre peut être tous les paramètres dans l'objet.

Je suis nouveau dans le noyau .net. J'espère donc que je n'ai pas formulé d'exigence utopique.

Answer 1

Quelque chose comme ça devrait faire l'affaire (par réflexion):

var isAscending = GetIsAscending(sort); 
var pi = typeof(User).GetProperty(parameter); 
if (pi != null) 
    user = isAscending 
     ? user.OrderBy(a => pi.GetValue(a, null)) 
     : user.OrderByDescending(a => pi.GetValue(a, null)); 

Answer 2

Je vais essayer de le garder dactylographiée et utiliser une carte avec des chaînes à funcs afin que vous puissiez rechercher la valeur à venir et mapper .

var list = new List<Item> { new Item() { Name = "aob", Age = 11 }, new Item() {Name = "bob", Age = 10},}; 
var input = "-name"; 

var map = new Dictionary<string, Func<Item, object>>() 
{ 
    {"name", x => x.Name}, 
    {"age", x => x.Age} 
}; 

if (input.StartsWith('-')) 
{ 
    var orderby = map[input.Substring(1)]; 
    var orderedEnumerable = list.OrderByDescending(orderby); 
} 
else 
{ 
    var orderby = map[input]; 
    var orderedEnumerable = list.OrderBy(orderby); 
} 

Answer 3

Intéressant .. il peut être aussi pertinent d'utiliser l'espace de noms System.Linq.Expression pour créer dynamiquement une func passée à l'ordre ou OrderByDescending, surtout si de nombreux paramètres de tri possibles sont attendus.

E.g. après que nous avons un paramètre de chaîne

var parameter = isSortStringInsideObject(sort) 

il est possible de construire une fonction comme celui-ci (T est le type pour l'utilisateur):

Dictionary<string, PropertyInfo> properties = typeof(T).GetProperties().ToDictionary(pi => pi.Name); 
ParameterExpression parameterExpression = Expression.Parameter(typeof(T)); 
Expression expression = Expression.MakeMemberAccess(parameterExpression, properties[parameter]); 
Func<T, string> orderFunc = Expression.Lambda<Func<T, string>>(expression, parameterExpression).Compile(); 

ressemble un peu lourd :) mais il peut être efficace.