组装所有单元格数据后，计算需要合并的单元格数据

在进行pdf报表的绘制过程中，报表基本都是表格形式的，会有合并行、列的情况，使用的是itextsharp组件；

之前表格的单元格合并和业务是耦合在一起的，都需要开发人员每次绘制表格时，自己用各种办法合并单元格，还需要考虑分页的情况，需要开发人员有较强的逻辑分析能力、足够细致才不会有很多bug，且开发周期长。

在熟悉相关业务之后，我觉得可以把计算单元格的合并和业务分页，开发人员只需关心数据如何组装，单元格的合并及分页由系统自动完成，可以提升开发速度及质量，具体思路如下：

 

1、组装所有单元格数据（X坐标、Y坐标、单元格内容、是否允许合并、合并单元格时的判断依据的值、合并的行数、合并的列数）。

2、逐行遍历，计算每一行中需要合并的单元格，返回合并后的单元格列表（包含合并了的，以及未合并但需要合并的单元格）。

3、对上一个方法返回的结果逐列遍历，计算每一列中需要合并的单元格，最终返回所有需要合并的单元格数据列表。

4、用原始的单元格数据，一行一行地把单元格数据画到pdf上，画每一个单元格的时候，判断一下该单元格是否被合并了，如果被合并了就先不画；

等到一页pdf画满之后，用这一页的所有单元格数据再组成一个集合，重新计算一下当前页需要合并的单元格数据，然后画到pdf上即可。

5、然后再拿到剩余的没绘制的单元格数据，重复2、3、4，直至把所有单元格都绘制到pdf上。

 

这里只展示一下计算单元格的合并的代码：

/// <summary>
/// 根据源数据生成所有合并的单元格信息
/// </summary>
/// <param name="originalData"></param>
/// <returns></returns>
public static List<CellInfo> GenerateMergeCellList(List<CellInfo> originalData)
{
    if (originalData == null || !originalData.Any())
    {
        return new List<CellInfo>();
    }
    int maxRowCount = originalData.Max(c => c.XNum);//最大行号下标
    Dictionary<int, List<CellInfo>> rowMergeResult = new Dictionary<int, List<CellInfo>>();
    for (int i = 0; i <= maxRowCount; i++)
    {
        List<CellInfo> currentRowData = originalData.Where(c => c.XNum == i).ToList();//当前这一行数据
        List<CellInfo> rowResult = GenerateRowMergeInfo(currentRowData).ToList();//生成这一行的单元格信息,不包含不允许合并的单元格
        rowMergeResult.Add(i, rowResult);
    }
    List<CellInfo> mergeResult = GenerateMergeInfo(rowMergeResult);
    return mergeResult;
}

/// <summary>
/// 把某一行单元格集合传进去
/// 对单元格进行合并计算，返回需要进行列合并计算的单元格集合
/// </summary>
/// <param name="originalCellList">当前行的数据集合</param>
/// <returns>包含已经合并了的单元格信息以及需要进行列合并计算的单元格信息</returns>
private static List<CellInfo> GenerateRowMergeInfo(List<CellInfo> originalCellList)
{
    if (originalCellList == null || !originalCellList.Any())
    {
        return new List<CellInfo>();
    }
    int rowIndex = originalCellList.Any() ? originalCellList.First().XNum : 0;
    List<string> contentList = originalCellList.OrderBy(c => c.YNum).Select(c => c.Content).ToList();//把这一行数据组成一个string串
    List<CellInfo> result = new List<CellInfo>();
    int colspan;//要合并的列数

    for (int i = 0; i < contentList.Count; i++)
    {
        colspan = 1;
        if (!originalCellList.Single(c => c.YNum == i).AllowMerge)//不允许合并的，直接continue
        {
            continue;
        }

        //非最后一个单元格，且当前单元格与下一个单元格内容一致，需要计算一下要合并的单元格
        //如果是最后一个单元格，就不需要判断是否与下一个单元格内容一致了，直接添加到结果数据中
        if (i < (contentList.Count - 1) && contentList[i] == contentList[i + 1])//表示当前值和下一个值是相同的
        {
            while (i < contentList.Count - 1)
            {
                if (contentList[i] == contentList[i + 1])
                {
                    ++i;
                    ++colspan;
                }
                else
                {
                    break;
                }
            }
        }
        CellInfo originalCellFirst = originalCellList.Single(c => c.YNum == (i - colspan + 1));
        result.Add(new CellInfo()
        {
            XNum = rowIndex,
            YNum = originalCellFirst.YNum,
            Content = originalCellFirst.Content,
            DrawContent = originalCellFirst.DrawContent,
            Colspan = colspan
        });
    }
    return result;
}

/// <summary>
/// 生成所有合并的单元格信息
/// </summary>
/// <param name="rowMergeResult">一行一行的单元格数据集合</param>
/// <returns></returns>
private static List<CellInfo> GenerateMergeInfo(Dictionary<int, List<CellInfo>> rowMergeResult)
{
    List<CellInfo> result = new List<CellInfo>();
    int rowspan;
    int index;
    CellInfo currentRowCell;
    CellInfo startRowCell;
    CellInfo nextRowCell;
    for (int i = 0; i < rowMergeResult.Count; i++)//循环行
    {
        for (int j = 0; j < rowMergeResult[i].Count; j++)//循环列
        {
            rowspan = 1;
            currentRowCell = rowMergeResult[i][j];//当前单元格
            startRowCell = rowMergeResult[i][j];//初始单元格
            if (IsContainedMergeCell(result, currentRowCell) || !currentRowCell.AllowMerge)//单元格已经被合并时，不处理
            {
                continue;
            }
            if (i == rowMergeResult.Count - 1)//最后一行时，直接加到结果集中了（在最后一行会排除掉不合并的单元格）
            {
                result.Add(startRowCell);
                continue;
            }

            nextRowCell = rowMergeResult[i + 1].FirstOrDefault(r => r.YNum == currentRowCell.YNum && r.Content == currentRowCell.Content && r.Colspan == currentRowCell.Colspan && r.AllowMerge);
            if (nextRowCell == null)//如果该单元格在竖直方向上不需要合并，即rowspan保持不变
            {
                result.Add(startRowCell);
                continue;
            }
            index = 0;//遍历的行数
            while ((i + index) < rowMergeResult.Count - 1)//循环到倒数第二行
            {
                index++;
                nextRowCell = rowMergeResult[i + index].FirstOrDefault(r => r.YNum == currentRowCell.YNum && r.Content == currentRowCell.Content && r.Colspan == currentRowCell.Colspan && r.AllowMerge);
                if (nextRowCell == null)
                {
                    break;
                }
                rowspan++;
                currentRowCell = nextRowCell;
            }
            startRowCell.Rowspan = rowspan;
            result.Add(startRowCell);
        }
    }
    return result.Where(r => !(r.Colspan == 1 && r.Rowspan == 1)).ToList();//去除掉不需要合并的单元格
}

/// <summary>
/// 查询单元格是否被合并了
/// </summary>
/// <param name="mergedCellList">合并的单元格集合</param>
/// <param name="source">要查询的单元格信息</param>
/// <returns></returns>
public static bool IsContainedMergeCell(List<CellInfo> mergedCellList, CellInfo source)
{
    CellInfo cell = mergedCellList.FirstOrDefault(r => source.XNum >= r.XNum && source.YNum >= r.YNum && source.XNum < (r.XNum + r.Rowspan) && source.YNum < (r.YNum + r.Colspan));
    return cell != null;
}

实体类如下：

//实体类如下：
public class CellInfo
{
    /// <summary>
    /// 是否启用DrawContent字段
    /// </summary>
    private bool _UsingDrawContent = false;

    /// <summary>
    /// 单元格绘制的内容
    /// </summary>
    private string _DrawContent;

    /// <summary>
    /// X下标
    /// </summary>
    public int XNum { get; set; }

    /// <summary>
    /// Y下标
    /// </summary>
    public int YNum { get; set; }

    /// <summary>
    /// 单元格内容（AllowMerge=true时，判断是否可以合并的依据）
    /// </summary>
    public string Content { get; set; }

    /// <summary>
    /// 单元格绘制内容
    /// </summary>
    public string DrawContent
    {
        get
        {
            if (_UsingDrawContent)
            {
                return _DrawContent;
            }
            return Content;
        }
        set
        {
            _DrawContent = value ?? string.Empty;
            if (!_DrawContent.Equals(Content))
            {
                _UsingDrawContent = true;
            }
        }
    }

    private bool _allowMerge = true;
    /// <summary>
    /// 是否允许合并
    /// </summary>
    public bool AllowMerge
    {
        set
        {
            _allowMerge = value;
        }
        get
        {
            return _allowMerge;
        }
    }

    private int _rowspan = 1;
    /// <summary>
    /// 合并的行数
    /// </summary>
    public int Rowspan
    {
        set
        {
            _rowspan = value;
        }
        get
        {
            return _rowspan;
        }
    }

    private int _cowspan = 1;
    /// <summary>
    /// 合并的列数
    /// </summary>
    public int Colspan
    {
        set
        {
            _cowspan = value;
        }
        get
        {
            return _cowspan;
        }
    }
}

测试代码：

static void Main(string[] args)
{
    List<CellInfo> originalData = new List<CellInfo>();

    #region 原始数据
    AddCellInfo(originalData, 0, 0, "123", true);
    AddCellInfo(originalData, 0, 1, "123", true);
    AddCellInfo(originalData, 0, 2, "456", true);
    AddCellInfo(originalData, 0, 3, "999", true);
    AddCellInfo(originalData, 0, 4, "999", true);
    AddCellInfo(originalData, 0, 5, "789", true);
    AddCellInfo(originalData, 1, 0, "123", true);
    AddCellInfo(originalData, 1, 1, "123", true);
    AddCellInfo(originalData, 1, 2, "789", true);
    AddCellInfo(originalData, 1, 3, "999", true);
    AddCellInfo(originalData, 1, 4, "999", true);
    AddCellInfo(originalData, 1, 5, "999", true);
    AddCellInfo(originalData, 2, 0, "123", true);
    AddCellInfo(originalData, 2, 1, "123", true);
    AddCellInfo(originalData, 2, 2, "789", true);
    AddCellInfo(originalData, 2, 3, "999", true);
    AddCellInfo(originalData, 2, 4, "999", true);
    AddCellInfo(originalData, 2, 5, "789", true);
    #endregion

    List<CellInfo> mergeCellList = GenerateMergeCellList(originalData);
    foreach (CellInfo item in mergeCellList)
    {
        Console.WriteLine($"({item.XNum},{item.YNum}),clospan:{item.Colspan},rowspan:{item.Rowspan},content:{item.Content}");
    }
    Console.ReadKey();
}

private static void AddCellInfo(List<CellInfo> resultList, int xNum, int yNum, string content, bool allowMerge)
{
    resultList.Add(new CellInfo()
    {
        XNum = xNum,
        YNum = yNum,
        Content = content,
        AllowMerge = allowMerge
    });
}