C# Range.SpecialCells方法代码示例

 private static Range GetSpecialCells(Range selectedRange, XlCellType type)
 {
     try
     {
         return selectedRange.SpecialCells(type);
     }
     catch
     {
         return null;
     }
 }

        TryGetVisibleRange
        (
            Range range,
            out Range visibleRange
        )
        {
            Debug.Assert(range != null);

            visibleRange = null;

            // WARNING: If the range contains hidden cells, range.SpecialCells()
            // causes the Microsoft.Office.Tools.Excel.ListObject.SelectionChange
            // event to fire.  It shouldn't, but it does.  Allow the application to
            // work around this Excel bug by checking the SpeciealCellsBeingCalled
            // property from within the application's event handler.

            m_bSpecialCellsBeingCalled = true;

            try
            {
                if (range.Rows.Count == 1 && range.Columns.Count == 1)
                {
                    // The Range.SpecialCells() call below does not work for single
                    // cells.  For example, if range is "B3", Range.SpecialCells()
                    // returns "A:Y,AB:XFD".

                    if ((Boolean)range.EntireRow.Hidden ||
                        (Boolean)range.EntireColumn.Hidden)
                    {
                        return (false);
                    }

                    visibleRange = range;
                    return (true);
                }

                visibleRange = range.SpecialCells(
                    XlCellType.xlCellTypeVisible, Missing.Value);
            }
            catch (COMException)
            {
                // This can definitely occur.

                return (false);
            }
            finally
            {
                m_bSpecialCellsBeingCalled = false;
            }

            // Can a null visibleRange occur as well?  The documentation doesn't
            // say.

            return (visibleRange != null);
        }

        //*************************************************************************
        //  Method: DeleteDuplicateRows()
        //
        /// <summary>
        /// Deletes the duplicate rows from the edge table.
        /// </summary>
        ///
        /// <param name="oEdgeTable">
        /// Edge table.
        /// </param>
        ///
        /// <param name="oEdgeWeightColumn">
        /// Edge weight column.
        /// </param>
        ///
        /// <param name="oEdgeWeightData">
        /// Data range for the edge weight column.
        /// </param>
        ///
        /// <param name="aoEdgeWeightValues">
        /// Data values from the edge weight column.
        /// </param>
        ///
        /// <remarks>
        /// All rows for which the edge weight cell is null are deleted.
        /// </remarks>
        //*************************************************************************
        protected void DeleteDuplicateRows(
            ListObject oEdgeTable,
            ListColumn oEdgeWeightColumn,
            Range oEdgeWeightData,
            Object [,] aoEdgeWeightValues
            )
        {
            Debug.Assert(oEdgeTable != null);
            Debug.Assert(oEdgeWeightColumn != null);
            Debug.Assert(oEdgeWeightData != null);
            Debug.Assert(aoEdgeWeightValues != null);
            AssertValid();

            Range oDuplicateRows = null;

            // Find the rows with null edge weights, which are the duplicates.  To
            // avoid multiple areas, which can slow things down signficantly, sort
            // the table on the edge weight column.  That forces the duplicates
            // to be contiguous.
            //
            // But first, add a temporary column and set its values to the
            // worksheet row numbers.  This will be used later to restore the
            // original sort order.

            ListColumn oTemporaryColumn;

            if ( !ExcelUtil.TryAddTableColumnWithRowNumbers(oEdgeTable,
            "Temporary for Sort", 5F, null, out oTemporaryColumn) )
            {
            return;
            }

            Sort oSort = oEdgeTable.Sort;
            SortFields oSortFields = oSort.SortFields;
            oSortFields.Clear();

            oSortFields.Add(oEdgeWeightColumn.Range, XlSortOn.xlSortOnValues,
            XlSortOrder.xlAscending, Missing.Value,
            XlSortDataOption.xlSortNormal);

            oSort.Apply();

            if (oEdgeWeightData.Rows.Count != 1)
            {
            try
            {
                oDuplicateRows = oEdgeWeightData.SpecialCells(
                    XlCellType.xlCellTypeBlanks, Missing.Value);
            }
            catch (COMException)
            {
                // There are no such rows.

                oDuplicateRows = null;
            }
            }
            else
            {
            // Range.SpecialCells() can't be used in the one-cell case, for
            // which it behaves in a bizarre manner.  See this posting:
            //
            // http://ewbi.blogs.com/develops/2006/03/determine_if_a_.html
            //
            // ...of which this is an excerpt:
            //
            // "SpecialCells ignores any source Range consisting of only one
            // cell. When executing SpecialCells on a Range having only one
            // cell, it will instead consider all of the cells falling within
            // the boundary marked by the bottom right cell of the source Range
            // sheet's UsedRange."
            //
            // Instead, just check the single row.

//.........这里部分代码省略.........

    DeleteMarkedRows
    (
        ListObject oEdgeTable,
        Range oDeleteIfEmptyData,
        Object [,] aoDeleteIfEmptyValues
    )
    {
        Debug.Assert(oEdgeTable != null);
        Debug.Assert(oDeleteIfEmptyData != null);
        Debug.Assert(aoDeleteIfEmptyValues != null);
        AssertValid();

        Range oMarkedRows = null;

        if (oDeleteIfEmptyData.Rows.Count != 1)
        {
            try
            {
                oMarkedRows = oDeleteIfEmptyData.SpecialCells(
                    XlCellType.xlCellTypeBlanks, Missing.Value);
            }
            catch (COMException)
            {
                // There are no such rows.

                oMarkedRows = null;
            }
        }
        else
        {
            // Range.SpecialCells() can't be used in the one-cell case, for
            // which it behaves in a bizarre manner.  See this posting:
            //
            // http://ewbi.blogs.com/develops/2006/03/determine_if_a_.html
            //
            // ...of which this is an excerpt:
            //
            // "SpecialCells ignores any source Range consisting of only one
            // cell. When executing SpecialCells on a Range having only one
            // cell, it will instead consider all of the cells falling within
            // the boundary marked by the bottom right cell of the source Range
            // sheet's UsedRange."
            //
            // Instead, just check the single row.

            if (aoDeleteIfEmptyValues[1, 1] == null)
            {
                oMarkedRows = oDeleteIfEmptyData.EntireRow;
            }
        }

        if (oMarkedRows != null)
        {
            // Delete the marked rows, which are now contiguous.

            Debug.Assert(oMarkedRows.Areas.Count == 1);

            oMarkedRows.EntireRow.Delete(XlDeleteShiftDirection.xlShiftUp);
        }
    }