Cómo probar si cualquier célula no cabecera en el archivo de Excel está en negrita o cursiva

Question

utilizar una hoja de Excel que contiene algo de lógica de negocio (y por lo que se edita a menudo por la falta de ella). Algunos de código C ++ se genera en VBA de la misma hoja - tonto, lo sé. Planeo escribir un montón de pruebas de unidad en contra de esta hoja de trabajo, asegurando formato estricto para el beneficio de todos. Por ejemplo, las cosas deben ser ordenados alfabéticamente. No he hecho este tipo de trabajo antes; ni siquiera seguro de qué biblioteca para su uso. Para obtener los pies mojados, me gustaría encontrar todas las células que tienen fuente que no sea "automática del color, estilo llano, Arial, tamaño 10" - por ejemplo, tamaño rojo o negrita o 11, o de la fuente Comic Sans. Entonces quiero comprobar si esas células son las células "no" de cabecera. Las células "cabecera" son aquellos que son parte de los rangos con nombre conocidos. Por ejemplo, si tales células hace pertenecer a un "nombre" XYZheaders rango, entonces está bien. Si no, entonces me gustaría reportar las coordenadas de una celda (idealmente como algo legible como "D25" por cada célula que tiene un problema, así como indicar si el problema es con el color, tipo de letra, el estilo o el tamaño .

EDIT: acabo de recompensas poner en esta pregunta porque estoy buscando un C # muestra completa. Por favor, pregunte si usted piensa que mi pregunta es ambigua.

Answer 1

Aquí está mi solución. Lo he probado con algunos archivos de Excel 2007 (.xlsx). El programa se puede construir utilizando VS 2010 (dirigida .NET 4) con los siguientes cuatro referencias: Microsoft.CSharp, Microsoft.Office.Interop.Excel, Sistema y System.Core.

El uso de .NET 4 hace que sea un poco más fácil trabajar con Excel.

De todos modos aquí está el código:

using System;
using System.Collections.Generic;
using System.Linq;
using Excel = Microsoft.Office.Interop.Excel;

namespace ExcelTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Excel.Application excelapplication = null;
            Excel.Workbook workbook = null;

            try
            {
                excelapplication = new Excel.Application();
                workbook = excelapplication.Workbooks.Open(args[0]);
                var errors = new Dictionary<string, List<string>>();
                foreach (Excel.Worksheet sheet in workbook.Sheets)
                {
                    int rowCount = sheet.UsedRange.Cells.Rows.Count;
                    int colCount = sheet.UsedRange.Cells.Columns.Count;
                    var usedCells = sheet.UsedRange.Cells;

                    for (int i = 1; i <= rowCount; i++)
                    {
                        for (int j = 1; j <= colCount; j++)
                        {
                            Excel.Range range = usedCells[i, j];
                            List<string> cellErrors;
                            if (HasNonDefaultFont(range, out cellErrors))
                            {
                                if (!IsHeaderCell(workbook, range))
                                {
                                    string cellDisplayTitle = String.Format("{0}!{1}", sheet.Name, range.Address);
                                    errors[cellDisplayTitle] = cellErrors;
                                }
                            }
                        }
                    }
                }
                ReportErrors(errors);
            }
            finally
            {
                if (workbook != null)
                    workbook.Close();
                if (excelapplication != null)
                    excelapplication.Quit();
            }
        }

        static bool HasNonDefaultFont(Excel.Range range, out List<string> differences)
        {
            differences = new List<string>();

            if (range.Font.Color != 0.0)
                differences.Add("Has font-color");

            if (range.Font.Bold)
                differences.Add("Is bold");

            if (range.Font.Italic)
                differences.Add("Is italic");

            if (range.Font.Underline != (int)Microsoft.Office.Interop.Excel.XlUnderlineStyle.xlUnderlineStyleNone)
                differences.Add("Is underline");

            if (range.Font.Strikethrough)
                differences.Add("Is strikethrough");

            if (range.Font.Name != "Arial")
                differences.Add(String.Format("Font is {0}", range.Font.Name));

            if (range.Font.Size != 10)
                differences.Add(String.Format("Font size is {0}", range.Font.Size));

            return differences.Count != 0;
        }

        static bool IsHeaderCell(Excel.Workbook workbook, Excel.Range range)
        {
            // Look through workbook names:
            foreach (Excel.Name namedRange in workbook.Names)
            {
                if (range.Parent == namedRange.RefersToRange.Parent && range.Application.Intersect(range, namedRange.RefersToRange) != null)
                    return true;
            }

            // Look through worksheet-names.
            foreach (Excel.Name namedRange in range.Worksheet.Names)
            {
                if (range.Parent == namedRange.RefersToRange.Parent && range.Worksheet.Application.Intersect(range, namedRange.RefersToRange) != null)
                    return true;
            }
            return false;
        }

        static void ReportErrors(Dictionary<string, List<string>> errors)
        {
            if (errors.Count > 0)
            {
                Console.WriteLine("Found the following errors:");
                Console.WriteLine("---------------------------------");
                Console.WriteLine("{0,-15} | Error", "Cell");
                Console.WriteLine("---------------------------------");
            }

            foreach (KeyValuePair<string, List<string>> kv in errors)
                Console.WriteLine("{0,-15} | {1}", kv.Key, kv.Value.Aggregate((e, s) => e + ", " + s));
        }
    }
}

El programa asume el nombre de un archivo de Excel-como primer argumento. Este archivo se abre y cada célula se prueba contra diferentes font-criterios. Las células con "non-default-fuente" se prueba contra el nombrado a distancia, y los que quedan fuera de estos rangos son de salida a la consola.

Como de costumbre algunos ErrorHandling debe añadirse al programa -. Pero espero que esto debería empezar

Answer 2

Esto debería hacer el truco, disfrutar. Tenga en cuenta que la puesta en nuevos nombres de rango no se disparará un recálculo de una célula que contiene esta función (así que pulse F9 después de la creación de nombres de rango).

Option Explicit

Public Function IsDataCellBoldOrItalic() As Boolean
    Dim rngName As Name
    Dim intersectRange As Name

    For Each rngName In ActiveWorkbook.Names
        If Not Intersect(rngName.RefersToRange, Application.ThisCell) Is Nothing Then
            IsDataCellBoldOrItalic = False
            Exit Function
        End If
    Next

    ''# Now we know we are not in a "header" cell
    IsDataCellBoldOrItalic = Application.ThisCell.Font.Bold Or Application.ThisCell.Font.Italic

End Function