WPF: Liaison à ObservableCollection dans ControlTemplate n'est pas mis à jour

Question

J'ai créé un ControlTemplate pour mon contrôle personnalisé MyControl.

MyControl dérive de System.Windows.Controls.Control et définit la propriété suivante public ObservableCollection<MyControl> Children{ get; protected set; }.

Pour afficher les contrôles enfants imbriqués j'utilise un ItemsControl (StackPanel) qui est entouré par un GroupBox. S'il n'y a aucun contrôle enfant, je veux masquer le GroupBox.

Tout fonctionne correctement au démarrage de l'application: La zone de groupe et les contrôles enfants sont affichés si la propriété Children contenait initialement au moins un élément. Dans l'autre cas, il est caché.

Le problème commence lorsque l'utilisateur ajoute un contrôle enfant à une collection vide. La visibilité de GroupBox est toujours réduite. Le même problème se produit lorsque le dernier contrôle enfant est supprimé de la collection. Le GroupBox est toujours visible. Un autre symptôme est que le convertisseur HideEmptyEnumerationConverter n'est pas appelé. Ajouter/supprimer des contrôles enfants à des collections non vides fonctionne comme prévu.

Quel est le problème avec la liaison suivante? Évidemment, cela fonctionne une fois mais n'est pas mis à jour, bien que la collection à laquelle je suis lié soit de type ObservableCollection.

<!-- Converter for hiding empty enumerations --> 
<Common:HideEmptyEnumerationConverter x:Key="hideEmptyEnumerationConverter"/> 
<!--- ... ---> 

<ControlTemplate TargetType="{x:Type MyControl}"> 
    <!-- ... other stuff that works ... --> 
    <!-- Child components --> 
    <GroupBox Header="Children" 
      Visibility="{Binding RelativeSource={RelativeSource TemplatedParent}, 
       Path=Children, Converter={StaticResource hideEmptyEnumerationConverter}}"> 
    <ItemsControl ItemsSource="{TemplateBinding Children}"/> 
    </GroupBox> 
</ControlTemplate> 

.

[ValueConversion(typeof (IEnumerable), typeof (Visibility))] 
public class HideEmptyEnumerationConverter : IValueConverter 
{ 
    #region IValueConverter Members 

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
     int itemCount = ((IEnumerable) value).Cast<object>().Count(); 
     return itemCount == 0 ? Visibility.Collapsed : Visibility.Visible; 
    } 

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) 
    { 
     throw new NotImplementedException(); 
    } 

    #endregion 
} 

Une autre question plus générale: Comment les gars déboguez-vous les liaisons? J'ai trouvé ça (http://bea.stollnitz.com/blog/?p=52) mais je trouve que c'est très difficile à faire.

Je suis content pour toute aide ou suggestion.

Answer 1

Le problème est que votre propriété Children elle-même ne change jamais, juste son contenu. Puisque la valeur de la propriété ne change pas, la liaison n'est pas réévaluée. Ce que vous devez faire est de lier à la propriété Count de la collection. La meilleure façon que vous pouvez y parvenir est avec un DataTrigger dans votre modèle:

<ControlTemplate TargetType="{x:Type MyControl}"> 
    <!-- ... other stuff that works ... --> 
    <!-- Child components --> 
    <GroupBox x:Name="gb" Header="Children"> 
    <ItemsControl ItemsSource="{TemplateBinding Children}"/> 
    </GroupBox> 
    <ControlTemplate.Triggers> 
     <DataTrigger Binding="{Binding Path=Children.Count, RelativeSource={RelativeSource TemplatedParent}}" 
        Value="0"> 
     <Setter TargetName="gb" Property="Visibility" Value="Collapsed" /> 
     </DataTrigger> 
    </ControlTemplate.Triggers> 
</ControlTemplate> 

Answer 2

Vous devez informer chaque fois que le nombre d'éléments dans vos changements de propriété enfants. Vous pouvez le faire en implémentant l'interface INotifyPropertyChanged, en vous inscrivant à l'événement CollectionChanged de la collection Children et en augmentant PropertyChanged à partir de là.

Exemple:

public class MyControl : Control, INotifyPropertyChanged 
{ 
    static MyControl() 
    { 
     DefaultStyleKeyProperty.OverrideMetadata(typeof(MyControl), new FrameworkPropertyMetadata(typeof(MyControl))); 
    } 

    public ObservableCollection<UIElement> Children 
    { 
     get { return (ObservableCollection<UIElement>)GetValue(ChildrenProperty); } 
     set { SetValue(ChildrenProperty, value); } 
    } 

    // Using a DependencyProperty as the backing store for Children. This enables animation, styling, binding, etc... 
    public static readonly DependencyProperty ChildrenProperty = 
     DependencyProperty.Register("Children", typeof(ObservableCollection<UIElement>), typeof(MyControl), new UIPropertyMetadata(0)); 

    public MyControl() 
    { 
     Children = new ObservableCollection<UIElement>(); 
     Children.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(Children_CollectionChanged); 
    } 

    void Children_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) 
    { 
     RaisePropertyChanged("Children"); 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 
    public void RaisePropertyChanged(String propertyName) 
    { 
     PropertyChangedEventHandler temp = PropertyChanged; 
     if (temp != null) 
     { 
      temp(this, new PropertyChangedEventArgs(propertyName)); 
     } 
    } 
}