BindingOperations.EnableCollectionSynchronization Méthode

Définition

Espace de noms:

System.Windows.Data

Assembly:

PresentationFramework.dll

Permet à un objet CollectionView de participer à un accès synchronisé à une collection utilisée sur plusieurs threads.

Surcharges

EnableCollectionSynchronization(IEnumerable, Object)	Permet à un objet CollectionView de participer à un accès synchronisé à une collection utilisée sur plusieurs threads avec un mécanisme de verrouillage simple.
EnableCollectionSynchronization(IEnumerable, Object, CollectionSynchronizationCallback)	Permet à un objet CollectionView de participer à un accès synchronisé à une collection utilisée sur plusieurs threads avec un mécanisme de verrouillage autre qu’un verrou simple.

Remarques

Une application WPF peut afficher une collection de données à l’aide d’une ou d’une ItemsControl de ses sous-classes (ListBox, DataGrid, TreeView, ListViewetc.). WPF canalise tout son accès à la collection via une sous-classe de CollectionView. Les et ont une ItemsControlCollectionView affinité avec le thread sur lequel ItemsControl le a été créé, ce qui signifie que leur utilisation sur un autre thread est interdite et lève une exception. En effet, cette restriction s’applique également à la collection.

Vous pouvez utiliser la collection sur plusieurs threads.   Par exemple, vous souhaitez mettre à jour la collection (ajouter ou supprimer des éléments) sur un thread « collecte de données », tout en affichant les résultats sur un thread « interface utilisateur », afin que l’interface utilisateur reste réactive pendant la collecte des données. Dans ce cas, vous êtes responsable de la synchronisation de l’accès (« thread-safe ») à la collection.   Cela se fait généralement à l’aide d’un mécanisme de verrouillage simple ou d’un mécanisme de synchronisation plus élaboré tel que des sémaphores, des événements de réinitialisation, etc.

Bien que vous deviez synchroniser l’accès de votre application à la collection, vous devez également garantir que l’accès à partir de WPF (en particulier à partir de CollectionView) participe au même mécanisme de synchronisation.  Pour ce faire, appelez la méthode EnableCollectionSynchronization.

Pour utiliser une collection sur plusieurs threads, dont l’un est le thread d’interface utilisateur qui possède le ItemsControl, une application a les responsabilités suivantes :

1. Choisissez un mécanisme de synchronisation.

2. Synchronisez tout l’accès de l’application à la collection à l’aide de ce mécanisme.

3. Appelez EnableCollectionSynchronization pour informer WPF du mécanisme.

   • L’appel doit se produire sur le thread d’interface utilisateur.

   • L’appel doit avoir lieu avant d’utiliser la collection sur un autre thread ou avant d’attacher la collection au , selon ce ItemsControlqui est le cas plus tard.

   • Appelez la EnableCollectionSynchronization(IEnumerable, Object) surcharge si vous utilisez un mécanisme de verrouillage simple; appelez la EnableCollectionSynchronization(IEnumerable, Object, CollectionSynchronizationCallback) surcharge si vous utilisez un mécanisme plus élaboré.

4. Vérifiez qu’une modification apportée à la collection et la notification de cette modification (via INotifyCollectionChanged) sont atomiques ; aucun accès à partir d’autres threads ne peut intervenir.  (Cela est généralement gratuit. Par instance, ObservableCollection<T> garantit cela, à condition que toutes les modifications soient protégées par la synchronisation.)

5. Si vous appelez DisableCollectionSynchronization, cet appel doit également se produire sur le thread d’interface utilisateur.

6. Si vous souhaitez utiliser la même collection sur plusieurs threads d’interface utilisateur, vous devez appeler EnableCollectionSynchronization (et DisableCollectionSynchronization, si nécessaire) séparément sur chaque thread d’interface utilisateur.

7. Évitez l’interblocage.  C’est déjà la responsabilité de l’application une fois qu’elle choisit d’utiliser la synchronisation, mais elle doit également prendre en compte la participation de WPF à la synchronisation, comme indiqué dans le paragraphe suivant.

En retour, WPF fournit le comportement suivant :

• Accède CollectionView à la collection à l’aide du mécanisme de synchronisation donné.

• le CollectionView conserve un « cliché instantané » de la collection à utiliser sur le thread d’interface utilisateur.

• CollectionChanged Les événements sont mis en file d’attente à mesure qu’ils arrivent (sur n’importe quel thread).

• Les événements en attente sont appliqués au cliché instantané de manière asynchrone sur le thread d’interface utilisateur lorsqu’il a la possibilité de le faire.

• le CollectionView n’utilise pas directement d’autres mécanismes de synchronisation visibles par l’application. Il s’agit de la façon de WPF d’aider à éviter les blocages (voir l’élément précédent 7).  

L’effet net est que vous pouvez modifier la collection sur n’importe quel thread, et ces modifications finissent par apparaître dans le ItemsControl lorsque le thread d’interface utilisateur a le temps de « rattraper ».  L’implémentation a été réglée pour limiter la vitesse de modification du flux dans le thread d’interface utilisateur afin d’empêcher les threads d’arrière-plan de saturer le thread d’interface utilisateur et de priver la réponse de l’entrée utilisateur normale.

EnableCollectionSynchronization(IEnumerable, Object)

Permet à un objet CollectionView de participer à un accès synchronisé à une collection utilisée sur plusieurs threads avec un mécanisme de verrouillage simple.

public:
 static void EnableCollectionSynchronization(System::Collections::IEnumerable ^ collection, System::Object ^ lockObject);

public static void EnableCollectionSynchronization (System.Collections.IEnumerable collection, object lockObject);

static member EnableCollectionSynchronization : System.Collections.IEnumerable * obj -> unit

Public Shared Sub EnableCollectionSynchronization (collection As IEnumerable, lockObject As Object)

Paramètres

collection

IEnumerable

Collection qui a besoin de l’accès synchronisé.

lockObject

Object

Objet à verrouiller lors de l’accès à la collection.

Remarques

Une application WPF peut afficher une collection de données à l’aide d’une ou d’une ItemsControl de ses sous-classes (ListBox, DataGrid, TreeView, ListViewetc.). WPF canalise tout son accès à la collection via une sous-classe de CollectionView. Les et ont une ItemsControlCollectionView affinité avec le thread sur lequel ItemsControl le a été créé, ce qui signifie que leur utilisation sur un autre thread est interdite et lève une exception. En effet, cette restriction s’applique également à la collection.

Vous pouvez utiliser la collection sur plusieurs threads.   Par exemple, vous souhaitez mettre à jour la collection (ajouter ou supprimer des éléments) sur un thread « collecte de données », tout en affichant les résultats sur un thread « interface utilisateur », afin que l’interface utilisateur reste réactive pendant la collecte des données. Dans ce cas, vous êtes responsable de garantir l’accès synchronisé (« thread-safe ») à la collection et de garantir que l’accès à partir de WPF (en particulier à partir de CollectionView) participe au même mécanisme de synchronisation. En appelant la EnableCollectionSynchronization(IEnumerable, Object) méthode, vous pouvez le faire à l’aide d’un mécanisme de verrouillage simple.

Pour utiliser une collection sur plusieurs threads, dont l’un est le thread d’interface utilisateur qui possède le ItemsControl, vous devez effectuer les opérations suivantes :

1. Instancier un objet à verrouiller lors de l’accès à la collection.

2. Synchronisez tout l’accès de l’application à la collection en verrouillant cet objet.

3. Appelez EnableCollectionSynchronization(IEnumerable, Object) pour informer WPF que vous utilisez un mécanisme de verrouillage simple.

   • L’appel doit se produire sur le thread d’interface utilisateur.

   • L’appel doit avoir lieu avant d’utiliser la collection sur un autre thread ou avant d’attacher la collection au , selon ce ItemsControlqui est le cas plus tard.

4. Assurez-vous qu’une modification apportée à la collection et la notification de cette modification (via INotifyCollectionChanged) sont atomiques ; aucun accès à partir d’autres threads ne peut intervenir.  (C’est généralement gratuit. Par instance, ObservableCollection<T> garantit cela, à condition que toutes les modifications soient protégées par la synchronisation.)

5. Si vous appelez DisableCollectionSynchronization, cet appel doit également se produire sur le thread d’interface utilisateur.

6. Si vous souhaitez utiliser la même collection sur plusieurs threads d’interface utilisateur, vous devez appeler EnableCollectionSynchronization (et DisableCollectionSynchronization, si nécessaire) séparément sur chaque thread d’interface utilisateur.

7. Évitez l’interblocage.  C’est déjà la responsabilité de l’application une fois qu’elle choisit d’utiliser la synchronisation, mais elle doit également prendre en compte la participation de WPF à la synchronisation. (Voir plus, ci-dessous.)

En retour, WPF fournit le comportement suivant :

• Accède CollectionView à la collection à l’aide du mécanisme de verrouillage.

• conserve CollectionView un « cliché instantané » de la collection pour une utilisation sur le thread d’interface utilisateur.

• CollectionChanged les événements sont mis en file d’attente à mesure qu’ils arrivent (sur n’importe quel thread).

• Les événements en attente sont appliqués au cliché instantané de manière asynchrone sur le thread d’interface utilisateur lorsqu’il a la possibilité de le faire.

• le CollectionView n’utilisera pas directement un autre mécanisme de synchronisation visible pour l’application. C’est la façon dont WPF permet d’éviter l’interblocage (voir l’élément 7 précédent).  

L’effet net est que vous pouvez modifier la collection sur n’importe quel thread, et ces modifications s’affichent finalement dans le lorsque le thread d’interface utilisateur a le ItemsControl temps de « rattraper ».  L’implémentation a été paramétrée pour limiter la vitesse de modification du flux dans le thread d’interface utilisateur afin d’empêcher les threads d’arrière-plan de saturer le thread d’interface utilisateur et d’affamer la réponse aux entrées utilisateur normales.

EnableCollectionSynchronization(IEnumerable, Object, CollectionSynchronizationCallback)

Permet à un objet CollectionView de participer à un accès synchronisé à une collection utilisée sur plusieurs threads avec un mécanisme de verrouillage autre qu’un verrou simple.

public:
 static void EnableCollectionSynchronization(System::Collections::IEnumerable ^ collection, System::Object ^ context, System::Windows::Data::CollectionSynchronizationCallback ^ synchronizationCallback);

public static void EnableCollectionSynchronization (System.Collections.IEnumerable collection, object context, System.Windows.Data.CollectionSynchronizationCallback synchronizationCallback);

static member EnableCollectionSynchronization : System.Collections.IEnumerable * obj * System.Windows.Data.CollectionSynchronizationCallback -> unit

Public Shared Sub EnableCollectionSynchronization (collection As IEnumerable, context As Object, synchronizationCallback As CollectionSynchronizationCallback)

Paramètres

collection

IEnumerable

Collection qui a besoin de l’accès synchronisé.

context

Object

Objet qui est passé au rappel.

synchronizationCallback

CollectionSynchronizationCallback

Rappel qui est appelé chaque fois que l’accès à la collection est nécessaire. Vous pouvez l’utiliser pour garantir que la collection est accessible par un seul thread à la fois.

Remarques

Une application WPF peut afficher une collection de données à l’aide d’une ou d’une ItemsControl de ses sous-classes (ListBox, DataGrid, TreeView, ListViewetc.). WPF canalise tout son accès à la collection via une sous-classe de CollectionView. Les et ont une ItemsControlCollectionView affinité avec le thread sur lequel ItemsControl le a été créé, ce qui signifie que leur utilisation sur un autre thread est interdite et lève une exception. En effet, cette restriction s’applique également à la collection.

Vous pouvez utiliser la collection sur plusieurs threads.   Par exemple, vous souhaitez mettre à jour la collection (ajouter ou supprimer des éléments) sur un thread « collecte de données », tout en affichant les résultats sur un thread « interface utilisateur », afin que l’interface utilisateur reste réactive pendant la collecte des données. Dans ce cas, vous êtes responsable de garantir l’accès synchronisé (« thread-safe ») à la collection et de garantir que l’accès à partir de WPF (en particulier à partir de CollectionView) participe au même mécanisme de synchronisation. En appelant la EnableCollectionSynchronization(IEnumerable, Object, CollectionSynchronizationCallback) méthode, vous pouvez le faire à l’aide d’un mécanisme de synchronisation tel qu’un sémaphores, un événement de réinitialisation, etc.

Pour utiliser une collection sur plusieurs threads, dont l’un est le thread d’interface utilisateur qui possède le ItemsControl, vous devez effectuer les opérations suivantes :

1. Choisissez un mécanisme de synchronisation.

2. Synchronisez tout l’accès de l’application à la collection à l’aide de ce mécanisme.

3. Appelez la EnableCollectionSynchronization(IEnumerable, Object, CollectionSynchronizationCallback) surcharge pour informer WPF que vous utilisez un mécanisme autre que le simple verrouillage.

   • L’appel doit se produire sur le thread d’interface utilisateur.

   • L’appel doit avoir lieu avant d’utiliser la collection sur un autre thread ou avant d’attacher la collection au , selon ce ItemsControlqui est le cas plus tard.

4. Assurez-vous qu’une modification apportée à la collection et la notification de cette modification (via INotifyCollectionChanged) sont atomiques ; aucun accès à partir d’autres threads ne peut intervenir.  (C’est généralement gratuit. Par instance, ObservableCollection<T> garantit cela, à condition que toutes les modifications soient protégées par la synchronisation.)

5. Si vous appelez DisableCollectionSynchronization, cet appel doit également se produire sur le thread d’interface utilisateur.

6. Si vous souhaitez utiliser la même collection sur plusieurs threads d’interface utilisateur, vous devez appeler EnableCollectionSynchronization (et DisableCollectionSynchronization, si nécessaire) séparément sur chaque thread d’interface utilisateur.

7. Évitez l’interblocage.  C’est déjà la responsabilité de l’application une fois qu’elle choisit d’utiliser la synchronisation, mais elle doit également prendre en compte la participation de WPF à la synchronisation. (Voir plus, ci-dessous.)

En retour, WPF fournit le comportement suivant :

• Accède CollectionView à la collection en appelant l’inscrit CollectionSynchronizationCallback avec les arguments suivants :

  • collection: collection d’intérêt.
  • context: objet de contexte inscrit.
  • accessMethod: délégué qui effectue l’accès réel.
  • writeAccess: true si le délégué modifie la collection ; false sinon.

  Vous CollectionSynchronizationCallback devez établir la synchronisation sur la collection (à l’aide de l’objet context et de la writeAccess valeur, le cas échéant), appeler le , puis libérer la accessMethodsynchronisation.

• conserve CollectionView un « cliché instantané » de la collection pour une utilisation sur le thread d’interface utilisateur.

• CollectionChanged les événements sont mis en file d’attente à mesure qu’ils arrivent (sur n’importe quel thread).

• Les événements en attente sont appliqués au cliché instantané de manière asynchrone sur le thread d’interface utilisateur lorsqu’il a la possibilité de le faire.

• le CollectionView n’utilisera pas directement un autre mécanisme de synchronisation visible pour l’application. C’est la façon dont WPF permet d’éviter l’interblocage (voir l’élément 7 précédent).  

L’effet net est que vous pouvez modifier la collection sur n’importe quel thread, et ces modifications s’affichent finalement dans le lorsque le thread d’interface utilisateur a le ItemsControl temps de « rattraper ».  L’implémentation a été paramétrée pour limiter la vitesse de modification du flux dans le thread d’interface utilisateur afin d’empêcher les threads d’arrière-plan de saturer le thread d’interface utilisateur et d’affamer la réponse aux entrées utilisateur normales.

Le context paramètre est un objet arbitraire passé à .callback Vous pouvez l’utiliser pour déterminer le mécanisme de synchronisation utilisé pour contrôler l’accès à collection. Context peut être null.