Szukam lepszego sposobu sortowania mojej listy <T>

Question

Przeglądam kawałek kodu, który napisałem nie tak dawno temu, i po prostu nienawidzę sposobu, w jaki zajmowałem się sortowaniem - zastanawiam się, czy ktoś może być w stanie pokazać ja lepszy sposób.

Mam klasę, Holding, która zawiera pewne informacje. Mam inną klasę, HoldingsList, która zawiera element List<Holding>. Mam również enum, PortfolioSheetMapping, który ma około 40 elementów.

To rodzaj wygląda następująco:

public class Holding 
{ 
    public ProductInfo Product {get;set;} 
    // ... various properties & methods ... 
} 

public class ProductInfo 
{ 
    // .. various properties, methods... 
} 

public class HoldingsList 
{ 
    public List<Holding> Holdings {get;set;} 
    // ... more code ... 
} 

public enum PortfolioSheetMapping 
{ 
    Unmapped = 0, 
    Symbol, 
    Quantitiy, 
    Price, 
    // ... more elements ... 
} 

Mam metodę, która może powołać się na liście, aby być posortowane w zależności od wyliczenie użytkownik wybierze. Metoda używa instrukcji switch mondo, która ma ponad 40 przypadków (ugh!). poniżej

Krótki fragment ilustruje kod:

if (frm.SelectedSortColumn.IsBaseColumn) 
{ 
    switch (frm.SelectedSortColumn.BaseColumn) 
    { 
     case PortfolioSheetMapping.IssueId: 
      if (frm.SortAscending) 
      { 
       // here I'm sorting the Holding instance's 
       // Product.IssueId property values... 
       // this is the pattern I'm using in the switch... 
       pf.Holdings = pf.Holdings.OrderBy 
        (c => c.Product.IssueId).ToList(); 
      } 
      else 
      { 
       pf.Holdings = pf.Holdings.OrderByDescending 
        (c => c.Product.IssueId).ToList(); 
      } 
      break; 
     case PortfolioSheetMapping.MarketId: 
      if (frm.SortAscending) 
      { 
       pf.Holdings = pf.Holdings.OrderBy 
        (c => c.Product.MarketId).ToList(); 
      } 
      else 
      { 
       pf.Holdings = pf.Holdings.OrderByDescending 
        (c => c.Product.MarketId).ToList(); 
      } 
      break; 
     case PortfolioSheetMapping.Symbol: 
      if (frm.SortAscending) 
      { 
       pf.Holdings = pf.Holdings.OrderBy 
        (c => c.Symbol).ToList(); 
      } 
      else 
      { 
       pf.Holdings = pf.Holdings.OrderByDescending 
        (c => c.Symbol).ToList(); 
      } 
      break; 
     // ... more code .... 

Mój problem jest z instrukcji switch. Model switch jest ściśle powiązany z enumem PortfolioSheetMapping, który może zostać zmieniony jutro lub na następny dzień. Za każdym razem, gdy się to zmieni, będę musiał ponownie przejrzeć tę instrukcję przełączania i dodać do niej kolejny blok case. Obawiam się, że w końcu ta zmiana będzie tak duża, że ​​nie da się nią zarządzać.

Czy ktoś może mi powiedzieć, czy istnieje lepszy sposób sortowania mojej listy?

Answer 1

pan ponownie przypisując dane posortowane prosto do swojej własności pf.Holdings, więc dlaczego nie ominąć napowietrznej OrderBy i ToList i po prostu korzystać z listy za Sort metodę bezpośrednio zamiast?

Można użyć mapy, aby trzymać Comparison<T> delegatów dla wszystkich obsługiwanych dobieranie a następnie zadzwonić Sort(Comparison<T>) z odpowiednim Delegat:

if (frm.SelectedSortColumn.IsBaseColumn) 
{ 
    Comparison<Holding> comparison; 
    if (!_map.TryGetValue(frm.SelectedSortColumn.BaseColumn, out comparison)) 
     throw new InvalidOperationException("Can't sort on BaseColumn"); 

    if (frm.SortAscending) 
     pf.Holdings.Sort(comparison); 
    else 
     pf.Holdings.Sort((x, y) => comparison(y, x)); 
} 

// ... 

private static readonly Dictionary<PortfolioSheetMapping, Comparison<Holding>> 
    _map = new Dictionary<PortfolioSheetMapping, Comparison<Holding>> 
    { 
     { PortfolioSheetMapping.IssueId, GetComp(x => x.Product.IssueId) }, 
     { PortfolioSheetMapping.MarketId, GetComp(x => x.Product.MarketId) }, 
     { PortfolioSheetMapping.Symbol, GetComp(x => x.Symbol) }, 
     // ... 
    }; 

private static Comparison<Holding> GetComp<T>(Func<Holding, T> selector) 
{ 
    return (x, y) => Comparer<T>.Default.Compare(selector(x), selector(y)); 
} 

Answer 2

Czy spojrzał Dynamic LINQ

Konkretnie, można po prostu zrobić coś takiego:

var column = PortFolioSheetMapping.MarketId.ToString(); 
if (frm.SelectedSortColumn.IsBaseColumn) 
{ 
    if (frm.SortAscending) 
     pf.Holdings = pf.Holdings.OrderBy(column).ToList(); 
    else 
     pf.Holdings = pf.Holdings.OrderByDescending(column).ToList(); 
} 

Uwaga: To ma ograniczenie, że wyliczenia dopasować swoje nazwy kolumn, jeśli to Ci odpowiada .

EDIT

po raz pierwszy opuścił z obiektem Product. W takich przypadkach DynamicLINQ będzie musiał zobaczyć, na przykład, "Product.ProductId". Możesz podać nazwę właściwości lub po prostu użyć "dobrze znanej" wartości i dołączyć do enum .ToString(). W tym momencie po prostu zmuszam moją odpowiedź na twoje pytanie, aby przynajmniej było sprawnym rozwiązaniem.

Answer 3

Można zaimplementować niestandardową klasę IComparer, która używa refleksji. Jednak byłoby to wolniej.

Oto klasę, która kiedyś używany:

class ListComparer : IComparer 
{ 
    private ComparerState State = ComparerState.Init; 
    public string Field {get;set;} 


    public int Compare(object x, object y) 
    { 
     object cx; 
     object cy; 

     if (State == ComparerState.Init) 
     { 
      if (x.GetType().GetProperty(pField) == null) 
       State = ComparerState.Field; 
      else 
       State = ComparerState.Property; 
     } 

     if (State == ComparerState.Property) 
     { 
      cx = x.GetType().GetProperty(Field).GetValue(x,null); 
      cy = y.GetType().GetProperty(Field).GetValue(y,null); 
     } 
     else 
     { 
      cx = x.GetType().GetField(Field).GetValue(x); 
      cy = y.GetType().GetField(Field).GetValue(y); 
     } 


     if (cx == null) 
      if (cy == null) 
       return 0; 
      else 
       return -1; 
     else if (cy == null) 
      return 1; 

     return ((IComparable) cx).CompareTo((IComparable) cy); 

    } 

    private enum ComparerState 
    { 
     Init, 
     Field, 
     Property 
    } 
} 

następnie używać go tak:

var comparer = new ListComparer() { 
    Field= frm.SelectedSortColumn.BaseColumn.ToString() }; 
if (frm.SortAscending) 
    pf.Holding = pf.Holding.OrderBy(h=>h.Product, comparer).ToList(); 
else 
    pf.Holding = pf.Holding.OrderByDescending(h=>h.Product, comparer).ToList(); 

Answer 4

jak o:

Func<Holding, object> sortBy; 

switch (frm.SelectedSortColumn.BaseColumn) 
{ 
    case PortfolioSheetMapping.IssueId: 
     sortBy = c => c.Product.IssueId; 
     break; 
    case PortfolioSheetMapping.MarketId: 
     sortBy = c => c.Product.MarketId; 
     break; 
    /// etc. 
} 

/// EDIT: can't use var here or it'll try to use IQueryable<> which doesn't Reverse() properly 
IEnumerable<Holding> sorted = pf.Holdings.OrderBy(sortBy); 
if (!frm.SortAscending) 
{ 
    sorted = sorted.Reverse(); 
} 

?

Niezupełnie najszybsze rozwiązanie, ale jest dość eleganckie, o co prosisz!

EDYTOWANIE: Aha, i ze sprawą case, prawdopodobnie potrzebuje refaktoryzacji do oddzielnej funkcji, która zwraca Func, nie jest to dobry sposób na pozbycie się go w całości, ale możesz przynajmniej ukryć go przed środek twojej procedury!

Answer 5

Można spróbować zmniejszyć przełącznik do czegoś takiego:

private static readonly Dictionary<PortfolioSheetMapping, Func<Holding, object>> sortingOperations = new Dictionary<PortfolioSheetMapping, Func<Holding, object>> 
    { 
     {PortfolioSheetMapping.Symbol, h => h.Symbol}, 
     {PortfolioSheetMapping.Quantitiy, h => h.Quantitiy}, 
     // more.... 
    }; 

    public static List<Holding> SortHoldings(this List<Holding> holdings, SortOrder sortOrder, PortfolioSheetMapping sortField) 
    { 
     if (sortOrder == SortOrder.Decreasing) 
     { 
      return holdings.OrderByDescending(sortingOperations[sortField]).ToList(); 
     } 
     else 
     { 
      return holdings.OrderBy(sortingOperations[sortField]).ToList();     
     } 
    } 

Można wypełnić sortingOperations z refleksji, lub utrzymać ją ręcznie. Możesz także sprawić, by SortHoldings akceptował i zwracał wartość IEnumerable i usuwał wywołania ToList, jeśli nie masz nic przeciwko wywołaniu ToList w dzwoni później. Nie jestem w 100% pewna, że ​​OrderBy jest szczęśliwy, otrzymując obiekt, ale wart strzał.

Edycja: Zobacz rozwiązanie LukeH, aby trzymać rzeczy mocno wpisane.

Answer 6

Wydaje mi się, że istnieją dwa natychmiastowe ulepszenia możemy zrobić:

• logika, która wykorzystuje frm.SortAscending zdecydować między OrderBy i OrderByDesccending jest powielany w każdym case i może być wyciągnięta do po switch jeśli case s zmieniane są nic nie robić więcej niż ustalenia klucza sortowania i wprowadzenie go w Func

• że nadal pozostawia switch się z Oczywiście - i to może być zastąpione statyczną mapą (w Dictionary, powiedzmy) z PortfolioSheetMapping na Func biorąc Holding i zwracając klucz sortowania. np

Answer 7

Jeśli właściwości w klasie Holding (symbol, cena itp) są takie same wpisać można wykonać następujące czynności:

var holdingList = new List<Holding>() 
{ 
     new Holding() { Quantity = 2, Price = 5 }, 
     new Holding() { Quantity = 7, Price = 2 }, 
     new Holding() { Quantity = 1, Price = 3 } 
}; 

var lookup = new Dictionary<PortfolioSheetMapping, Func<Holding, int>>() 
{ 
     { PortfolioSheetMapping.Price, new Func<Holding, int>(x => x.Price) }, 
     { PortfolioSheetMapping.Symbol, new Func<Holding, int>(x => x.Symbol) }, 
     { PortfolioSheetMapping.Quantitiy, new Func<Holding, int>(x => x.Quantity) } 
}; 

Console.WriteLine("Original values:"); 
foreach (var sortedItem in holdingList) 
{ 
    Console.WriteLine("Quantity = {0}, price = {1}", sortedItem.Quantity, sortedItem.Price); 
} 

var item = PortfolioSheetMapping.Price; 
Func<Holding, int> action; 
if (lookup.TryGetValue(item, out action)) 
{ 
    Console.WriteLine("Values sorted by {0}:", item); 
    foreach (var sortedItem in holdingList.OrderBy(action)) 
    { 
     Console.WriteLine("Quantity = {0}, price = {1}", sortedItem.Quantity, sortedItem.Price); 
    } 
} 

który następnie wyświetla:

Original values:
Quantity = 2, price = 5
Quantity = 7, price = 2
Quantity = 1, price = 3

Values sorted by Price:
Quantity = 7, price = 2
Quantity = 1, price = 3
Quantity = 2, price = 5