简化 excel 单元格列表以创建范围答案

【问题标题】：Simplify a list of excel cells to create a Range简化 excel 单元格列表以创建范围
【发布时间】：2012-08-23 17:37:29
【问题描述】：

我想从动态生成的单元格引用列表中创建一个 Excel.Range 对象。

Excel.Range outputRange = sheet.get_Range(strCellRange, Type.Missing);

由于 strCellRange 可以变得相当大，它会给出 com 异常。因此，我想将其简化为带有联合的范围表示法。

例如

string strCellRange = "F2,G2,H2,I2,J2,K2,L2,F7,G7,H7,I7,J7,K7,L7,F12,G12,H12,I12,J12,K12,L12,F17,G17,H17,I17,J17,K17,L17,F22,G22,H22,I22,J22,K22,L22,F27,G27,H27,I27,J27,K27,L27";

到

string strCellRange = "F2:L2,F7:L7,F12:L12,F17:L17,F22:L22,F27:L27";

是否有任何 Excel 方法可以创建具有大量单元格引用的 Range 对象？
是否有已知的算法来实现上述简化（矩阵算法）？

【问题讨论】：

在 Excel VBA 中，您将使用 Union 来完成 1&2。我不知道您如何 - 或者是否 - 您可以通过 C# 实现这一目标
@brettdj：是的，我可以使用 application.Union(,)。但是我原始字符串中的 AFAIK 逗号“，”也是联合运算符。
更多信息： 方法 sheet.get_Range(, Type.Missing);方法只接受一个最大长度为 255 的字符串作为它的第一个参数。 255 个字符包括所有空格、逗号 $ 符号等。

标签： c# algorithm excel vsto

【解决方案1】：

盖恩，

在VBA 中，您可以使用以下命令将您的直接字符串强制到一个范围内

Sub Test()
Dim rng1 As Range
Dim strCellRange As String
strCellRange = "F2,G2,H2,I2,J2,K2,L2,F7,G7,H7,I7,J7,K7,L7,F12,G12,H12,I12,J12,K12,L12,F17,G17,H17,I17,J17,K17,L17,F22,G22,H22,I22,J22,K22,L22,F27,G27,H27,I27,J27,K27,L27"
Set rng1 = Range(strCellRange)
Set rng1 = Union(rng1, rng1)
Debug.Print rng1.Address
End Sub

【讨论】：

好的，但是 OP 的问题是，由于字符串中单元格的数量，给定字符串的 Range 生成会产生异常......
@brettdj：你回答了我的简化问题，我现在可以在接近单元格限制时进行自我联合。最终我可能会在简化版本中达到另一个限制，但之后我可以打破并拥有不同的范围。
@FrancescoBaruchelli 实际上不，这不是 OP 问题，因为联合减少了字符串中的单元格。 Gayan，是的，如果简化的联合仍然存在问题（有吗？），那么（1）首先将字符串拆分为特定的长度，或者（2）在 Union 结果中出现错误将是解决方法

【解决方案2】：

VBA

Function Unionize(src As Range) As Range
Dim cell As Range
Dim unionizedRange As Range

For Each cell In src
    If unionizedRange Is Nothing Then
        Set unionizedRange = cell
    Else
        Set unionizedRange = Union(unionizedRange, cell)
    End If
Next

Set Unionize = unionizedRange
End Function

c#（粗略，没有通过编译器运行语法）

Excel.Range Unionize(Excel.Range src)
{
    Excel.Range unionizedRange;

    foreach (Excel.Range cell in src)
    {
        if (unionizedRange == null)
        {
            unionizedRange = cell;
        }
        Else
        {
            unionizedRange = Application.Union(unionizedRange, cell);
        }
    }
    return unionizedRange;
}

编辑：基于@brettdj 的解决方案

Excel.Range outputRange = sheet.get_Range(strCellRange, Type.Missing);
strCellRange = Application.Union(outputRange, outputRange).Address(false, false);

【讨论】：

据我了解， strCellRange 的缩短版本不是 OP 的目标。这只是绕过试图从原始字符串中获取 Range 引发异常这一事实的一种方法

【解决方案3】：

这可能是一个起点（它不适用于 Z 以外的列，并且不能识别矩形）：

    private string CompactRangeStringByRows(string strCellRange)
    {
        SortedDictionary<int, SortedList<char, char>> rows = new SortedDictionary<int, SortedList<char, char>>();
        foreach (string aCell in strCellRange.Split(new Char[] { ',' }))
        {
            char col = aCell[0];
            int row = int.Parse(aCell.Substring(1, aCell.Length - 1));
            SortedList<char, char> cols;
            if (!rows.TryGetValue(row, out cols))
            {
                cols = new SortedList<char, char>();
                rows[row] = cols;
            }
            cols.Add(col, col);
        }
        StringBuilder sb = new StringBuilder();
        bool first = true;
        foreach (KeyValuePair<int, SortedList<char, char>> rowCols in rows)
        {
            char minCol = '0';
            char maxCol = '0';
            foreach (char col in rowCols.Value.Keys)
            {
                if (minCol == '0')
                {
                    minCol = col;
                    maxCol = col;
                }
                else
                {
                    if (col == maxCol + 1)
                        maxCol = col;
                    else
                    {
                        AddRangeString(sb, first, rowCols.Key, minCol, maxCol);
                        minCol = col;
                        maxCol = col;
                        first = false;
                    }
                }
            }
            AddRangeString(sb, first, rowCols.Key, minCol, maxCol);
            first = false;
        }
        return sb.ToString();
    }

    private void AddRangeString(StringBuilder sb, bool first, int row, char minCol, char maxCol)
    {
        if (!first)
            sb.Append(',');
        sb.Append(minCol);
        sb.Append(row);
        if (maxCol != minCol)
        {
            sb.Append(':');
            sb.Append(maxCol);
            sb.Append(row);
        }
    }

【讨论】：

一旦完全开发，这将是最好的答案。非常有用+1。我可以生成具有 R1C1 样式的单元格引用。甚至 (row^col) 这将使算法非常有用。时间允许的时候一定会试试的。但目前我认为 brettdj 的解决方案还可以。
开发了一种类似的算法来“手动”获取范围内的线条和矩形。请参阅下面的答案。

【解决方案4】：

首先有一些类持有引用...

public class CellRef : IEquatable<CellRef>
{
    public int Row { get; private set; }
    public int Col { get; private set; }

    // some more code...
}

public class CellRange : IEquatable<CellRange>
{
    public CellRef Start { get; private set; }
    public CellRef Stop { get; private set; }

    // some more code...
}

然后算法和方法... 在传递给此方法之前，需要将单元格列表放入 List 并排序。

    public static string GetSimplifiedRangeString(List<CellRef> cellList)
    {
        #region Column wise simplify (identify lines)

        Dictionary<CellRef, CellRef> rowRanges = new Dictionary<CellRef, CellRef>(new CellRefEqualityComparer());

        int currentRangeStart = 0;
        for (int currentRangeStop = 0; currentRangeStop < cellList.Count; currentRangeStop++)
        {
            CellRef currentCell = cellList[currentRangeStop];
            CellRef previousCell = (currentRangeStop == 0) ? null : cellList[currentRangeStop - 1];

            bool cont = IsContigousX(currentCell, previousCell);

            if (!cont)
            {
                currentRangeStart = currentRangeStop;
            }

            if (!rowRanges.ContainsKey(cellList[currentRangeStart]))
                rowRanges.Add(cellList[currentRangeStart], cellList[currentRangeStop]);
            else
                rowRanges[cellList[currentRangeStart]] = cellList[currentRangeStop];
        }

        #endregion


        #region Row wise simplify (identify rectangles)

        List<CellRange> rangeList = new List<CellRange>();
        foreach (KeyValuePair<CellRef, CellRef> range in rowRanges)
        {
            rangeList.Add(new CellRange(range.Key, range.Value));                
        }            
        Dictionary<CellRange, CellRange> colRanges = new Dictionary<CellRange, CellRange>(new CellRangeEqualityComparer()); 

        currentRangeStart = 0;
        for (int currentRangeStop = 0; currentRangeStop < rangeList.Count; currentRangeStop++)
        {
            CellRange currentCellRange = rangeList[currentRangeStop];
            CellRange previousCellRange = (currentRangeStop == 0) ? null : rangeList[currentRangeStop - 1];

            bool cont = IsContigousY(currentCellRange, previousCellRange);

            if (!cont)
            {
                currentRangeStart = currentRangeStop;
            }

            if (!colRanges.ContainsKey(rangeList[currentRangeStart]))
                colRanges.Add(rangeList[currentRangeStart], rangeList[currentRangeStop]);
            else
                colRanges[rangeList[currentRangeStart]] = rangeList[currentRangeStop];
        }

        #endregion


        #region Simplify ranges (identify atomic lines and rectangles)

        StringBuilder retStr = new StringBuilder();
        foreach (KeyValuePair<CellRange, CellRange> ranges in colRanges)
        {
            string rangePart = string.Empty;
            if (ranges.Key.Equals(ranges.Value))
            {
                if (ranges.Key.Start.Equals(ranges.Key.Stop))
                {
                    rangePart = ranges.Key.Start.ToString();
                }
                else
                {
                    rangePart = ranges.Key.ToString();
                }
            }
            else
            {
                rangePart = new CellRange(ranges.Key.Start, ranges.Value.Stop).ToString();
            }

            if (retStr.Length == 0)
            {
                retStr.Append(rangePart);
            }
            else
            {
                retStr.Append("," + rangePart);
            }
        }

        return retStr.ToString();

        #endregion
    }

    /// <summary>
    /// Checks whether the given two cells represent a line.
    /// </summary>
    /// <param name="currentCell">Line start</param>
    /// <param name="previousCell">Line end</param>
    /// <returns></returns>
    private static bool IsContigousX(CellRef currentCell, CellRef previousCell)
    {
        if (previousCell == null)
            return false;
        return (currentCell.Row == previousCell.Row) && (currentCell.Col == (previousCell.Col + 1));
    }

    /// <summary>
    /// Checks whether the given two cells represents a rectangle.
    /// </summary>
    /// <param name="currentCellRange">Top-left cell</param>
    /// <param name="previousCellRange">Bottom-right cell</param>
    /// <returns></returns>
    private static bool IsContigousY(CellRange currentCellRange, CellRange previousCellRange)
    {
        if (previousCellRange == null)
            return false;

        bool sameVertically = (currentCellRange.Start.Col == previousCellRange.Start.Col) && (currentCellRange.Stop.Col == previousCellRange.Stop.Col);
        bool contigous = (currentCellRange.Start.Row == currentCellRange.Stop.Row) && (previousCellRange.Start.Row == previousCellRange.Stop.Row) && ((previousCellRange.Stop.Row + 1) == currentCellRange.Stop.Row);
        return sameVertically && contigous;
    }

希望这对某人有所帮助。

【讨论】：

【解决方案5】：

我认为没有任何方法可以检索长范围的单元格引用。我更喜欢获取完整的工作表，然后通过编码在其中导航。

【讨论】：