Aumento del rendimiento ObservableCollection WPF

Question

En la actualidad tengo dos cuadros de lista WPF imitando la siguiente funcionalidad

Word 2007 customize screen http://tlt.its.psu.edu/suggestions/international/graphics/vista/WordCustomize.gif

estoy usando 2 ObservableCollections para permitir a los usuarios seleccionar cualquier elemento que requieren (flexibilidad es la clave aquí). El principal problema es que tengo miles de artículos que se agrupan en los dos cuadros de lista. En general, el diseño funciona muy bien (con algunas docenas de elementos), pero mi obstáculo es cuando un usuario copia todos los elementos disponibles de izquierda a derecha a medida que la pantalla se congela (¿hora de ejecutar en un hilo diferente?).

En cuanto a ObservableCollection carece de un método AddRange y hay varias implementaciones disponibles en Internet. También sé que el evento CollectionChanged se dispara innecesariamente ya que cada elemento se copia horriblemente sobre el rendimiento de drenaje.

Es posible que tenga que permitir a los usuarios elegir entre grupos de más de 10 000 elementos en el futuro, lo cual suena como una mala idea, pero no es negociable ya que la agrupación en el listbox (CollectionViewSource) funciona realmente bien, pero tiene el efecto secundario de conmutación fuera la virtualización tanto de los cuadros de lista

¿Qué puedo hacer para mejorar el rendimiento cuando se carga un cuadro de lista con miles de artículos cuando enlace de datos a un ObservableCollection? ¿Hay implementaciones de tipo AddRange que recomendarías? ¿Es la única opción que tengo aquí para ejecutar esto en un hilo de fondo que parece caro porque no estoy cargando datos de una base de datos?

Answer 1

He eliminado el CollectionViewSource y la agrupación y los elementos se copian en 1/2 segundo, pero con la agrupación puede tardar hasta un minuto porque la virtualización no funciona con la agrupación.

que tendrá que decidir si desea utilizar la CollectionViewSource

Answer 2

Probablemente se podría heredar de ObservableCollection<T> (o implementa directamente INotifyCollectionChanged) para añadir BeginUpdate y EndUpdate métodos. Los cambios realizados entre llamadas al BeginUpdate y EndUpdate se pondrían en cola, luego se combinarían en uno (o varios si hay rangos separados) NotifyCollectionChangedEventArgs objeto que se pasaría a los controladores del evento CollectionChanged cuando se llama al EndUpdate.

Answer 3

Puede encontrar una colección observable Thread safe here. Haga seguro su hilo de colección Observable y agréguelo al listbox.

Answer 4

no pude resistir responder a esta. No creo que ya no necesites esta respuesta, pero tal vez alguien más pueda usarla.

No lo piense demasiado (no se acerque a este multiproceso (esto hará que las cosas sean propensas a errores e innecesariamente complicadas. Solo utilice el subprocesamiento para cálculos difíciles/IO), todos esos diferentes tipos de acción dificultarán el almacenamiento. La parte más molesta es que si elimina o agrega 10000 elementos su aplicación (listboxes) estará muy ocupada manejando los eventos generados por ObservableCollection. El evento ya admite múltiples elementos. Así que .....

Usted podría almacenar en búfer los elementos hasta que cambie la acción. Por lo tanto, las acciones Agregar se almacenarán en búfer y se generarán como un lote si el "usuario" cambia la acción o la vacía. No han probarlo, pero se puede hacer algo como esto:

// Written by JvanLangen 
public class BufferedObservableCollection<T> : ObservableCollection<T> 
{ 
    // the last action used 
    public NotifyCollectionChangedAction? _lastAction = null; 
    // the items to be buffered 
    public List<T> _itemBuffer = new List<T>(); 

    // constructor registeres on the CollectionChanged 
    public BufferedObservableCollection() 
    { 
     base.CollectionChanged += new NotifyCollectionChangedEventHandler(ObservableCollectionUpdate_CollectionChanged); 
    } 

    // When the collection changes, buffer the actions until the 'user' changes action or flushes it. 
    // This will batch add and remove actions. 
    private void ObservableCollectionUpdate_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) 
    { 
     // if we have a lastaction, check if it is changed and should be flush else only change the lastaction 
     if (_lastAction.HasValue) 
     { 
      if (_lastAction != e.Action) 
      { 
       Flush(); 
       _lastAction = e.Action; 
      } 
     } 
     else 
      _lastAction = e.Action; 

     _itemBuffer.AddRange(e.NewItems.Cast<T>()); 
    } 

    // Raise the new event. 
    protected void RaiseCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) 
    { 
     if (this.CollectionChanged != null) 
      CollectionChanged(sender, e); 
    } 

    // Don't forget to flush the list when your ready with your action or else the last actions will not be 'raised' 
    public void Flush() 
    { 
     if (_lastAction.HasValue && (_itemBuffer.Count > 0)) 
     { 
      RaiseCollectionChanged(this, new NotifyCollectionChangedEventArgs(_lastAction.Value, _itemBuffer)); 
      _itemBuffer.Clear(); 
      _lastAction = null; 
     } 
    } 

    // new event 
    public override event NotifyCollectionChangedEventHandler CollectionChanged; 
} 

Diviértete !, J3R03N