RadGridView CellTemplate

Question

我需要更改CellTemplate的RadGridView。我可以在网上找到的所有示例都在Xaml中静态地定义列，然后在该列标记中定义CellTemplate：

<telerik:RadGridView AutoGenerateColumns="False" ItemsSource="{Binding}" RowStyleSelector="{StaticResource styleSelector}">
    <telerik:RadGridView.Columns>
        <telerik:GridViewDataColumn DataMemberBinding="{Binding ID}" CellTemplateSelector="{StaticResource templateSelector}" />
    </telerik:RadGridView.Columns>
</telerik:RadGridView>

上面的示例只为标题为"ID“的列加载CellTemplate，并对该列中的所有单元格进行加载。

我成功地在后面的代码中加载了CellTemplates，但这要求我将整个网格的一个实例传递给ViewModel，还必须向GridView添加一个依赖项属性，以便将网格的列绑定到ViewModel中的GridViewColumnCollection。

这是一个非常混乱的解决办法，如果被错误的眼睛看到，我肯定会被解雇的。我需要做的是类似这样的事情：

<telerik:RadGridView.CellTemplateSelector>
    <local:MyTemplateSelector>
        <local:MyTemplateSelector.NormalTemplate>
            <DataTemplate>
                ...Some [Normal] template...
            </DataTemplate>
        </local:MyTemplateSelector.NormalTemplate
        <local:MyTemplateSelector.DropdownTemplate>
            <DataTemplate>
                ...Some [ComboBox] template...
            </DataTemplate>
        </local:MyTemplateSelector.DropdownTemplate>
    </local:MyTemplateSelector>
</telerik:RadGridView.CellTemplateSelector>

老实说，我不知道为什么这个RadGridView会使更改CellTemplate变得如此困难，因为这会阻止您更改一个公共属性，例如在单元格本身的ContentTemplate中找到的标签中的前景色。对我能做什么有什么想法吗？

Answer 1

因此，在此之前，我不确定如何“正确”地做到这一点，因为WPF看起来非常符合上下文，所以它看起来确实是一个最适合您的特殊需求的案例。

我自己的方法可能是最推荐的，但我需要集中所有样式选择器和选择器变体，并使用用代码编写的逻辑，而不是用xaml编写的逻辑。

我所做的是一些类似于telerik.StyleRule的方法，但要简单得多，就像在代码隐藏的atm中一样。与其在共享xaml资源库中定义类或在每个视图中定义类，不如在一个文件夹中使用类，然后在xaml中使用CLR命名空间和其他方法调用它(当然，可以在代码隐藏中设置)。

它使用列名，并且非常容易地使用以下方法定义条件：

Expression<Func<BaseModelForAllTableObjectClasses,bool>>

它使用的实际资源(数据板和样式)是在共享xaml资源库中定义的，但如果需要的话，这些资源可以是相当通用的。

这有点粗糙，如果有兴趣的话，我会留出评论的。

MyProject.CellStyleSelector

/// <summary>
/// Used in CellStyleSelector and its inheriting classes.
/// 
/// Wouldnt be too hard to modify to allow declarative if highly desired.
/// 
/// NOTE - tried extending telerik.StyleRule, issues with setting condition value
/// </summary>
public class CellStyleRule
{
    /*
    object _Value;
    public object Value
    {
        get
        {
            return this._Value;
        }
        set
        {
            this._Value = value;
        }
    }
     */

    // NOTE - if needing to widen use case, use <T>, but ONLY if needed
    Expression<Func<BaseDataModel, bool>> _Condition;
    public Expression<Func<BaseDataModel, bool>> Condition
    {
        get
        {
            return this._Condition;
        }
        set
        {
            this._Condition = value;
        }
    }


    Style _Style;
    public Style Style
    {
        get
        {
            return this._Style;
        }
        set
        {
            this._Style = value;
        }
    }



    public CellStyleRule(Expression<Func<BaseDataModel, bool>> c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            this.Style = d as Style;
        else
            throw new Exception("No such style resource as '" + s + "'");

        // Value = v;
        Condition = c;
    }



    /*
    public CellStyleRule(string c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            Style = d as Style;
        else
            throw new Exception("No such style resource as '" + s + "'");

        // TODO - test - guessing at how to do this based on telerik classes

        // Value = v;
        Telerik.Windows.Data.ExpressionTypeConverter converter = new Telerik.Windows.Data.ExpressionTypeConverter();
        Condition = (System.Linq.Expressions.Expression) converter.ConvertFromString(c);

        c.ToString();
    }
     */
}






// NOTE IMPORTANT - use of xaml defined ConditionalStyleSelectors is not a bad alternative approach, though diferent selector
//                  for each column it could all be defined in same resource dictionary
//                - problem is that issues encountered with Enums, so decided on this approach instead

/// <summary>
/// A variation of StyleSelecter not unlike telerik:ConditionalStyleSelector. 
/// 
/// However, rules are defined using a Dictionary<string,CellStyle> to distinct columns and use same 
/// selector, with rules (currently) defined not declarativly (xaml), but in inheriting classes, 
/// typically one for each entity type requiring a RadGridView and conditional styling.
/// </summary>
public abstract class CellStyleSelector : StyleSelector
{
    // public Dictionary<String, Dictionary<string, Style>> conditions { get; set; }


    // Use a Dictionary mapping X columns to individual Lists of rules to check
    Dictionary<string, List<CellStyleRule>> _Rules;
    public Dictionary<string, List<CellStyleRule>> Rules
    {
        get
        {
            if (this._Rules == null)
            {
                this._Rules = new Dictionary<string, List<CellStyleRule>>();
            }

            return this._Rules;
        }
        set { this._Rules = value; }
    }

    public override Style SelectStyle(object item, DependencyObject container)
    {
        if (item is BaseDataModel)
        {
            GridViewCell cell = container as GridViewCell;
            var currentColumn = cell.Column as GridViewDataColumn;
            string key = currentColumn.DataMemberBinding.Path.Path;


            if (Rules.ContainsKey(key))
            {
                foreach (CellStyleRule rule in Rules[key])
                {
                    // string debug = DebugHelper.Debug(rule.Condition);

                    // REVERTED NOTE - if just Func<>
                    // if (rule.Condition((BaseDataModel)item))

                    // NOTE - if Expression<Func<>>, first compile then pass in param
                    if (rule.Condition.Compile()((BaseDataModel)item))
                    {
                        return rule.Style;
                    }
                }
            }

        }
        return null;
    }


}


/// <summary>
/// Used in CellCellTemplateRuleSelector and its inheriting classes.
/// 
/// Wouldnt be too hard to modify to allow declarative if highly desired.
/// </summary>
public class CellTemplateRule
{
    /*
    object _Value;
    public object Value
    {
        get
        {
            return this._Value;
        }
        set
        {
            this._Value = value;
        }
    }
     */

    // NOTE - if needing to widen use case, use <T>, but ONLY if needed
    Expression<Func<BaseDataModel, bool>> _Condition;
    public Expression<Func<BaseDataModel, bool>> Condition
    {
        get
        {
            return this._Condition;
        }
        set
        {
            this._Condition = value;
        }
    }


    DataTemplate _Template;
    public DataTemplate Template
    {
        get
        {
            return this._Template;
        }
        set
        {
            this._Template = value;
        }
    }



    public CellTemplateRule(Expression<Func<BaseDataModel, bool>> c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            this.Template = d as DataTemplate;
        else
            throw new Exception("No such template resource as '" + s + "'");

        Condition = c;
    }


}

// Implementing class, used for any licence table
public class LicenceTableCellStyleSelector : CellStyleSelector
{
    public LicenceTableCellStyleSelector()
        : base()
    {
        this.Rules = new Dictionary<string, List<CellStyleRule>>()
        {
            { "LicenceStatus" , new List<CellStyleRule>()
                {
                    // Always most specific rules at top

                    // Error catcher, leave in as visual cue just in case
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < DateTime.Now && ((Licence)x).LicenceStatus != LicenceStatus.Expired, "CellStyle_Licence_ExpiryMismatch") } ,

                    { new CellStyleRule(x => ((Licence)x).LicenceStatus == LicenceStatus.Active, "CellStyle_Status_Active") } ,

                    // Same as != Active, as only those would through this far
                    { new CellStyleRule(x => x != null, "CellStyle_Status_Inactive") } ,


                }
            },

            { "LicenceType" , new List<CellStyleRule>()
                {                        
                    { new CellStyleRule(x => ((Licence)x).LicenceType == LicenceType.Full, "CellStyle_Licence_Full") } ,
                    { new CellStyleRule(x => ((Licence)x).LicenceType == LicenceType.Upgrade, "CellStyle_Licence_Upgrade") } ,

                    // Timed, uses fallthrough so no need to actually check unless wanting to distinct types of timed
                    { new CellStyleRule(x => x != null, "CellStyle_Licence_Timed") } ,
                }
            },

            { "LicenceExpired" , new List<CellStyleRule>()
                {                        
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < DateTime.Now && ((Licence)x).LicenceStatus != LicenceStatus.Expired, "CellStyle_Licence_ExpiryMismatch")  }, 
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < ((Licence)x).LicenceIssued, "CellStyle_Licence_ExpiryMismatch") } ,
                }
            },

            { "LicenceIssued" , new List<CellStyleRule>()
                {
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < ((Licence)x).LicenceIssued, "CellStyle_Licence_ExpiryMismatch") } ,
                }
            }
        };
    }
}

​

CellTemplateSelector

/// <summary>
/// Used in CellCellTemplateRuleSelector and its inheriting classes.
/// 
/// Wouldnt be too hard to modify to allow declarative if highly desired.
/// </summary>
public class CellTemplateRule
{
    /*
    object _Value;
    public object Value
    {
        get
        {
            return this._Value;
        }
        set
        {
            this._Value = value;
        }
    }
     */

    // NOTE - if needing to widen use case, use <T>, but ONLY if needed
    Expression<Func<BaseDataModel, bool>> _Condition;
    public Expression<Func<BaseDataModel, bool>> Condition
    {
        get
        {
            return this._Condition;
        }
        set
        {
            this._Condition = value;
        }
    }


    DataTemplate _Template;
    public DataTemplate Template
    {
        get
        {
            return this._Template;
        }
        set
        {
            this._Template = value;
        }
    }



    public CellTemplateRule(Expression<Func<BaseDataModel, bool>> c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            this.Template = d as DataTemplate;
        else
            throw new Exception("No such template resource as '" + s + "'");

        Condition = c;
    }


}

// NOTE IMPORTANT - use of xaml defined ConditionalTemplateSelectors is not a bad alternative approach, though diferent selector
//                  for each column it could all be defined in same resource dictionary
//                - problem is that issues encountered with Enums, so decided on this approach instead

/// <summary>
/// See CellStyleSelector, this is a variant used with the CellTemplateSelector property
/// </summary>
public abstract class CellTemplateSelector : DataTemplateSelector
{
    // public Dictionary<String, Dictionary<string, Template>> conditions { get; set; }


    // Use a Dictionary mapping X columns to individual Lists of rules to check
    Dictionary<string, List<CellTemplateRule>> _Rules;
    public Dictionary<string, List<CellTemplateRule>> Rules
    {
        get
        {
            if (this._Rules == null)
            {
                this._Rules = new Dictionary<string, List<CellTemplateRule>>();
            }

            return this._Rules;
        }
        set { this._Rules = value; }
    }

    public override DataTemplate SelectTemplate(object item, DependencyObject container)
    {
        if (item is BaseDataModel)
        {
            GridViewCell cell = container as GridViewCell;
            var currentColumn = cell.Column as GridViewDataColumn;
            string key = currentColumn.DataMemberBinding.Path.Path;


            if (Rules.ContainsKey(key))
            {
                foreach (CellTemplateRule rule in Rules[key])
                {
                    // string debug = DebugHelper.Debug(rule.Condition);

                    // REVERTED NOTE - if just Func<>
                    // if (rule.Condition((BaseDataModel)item))

                    // NOTE - if Expression<Func<>>, first compile then pass in param
                    if (rule.Condition.Compile()((BaseDataModel)item))
                    {
                        return rule.Template;
                    }
                }
            }

        }
        return null;
    }


}


// Implementing class for a different table, though RadGridView can use both CellStyleSelector and CellTemplateSelector at same time, i just didnt need yet
public class OrderDongleWrapTableCellTemplateSelector : CellTemplateSelector
{
    public OrderDongleWrapTableCellTemplateSelector()
        : base()
    {
        this.Rules = new Dictionary<string, List<CellTemplateRule>>()
        {
            { "ReplacedDongle.DongleID" , new List<CellTemplateRule>()
                {
                    // Always most specific rules at top


                    { new CellTemplateRule(x => ((OrderDongleWrap)x).IsReplacementDongle == false  , "CellTemplate_OrderDongleWrap_NotReplacementDongler_NAField") },


                }
            },
            { "ReplacedDongleStatus" , new List<CellTemplateRule>()
                {
                    // Always most specific rules at top


                    { new CellTemplateRule(x => ((OrderDongleWrap)x).IsReplacementDongle == false  , "CellTemplate_OrderDongleWrap_NotReplacementDongler_NAField") },


                }
            },
            /*
             * // REVERTED - better to just set to UNKNOWN CUSTOMER explicitly before shown in table, rather than overwrite datatemplate
            { "Customer.CustomerName" , new List<CellTemplateRule>()
                {
                    // Always most specific rules at top


                    { new CellTemplateRule(x => ((OrderDongleWrap)x).Customer == null || ((OrderDongleWrap)x).Customer.CustomerID == 1 , "CellTemplate_OrderDongleWrap_UnknownCustomerField") },


                }
            },
            */
        };
    }
}

xaml资源

<!-- 
    The following are styles applied to cells or rows in RadGridViews based on StyleSelectors

    First is generic colours, which are inherited by semi-generic flag styles, which optionally 
    can be further inherited by table-specific styles (which can include tooltips and other properties)

    As a general rule, no colour style is applied directly, instead using semi-generic or table-specific 
    styles so as to make changes easier to manage. Which style actually matches which condition is 
    entirely the responsibility of the StyleSelector.

    https://en.wikipedia.org/wiki/Web_colors

    http://www.flounder.com/csharp_color_table.htm 

    <Style x:Key="CellStyle_"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
        <Setter Property="Foreground" Value=""/>
    </Style>
-->
<!--
    NOTE: to get cell text underlining to work, see http://www.telerik.com/forums/underline-cell-contents
-->

<Style x:Key="CellStyle_Green"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="Green"/>
</Style>
<Style x:Key="CellStyle_DarkGreen"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="DarkGreen"/>
</Style>
<Style x:Key="CellStyle_ExtraDarkGreen"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="#004000"/>
</Style>
<Style x:Key="CellStyle_MediumBlue"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="MediumBlue"/>
</Style>
<Style x:Key="CellStyle_DarkBlue"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="DarkBlue"/>
</Style>
<Style x:Key="CellStyle_Purple"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="Purple"/>
</Style>
<Style x:Key="CellStyle_Red"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="Red"/>
</Style>
<Style x:Key="CellStyle_Crimson"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="Crimson"/>
</Style>
<Style x:Key="CellStyle_DarkOrange"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="DarkOrange"/>
</Style>
<Style x:Key="CellStyle_Silver"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="Silver"/>
</Style>
<Style x:Key="CellStyle_DarkGray"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="DarkGray"/>
</Style>
<Style x:Key="CellStyle_Gray"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Foreground" Value="Gray"/>
</Style>

<Style x:Key="CellStyle_RedBG_WhiteFG"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}">
    <Setter Property="Background" Value="Red"/>
    <Setter Property="Foreground" Value="White"/>
</Style>



<Style x:Key="CellStyle_Muted"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Gray}" />
<Style x:Key="CellStyle_Status_Active"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_ExtraDarkGreen}" />
<Style x:Key="CellStyle_Status_Inactive"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Gray}" />
<Style x:Key="CellStyle_Status_Warning"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Crimson}" />
<Style x:Key="CellStyle_Status_Error"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Red}" />
<Style x:Key="CellStyle_Status_ErrorBG"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_RedBG_WhiteFG}" />

<Style x:Key="CellStyle_Dongle_InactiveWithActiveLicences"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Status_Error}">
    <Setter Property="ToolTip" Value="This Dongle is not Active, but has Licences which are"/>
</Style>

<Style x:Key="CellStyle_Licence_Full"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource GridViewCellStyle}" />
<Style x:Key="CellStyle_Licence_Upgrade"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_DarkBlue}" />
<Style x:Key="CellStyle_Licence_Timed"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Purple}" />
<Style x:Key="CellStyle_Licence_ExpiryMismatch"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Status_ErrorBG}">
    <Setter Property="ToolTip" Value="Expiry doesnt match Status or Issued Date"/>
</Style>


<Style x:Key="CellStyle_OrderDongleWrap_NotReplacementDongler_NAField"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Gray}">
    <Setter Property="Content" Value="N/A"/>
</Style>
<Style x:Key="CellStyle_OrderDongleWrap_UnknownCustomerField"  TargetType="telerik:GridViewCell" BasedOn="{StaticResource CellStyle_Gray}">
    <Setter Property="Content" Value="N/A"/>
</Style>






<DataTemplate x:Key="CellTemplate_OrderDongleWrap_NotReplacementDongler_NAField">
    <TextBlock>N/A</TextBlock>
</DataTemplate>

为CellStyleSelector实现xaml

<telerik:RadGridView.Resources>                               
    <gridviewstyleselectors:LicenceTableCellStyleSelector x:Key="LicenceTableCellStyleSelector" />
</telerik:RadGridView.Resources>

<telerik:RadGridView.Columns>
    <telerik:GridViewDataColumn DataMemberBinding="{Binding DongleID}" Header="DongleID"  IsReadOnly="True" />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding LicenceSerial}" Header="Serial"  IsReadOnly="True" />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding LicenceStatus}" Header="Status"  IsReadOnly="True" 
                                CellStyleSelector="{StaticResource LicenceTableCellStyleSelector}"/>
    <telerik:GridViewDataColumn DataMemberBinding="{Binding Product.ProductName}" Header="Product"  IsReadOnly="True" />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding LicenceType}" Header="Licence Type" 
                                CellStyleSelector="{StaticResource LicenceTableCellStyleSelector}" IsReadOnly="True" />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding LicenceIssued}" Header="Issued" 
                                CellStyleSelector="{StaticResource LicenceTableCellStyleSelector}" IsReadOnly="True" />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding LicenceExpires}" Header="Expiry" 
                                CellStyleSelector="{StaticResource LicenceTableCellStyleSelector}" IsReadOnly="True" />
</telerik:RadGridView.Columns>

到目前为止，我只为CellTemplateSelector找到了一个案例，如下所示：

为CellTemplateSelector实现xaml

<telerik:RadGridView.Columns>
    <telerik:GridViewDataColumn DataMemberBinding="{Binding Dongle.DongleID}" Header="DongleID">
        <telerik:GridViewDataColumn.AggregateFunctions>
            <telerik:CountFunction ResultFormatString="{}Dongles: {0}" />
        </telerik:GridViewDataColumn.AggregateFunctions>
    </telerik:GridViewDataColumn>
    <telerik:GridViewDataColumn DataMemberBinding="{Binding OrderRows.Count}" Header="Licences"  
                                CellStyleSelector="{StaticResource OrderDongleWrapTableCellStyleSelector}"
                                CellTemplateSelector="{StaticResource OrderDongleWrapTableCellTemplateSelector}"  />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding Customer.CustomerName}" Header="Customer"  
                                CellStyleSelector="{StaticResource OrderDongleWrapTableCellStyleSelector}"
                                CellTemplateSelector="{StaticResource OrderDongleWrapTableCellTemplateSelector}"  />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding IsReplacementDongle}" Header="Replacement?" 
                                IsVisible="False"
                                CellStyleSelector="{StaticResource OrderDongleWrapTableCellStyleSelector}"
                                CellTemplateSelector="{StaticResource OrderDongleWrapTableCellTemplateSelector}" />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding IsEducationalDongle}" Header="Educational?"  
                                CellStyleSelector="{StaticResource OrderDongleWrapTableCellStyleSelector}"
                                CellTemplateSelector="{StaticResource OrderDongleWrapTableCellTemplateSelector}"  />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding ReplacedDongle.DongleID}" Header="Replaced"  
                                CellStyleSelector="{StaticResource OrderDongleWrapTableCellStyleSelector}"
                                CellTemplateSelector="{StaticResource OrderDongleWrapTableCellTemplateSelector}"  />
    <telerik:GridViewDataColumn DataMemberBinding="{Binding ReplacedDongleStatus}" Header="Replacement Status"  
                                CellStyleSelector="{StaticResource OrderDongleWrapTableCellStyleSelector}"
                                CellTemplateSelector="{StaticResource OrderDongleWrapTableCellTemplateSelector}"/>
    <telerik:GridViewDataColumn DataMemberBinding="{Binding OrderRows[0].OrderRowCosts[0].CostValue }" Header="Sub-Total (AUD)">
    </telerik:GridViewDataColumn>

</telerik:RadGridView.Columns>

这是我自己的方法，但它将条件逻辑和样式集中到每个目标类(GridView ItemsSource对象)仅1cs类和所有GridView的一个资源表中。

如果你想要的话，你可以很容易地把它重构成声明式的，我认为这是可能的，但不需要或者不想做，所以我没有。

您也可以重构，以便规则级联单个cs类为所有表，甚至声明样式的动态.？(通过新的样式和添加属性？)

无论如何，我希望这能帮助其他人解决这个问题。