WPF 4数据网格：显示和隐藏列

Question

我正在尝试为DataGrid实现列选择器功能，但是如果我尝试将列的标题内容定义为不仅仅是字符串，就会遇到问题。下面是一个非常简单的示例，其中所有样式、视图模型、绑定等都被剥离了。

有3列：

第一列使用字符串作为标题。 第二列尝试将标题内容设置为带有工具提示的Label。 第三列尝试将标题内容设置为带有工具提示的TextBlock。

单击“切换可见性”按钮以显示/隐藏A列时没有问题。单击B和C列的“切换可见性”按钮会导致InvalidOperationException，消息为“指定的元素已经是另一个元素的逻辑子元素。请先断开连接。”

<Window x:Class="DataGridColumnChoosing.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" Height="350" Width="525">
<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="*" />
    </Grid.RowDefinitions>
    <StackPanel Orientation="Horizontal" Margin="0,10">
        <TextBlock Margin="15, 0">Toggle Visibility:</TextBlock>
        <Button Click="ToggleA">Column A</Button>
        <Button Click="ToggleB">Column B</Button>
        <Button Click="ToggleC">Column C</Button>
    </StackPanel>
    <!-- Main Fuel Mileage Datagrid -->
    <DataGrid  x:Name="mySampleDataGrid" Grid.Row="1"
                    AutoGenerateColumns="False" CanUserSortColumns="False" CanUserResizeRows="False" CanUserAddRows="False"
                    GridLinesVisibility="All" RowHeaderWidth="0">
        <DataGrid.Columns>
            <DataGridTemplateColumn x:Name="colA" Width="40*" IsReadOnly="True" Header="Column A">
                <DataGridTemplateColumn.CellTemplate>
                    <DataTemplate>
                        <TextBlock />
                    </DataTemplate>
                </DataGridTemplateColumn.CellTemplate>
            </DataGridTemplateColumn>


            <DataGridTemplateColumn x:Name="colB" Width="40*" IsReadOnly="True" >
                <DataGridTemplateColumn.Header>
                    <Label Content="Column B" ToolTip="A short explanation of Column B"/>
                </DataGridTemplateColumn.Header>
                <DataGridTemplateColumn.CellTemplate>
                    <DataTemplate>
                        <TextBlock />
                    </DataTemplate>
                </DataGridTemplateColumn.CellTemplate>
            </DataGridTemplateColumn>

            <DataGridTemplateColumn x:Name="colC" Width="40*" IsReadOnly="True" >
                <DataGridTemplateColumn.Header>
                    <TextBlock Text="Column C" ToolTip="A short explanation of Column C " />
                </DataGridTemplateColumn.Header>
                <DataGridTemplateColumn.CellTemplate>
                    <DataTemplate>
                        <TextBlock  />
                    </DataTemplate>
                </DataGridTemplateColumn.CellTemplate>
            </DataGridTemplateColumn>
        </DataGrid.Columns>
    </DataGrid>
</Grid>

在这个例子中，用于切换可见性的按钮的简单点击事件处理程序只是修改列的可见性。

    private void ToggleA(object sender, RoutedEventArgs e)
    {
        colA.Visibility = colA.Visibility == System.Windows.Visibility.Visible ? System.Windows.Visibility.Hidden : System.Windows.Visibility.Visible;
    }

    private void ToggleB(object sender, RoutedEventArgs e)
    {
        colB.Visibility = colB.Visibility == System.Windows.Visibility.Visible ? System.Windows.Visibility.Hidden : System.Windows.Visibility.Visible;
    }

    private void ToggleC(object sender, RoutedEventArgs e)
    {
        colC.Visibility = colC.Visibility == System.Windows.Visibility.Visible ? System.Windows.Visibility.Hidden : System.Windows.Visibility.Visible;
    }

感谢大家。

- Greg Andora

---

我的强迫症说，请把事件处理程序ToggleA和ToggleB交换位置，使它们按字母顺序排列。 抽搐 - xdumaine

哈哈，我替你交换了它们，以防止过度抽搐。 - Greg Andora

虽然这是针对ComboBox的，但你是否看过这里http://connect.microsoft.com/VisualStudio/feedback/details/496959/specified-element-is-already-the-logical-child-of-another-element-disconnect-it-first - Aaron McIver

有趣的是，但如果它适合某种方式，我找不到如何做到。错误发生时，无论在标题定义中的文本块（或标签）上是否有工具提示...并且遵循他们用<ToolTip> </ ToolTip>包装工具提示的解决方法，我不太确定我会在我的标题内容周围包裹什么。 - Greg Andora

Answer 1

我曾经遇到过这个问题，当我在资源中定义一个控件并尝试在多个控件的内容区域中使用它时，会出现这种情况。这不起作用，因为控件只能属于一个父级。

相反，我需要定义某种模板，其中包含我想要的控件，并设置我的对象的模板，而不是直接设置内容。

您对@Gimno答案的评论让我想到了这一点。

尝试更改它，使其不是直接设置DataGrid.Header的内容中的标签/文本框，而是将DataGrid.HeaderTemplate设置为包含该标签或文本框的DataTemplate。

编辑

这里是一些示例代码

<DataGridTemplateColumn x:Name="colB" Width="40*" IsReadOnly="True" >
    <DataGridTemplateColumn.HeaderTemplate>
        <DataTemplate>
            <Label Content="Column B" ToolTip="A short explanation of Column B"/>
        </DataTemplate>
    </DataGridTemplateColumn.HeaderTemplate>
    <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
            <TextBlock />
        </DataTemplate>
    </DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>

- Rachel

---

听起来很合理，但并没有奏效。我从MSDN中提取了一个内容控件的样本。（哦，好吧，代码不能放在这里）我将页眉设置为指向输出字符串的样式的内容控件...仍然抛出错误。 - Greg Andora

你需要设置实际的模板，而不是内容。我之前遇到的问题是我试图设置 ContentControl.Content，而我需要设置 ContentControl.ContentTemplate。我认为你有同样的问题...... 你应该设置 DataGrid.HeaderTemplate 而不是 DataGrid.Header。 - Rachel

哇，非常感谢Rachel，幸好它并没有按照我预期的那样工作。我本来以为HeaderStyle定义中的Template属性和HeaderTemplate是同一件事，并且这两个定义会互相竞争以确定哪一个被实现。幸运的是，我错了，现在它完美地工作了！ - Greg Andora

Answer 2

我认为最简单的方法是使用DataGridTemplateColumn.HeaderStyle而不是DataGridTemplateColumn.Header

以列c为例：

<DataGridTemplateColumn x:Name="colC" Width="40*" IsReadOnly="True" >
    <DataGridTemplateColumn.HeaderStyle>
        <Style TargetType="DataGridColumnHeader">
            <Setter Property="ContentTemplate">
                <Setter.Value>
                    <DataTemplate>
                        <TextBlock Text="Column C"  ToolTip="A short explanation of Column C "/>
                    </DataTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </DataGridTemplateColumn.HeaderStyle>
    <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
            <TextBlock  />
        </DataTemplate>
    </DataGridTemplateColumn.CellTemplate>
  </DataGridTemplateColumn>
</DataGridTemplateColumn.HeaderStyle>

- Gimno

---

这对于像这样的示例是最简单的，但是此示例构建的 DataGrid 具有约20个列，这些列都共享相同的自定义 ContentTemplate（与同一应用程序中的其他 DataGrid 相同）。使用 DataGridTemplateColumn.Header 可以让我在模板中拥有 ContentPresenter，并且仅需定义一次模板。 - Greg Andora

好的，那就这样改吧。我会选择Rachel的解决方案。 - Gimno

Answer 3

我喜欢来自CodePlex的列选择器解决方案： DataGrid Behavior

我清理了代码并删除了不必要的代码：

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;
using Microsoft.Xaml.Behaviors;

namespace Behaviors
{
    public class WpfDataGridConfigurationBehavior : Behavior<DependencyObject>
    {

        #region "public Properties"


        public bool DontPersistVisibleColumns { get; set; }
        public bool DontPersistColumnsOrder { get; set; }

        public string ContextMenuChoices { get; set; } = "Alphabetical Menu,Show All Columns";

        public string DataGridName { get; set; }

        #endregion "public Properties"

        #region "private Properties"

        private DataGrid dataGrid;

        private ContextMenu theContextMenu; // Context Menu for the field chooser.

        private string AllColumnsHeaders { get; set; }
        private string AllColumnDisplayIndexes { get; set; }

        private int nBaseItems = 5;
        private MenuItem mnuAlpha;
        private MenuItem mnuShowAll;

        #endregion "Private Properties"

        protected override void OnAttached()
        {
            base.OnAttached();

            dataGrid = this.AssociatedObject as DataGrid;
            if (DataGridName == null) DataGridName = dataGrid.Name;

            ContextMenu_BuildStaticMenu();

            dataGrid.Loaded += (sender, e) => { DataGrid_Loaded(); };
            dataGrid.AutoGeneratedColumns += DataGrid_AutoGeneratedColumns;

            dataGrid.ColumnReordered += (sender, e) => { DataGrid_ColumnReordered(sender); };

            dataGrid.ContextMenuOpening += (sender, e) => { DataGrid_ContextMenuOpening(e); };

            dataGrid.LoadingRow += (sender, e) => { e.Row.Header = (e.Row.GetIndex() + 1).ToString(); };

            dataGrid.RowHeaderWidth = 0;
            var ns = new Style(typeof(DataGridRowHeader)) { BasedOn = dataGrid.RowHeaderStyle };
            ns.Setters.Add(new Setter(Control.FontWeightProperty, FontWeights.Bold));
            ns.Setters.Add(new Setter(Control.FontSizeProperty, 11.0));
            ns.Setters.Add(new Setter(Control.PaddingProperty, new Thickness(4, 0, 4, 0)));
            dataGrid.RowHeaderStyle = ns;
        }

        private void DataGrid_AutoGeneratedColumns(object sender, EventArgs e)
        {
            DataGrid_Loaded();
        }


        #region "DataGrid Events"


        private void DataGrid_ContextMenuOpening(ContextMenuEventArgs e)
        {
            var dep = (DependencyObject)e.OriginalSource;

            // iteratively traverse the visual tree
            while ((dep != null) && !(dep is DataGridCell) && !(dep is DataGridColumnHeader))
                dep = VisualTreeHelper.GetParent(dep);

            if (dep == null)
                return;

            if (dep is DataGridColumnHeader)
            {
                // do something
            }

            if (dep is DataGridCell)
            {
                // navigate further up the tree
                while ((dep != null) && !(dep is DataGridRow))
                    dep = VisualTreeHelper.GetParent(dep);

                var row = dep as DataGridRow;

                dataGrid.ItemContainerGenerator.IndexFromContainer(row);
            }
        }

        private void DataGrid_ColumnReordered(object sender)
        {
            Settings_SaveDisplayIndexes(sender);

            ContextMenu_BuildMenu();
        }

        private void DataGrid_Loaded()
        {
            ContextMenu_BuildMenu(false);

            VisibleColumns_Initialize();
        }

        #endregion "DataGrid Events"

        #region "ContextMenu Methods and Events"

        private void ContextMenu_BuildStaticMenu()
        {
            theContextMenu = new ContextMenu { FontSize = 11, StaysOpen = true };

            mnuAlpha = new MenuItem
            {
                Header = ContextMenuChoices.Split(',')[0],
                FontWeight = FontWeights.Bold,
                IsCheckable = true,
                StaysOpenOnClick = true
            };
            mnuAlpha.Click += (sender, e) => { ContextMenu_BuildMenu(); };

            mnuShowAll = new MenuItem
            {
                Header = ContextMenuChoices.Split(',')[1],
                FontWeight = FontWeights.Bold,
                IsCheckable = true,
                StaysOpenOnClick = true
            };
            mnuShowAll.Checked += (sender, e) => { VisibleColumns = AllColumnsHeaders; };
            mnuShowAll.Click += (sender, e) =>
            {
                if (mnuShowAll.IsChecked == false) VisibleColumns_Initialize();
            };


            theContextMenu.Items.Add(mnuShowAll);
            theContextMenu.Items.Add(mnuAlpha);
        }

        private void ContextMenu_BuildMenu(bool pbRebuild = true)
        {
            for (int i = theContextMenu.Items.Count - 1; i > 0; i--)
                if (((MenuItem)theContextMenu.Items[i]).FontWeight != FontWeights.Bold)
                    theContextMenu.Items.Remove(theContextMenu.Items[i]);

            nBaseItems = theContextMenu.Items.Count;

            // Attach the context menu to the DataGrid ColumnHeaders
            var headersPresenter = WpfDataGridConfigurationBehaviorFinder.FindChild<DataGridColumnHeadersPresenter>(dataGrid);
            ContextMenuService.SetContextMenu(headersPresenter, theContextMenu);

            if (VisibleColumns == null)
                throw (new SettingsPropertyNotFoundException("User's VisibleColumns setting not found."));

            // Get the current column ordering from user.config

            if (DisplayIndexes == null)
                throw (new SettingsPropertyNotFoundException("User's DisplayIndexes setting not found."));

            AllColumnDisplayIndexes = DisplayIndexes;
            string[] colIndexes = AllColumnDisplayIndexes.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);

            var dataGridColumns = dataGrid.Columns.OrderBy(x => x.DisplayIndex);

            // Sort the columns in display index order so menu header order matchs display column order
            if (pbRebuild == false)
                // Initially the datagrid column order is such that display indexes are the same as the col indexes
                if (colIndexes.Length > 0)
                    dataGridColumns = dataGrid.Columns.OrderBy(x => Convert.ToInt16(colIndexes[x.DisplayIndex]));

            if (mnuAlpha.IsChecked)
                dataGridColumns = dataGrid.Columns.OrderBy(x => x.Header.ToString());

            AllColumnsHeaders = "";
            foreach (var col in dataGridColumns)
            {
                // All column name to a list of all column headers for later use.
                AllColumnsHeaders = $"{col.Header.ToString().Replace("\n", " ").Replace("\r", " ")};{AllColumnsHeaders}";

                // Add new menu item in display order.
                ContextMenu_AddNewMenuItem(col);
            }

            string sTemp = VisibleColumns;
            VisibleColumns = null;
            VisibleColumns = sTemp;

        }

        private void ContextMenu_AddNewMenuItem(DataGridColumn col)
        {
            var menuItem = new MenuItem { Header = col.Header.ToString().Replace("\n", " ").Replace("\r", " "), StaysOpenOnClick = true };
            var saVisibleColumns = new List<string> { string.Empty };
            if (VisibleColumns != null)
            {
                saVisibleColumns = VisibleColumns.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList();
            }

            menuItem.IsChecked = (saVisibleColumns.Contains(menuItem.Header));
            menuItem.Click += (sender, e) => { ContextMenu_ColumnName_Click(sender); };

            theContextMenu.Items.Add(menuItem);
        }

        private void ContextMenu_ColumnName_Click(object sender)
        {
            var mi = sender as MenuItem;

            // Get the column name that was clicked
            string colName = mi.Header.ToString();


            // Capture new visible columns list
            Settings_SaveVisibleColumns(mi, colName);
        }

        #endregion "ContextMenu Methods and Events"

        #region "Settings Methods"

        private void Settings_SaveVisibleColumns(MenuItem mi, string colName)
        {
            if (theContextMenu.Items.Count - nBaseItems < dataGrid.Columns.Count)
                return;

            // Put the visible column names into an array
            var saVisibleColumns = VisibleColumns.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries).ToList();
            if (saVisibleColumns != null && saVisibleColumns.Count > 0 &&
                saVisibleColumns[saVisibleColumns.Count - 1].StartsWith("-"))
                saVisibleColumns.RemoveAt(saVisibleColumns.Count - 1);

            // If the menu item is unchecked (column is not visible)
            if (!mi.IsChecked)
                // Make the column visible by adding its name to the Visible Columns list
                saVisibleColumns.Add(colName);

            else
            // Hide the column by removing its name from the VisibleColumns list
            if (saVisibleColumns.Contains(colName) && saVisibleColumns.Count > 1)
                saVisibleColumns.Remove(colName);

            VisibleColumns = string.Join(";", saVisibleColumns) + ";";
        }

        private void Settings_SaveDisplayIndexes(object sender)
        {
            // Capture the new column order
            AllColumnDisplayIndexes = "";
            foreach (DataGridColumn col in ((DataGrid)sender).Columns)
            {
                AllColumnDisplayIndexes +=
                    (AllColumnDisplayIndexes.Length > 0 ? ";" : "") + col.DisplayIndex;
            }

            DisplayIndexes = AllColumnDisplayIndexes;
        }

        #endregion "Settings Methods"

        #region DisplayIndexes (DependencyProperty)

        public string DisplayIndexes
        {
            get { return (string)GetValue(DisplayIndexesProperty); }
            set { SetValue(DisplayIndexesProperty, value); }
        }

        public static readonly DependencyProperty DisplayIndexesProperty =
            DependencyProperty.Register("DisplayIndexes", typeof(string), typeof(WpfDataGridConfigurationBehavior), new PropertyMetadata("", OnDisplayIndexesChanged));

        private static void OnDisplayIndexesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ((WpfDataGridConfigurationBehavior)d).DisplayIndexesChanged(e);
        }

        public void DisplayIndexesChanged(DependencyPropertyChangedEventArgs e)
        {
            // Persist the new column order
            if (dataGrid != null && !DontPersistColumnsOrder)
                Settings_Save(DataGridName + "DisplayIndexes", AllColumnDisplayIndexes);
        }

        #endregion "DisplayIndexes (DependencyProperty)"

        #region VisibleColumns (DependencyProperty)

        /// <summary>
        /// 
        /// Gets or sets a value indicating the names of columns 
        /// (as they appear in the column header) to be visible, seperated by a semicolon.
        /// 
        /// Columns whose names are not here will be hidden.
        /// </summary>

        public string VisibleColumns
        {
            get { return (string)GetValue(VisibleColumnsProperty); }
            set { SetValue(VisibleColumnsProperty, value); }
        }

        private void VisibleColumns_Initialize()
        {
            // Get saved VisibleColumns from app.config
            // Initialize VisibleColumns
            VisibleColumns = string.IsNullOrEmpty(VisibleColumns.Replace("\n", " ").Replace("\r", " ")) ? AllColumnsHeaders : VisibleColumns;
        }


        public static readonly DependencyProperty VisibleColumnsProperty =
            DependencyProperty.Register("VisibleColumns", typeof(string), typeof(WpfDataGridConfigurationBehavior), new PropertyMetadata("", OnVisibleColumnsChanged));

        private static void OnVisibleColumnsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ((WpfDataGridConfigurationBehavior)d).VisibleColumnsChanged(e);
        }



        /// <summary>
        /// 
        /// Updates the display
        /// 
        /// </summary>
        /// <param name="e"></param>

        public void VisibleColumnsChanged(DependencyPropertyChangedEventArgs e)
        {
            if (theContextMenu == null)
                return;

            if (e.NewValue != null)
            {
                var showTheseColumns = e.NewValue.ToString().Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                var saContextMenuVisibleItems = new List<string>();

                int iCol = 0;

                foreach (MenuItem menuItem in theContextMenu.Items)
                {
                    // Show/Hide the Context Menu item's checkmark.
                    if (menuItem.FontWeight == FontWeights.Bold) continue;

                    menuItem.IsChecked = showTheseColumns.Contains(menuItem.Header.ToString());
                    if (menuItem.IsChecked) saContextMenuVisibleItems.Add(menuItem.Header.ToString());

                    mnuShowAll.IsChecked = mnuShowAll.IsChecked && menuItem.IsChecked;

                    // Assign menu item's column's DisplayIndex in display order, (i.e. in menu item order), looking up each column by header name.)
                    if (mnuAlpha.IsChecked == false)
                        dataGrid.Columns.First(x => x.Header.ToString().Replace("\n", " ").Replace("\r", " ") == menuItem.Header.ToString()).DisplayIndex = iCol++;
                }

                // Show the columns
                foreach (var col in dataGrid.Columns)
                    col.Visibility =
                        showTheseColumns.Contains(col.Header.ToString().Replace("\n", " ").Replace("\r", " "))
                        && (saContextMenuVisibleItems.Contains(col.Header.ToString().Replace("\n", " ")
                            .Replace("\r", " ")))
                            ? Visibility.Visible
                            : Visibility.Collapsed;

                // Persist the new visible columns list

                if (dataGrid != null && !DontPersistVisibleColumns)
                    Settings_Save(DataGridName + "VisibleColumns", VisibleColumns);

            }
        }

        #endregion "VisibleColumns"

        public static void Settings_Save(string propertyName, string propertyValue)
        {
            foreach (SettingsPropertyValue property in Settings.Default.PropertyValues)
            {
                if (propertyName == property.Name)
                {
                    property.PropertyValue = propertyValue;
                    Settings.Default.Save();
                }
            }
        }

    }
    
     public static class WpfDataGridConfigurationBehaviorFinder
    {
        public static T FindChild<T>(DependencyObject depObj) where T : DependencyObject
        {
            // Confirm obj is valid. 
            if (depObj == null) return null;

            // success case
            if (depObj is T) return depObj as T;

            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++)
            {
                T obj = FindChild<T>(VisualTreeHelper.GetChild(depObj, i));
                if (obj != null) return obj;
            }
            return null;
        }

        public interface IBreakVisualParenting
        {
            DependencyObject Parent { get; }
        }

        public static T LastVisualAncestorOfType<T>(this DependencyObject element) where T : DependencyObject
        {
            T item = null;

            var parent = VisualTreeHelper.GetParent(element);
            while (parent != null)
            {
                if (parent is T)
                    item = (T)parent;
                if (parent is IBreakVisualParenting)
                {
                    parent = ((IBreakVisualParenting)parent).Parent;
                }
                else
                    parent = VisualTreeHelper.GetParent(parent);
            }

            return item;
        }

    }
}

- std8590