Comment trier une liste d'objets par un champ spécifique en C#?

J'ai cette classe:

public class StatInfo
{
  public string contact;
  public DateTime date;
  public string action;
}

puis-je avoir une liste de StatInfo, mais je ne suis pas sûr de la façon de les trier selon la date de champ. Dois-je utiliser la méthode de tri? Dois-je créer mon propre?

var _allStatInfo = new List<StatInfo>();
//adding lots of stuff in it
_allStatInfo.SortByDate???

Quelle est la meilleure façon de le faire sans avoir à écrire des tonnes de code (si possible)?

Grâce

Attendre Jon Skeet de montrer. Son C# en Profondeur: Ce que vous devez à la maîtrise de C# 2 et 3 a une grosse section sur tout ce qui.
Trop tard! Je suis toujours surpris quand un de mes questions sur le C# ne pas obtenir une réponse de Jon Skeet 🙂
le titre est faux. dit "array"

InformationsquelleAutor marcgg | 2009-08-19

c#sorting

61

À l'aide de LINQ:
```
var sortedList = _allStatInfo.OrderBy(si => si.date).ToList();
```
De tri de la liste d'origine:
```
_allStatInfo.Sort(new Comparison<StatInfo>((x, y) => DateTime.Compare(x.date, y.date)));
```
- Merci, la deuxième méthode a fonctionné. Je n'ai pas utiliser LINQ donc je ne peux pas tester le second.
InformationsquelleAutor Ben M
15

Je vois que vous avez la réponse, de toute façon, mais...
1. Vous pouvez éviter certains laideur par juste le fractionnement de la déclaration en deux moitiés:
```
Comparison<StatInfo> comparison = (x, y) => DateTime.Compare(x.date, y.date);
_allStatInfo.Sort(comparison);
```
  Vous pourriez envisager d'appeler CompareTo directement, trop:
```
Comparison<StatInfo> comparison = (x, y) => x.date.CompareTo(y.date);
_allStatInfo.Sort(comparison);
```
2. Vous pouvez créer une IComparer<T> mise en œuvre à l'aide de mon ProjectionComparer classe
  c'est une partie de MiscUtil, et j'ai inclus une version sans commentaire au bas de
  cette réponse. Vous devez ensuite écrire:
```
_allStatInfo.Sort(ProjectionComparer<StatInfo>.Create(x => x.date));
```
3. Même si vous êtes en utilisant .NET 2.0, vous pouvez toujours utiliser LINQ par LINQBridge.
Voici la ProjectionComparer classe requise pour la deuxième réponse. Les deux premières classes sont vraiment juste des aides pour laisser l'inférence de type générique fonctionne mieux.
```
public static class ProjectionComparer
{
public static ProjectionComparer<TSource, TKey> Create<TSource, TKey>
(Func<TSource, TKey> projection)
{
return new ProjectionComparer<TSource, TKey>(projection);
}
public static ProjectionComparer<TSource, TKey> Create<TSource, TKey>
(TSource ignored, Func<TSource, TKey> projection)
{
return new ProjectionComparer<TSource, TKey>(projection);
}
}
public static class ProjectionComparer<TSource>
{
public static ProjectionComparer<TSource, TKey> Create<TKey>
(Func<TSource, TKey> projection)
{
return new ProjectionComparer<TSource, TKey>(projection);
}
}
public class ProjectionComparer<TSource, TKey> : IComparer<TSource>
{
readonly Func<TSource, TKey> projection;
readonly IComparer<TKey> comparer;
public ProjectionComparer(Func<TSource, TKey> projection)
: this (projection, null)
{
}
public ProjectionComparer(Func<TSource, TKey> projection,
IComparer<TKey> comparer)
{
projection.ThrowIfNull("projection");
this.comparer = comparer ?? Comparer<TKey>.Default;
this.projection = projection;
}
public int Compare(TSource x, TSource y)
{
//Don't want to project from nullity
if (x==null && y==null)
{
return 0;
}
if (x==null)
{
return -1;
}
if (y==null)
{
return 1;
}
return comparer.Compare(projection(x), projection(y));
}
}
```
- Vous voulez dire que mon code est moche? 🙁
- Oh merci, juste quand je disais que je n'avais pas à avoir une réponse de votre part sur un C# question 🙂 je vais garder Ben la réponse est acceptée, mais je upvoted la vôtre, et je suis sûr que ce sera juste en dessous
- Je n'aime pas que beaucoup de parenthèses si je peux aider 🙂
- Jon, dans votre Compare méthode, sont nulles vérifie vraiment nécessaire? Qui devrait être laissé à l'appelant.
- Je n'ai pas tellement. Vous voulez être en mesure de commander par foo => foo.Name sans avoir à faire foo => foo == null ? null : foo.Name de l'OMI.
- L'exemple que vous pourrait être mieux écrit, mais cela n'est pas le cas. Que faire si nous fournir une méthode comme Compute(int, string) comme la projection, comme _allStatInfo.Sort(ProjectionComparer<StatInfo>.Create(x => Compute(someInt, x))) où la valeur null pour x est parfaitement acceptable? Lancer une référence nulle exception ou d'ignorer une valeur null devrait être à la discrétion de la projection si cela doit être entièrement générique..
- Vous pouvez toujours créer une surcharge pour que, si vous le souhaitez. Mais je pense qu'il est utile de ne pas pour traiter explicitement la valeur null pour le cas le plus courant. Notez que c'est aussi l'approche que Comparer<T>.Default prend.
- Je n'ai pas ce que tu voulais dire par la surcharge? D'où une surcharge dans ce scénario?
- Je ne sais pas si c'est approprié de comparer avec Comparer<T>.Default parce que Default compare x et y (votre exemple) en tant que tel, et non pas une projection de x et y. Dans un tel cas, il est parfaitement logique pour gérer les valeurs null, parce que l'ensemble de la logique de comparaison est dans le IComparer<T> mise en œuvre.
- Eh bien, c'est un peu le fait, que le client n'obtient pas de travailler sur la façon de gérer une valeur non nulle d'être comparé avec une valeur null d'un, il est censé suivre le contrat d'origine. Quand j'ai parlé des surcharges, en fait, je voulait dire que vous pouvez ajouter une autre méthode nom (pas de surcharge, désolé) pour la classe statique, de sorte que la comparaison pourrait savoir si ou de ne pas transmettre les valeurs null ou le long de la poignée elle-même.
- J'ai compris à propos de la surcharge de la partie. Mais je pense que vous n'avez pas de moi bien sur mon point de vue sur la nature de votre Compare méthode. Je comprends le désagrément de l'appelant s'il s'agit de vérifier les valeurs null à l'avance, et il est convenu que c'est la majorité des cas. Mais mon point est qu'il y a pas de contrat original ici en cas de projections. À moins que le contrat ne couvre pas tous les scénarios.
- Si x == null & y != null, & si nous avons à comparer x & y, le contrat initial serait x < y comme vous le dites, ce qui est correct. Mais si nous avons à comparer projection(x) & projection(y) où x & y peut être nulle, alors il n'y a pas de contrat d'origine - tout dépend du contexte de l'appelant. C'est là que votre tentative échoue. Ce que j'essaie de dire, c'est il y a un bug dans votre code, mais il est rare. Par exemple, new[] { "-1", null, "1" }.Sort(ProjectionComparer<string>.Create(x => Convert.ToInt32(x))) votre code renvoie [null, "-1", "1"] mais attendu est ["-1", null, "1"]
- Ce n'est pas un bug, c'est de travailler comme je l'ai conçu pour le travail. C'est juste pas ce que vous en attendre. Nous avons des idées différentes sur la façon dont il doit de travail. Notez que ma mise en œuvre obéit à des docs pour IComparer<T>.Compare, tandis que d'autres projections ne pourrait pas. Après tout, nous est être demandé de comparer x et y, et la comparaison est par l'intermédiaire d'une projection - votre "attendre" les résultats de violer le marché documenté, même si c'est ce que vous voulez vraiment.
- Je pense alors que nous avons une différence d'opinion sur la manière d'une projection devrait fonctionner. Mon idée, c'est quand vous dites _allStatInfo.Sort(ProjectionComparer<StatInfo>.Create(x => x.date)) il devrait régler _allStatInfo basé sur la date propriété des objets indépendamment de l'élément. Sinon, sur quelle base est quelque chose comme items.OrderBy(x => Guid.NewGuid()) écrit? Mais vous dire qu'il devrait être respectif de l'élément. Pouvez-vous m'indiquer une documentation à ce sujet? Je suis désolé d'avoir dérangé avec cette. Je vais faire une nouvelle question si elle justifie..
- Bien que la documentation de IComparer<T>.Compare est ici: msdn.microsoft.com/en-us/library/xh5ks3b3.aspx Vous pourriez certainement faire valoir que IComparer<T> a été mal conçu sur ce front, mais ProjectionComparer<T> est destinée à mettre en place, et je crois que votre suggestion serait fondamentalement violer le contrat.
- merci pour le lien, certainement utiles. Je voudrais prendre cette recommandation comme une ligne directrice spécifique lors de la mise en œuvre de IComparer<T> sur null-throwable implémentations, comme foo.Name (qui est la norme généralement) qui a du sens. Mais dans un générique de mise en œuvre, comme la vôtre, je voudrais l'éviter. Ou encore mieux, peut-être que nous pourrions prendre un Expression<Func<>> comme entrée et de mettre en œuvre un fou approche hybride! 🙂
- Quelle raison avez-vous pour l'interprétation du contrat de cette manière? Je ne vois rien dans la documentation de l'interface qui dit "Vous pouvez l'ignorer si vous le souhaitez, en particulier si vous êtes en déléguant à un autre comparer sous le capot." C'est tout simplement une partie du comportement attendu de la Compare méthode. Encore une fois, qui peut avoir été une mauvaise idée - mais il est le comportement documenté.
- J'ai parfaitement comprendre ce que vous dites. La raison me pousserait à ignorer la remarque dans la documentation sont deux: 1. La lecture de cette partie j'ai senti MS portait davantage sur Compare méthode jeter référence nulle exception. De plus, comme il a été considéré que pour les foo.Name scénarios. 2. J'ai senti qu'il était logiquement incorrecte à ignorer les valeurs nulles sans savoir ce que la projection ne faire avec cette valeur null. Jon, sur une seconde pensée, je pense que MS l'idée a du sens aussi. Surtout quand vous avez dit: Après tout, on nous demande de comparer x et y, et la comparaison est par l'intermédiaire d'une projection
InformationsquelleAutor Jon Skeet
4

Pour illustrer Robert C. Cartaino réponse:
```
public class StatInfo : IComparable<StatInfo>
{
public string contact;
public DateTime date;
public string action;
public int CompareTo(StatInfo value)
{
return this.date.CompareTo(value.date);
}
}
var _allStatInfo = new List<StatInfo>();
//this now sorts by date
_allStatInfo.Sort();
```
Pas la plus générale de la solution, mais bon si vous allez seulement pour trier par date. Et, comme Robert a dit, vous pouvez toujours remplacer la valeur par défaut tri par le passage d'un IComparer paramètre à la méthode de tri.
- merci. Elle ne s'applique pas vraiment à ma situation car je ne vais trier par date dans cette situation particulière, mais je vais garder ça en tête pour plus tard
- Le code dans ma réponse est le tri par date le comportement par défaut. Donc, si vous êtes seulement de tri par date, je pense que c'est exactement ce que vous voulez.
InformationsquelleAutor Dan Tao
3

Utiliser une expression lambda à la carte d'une paire à une comparaison:
```
_allStatInfo.Sort((x, y) => x.date - y.date);
```
- Merci pour la réponse, mais j'obtiens un message d'erreur: Impossible de convertir l'expression lambda pour le type de Système.Les Collections.Génériques.IComparer<AdminTool.app.modèles.StatInfo> " car il n'est pas un type délégué
- Vous avez besoin d'au moins de C# 3.0 (Visual Studio 2008/peu importe l'édition).
InformationsquelleAutor Cecil Has a Name

il a travaillé pour moi ُDe tri de tableau de type personnalisé à l'aide de délégué

//sort array by name
Array.Sort(users, delegate(User user1, User user2) 
{
return user1.Name.CompareTo(user2.Name);
});
//write array (output: Betty23 Lisa25 Susan20)
foreach (User user in users) Console.Write(user.Name + user.Age + " ");

Merci, la seule solution qui a fonctionné pour moi.

InformationsquelleAutor Mina

1

Pour un DateTime il ne devrait pas être nécessaire de comparer.
```
_allStatInfo.OrderyBy(d => d.date);
```
ou
```
_allStatInfo.OrderByDescending(d => d.Date);
```
- Les deux méthodes retournent la liste, de sorte que vous devez _allStatInfo = _allStatInfo.OrderBy(d => d.la date).ToList();
- Merci, mais une Liste<> n'a pas de telles fonctions, si je ne suis pas confondre
- Je suppose que c'est LINQ. Je ne suis pas à l'aide de LINQ
InformationsquelleAutor TruthStands

Vous devez vous connecter pour publier un commentaire.