WPF 数据网格:在触发器中设置 ColumnWidth

Question

我在他的样式中设置触发器内DataGrid的ColumnWidth时遇到了问题。

我有这个：

<DataGrid ItemsSource="{Binding Data}">
    <DataGrid.Style>
        <Style TargetType="DataGrid">
            <Style.Triggers>
                <DataTrigger Binding="{Binding Data.Count}" Value="2">
                    <Setter Property="Background" Value="LightGreen" />
                    <Setter Property="ColumnWidth" Value="400" />
                </DataTrigger>
            </Style.Triggers>
        </Style>
    </DataGrid.Style>
</DataGrid>

在 2 行的情况下，我想用绿色填充背景并制作更宽的列，但我不能只实现绿色背景。为什么列宽设置不起作用？

[！在此处输入图像描述][1]][1]

如果我将列宽设置放在触发器之外，它会起作用..但我不想要这个..

<DataGrid ItemsSource="{Binding Data}">
    <DataGrid.Style>
        <Style TargetType="DataGrid">
            <Setter Property="ColumnWidth" Value="400" />
            <Style.Triggers>
                <DataTrigger Binding="{Binding Data.Count}" Value="2">
                    <Setter Property="Background" Value="LightGreen" />
                </DataTrigger>
            </Style.Triggers>
        </Style>
    </DataGrid.Style>
</DataGrid>

谢谢！

解决：

最后，我建立了ColumnWidt，绑定到我的数据和转换器：

<DataGrid ColumnWidth="{Binding Data, Converter={StaticResource DataToColumnWidthConverter}}" ItemsSource="{Binding Data}" IsReadOnly="True" MaxHeight="300" >

转炉：

[ValueConversion(typeof(DataTable), typeof(DataGridLength))]
public class DataToColumnWidthConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        DataTable dt = value as DataTable;
        if (dt != null && dt.Rows.Count == 2)
        {
            return new DataGridLength(400);
        }
        return new DataGridLength();
    }
    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return null;
    }
}

这对我来说没问题，因为我的数据不会改变执行时间的行数，所以 ColumnWidth 只需要在开始时计算一次。

谢谢大家

Answer 1

1. 从DataGrid中删除ItemsSource，然后将其移动到 DataTrigger 中。
2. 要在初始绑定后设置ColumnWidth，需要重新绑定。您不能从代码设置ColumnWidth，它不会有任何影响。要使ColumnWidth有任何效果，您需要首先删除DataGrid的DataContext/ItemsSource（设置为 null），然后重新分配它。

因此，如果在某处更改集合，则必须首先将 DataGrid 的 DataContext 设置为 null，然后重新分配它。看看我在下面的按钮点击中做了什么。 下面的代码是不言自明的。我已经为Data.Count不会为4的情况编写了一个转换器和MarkupExtension。

    <DataGrid x:Name="Dgrid" Margin="0,58,0,0">
    <DataGrid.Style>
       <Style TargetType="DataGrid">
          <Style.Triggers>
             <DataTrigger Binding="{Binding Data.Count}" Value="4">
                 <Setter Property="ColumnWidth" Value="200" />
                 <Setter Property="ItemsSource" Value="{Binding Data}" />
                 <Setter Property="Background" Value="LightGreen" />                            
             </DataTrigger>
             <DataTrigger Binding="{Binding Data.Count, Converter={local:CountToBool}}" Value="true">
                 <Setter Property="ColumnWidth" Value="100" />
                 <Setter Property="ItemsSource" Value="{Binding Data}" />
                 <Setter Property="Background" Value="Red" />
              </DataTrigger>
           </Style.Triggers>
        </Style>
     </DataGrid.Style>
    </DataGrid>

转炉：

    public class CountToBoolConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            if ((int)value != 4)
                return true;
            return false;
        }
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
    public class CountToBoolExtension : MarkupExtension
    {
        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            return new CountToBoolConverter();
        }
    }

代码隐藏 ：

ViewModel vm = new ViewModel();
// removing 2 items and reassigning DataContext to viewmodel.
private void Button_Click(object sender, RoutedEventArgs e)
{
    Dgrid.DataContext = null;
    vm.Students.RemoveAt(1);
    vm.Students.RemoveAt(2);
    Dgrid.DataContext = vm;
}

上面的代码将根据 Data.Count 值更改 ColumnWidth，如果我们在运行时更改集合中的记录数，则可以正常工作。

Answer 2

请尝试下一个解决方案。如您所见，我使用代理对象将主数据上下文传递给每个数据网格单元。此外，还有一个 DataTrigger，它在隐藏列的可见性更改时起作用，并且还有一个附加属性有助于控制实际列宽。这是代码：

Xaml 代码

<Window x:Class="DataGridSoHelpAttempt.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:dataGridSoHelpAttempt="clr-namespace:DataGridSoHelpAttempt"
    xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
    Title="MainWindow" Height="350" Width="525" x:Name="This">
<Window.DataContext>
    <dataGridSoHelpAttempt:MainViewModel/>
</Window.DataContext>
<Grid x:Name="MyGrid">
    <Grid.Resources>
        <dataGridSoHelpAttempt:FreezableProxyClass x:Key="ProxyElement" ProxiedDataContext="{Binding Source={x:Reference This}, Path=DataContext}"/>
    </Grid.Resources>
    <DataGrid x:Name="MyDataGrid" ItemsSource="{Binding DataSource}" AutoGenerateColumns="False">
        <DataGrid.Columns>
            <DataGridTextColumn Header="Name"  Binding="{Binding Name}"/>
            <DataGridTextColumn Header="Description" Binding="{Binding Description}"  Visibility="{Binding Source={StaticResource ProxyElement}, 
                Path=ProxiedDataContext.Visibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
            <DataGridTextColumn Header="Comments" Binding="{Binding Comments}"/>
            <DataGridTextColumn Header="Price (click to see total)" Binding="{Binding Price, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
        </DataGrid.Columns>
        <DataGrid.Resources>
            <Style TargetType="DataGridCell" BasedOn="{StaticResource {x:Type DataGridCell}}">
                <Style.Triggers>
                    <DataTrigger Binding="{Binding Source={StaticResource ProxyElement}, 
                Path=ProxiedDataContext.Visibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Value="Visible">
                        <Setter Property="Width" Value="200"></Setter>
                        <Setter Property="dataGridSoHelpAttempt:DataGridAttached.ColumnActualWidth" Value="200"/>
                    </DataTrigger>
                    <DataTrigger Binding="{Binding Source={StaticResource ProxyElement}, 
                Path=ProxiedDataContext.Visibility, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Value="Collapsed">
                        <Setter Property="Width" Value="400"></Setter>
                        <Setter Property="dataGridSoHelpAttempt:DataGridAttached.ColumnActualWidth" Value="400"/>
                    </DataTrigger>
                </Style.Triggers>
            </Style>
        </DataGrid.Resources>
    </DataGrid>
    <StackPanel HorizontalAlignment="Stretch" VerticalAlignment="Bottom">
        <Button Content="Show Description" Command="{Binding Command}"></Button>
    </StackPanel>
</Grid></Window>

附加属性代码

public class DataGridAttached
{
    public static readonly DependencyProperty ColumnActualWidthProperty = DependencyProperty.RegisterAttached(
        "ColumnActualWidth", typeof (double), typeof (DataGridAttached), new PropertyMetadata(default(double), ColumnActualWidthPropertyChanged));
    private static void ColumnActualWidthPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var data = d.FindParent<DataGrid>();
        var control = (d as Control);
        if(data == null || control == null) return;
        data.Columns.ToList().ForEach(column =>
        {
            var cellWidth = control.Width;
            if(double.IsNaN(cellWidth) || double.IsInfinity(cellWidth)) return;
            column.Width = cellWidth;
        });
    }
    public static void SetColumnActualWidth(DependencyObject element, double value)
    {
        element.SetValue(ColumnActualWidthProperty, value);
    }
    public static double GetColumnActualWidth(DependencyObject element)
    {
        return (double) element.GetValue(ColumnActualWidthProperty);
    }
}

查看模型和模型

    public class MainViewModel:BaseObservableObject
{
    private Visibility _visibility;
    private ICommand _command;
    private Visibility _totalsVisibility;
    private double _totalValue;
    private double _columnWidth;
    public MainViewModel()
    {
        Visibility = Visibility.Collapsed;
        TotalsVisibility = Visibility.Collapsed;
        DataSource = new ObservableCollection<BaseData>(new List<BaseData>
        {
            new BaseData {Name = "Uncle Vania", Description = "A.Chekhov, play", Comments = "worth reading", Price = 25},
            new BaseData {Name = "Anna Karenine", Description = "L.Tolstoy, roman", Comments = "worth reading", Price = 35},
            new BaseData {Name = "The Master and Margarita", Description = "M.Bulgakov, novel", Comments = "worth reading", Price = 56},
        });
    }
    public ICommand Command
    {
        get
        {
            return _command ?? (_command = new RelayCommand(VisibilityChangingCommand));
        }
    }
    private void VisibilityChangingCommand()
    {
        Visibility = Visibility == Visibility.Collapsed ? Visibility.Visible : Visibility.Collapsed;
        ColumnWidth = Visibility == Visibility.Visible ? 200d : 400d;
    }
    public ObservableCollection<BaseData> DataSource { get; set; }
    public Visibility Visibility
    {
        get { return _visibility; }
        set
        {
            _visibility = value;
            OnPropertyChanged();
        }
    }
    public ObservableCollection<BaseData> ColumnCollection
    {
        get { return DataSource; }
    }
    public Visibility TotalsVisibility
    {
        get { return _totalsVisibility; }
        set
        {
            _totalsVisibility = value;
            OnPropertyChanged();
        }
    }
    public double TotalValue
    {
        get { return ColumnCollection.Sum(x => x.Price); }
    }
    public double ColumnWidth
    {
        get { return _columnWidth; }
        set
        {
            _columnWidth = value;
            OnPropertyChanged();
        }
    }
}
public class BaseData:BaseObservableObject
{
    private string _name;
    private string _description;
    private string _comments;
    private int _price;
    public virtual string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            OnPropertyChanged();
        }
    }
    public virtual object Description
    {
        get { return _description; }
        set
        {
            _description = (string) value;
            OnPropertyChanged();
        }
    }
    public string Comments
    {
        get { return _comments; }
        set
        {
            _comments = value;
            OnPropertyChanged();
        }
    }
    public int Price
    {
        get { return _price; }
        set
        {
            _price = value;
            OnPropertyChanged();
        }
    }
}

可冻结助手

  public class FreezableProxyClass : Freezable
{
    protected override Freezable CreateInstanceCore()
    {
        return new FreezableProxyClass();
    }

    public static readonly DependencyProperty ProxiedDataContextProperty = DependencyProperty.Register(
        "ProxiedDataContext", typeof (object), typeof (FreezableProxyClass), new PropertyMetadata(default(object)));
    public object ProxiedDataContext
    {
        get { return (object) GetValue(ProxiedDataContextProperty); }
        set { SetValue(ProxiedDataContextProperty, value); }
    }
}

助手

    public static class VisualTreeHelperExtensions
{
    public static T FindParent<T>(this DependencyObject child) where T : DependencyObject
    {
        while (true)
        {
            //get parent item
            DependencyObject parentObject = VisualTreeHelper.GetParent(child);
            //we've reached the end of the tree
            if (parentObject == null) return null;
            //check if the parent matches the type we're looking for
            T parent = parentObject as T;
            if (parent != null)
                return parent;
            child = parentObject;
        }
    }
}
public class BaseObservableObject : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        var handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }
    protected virtual void OnPropertyChanged<T>(Expression<Func<T>> raiser)
    {
        var propName = ((MemberExpression)raiser.Body).Member.Name;
        OnPropertyChanged(propName);
    }
    protected bool Set<T>(ref T field, T value, [CallerMemberName] string name = null)
    {
        if (!EqualityComparer<T>.Default.Equals(field, value))
        {
            field = value;
            OnPropertyChanged(name);
            return true;
        }
        return false;
    }
}
public class RelayCommand : ICommand
{
    private readonly Func<bool> _canExecute;
    private readonly Action _execute;
    public RelayCommand(Action execute)
        : this(() => true, execute)
    {
    }
    public RelayCommand(Func<bool> canExecute, Action execute)
    {
        _canExecute = canExecute;
        _execute = execute;
    }
    public bool CanExecute(object parameter = null)
    {
        return _canExecute();
    }
    public void Execute(object parameter = null)
    {
        _execute();
    }
    public event EventHandler CanExecuteChanged;
}
public class RelayCommand<T> : ICommand
    where T:class 
{
    private readonly Predicate<T> _canExecute;
    private readonly Action<T> _execute;
    public RelayCommand(Action<T> execute):this(obj => true, execute)
    {
    }
    public RelayCommand(Predicate<T> canExecute, Action<T> execute)
    {
        _canExecute = canExecute;
        _execute = execute;
    }
    public bool CanExecute(object parameter)
    {
        return _canExecute(parameter as T);
    }
    public void Execute(object parameter)
    {
        _execute(parameter as T);
    }
    public event EventHandler CanExecuteChanged;
}

这是完整的测试解决方案，您应该只了解它是如何工作的。如果您遇到代码问题，我将很乐意提供帮助。

问候。