Chaning-Verarbeitungssequenz von ObservableCollection <T> (C#)

Question

Gibt es eine einfache Möglichkeit, die Verarbeitungsreihenfolge einer ObservableCollection in C# zu beeinflussen?

Lets sagen, dass ich die folgende Klasse:

public class GeneratorObject : IComparable 
{ 
     int processingSequence {get; set;} 
     string property1 {get; set;} 
     Boolean property2 {get; set;} 

     public GeneratorObject(int processingSequence) 
     { 
      this.processingSequence = processingSequence; 
     } 

     public int CompareTo(object obj) 
     { 
      // Implementation 
     }    
} 

Die Abarbeitungsreihenfolge jede natürliche Zahl sein könnte.

möchte ich einige von einigen von ihnen

ObservableCollection<GeneratorObject> toIterate = new ObservableCollection<GeneratorObject>(); 

toIterate.Add(new GeneratorObject(99)); 
toIterate.Add(new GeneratorObject(1)); 
toIterate.Add(new GeneratorObject(10)); 
toIterate.Add(new GeneratorObject(6)); 

foreach (GeneratorObject field in toIterate) 
{ 
    // Manipulating the properties of field 
} 

Ich möchte nicht wirklich zu durchlaufen, die Sammlung sortieren, espeacially in der Ansicht. Ich möchte nur die Reihenfolge für die Iteration ändern. Zuerst das Element mit der niedrigsten Sequenznummer, ..., Weiter ist es wichtig zu sagen, dass ich die Items während der Iteration manipuliere und nicht einfach eine Kopie der Collection verwenden kann.

Ich habe bereits IComparable implementiert und dachte, ich könnte einfach sagen, z. Collection.Sort(), ohne die Bindung mit der Benutzeroberfläche zu zerstören.

Danke für jede Hilfe.

Answer 1

Danke für den Hinweis mit der Kopie. Ich weiß nicht, ob das eine gute Antwort ist (vor allem hinsichtlich der Leistung), aber ich habe das Problem auf folgende Weise gelöst.

var copy = toIterate.ToList(); 
copy.Sort(); 

// iterate through the sorted List 
foreach (GeneratorObject field in copy) 
{ 
    // get the original object regarding to this sorted item 
    GeneratorObject originalObjectForAction = getGeneratorObject(toIterate, field); 
    // do stuff with the original item 
} 

public GeneratorObject getGeneratorObject(ObservableCollection<GeneratorObject> list, GeneratorObject objekt) 
{ 
    foreach (DwhRoboterGeneratorObjekt field in list) 
    { 
     if (field == objekt) return field; 
    } 
    throw new Exception("Not found"); 
} 

Answer 2

Sie können eine copy der Liste erstellen, sie zu sortieren und dann durchlaufen die copy Liste:

 //ObservableCollection<GeneratorObject> toIterate; 
     // I am assuming that 'toIterate' is not null and bound to the UI 
     toIterate.Add(new GeneratorObject(99)); 
     toIterate.Add(new GeneratorObject(1)); 
     toIterate.Add(new GeneratorObject(10)); 
     toIterate.Add(new GeneratorObject(6)); 

     var copy = toIterate.ToList(); 
     copy.Sort(); 

     foreach (GeneratorObject field in copy) 
     { 

     } 

Die Sortier Aktion hier auf einer anderen Liste ausgeführt, damit es nicht die Reihenfolge, in der Benutzeroberfläche ändern .

Answer 3

Wenn sich die Liste während der Iteration ändert, können Sie die Schleife wiederholen, bis die Liste leer ist, und die Min. Bei jeder Iteration finden.

while (toIterate.Any()) 
{ 
    GeneratorObject generatorObject = toIterate.Min(); 
    // do something with it 
}