Jak posortować listę obiektów według określonego pola w języku C#?

Question

mam tej klasy:

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

to mam listę StatInfo, ale nie jestem pewien, jak go uporządkować według polu daty. Czy powinienem użyć metody sortowania? Czy mogę tworzyć własne?

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

Jaki jest najlepszy sposób robienia tego bez konieczności pisania ton kodu (jeśli to możliwe)?

Dzięki

Answer 1

Używanie LINQ:

var sortedList = _allStatInfo.OrderBy(si => si.date).ToList(); 

Sortowanie oryginalną listę:

_allStatInfo.Sort(new Comparison<StatInfo>((x, y) => DateTime.Compare(x.date, y.date))); 

Answer 2

użycie wyrażenia lambda do mapowania parę do porównania:

_allStatInfo.Sort((x, y) => x.date - y.date); 

Answer 3

Dla DateTim e nie powinno być potrzeby porównywania.

_allStatInfo.OrderyBy(d => d.date); 

lub

_allStatInfo.OrderByDescending(d => d.Date); 

Answer 4

Aby zilustrować Robert C. Cartaino za odpowiedź:

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(); 

nie najbardziej ogólne rozwiązanie, ale dobre, jeśli tylko będzie sortować według daty. I, jak powiedział Robert, wciąż możesz zawsze przesłonić sortowanie domyślne, przekazując parametr IComparer do metody sortowania.

Answer 5

widzę masz odpowiedź tak, ale ...

1. można uniknąć tylko przez pewną brzydotę podział oświadczenie na dwie połówki:

   Comparison<StatInfo> comparison = (x, y) => DateTime.Compare(x.date, y.date); 
   _allStatInfo.Sort(comparison); 
   

   Możesz chcieć rozważyć właśnie dzwoni CompareTo bezpośrednio, za:

   Comparison<StatInfo> comparison = (x, y) => x.date.CompareTo(y.date); 
   _allStatInfo.Sort(comparison); 
   

2. można by utworzyć IComparer<T> Implementacja przy użyciu mojej klasy ProjectionComparer - jest częścią MiscUtil, a na tę odpowiedź dołączono wersję bez komentarza u dołu . Można by wtedy napisać:

   _allStatInfo.Sort(ProjectionComparer<StatInfo>.Create(x => x.date)); 
   

3. Nawet jeśli używasz .NET 2.0, można nadal korzystać z LINQ drodze LINQBridge.

Oto klasa ProjectionComparer wymagana dla drugiej odpowiedzi. Pierwsze dwie klasy są naprawdę tylko pomocnikami, aby pozwolić, aby ogólne wnioskowanie typu działało lepiej.

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)); 
    } 
} 

Answer 6

pracował dla mnie ُSorting array of custom type using delegate

// 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 + " ");