Est-il un des Threads collection Observable dans .NET 4?

Veuillez jeter un oeil à la BindableCollection<T> de Caliburn.Micro bibliothèque:

///<summary>
///A base collection class that supports automatic UI thread marshalling.
///</summary>
///<typeparam name="T">The type of elements contained in the collection.</typeparam>
#if !SILVERLIGHT && !WinRT
[Serializable]
#endif
public class BindableCollection<T> : ObservableCollection<T>, IObservableCollection<T> {
///<summary>
///  Initializes a new instance of the <see cref = "Caliburn.Micro.BindableCollection{T}" /> class.
///</summary>
public BindableCollection() {
IsNotifying = true;
}
///<summary>
///  Initializes a new instance of the <see cref = "Caliburn.Micro.BindableCollection{T}" /> class.
///</summary>
///<param name = "collection">The collection from which the elements are copied.</param>
///<exception cref = "T:System.ArgumentNullException">
///  The <paramref name = "collection" /> parameter cannot be null.
///</exception>
public BindableCollection(IEnumerable<T> collection) : base(collection) {
IsNotifying = true;
}
#if !SILVERLIGHT && !WinRT
[field: NonSerialized]
#endif
bool isNotifying; //serializator try to serialize even autogenerated fields
///<summary>
///  Enables/Disables property change notification.
///</summary>
#if !WinRT
[Browsable(false)]
#endif
public bool IsNotifying {
get { return isNotifying; }
set { isNotifying = value; }
}
///<summary>
///  Notifies subscribers of the property change.
///</summary>
///<param name = "propertyName">Name of the property.</param>
#if WinRT || NET45
public virtual void NotifyOfPropertyChange([CallerMemberName]string propertyName = "") {
#else
public virtual void NotifyOfPropertyChange(string propertyName) {
#endif
if(IsNotifying)
Execute.OnUIThread(() => OnPropertyChanged(new PropertyChangedEventArgs(propertyName)));
}
///<summary>
///  Raises a change notification indicating that all bindings should be refreshed.
///</summary>
public void Refresh() {
Execute.OnUIThread(() => {
OnPropertyChanged(new PropertyChangedEventArgs("Count"));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
});
}
///<summary>
///  Inserts the item to the specified position.
///</summary>
///<param name = "index">The index to insert at.</param>
///<param name = "item">The item to be inserted.</param>
protected override sealed void InsertItem(int index, T item) {
Execute.OnUIThread(() => InsertItemBase(index, item));
}
///<summary>
///  Exposes the base implementation of the <see cref = "InsertItem" /> function.
///</summary>
///<param name = "index">The index.</param>
///<param name = "item">The item.</param>
///<remarks>
///  Used to avoid compiler warning regarding unverifiable code.
///</remarks>
protected virtual void InsertItemBase(int index, T item) {
base.InsertItem(index, item);
}
#if NET || WP8 || WinRT
///<summary>
///Moves the item within the collection.
///</summary>
///<param name="oldIndex">The old position of the item.</param>
///<param name="newIndex">The new position of the item.</param>
protected sealed override void MoveItem(int oldIndex, int newIndex) {
Execute.OnUIThread(() => MoveItemBase(oldIndex, newIndex));
}
///<summary>
///Exposes the base implementation fo the <see cref="MoveItem"/> function.
///</summary>
///<param name="oldIndex">The old index.</param>
///<param name="newIndex">The new index.</param>
///<remarks>Used to avoid compiler warning regarding unverificable code.</remarks>
protected virtual void MoveItemBase(int oldIndex, int newIndex) {
base.MoveItem(oldIndex, newIndex);
}
#endif
///<summary>
///  Sets the item at the specified position.
///</summary>
///<param name = "index">The index to set the item at.</param>
///<param name = "item">The item to set.</param>
protected override sealed void SetItem(int index, T item) {
Execute.OnUIThread(() => SetItemBase(index, item));
}
///<summary>
///  Exposes the base implementation of the <see cref = "SetItem" /> function.
///</summary>
///<param name = "index">The index.</param>
///<param name = "item">The item.</param>
///<remarks>
///  Used to avoid compiler warning regarding unverifiable code.
///</remarks>
protected virtual void SetItemBase(int index, T item) {
base.SetItem(index, item);
}
///<summary>
///  Removes the item at the specified position.
///</summary>
///<param name = "index">The position used to identify the item to remove.</param>
protected override sealed void RemoveItem(int index) {
Execute.OnUIThread(() => RemoveItemBase(index));
}
///<summary>
///  Exposes the base implementation of the <see cref = "RemoveItem" /> function.
///</summary>
///<param name = "index">The index.</param>
///<remarks>
///  Used to avoid compiler warning regarding unverifiable code.
///</remarks>
protected virtual void RemoveItemBase(int index) {
base.RemoveItem(index);
}
///<summary>
///  Clears the items contained by the collection.
///</summary>
protected override sealed void ClearItems() {
Execute.OnUIThread(ClearItemsBase);
}
///<summary>
///  Exposes the base implementation of the <see cref = "ClearItems" /> function.
///</summary>
///<remarks>
///  Used to avoid compiler warning regarding unverifiable code.
///</remarks>
protected virtual void ClearItemsBase() {
base.ClearItems();
}
///<summary>
///  Raises the <see cref = "E:System.Collections.ObjectModel.ObservableCollection`1.CollectionChanged" /> event with the provided arguments.
///</summary>
///<param name = "e">Arguments of the event being raised.</param>
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) {
if (IsNotifying) {
base.OnCollectionChanged(e);
}
}
///<summary>
///  Raises the PropertyChanged event with the provided arguments.
///</summary>
///<param name = "e">The event data to report in the event.</param>
protected override void OnPropertyChanged(PropertyChangedEventArgs e) {
if (IsNotifying) {
base.OnPropertyChanged(e);
}
}
///<summary>
///  Adds the range.
///</summary>
///<param name = "items">The items.</param>
public virtual void AddRange(IEnumerable<T> items) {
Execute.OnUIThread(() => {
var previousNotificationSetting = IsNotifying;
IsNotifying = false;
var index = Count;
foreach(var item in items) {
InsertItemBase(index, item);
index++;
}
IsNotifying = previousNotificationSetting;
OnPropertyChanged(new PropertyChangedEventArgs("Count"));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
});
}
///<summary>
///  Removes the range.
///</summary>
///<param name = "items">The items.</param>
public virtual void RemoveRange(IEnumerable<T> items) {
Execute.OnUIThread(() => {
var previousNotificationSetting = IsNotifying;
IsNotifying = false;
foreach(var item in items) {
var index = IndexOf(item);
if (index >= 0) {
RemoveItemBase(index);
}
}
IsNotifying = previousNotificationSetting;
OnPropertyChanged(new PropertyChangedEventArgs("Count"));
OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
});
}
///<summary>
///Called when the object is deserialized.
///</summary>
///<param name="c">The streaming context.</param>
[OnDeserialized]
public void OnDeserialized(StreamingContext c) {
IsNotifying = true;
}
///<summary>
///Used to indicate whether or not the IsNotifying property is serialized to Xml.
///</summary>
///<returns>Whether or not to serialize the IsNotifying property. The default is false.</returns>
public virtual bool ShouldSerializeIsNotifying() {
return false;
}
}

Source

PS. Il suffit de prendre à l'esprit que cette classe d'utilisation d'autres classes de Caliburn.Micro de sorte que vous pouvez copier/pase toutes les dépendances par vous-même - OU - si vous n'utilisez pas d'autres structures d'application - il suffit de faire référence à la bibliothèque binaire et donner une chance.

Il y a une explication détaillée et une mise en œuvre ici. Il a été écrit principalement pour .NET 3.5 SP1, mais il faudra encore travailler en 4.0.

La cible principale de cette mise en œuvre est quand le "réel", il existe une liste plus longue que la bindable vue de celui-ci (par exemple. si il est lié à une fenêtre que l'utilisateur peut ouvrir et fermer). Si les durées de vie sont dans l'autre sens (par exemple. vous êtes à la mise à jour de la liste à partir d'un arrière-plan travailleur qui s'exécute uniquement lorsque la fenêtre est ouverte), alors il ya quelques modèles plus simple disponible.