WPF - la Liaison à une ObservableCollection Propriété de Dépendance au sein d'un UserControl

J'ai un contrôle

classe DragGrid : Grille
{
...
}

qui hérite de la grille d'origine et permet de glisser et redimensionner ses éléments enfants.
J'ai besoin de lier une coutume DP nommé WorkItemsProperty à une collection observable de type WorkItem (implémente INotifyPropertyChanged). Chaque élément de la grille est liée à un point de collecte.

Chaque fois que l'utilisateur ajoute un nouvel élément dynamiquement à l'exécution (les éléments ne peuvent pas être déclarées dans le code XAML!), ou supprime un élément de cette collection, la WorkItems DP sur le DragGrid doit être mis à jour, et les enfants dans la grille (où chaque enfant représente un WorkItem élément de la collection).

Ma question est comment le DP aviser le contrôle sur les enfants de l'élément de la grille doit être retiré, changé ("changement" signifie que l'utilisateur a traîné un élément, ou redimensionnée avec la souris) ou ajouté, et comment puis-je identifier l'un des enfants est celui qui doit être supprimé ou modifié.
Je comprends que c'est là que le DependencyPropertyChangedCallback. Mais qui sera appelée lorsque le DP propriété est définie de nouveau, non pas quand quelque chose à l'intérieur de la collection des changements (comme ajouter, supprimer l'élément). Donc en fin de compte, ne le DragGrid de contrôle en quelque sorte besoin de s'abonner à l'événement CollectionChanged? À quel point serait-je brancher le gestionnaire d'événement pour qui?

*EDIT::
La raison de l'utilisation d'une Grille en premier lieu, parce que je veux être en mesure de maintenir un minimum de delta pour lorsque l'utilisateur fait glisser ou redimensionne le contrôle dans la Grille. Un contrôle représente un laps de temps, et chaque colonne de la grille représente 15min (qui est la valeur minimale). Faire cela dans un Canevas avec les Pouces a été difficile et le buggy. Mise en œuvre d'un DragGrid résolu mon interaction de l'utilisateur des problèmes. Aussi, une Toile n'est pas extensible, donc le temps de travées ont recalculé tous les temps. Avec la Grille, je n'ai pas le problème, car les colonnes dites-moi le temps, peu importe la taille.**

OriginalL'auteur John | 2010-05-05

c#data-binding dependency-properties observablecollection wpf

17

En réponse à votre question réelle:

Vous devez ajouter un DepencyPropertyChanged gestionnaire, comme vous l'avez mentionné. Dans ce gestionnaire, vous devez ajouter un gestionnaire d'événements pour l'CollectionChanged bien sur la nouvelle collection et de supprimer le gestionnaire de l'ancienne collection, comme ceci:
```
    public ObservableCollection<WorkItem> WorkItems
{
get { return (ObservableCollection<WorkItem>)GetValue(WorkItemsProperty); }
set { SetValue(WorkItemsProperty, value); }
}
//Using a DependencyProperty as the backing store for WorkItems.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty WorkItemsProperty =
DependencyProperty.Register("WorkItems", typeof(ObservableCollection<WorkItem>), typeof(DragGrid), new FrameworkPropertyMetadata(null, OnWorkItemsChanged));
private static void OnWorkItemsChanged(object sender, DependencyPropertyChangedEventArgs e)
{
DragGrid me = sender as DragGrid;
var old = e.OldValue as ObservableCollection<WorkItem>;
if (old != null)
old.CollectionChanged -= me.OnWorkCollectionChanged;
var n = e.NewValue as ObservableCollection<WorkItem>;
if (n != null)
n.CollectionChanged += me.OnWorkCollectionChanged;
}
private void OnWorkCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Reset)
{
//Clear and update entire collection
}
if (e.NewItems != null)
{
foreach (WorkItem item in e.NewItems)
{
//Subscribe for changes on item
item.PropertyChanged += OnWorkItemChanged;
//Add item to internal collection
}
}
if (e.OldItems != null)
{
foreach (WorkItem item in e.OldItems)
{
//Unsubscribe for changes on item
item.PropertyChanged -= OnWorkItemChanged;
//Remove item from internal collection
}
}
}
private void OnWorkItemChanged(object sender, PropertyChangedEventArgs e)
{
//Modify existing item in internal collection
}
```
Comme gehho expliqué, il semble que vous n'êtes pas à l'aide de la classe de la Grille comme prévu à l'origine, bien que vous pouvez peut-être trop loin dans le développement de vouloir recommencer à partir de ce point. Les Classes dérivées à partir du Panneau sont effectivement destiné uniquement aux visuellement dessin/organiser leurs enfants, plutôt que de les manipuler et de les renforcer. Découvrez ItemsControl et la WPF Modèle de Contenu pour en savoir plus.

Josh, merci pour cette. Dans l'événement collectionchanged, je ne peux pas ajouter à la collection des workitems, parce que .NET ne permet pas que. Je pense que ce que tu voulais dire ici, c'est pour ajouter des contrôles à la grille de la collection d'Enfants.
Non, en fait je voulais l'ajouter à VOTRE collection + la grille de la collection d'Enfants ou etc. Je ne suis pas sûr exactement comment votre commande fonctionne, mais il est évident que vous effectuez un travail de gérer une partie de la collection d'éléments. En fonction de votre commentaire, on dirait que vous êtes à la gestion de la Grille.Collection d'enfants, donc oui, l'ajouter.
L'idéal serait de prendre un ItemsControl (ou peut-être un enfant personnalisé de classe, pas sûr que sans une meilleure compréhension de votre problème), et de définir les WorkItems que les enfants de la ItemsControl.Ensuite, vous devez utiliser un ItemsPanelTemplate pour afficher les éléments sur une Grille. Vous pouvez utiliser un DataTemplate pour générer le réel visuels pour les éléments de travail. La liaison de données sur le modèle d'élément de contrôle , le contrôle des conteneurs (généré par le ItemsControl), et la Grille permettrait éléments à être dessiné dans leurs endroits corrects.
Merci Josh, votre suggestion résolu notre problème. Il fonctionne comme prévu!

OriginalL'auteur Josh G
1

Désolé, je n'ai pas de solution à votre béton personnalisé Grid problème, mais je n'ai qu'une suggestion comment vous pourriez le faire plus facile (et, je suppose, comment il est signifié par le WPF concepteurs). En fait, un Grid n'est pas un contrôle d'organiser éléments. C'est un Panel qui organise Controls. Donc, je suppose, c'est la (une des) raison(s) de pourquoi vous avez des ennuis avec votre solution.

Ce que je pourrais utiliser à la place, est un ItemsControl (par exemple, un ListBox) avec un Toile comme ItemsPanel.
```
<ListBox ItemsSource="{Binding WorkItemsProperty}">
<ListBox.ItemsPanel>
<ItemsPanelTemplate>
<Canvas IsItemsHost="True"/>
</ItemsPanelTemplate>
</ListBox.ItemsPanel>
</ListBox>
```
Maintenant, vous définissez les propriétés appropriées dans votre WorkItem (ou WorkItemViewModel) de la classe comme XPos et YPos qui sera lié aux données de la Canvas.Left et Canvas.Top les propriétés de ce type:
```
<Style x:Key="WorkItemStyle" TargetType="{x:Type ListBoxItem}">
<Setter Property="Canvas.Left" Value="{Binding XPos, Mode=TwoWay}"/>
<Setter Property="Canvas.Top" Value="{Binding YPos, Mode=TwoWay}"/>
</Style>
```
Vous pouvez ensuite utiliser cet élément de style en attribuant le ItemContainerStyle propriété de la ListBox:
```
ItemContainerStyle="{StaticResource WorkItemStyle}"
```
Je ne sais pas comment faire pour implémenter la fonction de glisser et déposer des trucs parce que je n'ai jamais fait cela, mais, évidemment, vous l'avez déjà fait pour la réalisation de votre Grid, de sorte qu'il ne devrait pas être un gros problème pour l'utiliser dans un ListBox. Cependant, si vous mettez à jour les propriétés de votre WorkItem, il devrait automatiquement repositionner l'élément. Aussi, si vous ajoutez/supprimer un élément de votre collection (WorkItemsProperty), il sera automatiquement ajouté/supprimé parce que les ListBox est liée aux données de la collection.

Vous pourriez avoir à changer votre WorkItemStyle en fonction de votre scénario. Par exemple, si la zone de liste est redimensionnée lors de l'exécution, vous pourriez avoir à faire les positions par rapport au conteneur (Toile) taille. Par conséquent, vous avez besoin d'une MultiBinding au lieu de la simple Binding. Mais c'est une autre histoire...

Maintenant, il est de votre décision quant à savoir si vous pouvez toujours déplacer à cette approche ou si votre Grid est presque terminée et vous n'êtes pas prêt à changer. Je sais que c'est dur, mais à mes yeux, l'approche ci-dessus est la plus propre (et le plus facile!) un!

OriginalL'auteur gehho

Vous devez vous connecter pour publier un commentaire.