Silverlight多重表头实现

效果：

　　

实现主要逻辑：通过动态拼接XML生成表头样式，绑定到列上。

主要是动态拼接XML时要仔细核对对应的占位行，具体可以看代码，注释很详细

两个类一个接口

NTree<T>：定义表头树形结构

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Collections.ObjectModel;

 namespace SLDGHeader
 {
     /// <summary>
     /// 树结构
     /// </summary>
     /// <typeparam name="T">节点中的数据</typeparam>
     public class NTree<T>
     {
         /// <summary>
         /// 节点数据
         /// </summary>
         private readonly T data;
         /// <summary>
         /// 节点数据
         /// </summary>
         public T Data
         {
             get { return data; }
         }
         /// <summary>
         /// 是否根节点
         /// </summary>
         public bool IsRoot { get { return Parent == null; } }
         /// <summary>
         /// 当前节点深度
         /// 根节点为1
         /// </summary>
         public int Depth { get; private set; }
         /// <summary>
         /// 父节点
         /// </summary>
         public NTree<T> Parent
         {
             get;
             private set;
         }
         /// <summary>
         /// 子节点
         /// </summary>
         public ReadOnlyCollection<NTree<T>> Children
         {
             get { return children.AsReadOnly(); }
         }
         private List<NTree<T>> children;
         /// <summary>
         /// 实例化一个节点
         /// </summary>
         /// <param name="data">节点数据</param>
         public NTree(T data)
         {
             this.Depth = ;
             this.data = data;
             children = new List<NTree<T>>();
         }
         /// <summary>
         /// 在当前节点添加子节点
         /// </summary>
         /// <param name="data">节点数据</param>
         /// <returns>当前节点</returns>
         public NTree<T> AddChild(T data)
         {
             var node = new NTree<T>(data) { Parent = this, Depth = this.Depth +  };
             children.Add(node);
             return this;
         }
         /// <summary>
         /// 在当前节点子节点中插入子节点
         /// </summary>
         /// <param name="index">插入位置</param>
         /// <param name="data">节点数据</param>
         /// <returns>当前节点</returns>
         public NTree<T> InsertChild(int index, T data)
         {
             var node = new NTree<T>(data) { Parent = this, Depth = this.Depth +  };
             children.Insert(index, node);
             return this;
         }
         /// <summary>
         /// 在当前节点添加子节点
         /// </summary>
         /// <param name="data">节点数据</param>
         /// <returns>当前节点</returns>
         public NTree<T> AddChilren(params T[] datas)
         {
             foreach (var data in datas)
             {
                 AddChild(data);
             }
             return this;
         }
         /// <summary>
         /// 移除当前节点下指定的子节点
         /// </summary>
         /// <param name="node">要移除的子节点</param>
         /// <returns>当前节点</returns>
         public NTree<T> RemoveChild(NTree<T> node)
         {
             children.Remove(node);
             return this;
         }
         /// <summary>
         /// 在当前节点添加兄弟节点
         /// </summary>
         /// <param name="data">节点数据</param>
         /// <returns>当前节点</returns>
         /// <exception cref="NullParentNodeException:当前节点没有父节点">当前节点没有父节点</exception>
         public NTree<T> AddBrother(T data)
         {
             if (this.Parent == null)
             {
                 throw new NullParentNodeException("有父节点的节点才能添加兄弟节点。");
             }

             this.Parent.AddChild(data);
             return this;
         }
         /// <summary>
         /// 获取指定索引处的子节点
         /// </summary>
         /// <param name="i">子节点索引</param>
         /// <returns>子节点</returns>
         /// <exception cref="ArgumentOutOfRangeException:子节点索引超出范围">子节点索引超出范围</exception>
         public NTree<T> GetChild(int i)
         {
             if (i >= children.Count || i < )
             {
                 throw new ArgumentOutOfRangeException("子节点索引超出范围");
             }
             return children[i];
         }
         /// <summary>
         /// 获取指定的子节点
         /// </summary>
         /// <param name="data">节点数据</param>
         /// <returns>查找到的第一个子节点</returns>
         public NTree<T> GetChild(T data)
         {
             return children.Where(i => i.data.Equals(data)).FirstOrDefault();
         }
         /// <summary>
         /// 获取指定子节点的索引
         /// </summary>
         /// <param name="data">节点数据</param>
         /// <returns>查找到的第一个子节点的索引，没有找到返回-1</returns>
         public int GetChildIndex(NTree<T> data)
         {
             var index = -;
             for (int i = ; i < children.Count; i++)
             {
                 if (children[i].Equals(data))
                 {
                     index = i;
                     break;
                 }
             }
             return index;
         }
         /// <summary>
         /// 遍历树节点
         /// </summary>
         /// <param name="node">起始节点</param>
         /// <param name="action">遍历到每个节点的操作</param>
         /// <exception cref="ArgumentNullException:参数action不可为空">参数action不可为空</exception>
         public static void Traverse(NTree<T> node, Action<T> action)
         {
             if (action == null)
             {
                 throw new ArgumentNullException("参数action不可为空");
             }
             action(node.data);
             foreach (var kid in node.children)
             {
                 Traverse(kid, action);
             }
         }
         /// <summary>
         /// 从当前节点开始遍历树节点
         /// </summary>
         /// <param name="action">遍历到每个节点的操作</param>
         /// <exception cref="ArgumentNullException:参数action不可为空">参数action不可为空</exception>
         public void Traverse(Action<T> action)
         {
             Traverse(this, action);
         }
         /// <summary>
         /// 遍历树节点
         /// </summary>
         /// <param name="node">起始节点</param>
         /// <param name="action">遍历到每个节点的操作</param>
         /// <exception cref="ArgumentNullException:参数action不可为空">参数action不可为空</exception>
         public static void Traverse(NTree<T> node, Action<NTree<T>> action)
         {
             if (action == null)
             {
                 throw new ArgumentNullException("参数action不可为空");
             }
             action(node);
             foreach (var kid in node.children)
             {
                 Traverse(kid, action);
             }
         }
         /// <summary>
         /// 从当前节点开始遍历树节点
         /// </summary>
         /// <param name="action">遍历到每个节点的操作</param>
         /// <exception cref="ArgumentNullException:参数action不可为空">参数action不可为空</exception>
         public void Traverse(Action<NTree<T>> action)
         {
             if (action == null)
             {
                 throw new ArgumentNullException("参数action不可为空");
             }
             action(this);
             foreach (var kid in this.children)
             {
                 Traverse(kid, action);
             }
         }
         /// <summary>
         /// 获取当前节点开始的所有节点中数据
         /// </summary>
         /// <returns>节点数据列表</returns>
         public IEnumerable<T> GetDatas()
         {
             return new[] { data }.Union(children.SelectMany(x => x.GetDatas()));
         }
         /// <summary>
         /// 当前节点下叶节点的数量
         /// </summary>
         /// <returns></returns>
         public int GetCount()
         {
             var count = ;
             Traverse((NTree<T> n) =>
             {
                 if (n.Children.Count == )
                 {
                     count++;
                 }
             });
             return count;
         }
         /// <summary>
         /// 获取当前节点所在树的深度
         /// </summary>
         /// <returns>当前节点所在树的深度</returns>
         public int GetTreeDepth()
         {
             int Depth = ;
             var parent = this;
             while (parent.Parent != null)
             {
                 parent = parent.Parent;
             }
             Traverse((NTree<T> n) =>
             {
                 if (Depth < n.Depth)
                 {
                     Depth = n.Depth;
                 }
             });

             return Depth;
         }
     }
     /// <summary>
     /// 父节点为空引用异常
     /// </summary>
     public class NullParentNodeException : Exception
     {
         public NullParentNodeException()
             : base("父节点为空引用")
         {

         }
         public NullParentNodeException(string message)
             : base(message)
         {

         }
         public NullParentNodeException(string message, Exception inner)
             : base(message)
         {

         }
         //public NullParentNodeException(SerializationInfo info, StreamingContext context)
         //{

         //}
     }
 }

MultiHeadersColumn：多重表头和绑定的列

IDataGridHeader：定义生成表头和绑定列的数据接口

 using System;
 using System.Windows;
 using System.Windows.Controls;
 using System.Collections.Generic;
 using System.Windows.Markup;
 using System.Text;

 namespace SLDGHeader
 {
     public class MultiHeadersColumn
     {
         #region 字段
         /// <summary>
         /// 单元格边框颜色
         /// </summary>
         string splitLineColor = "#ccc";
         /// <summary>
         /// 数据行宽度
         /// </summary>
         string dataWidth = "";
         /// <summary>
         /// 表头行高度
         /// </summary>
         string dataHeight = "auto";
         /// <summary>
         /// 分隔线线宽度
         /// </summary>
         string lineWidth = "";
         /// <summary>
         /// 分隔符线高度
         /// </summary>
         string lineHeight = "";
         #endregion
         #region 属性
         /// <summary>
         /// 单元格边框颜色
         /// </summary>
         public string SplitLineColor
         {
             get { return splitLineColor; }
             set { splitLineColor = value; }
         }
         /// <summary>
         /// 数据行宽度
         /// </summary>
         public string DataWidth
         {
             get { return dataWidth; }
             set { dataWidth = value; }
         }
         /// <summary>
         /// 表头行高度
         /// </summary>
         public string DataHeight
         {
             get { return dataHeight; }
             set { dataHeight = value; }
         }
         /// <summary>
         /// 分隔线线宽度
         /// </summary>
         public string LineWidth
         {
             get { return lineWidth; }
             set { lineWidth = value; }
         }
         /// <summary>
         /// 分隔符线高度
         /// </summary>
         public string LineHeight
         {
             get { return lineHeight; }
             set { lineHeight = value; }
         }
         #endregion
         public DataGridTemplateColumn GetMultiHeadersColumn(NTree<IDataGridHeader> node)
         {
             DataGridTemplateColumn col = GetTemplateColumn(node);
             col.HeaderStyle = GetStyle("NameHeaderStyle", node);
             return col;
         }
         DataGridTemplateColumn GetTemplateColumn(NTree<IDataGridHeader> node)
         {
             List<NTree<IDataGridHeader>> nodes = new List<NTree<IDataGridHeader>>();
             node.Traverse((NTree<IDataGridHeader> n) =>
             {
                 if (n.Children.Count == )
                 {
                     nodes.Add(n);
                 }
             });
             string strtemplate = GetDataTemplate(nodes);
             DataTemplate template = (DataTemplate)XamlReader.Load(strtemplate);

             DataGridTemplateColumn colunm = new DataGridTemplateColumn();
             colunm.CellTemplate = template;

             return colunm;
         }
         /// <summary>
         /// 获取绑定列模板XML字符串
         /// </summary>
         /// <param name="nodes">列对应节点</param>
         /// <returns>返回列模板XML字符串</returns>
         string GetDataTemplate(List<NTree<IDataGridHeader>> nodes)
         {
             if (nodes == null)
             {
                 throw new ArgumentNullException("参数nodes不能为空");
             }
             StringBuilder sb = new StringBuilder();

             sb.Append(@"<DataTemplate ");
             sb.AppendLine("xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' ");
             sb.AppendLine("xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' ");
             sb.AppendLine("xmlns:sdk='http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk'");
             sb.AppendLine(" >");

             sb.AppendLine("<StackPanel Orientation='Horizontal'> ");
             for (int i = ; i < nodes.Count *  - ; i++)
             {
                 if (i %  == )
                 {
                     sb.Append("<TextBlock VerticalAlignment='Center' ");
                     sb.Append(" Width='").Append(dataWidth).Append("' ");
                     sb.Append(" HorizontalAlignment='Center' TextWrapping='Wrap' Text='{Binding ").Append(nodes[(i + ) / ].Data.ColName).AppendLine("}' /> ");
                 }
                 else
                 {
                     sb.Append(" <Rectangle Fill='").Append(splitLineColor).Append("' VerticalAlignment='Stretch' ");
                     sb.Append(" Width='").Append(lineWidth).Append("' ");
                     sb.AppendLine(" /> ");
                 }
             }

             sb.AppendLine("</StackPanel> ");
             sb.AppendLine("</DataTemplate> ");
             return sb.ToString();
         }

         Style GetStyle(string headerstyle, NTree<IDataGridHeader> node)
         {
             var depth = node.GetTreeDepth();
             string stylestr = GetStyleStr("NameHeaderStyle", depth, node);
             Style ste = (Style)XamlReader.Load(stylestr);

             return ste;
         }
         /// <summary>
         /// 获取表头样式XML字符串
         /// </summary>
         /// <param name="headerstyle">样式名称</param>
         /// <param name="depth">树的深度</param>
         /// <param name="node">树的根节点</param>
         /// <returns>返回表头样式XML字符串</returns>
         string GetStyleStr(string headerstyle, int depth, NTree<IDataGridHeader> node)
         {

             StringBuilder sb = new StringBuilder();
             //计算数据列数量
             int colCount = node.GetCount();

             AppendHeader(headerstyle, sb);
             //构建表头行列
             sb.AppendLine("<Grid HorizontalAlignment='{TemplateBinding HorizontalContentAlignment}' VerticalAlignment='{TemplateBinding VerticalContentAlignment}'>");
             //多少行
             sb.AppendLine("<Grid.RowDefinitions>");
             //int rowCount = 3;
             for (int i = ; i < depth * ; i++)
             {
                 if (i %  == )
                 {
                     sb.AppendLine("<RowDefinition ");
                     sb.Append(" Height='").Append(dataHeight).Append("' ");
                     sb.AppendLine(" /> ");
                 }
                 else
                 {
                     sb.AppendLine("<RowDefinition ");
                     sb.Append(" Height='").Append(lineHeight).Append("' ");
                     sb.AppendLine("/>");
                 }
             }
             sb.AppendLine("</Grid.RowDefinitions>");

             //多少列
             sb.AppendLine("<Grid.ColumnDefinitions>");

             for (int i = ; i < colCount * ; i++)
             {
                 if (i %  == )
                 {
                     sb.AppendLine("<ColumnDefinition ");
                     sb.Append("Width='").Append(dataWidth).Append("' ");
                     sb.AppendLine(" />");
                 }
                 else
                 {
                     sb.AppendLine("<ColumnDefinition ");
                     sb.Append("Width='").Append(lineWidth).Append("' ");
                     sb.AppendLine(" />");
                 }

             }
             sb.AppendLine("</Grid.ColumnDefinitions>");

             //开始构单元格
             AppendCell(node, sb, depth, colCount);

             AppendEnd(sb);

             return sb.ToString();
         }
         /// <summary>
         /// 绘制头部和表头背景
         /// </summary>
         /// <param name="headerstyle">样式名称</param>
         /// <param name="sb"></param>
         private void AppendHeader(string headerstyle, StringBuilder sb)
         {
             sb.Append(@"<Style ");
             sb.AppendLine("xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation' ");
             sb.AppendLine("xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' ");
             sb.AppendLine("xmlns:dataprimitives='clr-namespace:System.Windows.Controls.Primitives;assembly=System.Windows.Controls.Data' ");

             //列样式名称
             sb.Append(@" x:Key='").Append(headerstyle).Append("' ");

             sb.AppendLine(@"TargetType='dataprimitives:DataGridColumnHeader' >");
             sb.AppendLine("<Setter Property='Template'>");
             sb.AppendLine("<Setter.Value>");
             sb.AppendLine("<ControlTemplate>");
             sb.AppendLine("<Grid x:Name='Root'>");
             sb.AppendLine("<Grid.ColumnDefinitions>");
             sb.AppendLine("<ColumnDefinition/>");
             sb.AppendLine("<ColumnDefinition Width='Auto'/>");
             sb.AppendLine("</Grid.ColumnDefinitions>");
             sb.AppendLine("<Rectangle x:Name='BackgroundRectangle' Fill='#FF1F3B53' Stretch='Fill' Grid.ColumnSpan='2'/>");
             sb.AppendLine("<Rectangle x:Name='BackgroundGradient' Stretch='Fill' Grid.ColumnSpan='2'>");
             sb.AppendLine("<Rectangle.Fill>");
             //表头背景色
             sb.AppendLine("<LinearGradientBrush EndPoint='.7,1' StartPoint='.7,0'>");
             sb.AppendLine(@"<GradientStop Color='#FCFFFFFF' Offset='0.015'/>
                         <GradientStop Color='#F7FFFFFF' Offset='0.375'/>
                         <GradientStop Color='#E5FFFFFF' Offset='0.6'/>
                         <GradientStop Color='#D1FFFFFF' Offset='1'/>");
             sb.AppendLine("</LinearGradientBrush>");
             sb.AppendLine("</Rectangle.Fill>");
             sb.AppendLine("</Rectangle>");
         }
         /// <summary>
         /// 添加结束XML部分
         /// </summary>
         /// <param name="sb"></param>
         private void AppendEnd(StringBuilder sb)
         {
             sb.AppendLine("</Grid>");
             //绘制最后一列分割线
             sb.AppendLine(@"<Rectangle x:Name='VerticalSeparator' Fill='")
                 .Append(splitLineColor)
                 .Append(@"' VerticalAlignment='Stretch'")
                 .Append(" Width='").Append(lineWidth).Append("' ")
                 .AppendLine(" Visibility='Visible' Grid.Row='1' Grid.Column='1' />");
             sb.AppendLine("</Grid>");
             sb.AppendLine("</ControlTemplate>");
             sb.AppendLine("</Setter.Value>");
             sb.AppendLine("</Setter>");
             sb.AppendLine("</Style>");
         }
         /// <summary>
         /// 构建行
         /// 偶数行、偶数列为数据，奇数行、奇数列为分割线，以此计算单元格占位、合并行列
         /// </summary>
         /// <param name="node">构建行的树结构</param>
         /// <param name="sb">字符串</param>
         /// <param name="depth">树的深度</param>
         private StringBuilder AppendCell(NTree<IDataGridHeader> node, StringBuilder sb, int depth, int totalCol)
         {
             //当前节点左兄弟节点的页节点数量，用于计算当前单元格列位置
             var precolCount = ;
             if (!node.IsRoot)
             {
                 precolCount = GetLeftCount(node);
             }

             //当前节点的页节点数量
             var colCount = node.GetCount();

             //1、数据单元格
             sb.Append(@"<ContentPresenter  ");
             sb.Append(@"Content='").Append(node.Data.DisplayColName).Append("' ");
             sb.Append(@"VerticalAlignment='Center' HorizontalAlignment='Center' ");
             sb.Append(" Grid.Row='").Append((node.Depth - ) * ).Append("' ");
             //考虑表头行可能不一致(层级有深有浅),层级较少的需要合并列显示，所有合并在最后一行表头
             var rowSpan = ;
             if (node.Children.Count ==  && node.Depth != depth)
             {
                 rowSpan = depth *  -  - (node.Depth - ) * ;
                 sb.Append(" Grid.RowSpan='").Append(rowSpan).Append("' ");
             }

             sb.Append(" Grid.Column='").Append(precolCount * ).Append("' ");
             sb.Append("Grid.ColumnSpan='").Append(colCount *  - ).AppendLine("' />");

             //2、行分隔线单元格
             sb.Append(@"<Rectangle Fill='").Append(splitLineColor).Append("' VerticalAlignment='Stretch' ")
                 .Append("Height='").Append(lineHeight).Append("' ");

             //表头行合并后要调整分割线，否则会在合并单元格中间显示分割线
             if (node.Children.Count ==  && node.Depth != depth)
             {
                 //如果有合并单元，则分割线要跳过合并单元格，合并数量为（rowSpan - 1）
                 sb.Append("Grid.Row='").Append(node.Depth *  -  + rowSpan - ).Append("' ");
             }
             else
             {
                 sb.Append("Grid.Row='").Append(node.Depth *  - ).Append("' ");
             }

             sb.Append(" Grid.Column='").Append(precolCount * ).Append("' ");
             sb.Append("Grid.ColumnSpan='").Append(colCount * ).AppendLine("' />");

             //4、列分隔线单元格
             //最后一列分割线不绘制，否则在调整了后面列的列宽会出现类似空列的单元格
             if ((precolCount + colCount) != totalCol)
             {
                 sb.Append(@"<Rectangle Fill='").Append(splitLineColor).Append("' VerticalAlignment='Stretch' ")
                     .Append(" Width='").Append(lineWidth).Append("' ");

                 sb.Append("Grid.Row='").Append((node.Depth - ) * ).Append("' ");
                 sb.Append("Grid.RowSpan='").Append(rowSpan).Append("' ");
                 sb.Append("Grid.Column='").Append((precolCount + colCount) *  - ).AppendLine("' />");
             }

             //5、递归生成子节点单元格
             if (node.Children.Count != )
             {
                 foreach (var item1 in node.Children)
                 {
                     AppendCell(item1, sb, depth, totalCol);
                 }
             }

             return sb;
         }
         /// <summary>
         /// 获取当前节点左边的叶节点数量
         /// </summary>
         /// <param name="node"></param>
         /// <returns></returns>
         private int GetLeftCount(NTree<IDataGridHeader> node)
         {
             var precolCount = ;
             var index = node.Parent.GetChildIndex(node);
             for (int i = ; i < index; i++)
             {
                 precolCount += node.Parent.GetChild(i).GetCount();
             }
             if (!node.Parent.IsRoot)
             {
                 precolCount += GetLeftCount(node.Parent);
             }
             return precolCount;
         }
     }
     public interface IDataGridHeader
     {
         /// <summary>
         /// 绑定列名
         /// </summary>
         string ColName { get; set; }
         /// <summary>
         /// 显示名称
         /// </summary>
         string DisplayColName { get; set; }
     }
 }