Ein Auslöser basiert auf dem Wert einer DataGridcell

Question

Ich habe einige Zellen in einem DataGrid und möchte Zellen in bestimmten Spalten rot hervorheben, wenn ihr Wert 0. Ich bin mir nicht sicher, wie ich mich daran nähern soll.

Ich habe mir diese Frage angesehen: WPF: Wie markiert man alle Zellen eines Datagrid -Treffens auf eine Bedingung? Aber keine der Lösungen hat für mich funktioniert.

Bei Verwendung von Stilauslöschern scheint es, dass die Auslöser auf Eigenschaften angewendet werden sollen. Wenn ich so etwas mache, passiert nichts (ich gehe davon aus, dass der Inhalt mehr als einen einfachen Wert gibt).

Mit der zuletzt vorgeschlagenen Lösung bekam ich ein Kompilierungszeitproblem, das eine Manifestation eines Fehlers zu sein schien, der seit einiger Zeit in VS ist: Benutzerdefinierte Bindungsklasse funktioniert nicht richtig

Irgendwelche Ideen, wie ich das erreichen kann?

Hat jemand irgendwelche Ideen?

Answer 1

Der beste Weg, um die Hintergrundfarbe einer Zelle basierend auf dem Wert einer DataGridcell zu ändern, besteht darin, eine DataTemplate für das DataGridTemPlateColumn mit einem Konverter zu definieren, um die Hintergrundfarbe der Zelle zu ändern. Die hier bereitgestellte Probe verwendet MVVM.

Zu den Teilen der Schlüssel, nach denen im folgenden Beispiel gesucht werden soll, gehören:

1: xaml, das eine Ganzzahl (Faktor) im Modell in eine Farbe umwandelt:

<TextBlock Text="{Binding Path=FirstName}" 
           Background="{Binding Path=Factor, 
             Converter={StaticResource objectConvter}}" />

2: Konverter, der eine SolidColorbrush zurückgibt, die auf einer Ganzzahleigenschaft im Modell basiert:

public class ObjectToBackgroundConverter : IValueConverter

3: ViewModel, das den Ganzzahlwert im Modell zwischen 0 und 1 von einer Schaltfläche ändert. Klicken Sie auf ein Ereignis, das die Farbe im Konverter ändert.

private void OnChangeFactor(object obj)
{
  foreach (var customer in Customers)
  {
    if ( customer.Factor != 0 )
    {
      customer.Factor = 0;
    }
    else
    {
      customer.Factor = 1;
    }
  }
}

4: Modell implementiert InotifyPropertyChanged, um das Ereignis zu entlassen

private int _factor = 0;
public int Factor
{
  get { return _factor; }
  set
  {
    _factor = value;
    OnPropertyChanged("Factor");
  }
}

Ich habe hier in meiner Antwort alle Bits zur Verfügung gestellt, mit Ausnahme von Kernteilen, die als Grundlage des MVVM -Musters verwendet werden, das ViewModelBase (InotifyPropertyChanged) und DelegateCommand enthält, die Sie in über Google finden können. Beachten Sie, dass ich den DataContext der Ansicht an das ViewModel im Konstruktor des Code-Behinds binden. Ich kann diese zusätzlichen Bits bei Bedarf veröffentlichen.

Hier ist der XAML:

<Window x:Class="DatagridCellsChangeColor.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:Helpers="clr-namespace:DatagridCellsChangeColor.Converter" 
    Title="MainWindow" 
    Height="350" Width="525">
  <Window.Resources>
    <Helpers:ObjectToBackgroundConverter x:Key="objectConvter"/>
   /Window.Resources>
 <Grid>
  <Grid.RowDefinitions>
   <RowDefinition Height="Auto"/>
   <RowDefinition/>
  </Grid.RowDefinitions>
  <Button Content="Change Factor" Command="{Binding Path=ChangeFactor}"/>
  <DataGrid
   Grid.Row="1"
   Grid.Column="0"
   Background="Transparent" 
   ItemsSource="{Binding Customers}" 
   IsReadOnly="True"
   AutoGenerateColumns="False">
   <DataGrid.Columns>
    <DataGridTemplateColumn
      Header="First Name" 
      Width="SizeToHeader">
      <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
          <TextBlock Text="{Binding Path=FirstName}" 
                      Background="{Binding Path=Factor, 
                      Converter={StaticResource objectConvter}}" />
        </DataTemplate>
      </DataGridTemplateColumn.CellTemplate>
    </DataGridTemplateColumn>
    <DataGridTemplateColumn
      Header="Last Name" 
      Width="SizeToHeader">
      <DataGridTemplateColumn.CellTemplate>
        <DataTemplate>
          <TextBox Text="{Binding Path=LastName}" />
        </DataTemplate>
      </DataGridTemplateColumn.CellTemplate>
    </DataGridTemplateColumn>
   </DataGrid.Columns>
  </DataGrid>
 </Grid>
</Window>

Hier ist der Konverter:

using System;
using System.Drawing;
using System.Globalization;
using System.Windows.Data;
using System.Windows.Media;
using Brushes = System.Windows.Media.Brushes;

namespace DatagridCellsChangeColor.Converter
{
  [ValueConversion(typeof(object), typeof(SolidBrush))]
  public class ObjectToBackgroundConverter : IValueConverter
  {
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
      int c = (int)value;

      SolidColorBrush b;
      if (c == 0)
      {
        b = Brushes.Gold;
      }
      else
      {
        b = Brushes.Green;
      }
      return b;
    }

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

Hier ist das ViewModel:

using System.Collections.ObjectModel;
using System.Windows.Input;
using DatagridCellsChangeColor.Commands;
using DatagridCellsChangeColor.Model;

namespace DatagridCellsChangeColor.ViewModel
{
  public class MainViewModel : ViewModelBase
  {
    public MainViewModel()
    {
      ChangeFactor = new DelegateCommand<object>(OnChangeFactor, CanChangeFactor);
    }

    private ObservableCollection<Customer> _customers = Customer.GetSampleCustomerList();
    public ObservableCollection<Customer> Customers
    {
      get
      {
         return _customers;
      }
    }

    public ICommand ChangeFactor { get; set; }
    private void OnChangeFactor(object obj)
    {
      foreach (var customer in Customers)
      {
        if ( customer.Factor != 0 )
        {
          customer.Factor = 0;
        }
        else
        {
          customer.Factor = 1;
        }
      }
    }

    private bool CanChangeFactor(object obj)
    {
      return true;
    }
  }
}

Hier ist das Modell:

using System;
using System.Collections.ObjectModel;
using DatagridCellsChangeColor.ViewModel;

namespace DatagridCellsChangeColor.Model
{
  public class Customer : ViewModelBase
  {
    public Customer(String first, string middle, String last, int factor)
    {
      this.FirstName = first;
      this.MiddleName = last;
      this.LastName = last;
      this.Factor = factor;
    }

    public String FirstName { get; set; }
    public String MiddleName { get; set; }
    public String LastName { get; set; }

    private int _factor = 0;
    public int Factor
    {
      get { return _factor; }
      set
      {
        _factor = value;
        OnPropertyChanged("Factor");
      }
    }

    public static ObservableCollection<Customer> GetSampleCustomerList()
    {
      return new ObservableCollection<Customer>(new Customer[4]
                               {
                                 new Customer("Larry", "A", "Zero", 0),
                                 new Customer("Bob", "B", "One", 1),
                                 new Customer("Jenny", "C", "Two", 0),
                                 new Customer("Lucy", "D", "THree", 2)
                               });
    }
  }
}