Xaml通过集合中任何子级的特定属性触发父级

本文关键字：属性 Xaml 集合 任何 | 更新日期: 2023-09-27 17:57:56

我在ViewModel中遇到了子-父关系的触发器问题。

考虑以下ViewModel（实现INotifyPropertyChanged）和View:

ViewModelType
 + Items: ObservableCollection<ViewModelType>
 + IsVisible: bool
 + Text: string
ViewType
 + Visibility: Visibility
 + Header: string

我有一个数据模板来绑定2:

<DataTemplate DataType="{x:Type vm:ViewModelType}">
  <views:ViewType Header="{Binding Text}"/>
</DataTemplate>

视图的样式：

<Style TargetType="{x:Type views:ViewType}">
  <Setter Property="Visibility" Value="{Binding IsVisible, Converter={StaticResource Bool2Visibility}}"/>
</Style>

这一切都很完美。

现在，我想要实现的是，如果从ViewModelTypeInstanceA所有ViewModelType.Items的IsVisible属性都设置为false，我希望ViewModelTypeInstance A对应的ViewType的Visibility属性设置为Visibility.Collapsed**

我尝试过DataTriggers、转换器等等，但我认为我不能在触发器中使用AncestorType之类的东西来指向不可引用的父级？似乎不可能触发父属性。也许一个元素可以观察到它的所有子元素的IsVisisble属性？

条件：
1.我更喜欢不更改ControlTemplate（它来自diff-lib）
2.修改ViewModel结构也不是一个选项（兼容性问题）。这意味着我不能在项目创建时维护属性Parent，也不能像Eli建议的那样更改Collection类型
3.我真的更喜欢一个优雅的解决方案。

**当然，如果可以通过样式设置，则取决于子级ViewType的VisibilityProperty也可以。

Xaml通过集合中任何子级的特定属性触发父级

您可以挂接每个项目的PropertyChanged事件。您还可以从ObservableCollection继承，并在添加/删除项时挂接事件。然后在视图模型中创建一个计算特性，并激发其特性更改事件。

另一种选择是使用像ReactiveUI这样的框架。

class ViewModel
{
    public ViewModel()
    {
        Items = new NotificationCollection<Item>();
        Items.ItemPropertyChanged += (o, e) =>
        {
            if (e.PropertyName == nameof(Item.IsVisible))
                OnPropertyChanged(nameof(IsVisible));
        };
    }
    public NotificationCollection<Item> Items { get; }
    public bool IsVisible => Items.All(i => i.IsVisible);
}

如果无法更改集合的类型，则可以使用CollectionChanged事件：

Items = new ObservableCollection<Item>();
PropertyChangedEventHandler propertyChangedHandler = (o, e) =>
{
    if (e.PropertyName == nameof(Item.IsVisible))
        OnPropertyChanged(nameof(IsVisible));
};
Items.CollectionChanged += (o, e) =>
{
    if (e.OldItems != null)
        foreach (var item in e.OldItems.OfType<INotifyPropertyChanged>())
            item.PropertyChanged -= propertyChangedHandler;
    if (e.NewItems != null)
        foreach (var item in e.NewItems.OfType<INotifyPropertyChanged>())
            item.PropertyChanged += propertyChangedHandler;
};

这是NotificationCollection类：

public class NotificationCollection<T> : ObservableCollection<T>
    where T : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler ItemPropertyChanged;
    protected virtual void OnItemPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        ItemPropertyChanged?.Invoke(sender, e);
    }
    protected override void ClearItems()
    {
        foreach (var item in Items)
        {
            DisconnectItem(item);
        }
        base.ClearItems();
    }
    protected override void InsertItem(int index, T item)
    {
        base.InsertItem(index, item);
        ConnectItem(item);
    }
    protected override void RemoveItem(int index)
    {
        DisconnectItem(Items[index]);
        base.RemoveItem(index);
    }
    protected override void SetItem(int index, T item)
    {
        DisconnectItem(Items[index]);
        base.SetItem(index, item);
        ConnectItem(item);
    }
    private void ConnectItem(T item)
    {
        if (item != null)
        {
            item.PropertyChanged += OnItemPropertyChanged;
        }
    }
    private void DisconnectItem(T item)
    {
        if (item != null)
        {
            item.PropertyChanged -= OnItemPropertyChanged;
        }
    }
}

不是最干净的，但我想是我能想到的最好的。我正在（ab）使用物理父对象的DataContext。

  1. 我添加了ViewModelType.HasVisibleChild-属性和EvaluateHasVisibleChildValue()方法

internal void EvaluateHasVisibleChild()
{
  foreach(ViewModelType node in Items)
    // Conditions for ultimate visibility
    if (node.IsVisible && node.HasVisibleChild)
    {
      HasVisibleChild = true;
      return;
    }
  HasVisibleChild = false;
}
  1. 我更改了使用转换器的样式绑定，并将可见性相关属性提供为物理ViewType祖先：

 

<Style TargetType="{x:Type views:ViewType}">
  <Setter.Value>
    <MultiBinding Converter="{StaticResource ConditionalVisibilityConverter}">
      <Binding Path="IsVisible"/>
      <Binding Path="HasVisibleChild"/>
      <Binding Path="." RelativeSource="{RelativeSource Mode=FindAncestor, AncestorType={x:Type views:ViewType}}"/>
    </MultiBinding>
  </Setter.Value>
</Style>
  1. 我编写了一个MultiBindingConverter：

public class ConditionalVisibilityConverter : IMultiValueConverter
{
  public object Convert(object[] values, Type targetType, object paramater, CultureInfo culture)
  {
    // Has no ancestor safety check
    if (values[2] != DependencyProperty.UnsetValue)
      // Sneak in an update of viewmodelparent via physical parent.
      (((values[2] as FrameworkElement).DataContext) as ViewModelType).EvaluateHasVisibleChild();
    return (bool)values[0] && (bool)values[1] ? Visibility.Visible : Visibility.Collapsed;
  }
  public object[] ConvertBack(object value, Type[] targetTypes, object paramweter, CultureInfo cultuer)
  {
    throw new NotImplementedException();
  }
}

在实践中，我有多个ViewType作为祖先，所以我为各种ancestorType添加了多个Binding。我也考虑过在各种ViewTypes中添加一个Interface，但是没有。

注意：这显然要求每个ViewModelType只使用1个ViewType，否则FindAncestorType可能会得到意外的结果。

相关文章：