Question

我是WPF的初学者。我在我的工作中开发了一个新项目，我需要插入一个具有多个选择的文件资源管理器控件。

该概念需要与acronis文件浏览器类似:(带有复选框的Treeview）

See Example

看看左侧容器，我需要实现与此类似的东西，我已经通过谷歌进行了很多搜索，但我看到很多实现，但没有什么与此类似。

因为我在WPF中没有很多经验，所以我很难开始。

您是否有一些技巧或类似的项目可以帮助我做到这一点？

我的项目基于MVVM DP。

由于

Answer 1

重新构建Treeview非常简单，您可以从要绑定的集合开始，即

<Grid>
  <TreeView ItemsSource="{Binding Folders}"/>
</Grid>

但是，您需要定义如何显示已绑定的数据。我假设你的项目只是一个IEnumerable（任何列表或数组）的FolderViewModels和FileViewModels（都有一个Name属性），所以现在我们需要说明如何显示它们。你可以通过定义一个DataTemplate来做到这一点，因为这是一个树，我们使用HeirarchicalDataTemplate，因为它也定义了subItems

<Grid.Resources>
  <HierarchicalDataTemplate DataType="{x:Type viewModel:FolderViewModel}"
                              ItemsSource="{Binding SubFoldersAndFiles}">
        <CheckBox Content="{Binding Name}"/>
  </HierarchicalDataTemplate>
<Grid.Resources/>

文件相同但不需要子项目

<HierarchicalDataTemplate DataType="{x:Type viewModel:FolderViewModel}">
   <CheckBox Content="{Binding Name}"/>
</HierarchicalDataTemplate>

所以把它们放在一起你就得到了

<Grid>
    <Grid.Resources>
        <HierarchicalDataTemplate DataType="{x:Type viewModel:FolderViewModel}"
                              ItemsSource="{Binding SubFoldersAndFiles}">
            <CheckBox Content="{Binding Name}"/>
       </HierarchicalDataTemplate>
       <HierarchicalDataTemplate DataType="{x:Type viewModel:FolderViewModel}">
            <CheckBox Content="{Binding Name}"/>
      </HierarchicalDataTemplate>
    <Grid.Resources/>
    <TreeView ItemsSource="{Binding Folders}"/>
</Grid>

<强>图标如果你想显示图标然后你改变CheckBox中的内容，我假设你将在你的ViewModel上定义一个图像。

        <CheckBox>
            <CheckBox.Content>
                <StackPanel Orientation="Horizontal">
                    <Image Source="{Binding Image}"/>
                    <TextBlock Text="{Binding Name}"/>
                </StackPanel>
            </CheckBox.Content>

<强>选择

最后，您必须处理项目的选择。我建议在FileViewModel和FolderViewModels中添加一个IsSelected属性。对于文件来说，这非常简单，只是一个布尔。

 public class FileViewModel : INotifyProperty
   ...
   public bool IsSelected //Something here to handle get/set and NotifyPropertyChanged that depends on your MVVM framework, I use ReactiveUI a lot so that's this syntax
   { 
      get { return _IsSelected;}
      set { this.RaiseAndSetIfChanged(x=>x.IsSelected, value); }
   }

和

<CheckBox IsChecked="{Binding IsSelected}">

使用FolderViewModel稍微复杂一点，我会在一秒钟内查看逻辑。首先是Xaml，只需用

替换当前的CheckBox声明

<CheckBox IsThreeState="True" IsChecked="{Binding IsSelected}">
    <!--IsChecked = True, False or null-->

所以现在我们需要返回一组Nullable<bool>（又名bool?）。

public bool? IsSelected
{
   get
   { 
      if (SubFoldersAndFiles.All(x=>x.IsSelected) return true;
      if (SubFoldersAndFiles.All(x=>x.IsSelected==false) return false;
      return null;
   }
   set
   {
      // We can't set to indeterminate at folder level so we have to set to 
      // set to oposite of what we have now
      if(value == null)
         value = !IsSelected;

      foreach(var x in SubFoldersAndFiles)
          x.IsSelected = value;
   }

或类似的东西...

Answer 2

在看了@AlSki的答案之后，我认为它既不直观也不够多才能满足我的喜好，并想出了我自己的解决方案。然而，使用我的解决方案的缺点是它需要更多的样板。另一方面，它提供了更多的灵活性。

以下示例假设您使用的是.NET 4.6.1和C＃6.0。

/// <summary>
/// A base for abstract objects (implements INotifyPropertyChanged).
/// </summary>
[Serializable]
public abstract class AbstractObject : INotifyPropertyChanged
{
    /// <summary>
    /// 
    /// </summary>
    [field: NonSerialized()]
    public event PropertyChangedEventHandler PropertyChanged;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="propertyName"></param>
    public void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="TKind"></typeparam>
    /// <param name="Source"></param>
    /// <param name="NewValue"></param>
    /// <param name="Names"></param>
    protected virtual bool SetValue<TKind>(ref TKind Source, TKind NewValue, params string[] Notify)
    {
        //Set value if the new value is different from the old
        if (!Source.Equals(NewValue))
        {
            Source = NewValue;

            //Notify all applicable properties
            Notify?.ForEach(i => OnPropertyChanged(i));

            return true;
        }

        return false;
    }

    /// <summary>
    /// 
    /// </summary>
    public AbstractObject()
    {
    }
}

具有检查状态的对象。

/// <summary>
/// Specifies an object with a checked state.
/// </summary>
public interface ICheckable
{
    /// <summary>
    /// 
    /// </summary>
    bool? IsChecked
    {
        get; set;
    }
}

/// <summary>
/// 
/// </summary>
public class CheckableObject : AbstractObject, ICheckable
{
    /// <summary>
    /// 
    /// </summary>
    [field: NonSerialized()]
    public event EventHandler<EventArgs> Checked;

    /// <summary>
    /// 
    /// </summary>
    [field: NonSerialized()]
    public event EventHandler<EventArgs> Unchecked;

    /// <summary>
    /// 
    /// </summary>
    [XmlIgnore]
    protected bool? isChecked;
    /// <summary>
    /// 
    /// </summary>
    public virtual bool? IsChecked
    {
        get
        {
            return isChecked;
        }
        set
        {
            if (SetValue(ref isChecked, value, "IsChecked") && value != null)
            {
                if (value.Value)
                {
                    OnChecked();
                }
                else OnUnchecked();
            }
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return base.ToString();
        //return isChecked.ToString();
    }

    /// <summary>
    /// 
    /// </summary>
    protected virtual void OnChecked()
    {
        Checked?.Invoke(this, new EventArgs());
    }

    /// <summary>
    /// 
    /// </summary>
    protected virtual void OnUnchecked()
    {
        Unchecked?.Invoke(this, new EventArgs());
    }

    /// <summary>
    /// 
    /// </summary>
    public CheckableObject() : base()
    {
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="isChecked"></param>
    public CheckableObject(bool isChecked = false)
    {
        IsChecked = isChecked;
    }
}

已检查系统对象的视图模型：

/// <summary>
/// 
/// </summary>
public class CheckableSystemObject : CheckableObject
{
    #region Properties

    /// <summary>
    /// 
    /// </summary>
    public event EventHandler Collapsed;

    /// <summary>
    /// 
    /// </summary>
    public event EventHandler Expanded;

    bool StateChangeHandled = false;

    CheckableSystemObject Parent { get; set; } = default(CheckableSystemObject);

    ISystemProvider SystemProvider { get; set; } = default(ISystemProvider);

    ConcurrentCollection<CheckableSystemObject> children = new ConcurrentCollection<CheckableSystemObject>();
    /// <summary>
    /// 
    /// </summary>
    public ConcurrentCollection<CheckableSystemObject> Children
    {
        get
        {
            return children;
        }
        private set
        {
            SetValue(ref children, value, "Children");
        }
    }

    bool isExpanded = false;
    /// <summary>
    /// 
    /// </summary>
    public bool IsExpanded
    {
        get
        {
            return isExpanded;
        }
        set
        {
            if (SetValue(ref isExpanded, value, "IsExpanded"))
            {
                if (value)
                {
                    OnExpanded();
                }
                else OnCollapsed();
            }
        }
    }

    bool isSelected = false;
    /// <summary>
    /// 
    /// </summary>
    public bool IsSelected
    {
        get
        {
            return isSelected;
        }
        set
        {
            SetValue(ref isSelected, value, "IsSelected");
        }
    }

    string path = string.Empty;
    /// <summary>
    /// 
    /// </summary>
    public string Path
    {
        get
        {
            return path;
        }
        set
        {
            SetValue(ref path, value, "Path");
        }
    }

    bool queryOnExpanded = false;
    /// <summary>
    /// 
    /// </summary>
    public bool QueryOnExpanded
    {
        get
        {
            return queryOnExpanded;
        }
        set
        {
            SetValue(ref queryOnExpanded, value);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public override bool? IsChecked
    {
        get
        {
            return isChecked;
        }
        set
        {
            if (SetValue(ref isChecked, value, "IsChecked") && value != null)
            {
                if (value.Value)
                {
                    OnChecked();
                }
                else OnUnchecked();
            }
        }
    }

    #endregion

    #region CheckableSystemObject

    /// <summary>
    /// 
    /// </summary>
    /// <param name="path"></param>
    /// <param name="systemProvider"></param>
    /// <param name="isChecked"></param>
    public CheckableSystemObject(string path, ISystemProvider systemProvider, bool? isChecked = false) : base()
    {
        Path = path;
        SystemProvider = systemProvider;
        IsChecked = isChecked;
    }

    #endregion

    #region Methods

    void Determine()
    {
        //If it has a parent, determine it's state by enumerating all children, but current instance, which is already accounted for.
        if (Parent != null)
        {
            StateChangeHandled = true;
            var p = Parent;
            while (p != null)
            {
                p.IsChecked = Determine(p);
                p = p.Parent;
            }
            StateChangeHandled = false;
        }
    }

    bool? Determine(CheckableSystemObject Root)
    {
        //Whether or not all children and all children's children have the same value
        var Uniform = true;

        //If uniform, the value
        var Result = default(bool?);

        var j = false;
        foreach (var i in Root.Children)
        {
            //Get first child's state
            if (j == false)
            {
                Result = i.IsChecked;
                j = true;
            }
            //If the previous child's state is not equal to the current child's state, it is not uniform and we are done!
            else if (Result != i.IsChecked)
            {
                Uniform = false;
                break;
            }
        }

        return !Uniform ? null : Result;
    }

    void Query(ISystemProvider SystemProvider)
    {
        children.Clear();
        if (SystemProvider != null)
        {
            foreach (var i in SystemProvider.Query(path))
            {
                children.Add(new CheckableSystemObject(i, SystemProvider, isChecked)
                {
                    Parent = this
                });
            }
        }
    }

    /// <summary>
    /// 
    /// </summary>
    protected override void OnChecked()
    {
        base.OnChecked();

        if (!StateChangeHandled)
        {
            //By checking the root only, all children are checked automatically
            foreach (var i in children)
                i.IsChecked = true;

            Determine();
        }
    }

    /// <summary>
    /// 
    /// </summary>
    protected override void OnUnchecked()
    {
        base.OnUnchecked();

        if (!StateChangeHandled)
        {
            //By unchecking the root only, all children are unchecked automatically
            foreach (var i in children)
                i.IsChecked = false;

            Determine();
        }
    }

    /// <summary>
    /// 
    /// </summary>
    protected virtual void OnCollapsed()
    {
        Collapsed?.Invoke(this, new EventArgs());
    }

    /// <summary>
    /// 
    /// </summary>
    protected virtual void OnExpanded()
    {
        Expanded?.Invoke(this, new EventArgs());

        if (!children.Any<CheckableSystemObject>() || queryOnExpanded)
            BeginQuery(SystemProvider);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="SystemProvider"></param>
    public async void BeginQuery(ISystemProvider SystemProvider)
    {
        await Task.Run(() => Query(SystemProvider));
    }

    #endregion
}

用于查询系统对象的实用程序;请注意，通过定义您自己的SystemProvider，您可以查询不同类型的系统（即本地或远程）。默认情况下，将查询本地系统。如果要显示来自远程服务器（如FTP）的对象，则需要定义使用适当Web协议的SystemProvider。

/// <summary>
/// Specifies an object capable of querying system objects.
/// </summary>
public interface ISystemProvider
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="Path">The path to query.</param>
    /// <param name="Source">A source used to make queries.</param>
    /// <returns>A list of system object paths.</returns>
    IEnumerable<string> Query(string Path, object Source = null);
}

/// <summary>
/// Defines base functionality for an <see cref="ISystemProvider"/>.
/// </summary>
public abstract class SystemProvider : ISystemProvider
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="Path"></param>
    /// <param name="Source"></param>
    /// <returns></returns>
    public abstract IEnumerable<string> Query(string Path, object Source = null);
}

/// <summary>
/// Defines functionality to query a local system.
/// </summary>
public class LocalSystemProvider : SystemProvider
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="Path"></param>
    /// <param name="Source"></param>
    /// <returns></returns>
    public override IEnumerable<string> Query(string Path, object Source = null)
    {
        if (Path.IsNullOrEmpty())
        {
            foreach (var i in System.IO.DriveInfo.GetDrives())
                yield return i.Name;
        }
        else
        {
            if (System.IO.Directory.Exists(Path))
            {
                foreach (var i in System.IO.Directory.EnumerateFileSystemEntries(Path))
                    yield return i;
            }
        }
    }
}

然后是一个继承的TreeView，它将所有这些放在一起：

/// <summary>
/// 
/// </summary>
public class SystemObjectPicker : TreeViewExt
{
    #region Properties

    /// <summary>
    /// 
    /// </summary>
    public static DependencyProperty QueryOnExpandedProperty = DependencyProperty.Register("QueryOnExpanded", typeof(bool), typeof(SystemObjectPicker), new FrameworkPropertyMetadata(false, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnQueryOnExpandedChanged));
    /// <summary>
    /// 
    /// </summary>
    public bool QueryOnExpanded
    {
        get
        {
            return (bool)GetValue(QueryOnExpandedProperty);
        }
        set
        {
            SetValue(QueryOnExpandedProperty, value);
        }
    }
    static void OnQueryOnExpandedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        d.As<SystemObjectPicker>().OnQueryOnExpandedChanged((bool)e.NewValue);
    }

    /// <summary>
    /// 
    /// </summary>
    public static DependencyProperty RootProperty = DependencyProperty.Register("Root", typeof(string), typeof(SystemObjectPicker), new FrameworkPropertyMetadata(string.Empty, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnRootChanged));
    /// <summary>
    /// 
    /// </summary>
    public string Root
    {
        get
        {
            return (string)GetValue(RootProperty);
        }
        set
        {
            SetValue(RootProperty, value);
        }
    }
    static void OnRootChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        d.As<SystemObjectPicker>().OnRootChanged((string)e.NewValue);
    }

    /// <summary>
    /// 
    /// </summary>
    static DependencyProperty SystemObjectsProperty = DependencyProperty.Register("SystemObjects", typeof(ConcurrentCollection<CheckableSystemObject>), typeof(SystemObjectPicker), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
    /// <summary>
    /// 
    /// </summary>
    ConcurrentCollection<CheckableSystemObject> SystemObjects
    {
        get
        {
            return (ConcurrentCollection<CheckableSystemObject>)GetValue(SystemObjectsProperty);
        }
        set
        {
            SetValue(SystemObjectsProperty, value);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public static DependencyProperty SystemProviderProperty = DependencyProperty.Register("SystemProvider", typeof(ISystemProvider), typeof(SystemObjectPicker), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, OnSystemProviderChanged));
    /// <summary>
    /// 
    /// </summary>
    public ISystemProvider SystemProvider
    {
        get
        {
            return (ISystemProvider)GetValue(SystemProviderProperty);
        }
        set
        {
            SetValue(SystemProviderProperty, value);
        }
    }
    static void OnSystemProviderChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        d.As<SystemObjectPicker>().OnSystemProviderChanged((ISystemProvider)e.NewValue);
    }

    #endregion

    #region SystemObjectPicker

    /// <summary>
    /// 
    /// </summary>
    public SystemObjectPicker() : base()
    {
        SetCurrentValue(SystemObjectsProperty, new ConcurrentCollection<CheckableSystemObject>());
        SetCurrentValue(SystemProviderProperty, new LocalSystemProvider());

        SetBinding(ItemsSourceProperty, new Binding()
        {
            Mode = BindingMode.OneWay,
            Path = new PropertyPath("SystemObjects"),
            Source = this
        });
    }

    #endregion

    #region Methods

    void OnQueryOnExpandedChanged(CheckableSystemObject Item, bool Value)
    {
        foreach (var i in Item.Children)
        {
            i.QueryOnExpanded = Value;
            OnQueryOnExpandedChanged(i, Value);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="Value"></param>
    protected virtual void OnQueryOnExpandedChanged(bool Value)
    {
        foreach (var i in SystemObjects)
            OnQueryOnExpandedChanged(i, Value);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="Provider"></param>
    /// <param name="Root"></param>
    protected virtual void OnRefreshed(ISystemProvider Provider, string Root)
    {
        SystemObjects.Clear();
        if (Provider != null)
        {
            foreach (var i in Provider.Query(Root))
            {
                SystemObjects.Add(new CheckableSystemObject(i, SystemProvider)
                {
                    QueryOnExpanded = QueryOnExpanded
                });
            }
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="Value"></param>
    protected virtual void OnRootChanged(string Value)
    {
        OnRefreshed(SystemProvider, Value);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="Value"></param>
    protected virtual void OnSystemProviderChanged(ISystemProvider Value)
    {
        OnRefreshed(Value, Root);
    }

    #endregion
}

显然，它比@ AlSki的答案要复杂得多，但是，再一次，你获得了更多的灵活性，而且已经为你解决了困难。

此外，如果您对此感兴趣，我已在最新版本的my open source project（3.1）中发布此代码;如果没有，上面的示例就是让它工作所需的全部内容。

如果您不下载该项目，请注意以下事项：

您会发现一些不存在的扩展方法，可以通过其对应方式进行补充（例如，IsNullOrEmpty扩展名与string.IsNullOrEmpty()相同）。
TreeViewExt是我设计的自定义TreeView，如果您不关心这一点，只需将TreeViewExt更改为TreeView;无论哪种方式，您都不必为其定义特殊的控制模板，因为它旨在与TreeView的现有设施配合使用。
在示例中，我使用自己的并发ObservableCollection版本;这样您就可以在后台线程上查询数据而无需跳过箍。将其更改为ObservableCollection并使所有查询同步或使用您自己的并发ObservableCollection来保留异步功能。

最后，以下是如何使用控件：

<Controls.Extended:SystemObjectPicker>
    <Controls.Extended:SystemObjectPicker.ItemContainerStyle>
        <Style TargetType="TreeViewItem" BasedOn="{StaticResource {x:Type TreeViewItem}}">
            <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
        </Style>
    </Controls.Extended:SystemObjectPicker.ItemContainerStyle>
    <Controls.Extended:SystemObjectPicker.ItemTemplate>
        <HierarchicalDataTemplate ItemsSource="{Binding Children, Mode=OneWay}">
            <StackPanel Orientation="Horizontal">
                <CheckBox
                    IsChecked="{Binding IsChecked, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
                    Margin="0,0,5,0"/>
                <TextBlock 
                    Text="{Binding Path, Converter={StaticResource FileNameConverter}, Mode=OneWay}"/>
            </StackPanel>
        </HierarchicalDataTemplate>
    </Controls.Extended:SystemObjectPicker.ItemTemplate>
</Controls.Extended:SystemObjectPicker>

待办事项

向CheckableSystemObject添加一个属性，公开系统对象的视图模型;这样，您就可以访问与其相关的FileInfo / DirectoryInfo路径或其他描述它的其他数据源。如果对象是远程的，您可能已经定义了自己的类来描述它，如果您有对它的引用，这可能很有用。
查询本地系统时捕获可能的异常;如果无法访问系统对象，则会失败。 LocalSystemProvider也无法解决超过260个字符的系统路径;但是，这超出了本项目的范围。

请注意版主

为方便起见，我引用了自己的开源项目，因为我在最新版本中发布了上述示例;我的意图不是自我推销，所以如果引用你自己的项目不满意，我会继续删除链接。

基于具有多个选择的树视图实现文件浏览器

2 个答案: