Come posso usare linq per ordinare per più campi?

Question

Sto creando un'origine dati fittizia su cui voglio essere in grado di passare in un elenco di SortExpressions.

public SortExpression(string name, SortDirection direction) 
{ 
    this.name = name; 
    this.direction = direction; 
} 

Aggiornamento con il codice di Jon Skeet e anche l'intera classe. GetData() sta compilando l'oggetto con il numero x di record.

public class Data 
{ 

public int Id { get; set; } 
public Guid gId { get; set; } 
public string Name { get; set; } 
public string Phone { get; set; } 
public string Address { get; set; } 
public DateTime Created { get; set; } 
public string SortMe { get; set; } 
public static List<Data> GetFakeData(int start, int numberToFetch, IList<SortExpression> sortExpressions, IList<FilterExpression> filterExpressions, out int totalRecords) 
{ 
    DataCollection items = GetData(); 
    IEnumerable<Data> query = from item in items select item; 

    bool sortExpressionsExist = sortExpressions != null; 
    if (sortExpressionsExist) 
    { 
     // Won't be read in the first iteration; will be written to 
     IOrderedEnumerable<Data> orderedQuery = null; 
     for (int i = 0; i < sortExpressions.Count; i++) 
     { 
      // Avoid single variable being captured: capture one per iteration. 
      // Evil bug which would be really hard to find :) 
      int copyOfI = i; 
      // Tailor "object" depending on what GetProperty returns. 
      Func<Data, object> expression = item => 
        item.GetType().GetProperty(sortExpressions[copyOfI].Name); 

      if (sortExpressions[i].Direction == SortDirection.Ascending) 
      { 
       orderedQuery = (i == 0) ? query.OrderBy(expression) 
             : orderedQuery.ThenBy(expression); 
      } 
      else 
      { 
       orderedQuery = (i == 0) ? query.OrderByDescending(expression) 
             : orderedQuery.ThenByDescending(expression); 
      } 
     } 
     query = orderedQuery; 
    } 

    bool filterExpressionsExist = filterExpressions != null; 
    if (filterExpressionsExist) 
    { 
     foreach (var filterExpression in filterExpressions) 
     { 
      query.Where(item => item.GetType().GetProperty(filterExpression.ColumnName).GetValue(item, null).ToString().Contains(filterExpression.Text)); 
     } 
    } 
    totalRecords = query.Count(); 


     return query.Skip(start).Take(numberToFetch).ToList<Data>(); 
    } 
} 

Non sembra che stia facendo nulla. Compilazioni, nessun errore, solo nessun tipo. Qualche idea?

Answer 1

Ci sono due problemi. Il primo è quello a cui altri hanno fatto riferimento: è necessario utilizzare il valore restituito da OrderBy ecc. Il secondo è che ogni volta che si chiama OrderBy, si aggiunge un nuovo ordinamento "primario". Vuoi veramente ThenBy dopo che il primo ordine è stato applicato. Questo lo rende piuttosto brutto, sfortunatamente. E 'ancora piuttosto brutto dopo un refactoring, ma non troppo male ...

IEnumerable<Data> query = from item in items select item; 
if (sortExpressionsExist) 
{ 
    // Won't be read in the first iteration; will be written to 
    IOrderedEnumerable<Data> orderedQuery = null; 
    for (int i = 0; i < sortExpressions.Count; i++) 
    { 
     // Avoid single variable being captured: capture one per iteration. 
     // Evil bug which would be really hard to find :) 
     int copyOfI = i; 
     // Tailor "object" depending on what GetProperty returns. 
     Func<Data, object> expression = item => 
       item.GetType() 
        .GetProperty(sortExpressions[copyOfI].Name) 
        .GetValue(item, null); 

     if (sortExpressions[i].Direction == SortDirection.Ascending) 
     { 
      orderedQuery = (i == 0) ? query.OrderBy(expression) 
            : orderedQuery.ThenBy(expression); 
     } 
     else 
     { 
      orderedQuery = (i == 0) ? query.OrderByDescending(expression) 
            : orderedQuery.ThenByDescending(expression); 
     } 
    } 
    query = orderedQuery; 
} 

Answer 2

OrderBy restituisce una nuova IEnumerable, quindi è necessario fare qualcosa di simile:

IEnumerable<Data> results 
    = query.OrderBy(item => item.GetType().GetProperty(sortExpressions[i].Name)); 

Answer 3

Il lavoro OrderBy/OrderByDescending 'operatori' come String.ToUpper(), vale a dire, prendono la cosa si richiama su e produci una "copia" che ha ciò che hai chiesto.

In altre parole, invece di dire:

query.Orderby(item->item.X) 

si dovrebbe fare

query = query.Orderby(item->item.X) 

o

sortedResult = query.Orderby(item->item.X) 

[E come fa notare Jon Skeet, utilizzare ThenBy/ThenByDescending come nella sua risposta]

Answer 4

La query non è modificabile, quindi OrderBy restituisce un nuovo oggetto. È necessario effettuare la stessa chiamata, ma aggiungere "query =" all'inizio.

query = query.OrderBy(item => item.GetType().GetProperty(sortExpressions[i].Name)); 

Answer 5

OrderBy on IEnumerable rendimenti restituisce un IOrderedEnumerable. Non li ordina in linea. Quindi prendi il valore di ritorno da .OrderBy e starai bene.

Answer 6

questo funzionerà:

YourCollection.Orderby(item => item.Property1).ThenBy(item => item.Property2);