L'ajout d'une plage de valeurs à une ObservableCollection efficacement

J'ai un ObservableCollection des éléments qui est lié à une liste de contrôle de mon point de vue.

J'ai une situation où j'ai besoin d'ajouter un morceau de valeurs pour le début de la collection.
Collection<T>.Insert documentation précise les insérer comme un O(n) opérations, et chaque insertion génère également un CollectionChanged notification.

J'ai donc l'idéal serait d'insérer l'ensemble des éléments en un seul mouvement, sens seule lecture aléatoire de la liste sous-jacente, et j'espère qu'un CollectionChanged de notification (sans doute un "reset").

Collection<T> ne pas exposer toute la méthode pour ce faire. List<T> a InsertRange(), mais IList<T>, que Collection<T> expose par l'intermédiaire de son Items propriété n'.

Est-il un moyen de faire cela?

Si vous avez une sauvegarde de terrain pour la collecte de la propriété, vous pouvez assigner une nouvelle instance, puis relancer OnPropertyChanged pour la collecte si elle manuellement
connexes/double possible: stackoverflow.com/questions/670577/...
+1 si ObservableCollection vous fait penser à de la mécanique quantique et de la double fente de l'expérience.
blogs.msdn.com/b/nathannesbit/archive/2009/04/20/...

InformationsquelleAutor GazTheDestroyer | 2011-12-22

c#collections insert observablecollection performance

L'ObservableCollection expose un protégé Items la propriété, qui est la collection sous-jacente sans la notification de la sémantique. Cela signifie que vous pouvez construire une collection qui fait ce que vous voulez en héritant ObservableCollection:

class RangeEnabledObservableCollection<T> : ObservableCollection<T>
{
    public void InsertRange(IEnumerable<T> items) 
    {
        this.CheckReentrancy();
        foreach(var item in items)
            this.Items.Add(item);
        this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
}

Utilisation:

void Main()
{
    var collection = new RangeEnabledObservableCollection<int>();
    collection.CollectionChanged += (s,e) => Console.WriteLine("Collection changed");
    collection.InsertRange(Enumerable.Range(0,100));
    Console.WriteLine("Collection contains {0} items.", collection.Count);  
}

Cet autre answer pour une question similaire a suggéré d'ajouter le code suivant à notifier les modifications de la numération et de l'indexeur propriétés: this.OnPropertyChanged(new PropertyChangedEventArgs("Count")); this.OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));

InformationsquelleAutor driis

Pour rendre la réponse ci-dessus utiles w/o dériver une nouvelle classe de base à l'aide de la réflexion, voici un exemple:

public static void InsertRange<T>(this ObservableCollection<T> collection, IEnumerable<T> items)
{
var enumerable = items as List<T> ?? items.ToList();
if (collection == null || items == null || !enumerable.Any())
{
return;
}
Type type = collection.GetType();
type.InvokeMember("CheckReentrancy", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null, collection, null);
var itemsProp = type.BaseType.GetProperty("Items", BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.Instance);
var privateItems = itemsProp.GetValue(collection) as IList<T>;
foreach (var item in enumerable)
{
privateItems.Add(item);
}
type.InvokeMember("OnPropertyChanged", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null,
collection, new object[] { new PropertyChangedEventArgs("Count") });
type.InvokeMember("OnPropertyChanged", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null,
collection, new object[] { new PropertyChangedEventArgs("Item[]") });
type.InvokeMember("OnCollectionChanged", BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.NonPublic, null, 
collection, new object[]{ new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)});
}

Quel est le problème avec inheritenance? Pourquoi utiliser l'aide de la réflexion au lieu de dériver une nouvelle classe?
Il n'y a rien de mal avec l'héritage, bien sûr. C'est juste une alternative à cela. Il peut s'avérer utile si vous avez une tonne de code héritage et votre sérialisation (binaire) dépend d'une ObservableCollection type. Plus facile et beaucoup plus pragmatique choix de simplement étendre ObservableCollection dans ce cas.
Salut @consanguine . désolé mais comment voulez-vous utiliser votre exemple. Merci
l'utiliser comme ceci: var coll = new ObservableCollection(); coll.InsertRange(<certains autres énorme liste>); C'est une méthode d'extension donc, assurez-vous juste que vous utilisez l'espace de noms où vous déclarer la méthode d'extension et vous devriez être bon d'aller.
J'ai voté pour cette extension de la méthode me permet de les utiliser sans avoir à changer mes collections dans une nouvelle classe.

InformationsquelleAutor outbred

Ce réponse ne m'a pas montré les nouvelles entrées dans un DataGrid. Cette OnCollectionChanged fonctionne pour moi:

public class SilentObservableCollection<T> : ObservableCollection<T>
{
public void AddRange(IEnumerable<T> enumerable)
{
CheckReentrancy();
int startIndex = Count;
foreach (var item in enumerable)
Items.Add(item);
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, new List<T>(enumerable), startIndex));
OnPropertyChanged(new PropertyChangedEventArgs("Count"));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
}
}

Ceux-ci semblent comme la plus appropriée des notifications de changement.

InformationsquelleAutor Thomas Christof

-3

Exemple:
Souhaité étapes 0,10,20,30,40,50,60,70,80,90,100
--> min=0, max=100, étapes=11

    static int min = 0;
static int max = 100;
static int steps = 11; 
private ObservableCollection<string> restartDelayTimeList = new ObservableCollection<string> (
Enumerable.Range(0, steps).Select(l1 => (min + (max - min) * ((double)l1 / (steps - 1))).ToString())
);

InformationsquelleAutor benoch

Vous devez vous connecter pour publier un commentaire.