Sorteer n saamgestelde versameling

Question

So WPF nie standaard sortering of filter gedrag vir sienings van CompositeCollections ondersteun, so wat sou 'n beste praktyk vir die oplossing van hierdie probleem.

Daar is twee of meer voorwerp versamelings van verskillende soorte. Jy wil om hulle te kombineer in 'n enkele sortable en filtreerbare versameling (sy binne hoef te sorteer of filter met die hand te implementeer).

Een van die benaderings wat ek beskou is om 'n nuwe voorwerp versameling met net 'n paar kern eienskappe, insluitend dié wat Ek wil hê dat die versameling gesorteer op, en 'n voorwerp geval van elke tipe te skep.

class MyCompositeObject
{
    enum           ObjectType;
    DateTime       CreatedDate;
    string         SomeAttribute;
    myObjectType1  Obj1;
    myObjectType2  Obj2;
{
class MyCompositeObjects : List<MyCompositeObject> { }

En dan loop deur my twee voorwerp versamelings na die nuwe saamgestelde versameling op te bou. Dit is duidelik dat hierdie 'n bietjie van 'n brute krag metode, maar dit sal werk. Ek sal al die standaard sorteer en filter gedrag kry op my nuwe saamgestelde voorwerp versameling, en Ek sal in staat wees om 'n data sjabloon op dit om te wys my lys items behoorlik afhangende van watter tipe eintlik in daardie saamgestelde item gestoor.

Watter voorstelle is daar om dit te doen in 'n meer elegante manier?

Answer 1

Update: Ek het 'n baie meer elegante oplossing:

class MyCompositeObject
{
    DateTime    CreatedDate;
    string      SomeAttribute;
    Object      Obj1;
{
class MyCompositeObjects : List<MyCompositeObject> { }

Ek het bevind dat as gevolg van besinning, die spesifieke tipe gestoor in Obj1 opgelos tydens looptyd en die tipe spesifieke DataTemplate toegepas as verwag!

Answer 2

Ek is nog nie baie vertroud is met WPF maar ek sien dit as 'n vraag oor die sortering en filtrering List<T> versamelings.

  

(sy binne hoef te sorteer of filter met die hand te implementeer)

Wil jy heroorweeg implementering jou eie soort of filter funksies? In my ervaring is dit maklik om te gebruik. Die onderstaande voorbeelde gebruik 'n anonieme afgevaardigde maar jy kan maklik jou eie metode of 'n klas te definieer om te implementeer 'n komplekse soort of filter. So 'n klas kan selfs eiendomme in te stel en te verander die soort en filter dinamies.

Gebruik List<T>.Sort(Comparison<T> comparison) met jou persoonlike vergelyk funksie:

// Sort according to the value of SomeAttribute
List<MyCompositeObject> myList = ...;
myList.Sort(delegate(MyCompositeObject a, MyCompositeObject b) 
{
    // return -1 if a < b
    // return 0 if a == b
    // return 1 if a > b
    return a.SomeAttribute.CompareTo(b.SomeAttribute);
};

'n Soortgelyke benadering vir die kry van 'n sub-versameling van items uit die lys.

Gebruik List<T>.FindAll(Predicate<T> match) met jou persoonlike filter funksie:

// Select all objects where myObjectType1 and myObjectType2 are not null
myList.FindAll(delegate(MyCompositeObject a)
{
    // return true to include 'a' in the sub-collection
    return (a.myObjectType1 != null) && (a.myObjectType2 != null);
}

Answer 3

"brute krag" metode wat jy noem is eintlik ideale oplossing. Mind you, al die voorwerpe is in RAM, daar is geen I / O bottelnek, sodat jy kan pretty much sorteer en filtreer miljoene voorwerpe in minder as 'n sekonde op 'n moderne rekenaar.

Die mees elegante manier om te werk met versamelings is System.Linq naamruimte in NET 3.5

  

Dankie - ek ook oorweeg linQ aan   voorwerpe, maar my kommer is daar verlies   van buigsaamheid vir getikte data   templates, wat ek nodig het om die vertoon   voorwerpe in my lys.

As jy nie kan voorspel op hierdie oomblik hoe mense sal sorteer en filtreer jou voorwerp versameling, dan moet jy kyk na System.Linq.Expressions naamruimte om jou lambda uitdrukkings op aanvraag te bou tydens looptyd ( eers moet jy laat gebruiker om uitdrukking te bou, dan stel, uit te voer en aan die einde wat jy weerspieëling naamruimte gebruik om opnoemen deur resultate). Dit is moeiliker om jou kop (finaal vir my) draai om dit maar waardevolle funksie, waarskynlik selfs meer grond-breaking funksie as LINQ self.