Trier une liste & lt; T & gt; en utilisant des expressions de requête

J'ai un problème à l'aide de Linq pour commander une structure comme ceci :

public class Person
{
    public int ID { get; set; }
    public List<PersonAttribute> Attributes { get; set; }
}

public class PersonAttribute
{
    public int ID { get; set; }
    public string Name { get; set; }
    public string Value { get; set; }
}

Une personne peut aller comme ceci:

PersonAttribute Age = new PersonAttribute { ID = 8, Name = "Age", Value = "32" };
PersonAttribute FirstName = new PersonAttribute { ID = 9, Name = "FirstName", Value = "Rebecca" };
PersonAttribute LastName = new PersonAttribute { ID = 10, Name = "LastName", Value = "Johnson" };
PersonAttribute Gender = new PersonAttribute { ID = 11, Name = "Gender", Value = "Female" };

Je voudrais utiliser LINQ projection de tri d'une liste de personnes de l'ascendant en la personne de l'attribut de mon choix, par exemple, un tri sur l'Âge, ou tri sur Prénom.

Je suis en train d'essayer quelque chose comme

string mySortAttribute = "Age"
PersonList.OrderBy(p => p.PersonAttribute.Find(s => s.Name == mySortAttribute).Value);

Mais la syntaxe est de ne pas en moi. Toute indices?

source d'informationauteur | 2009-03-30

c#expression linq sorting

OrderBy est une extension LINQ qui produit une nouvelle séquence. À l'ordre de la séquence existante, vous devez ajouter une méthode d'extension ou deux... ensuite, vous pouvez utiliser:

PersonList.Sort(p => p.Attributes.Find(
  s => s.Name == mySortAttribute).Value);

public static class ListExtensions {
  public static void Sort<TSource, TValue>(
    this List<TSource> source,
    Func<TSource, TValue> selector)
  {
    var comparer = Comparer<TValue>.Default;
    source.Sort((x, y) => comparer.Compare(selector(x), selector(y)));
  }
  public  static void SortDescending<TSource, TValue>(
    this List<TSource> source,
    Func<TSource, TValue> selector)
  {
    var comparer = Comparer<TValue>.Default;
    source.Sort((x, y) => comparer.Compare(selector(y), selector(x)));
  }
}

Je sais que c'est un vieux post, mais je pensais que je poste un comparateur, j'ai trouvé il y a un moment dans le cas où quelqu'un d'autre en a besoin.

public class GenericComparer<T> : IComparer<T>
 {
     public string SortExpression { get; set; }
     public int SortDirection { get; set; } //0:Ascending, 1:Descending

     public GenericComparer(string sortExpression, int sortDirection)
     {
         this.SortExpression = sortExpression;
         this.SortDirection = sortDirection;
     }
     public GenericComparer() { }

     #region IComparer<T> Members
     public int Compare(T x, T y)
     {
         PropertyInfo propertyInfo = typeof(T).GetProperty(SortExpression);
         IComparable obj1 = (IComparable)propertyInfo.GetValue(x, null);
         IComparable obj2 = (IComparable)propertyInfo.GetValue(y, null);

         if (SortDirection == 0)
         {
             return obj1.CompareTo(obj2);
         }
         else return obj2.CompareTo(obj1);
     }
     #endregion
 }

Utilisation

List<MyObject> objectList = GetObjects(); /* from your repository or whatever */
objectList.Sort(new GenericComparer<MyObject>("ObjectPropertyName", (int)SortDirection.Descending));
dropdown.DataSource = objectList;
dropdown.DataBind();

Vous peut surcharger le constructeur d'accepter la SortDirection enum. Je n'avais pas le faire parce que la classe est dans une bibliothèque sans une référence à System.Web.

Pourquoi n'utilisez-vous pas une valeur-clé de dictionnaire au lieu de votre Liste<PersonAttribute> ? Il conviendrait le mieux, je pense, et faire tout le reste plus facile.

Mise à jour comme ceci:

public class Person
{
  public Dictionary<string, string> Attributes = new Dictionary<string,string>();
}

List<Person> people = new List<Person>();

Person rebecca = new Person();
rebecca.Attributes["Age"] = "32";
rebecca.Attributes["FirstName"] = "Rebecca";
rebecca.Attributes["LastName"] = "Johnson";
rebecca.Attributes["Gender"] = "Female";
people.Add(rebecca);

var PeopleInAgeOrder = people.OrderBy(p => p.Attributes["Age"]);

C'est en supposant que l'Attribut de classe en œuvre IComparable ou a une belle fonction ToString (je l'espère).

var list = personList.OrderBy(p => p.Attributes.FirstOrDefault(a => a.Name == "Age"))

Sinon, la syntaxe devient plus compliquée:

var list = personList
            .OrderBy(p => 
                     p.Attributes.FirstOrDefault(a => a.Name == "Age") == null ?
                     "" : p.Attributes.First(a => a.Name == "Age").Value
            );

J'ai aussi supposer que vous avez une seule valeur pour chaque clé - sinon, vous auriez besoin d'avoir plus intelligente de code... 😉

0

Pourrait-il que votre syntaxe est mauvaise? Votre propriété est appelée Attributs, mais votre utilisation de quelque chose qui s'appelle ObjectSettings dans le code? Ou est-ce une faute de frappe.

Si c'est ton code a l'air bien moins que pas toutes les Personne instances de l'Attribut que vous essayez de faire une commande dans ce cas, vous obtiendrez une exception.

EDIT:
Aussi, au lieu d'utiliser le Trouver, essayez d'utiliser en Premier.
```
PersonList.OrderBy(p => p.Attributes.First(a => a.Name == "Age").Value)
```

J'imagine que vous avez une exception dans le cas où un article n'est pas un attribut d'âge.
J'ai essayé le code ci-dessous, et il a bien fonctionné - je suppose que vos données sont un peu hors, comme souligné par d'autres affiches. De toute façon, le ci-dessous fonctionne très bien...

    List<Person> personList = new List<Person>();
    Random rand = new Random();

    //generate 50 random persons
    for (int i = 0; i < 50; i++)
    {
        Person p = new Person();
        p.Attributes = new List<PersonAttribute>();
        p.Attributes.Add(new PersonAttribute() { ID = 8, Name = "Age", Value = rand.Next(0, 100).ToString() });
        p.Attributes.Add(new PersonAttribute() { ID = 10, Name = "Name", Value = rand.Next(0, 100).ToString() });
        personList.Add(p);
    }

    var finalList = personList.OrderBy(c => c.Attributes.Find(a => a.Name == "Age").Value).ToList();

Certains cas, vous devez tenir compte:

Depuis votre attribut est dans la corde à un âge "30" et "3" seront commandés avant l'époque de la "4"
L'attribut peut ne pas exister

Si vous créez cette extension des méthodes de classe:

public static class ListExtenstions
{
    public static List<Person> OrderList(this List<Person> list, string attributeName, PersonAttribute defaultAttribute)
    {
        return OrderList(list, attributeName, defaultAttribute, x => x);
    }

    public static List<Person> OrderList<T>(this List<Person> list, string attributeName, PersonAttribute defaultAttribute, Func<string, T> convertion)
    {
        return list.OrderBy(x => convertion((x.Attributes.FirstOrDefault(y => y.Name == attributeName) ?? defaultAttribute).Value)).ToList();

        //Query Syntax
        //return
        //   (from p in list
        //    let attribute = p.Attributes.FirstOrDefault(a => a.Name == attributeName) ?? defaultAttribute
        //    orderby attribute.Value
        //    select p).ToList();
    }
}

Vous pouvez ensuite trier la liste correctement de cette manière:

List<Person> persons = ...
...
PersonAttribute defaultAttribute = new PersonAttribute() { Value = "0" };
var ordered = persons.OrderList("Age", defaultAttribute, x => Convert.ToInt32(x));

Cela donnera à corriger ordre de tri.
Si l'attribut est toujours présent, vous pouvez supprimer defaultAttribute.

De tri, 'Nom' suffit d'utiliser:

List<Person> persons = ...
...
PersonAttribute defaultAttribute = new PersonAttribute() { Value = String.Empty };
var ordered persons.OrderList("Name", defaultAttribute);

Vous devez vous connecter pour publier un commentaire.