Leggere file Excel in C# senza installare Excel

Leggere un file Excel in C# è un'attività comune per report, importazioni di dati e automazione. Con Free Spire.XLS for .NET, un'edizione community gratuita, puoi caricare una cartella di lavoro Excel e leggerne i dati senza installare Microsoft Excel sulla macchina e senza usare Interop. Questo articolo mostra come leggere celle, fogli di lavoro e righe, esportare un foglio di lavoro in una DataTable e gestire i risultati delle formule.

Avvio rapido: leggere un file Excel in C#

Installa Free Spire.XLS for .NET da NuGet. Esegui questo comando in un terminale:

dotnet add package FreeSpire.XLS

Oppure esegui questo comando nella Console di Gestione pacchetti NuGet:

Install-Package FreeSpire.XLS

Puoi anche scaricare Free Spire.XLS for .NET e fare riferimento manualmente alla DLL, oppure trovare il pacchetto su NuGet.

L'esempio seguente carica un file Excel, ottiene il primo foglio di lavoro e stampa il valore della cella A1. Sostituisci input.xlsx con il percorso completo del tuo file, oppure assicurati che il file si trovi nella directory di lavoro corrente del programma.

using System;
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook workbook = new Workbook();

        try
        {
            // Load an existing Excel file
            workbook.LoadFromFile("input.xlsx");

            // Get the first worksheet
            Worksheet sheet = workbook.Worksheets[0];

            // Read the value of cell A1 (row 1, column 1)
            string value = sheet.Range[1, 1].Value;

            Console.WriteLine("Cell A1: " + value);
        }
        finally
        {
            workbook.Dispose();
        }
    }
}

Workbook.LoadFromFile() legge il file in memoria. Worksheets[0] restituisce il primo foglio di lavoro e Range[1, 1].Value restituisce il valore di testo della cella nella prima riga e prima colonna. Il blocco finally rilascia le risorse della cartella di lavoro quando hai finito.

Leggere una cella o un foglio di lavoro specifici

Gli esempi seguenti presuppongono che workbook sia già stato caricato con LoadFromFile(). Mostrano come accedere a un foglio di lavoro tramite indice o nome.

Un file Excel può contenere diversi fogli di lavoro. Puoi ottenere un foglio di lavoro tramite la sua posizione o il suo nome:

// By index (zero-based): the first sheet is 0, the second is 1
Worksheet first = workbook.Worksheets[0];

// By name
Worksheet sales = workbook.Worksheets["Sales"];

Puoi anche leggere una cella tramite i numeri di riga e colonna, oppure tramite il suo indirizzo Excel:

// By row and column numbers (one-based): row 2, column 3
string byIndex = sales.Range[2, 3].Value;

// By Excel address
string byAddress = sales.Range["C2"].Value;

Nota i due diversi punti di partenza. La raccolta di fogli di lavoro è basata su zero, quindi il primo foglio di lavoro è Worksheets[0]. I numeri di riga e colonna delle celle sono basati su uno, quindi Range[1, 1] è la cella A1.

Per leggere un blocco di celle, passa un indirizzo di intervallo e eseguine il loop:

CellRange range = sales.Range["A1:C3"];

foreach (CellRange cell in range.CellList)
{
    Console.WriteLine({BODY_CONTENT}quot;{cell.RangeAddress}: {cell.Value}");
}

Leggere i dati di Excel riga per riga in C#

Per leggere tutti i dati in un foglio di lavoro, esegui il loop delle righe con un ciclo esterno e delle colonne con un ciclo interno. Scrivi un'interruzione di riga dopo ogni riga in modo che l'output della console mantenga la struttura del foglio di lavoro:

using System;
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook workbook = new Workbook();

        try
        {
            workbook.LoadFromFile("input.xlsx");
            Worksheet sheet = workbook.Worksheets[0];

            for (int row = 1; row <= sheet.LastDataRow; row++)
            {
                for (int col = 1; col <= sheet.LastDataColumn; col++)
                {
                    Console.Write({BODY_CONTENT}quot;{sheet.Range[row, col].Value}\t");
                }

                Console.WriteLine();
            }
        }
        finally
        {
            workbook.Dispose();
        }
    }
}

I cicli vanno dalla riga 1 e colonna 1 fino a LastDataRow e LastDataColumn, che restituiscono l'ultima riga e colonna che contengono dati. Questo evita di includere celle formattate ma vuote che LastRow e LastColumn coprirebbero. Se il tuo foglio di lavoro ha un layout insolito, verifica l'intervallo effettivo sul tuo file di test prima di elaborare l'output.

Per un foglio di lavoro che contiene i dati di esempio seguenti:

la console mostra ogni riga del foglio di lavoro sulla propria riga, con i valori delle celle separati da tabulazioni:

Product    Category    Price
Keyboard   Accessories 25
Monitor    Displays    180

Leggere i dati di Excel in una DataTable

Se vuoi elaborare i dati del foglio di lavoro con ADO.NET, associarli a un controllo o inserirli in un database, esporta il foglio di lavoro in una DataTable con ExportDataTable():

using System;
using System.Data;
using Spire.Xls;

class Program
{
    static void Main()
    {
        Workbook workbook = new Workbook();

        try
        {
            workbook.LoadFromFile("input.xlsx");

            // Recalculate formulas before exporting computed values
            workbook.CalculateAllValue();

            Worksheet sheet = workbook.Worksheets[0];

            DataTable dataTable = sheet.ExportDataTable(
                sheet.AllocatedRange,
                true,   // exportColumnNames
                true    // computedFormulaValue
            );

            // Print each row to verify the exported data
            foreach (DataRow row in dataTable.Rows)
            {
                Console.WriteLine(string.Join("\t", row.ItemArray));
            }
        }
        finally
        {
            workbook.Dispose();
        }
    }
}

Questo overload accetta tre parametri:

• range: l'intervallo di celle da esportare. sheet.AllocatedRange restituisce l'intervallo usato del foglio di lavoro. A seconda della formattazione e delle impostazioni dell'intervallo usato della cartella di lavoro, potrebbe includere celle vuote. Se hai bisogno solo di una specifica area di dati, usa un intervallo esplicito e verificane i limiti.
• exportColumnNames: quando è true, la prima riga dell'intervallo diventa i nomi delle colonne della DataTable. Quando è false, la prima riga viene esportata come dati ordinari.
• computedFormulaValue: quando è true, l'esportatore usa i valori calcolati delle formule invece del testo della formula. Quando è false, le celle con formule vengono esportate come testo della formula. Se i tuoi dati contengono formule, verifica i valori esportati sul tuo file di test — il calcolo delle formule potrebbe dover essere attivato prima dell'esportazione affinché i risultati vengano popolati correttamente.

Per mostrare il risultato in un'applicazione Windows Forms, assegna la tabella a una DataGridView:

dataGridView1.DataSource = dataTable;

Controlla i nomi delle colonne e i tipi di dati della tabella esportata rispetto al tuo file Excel prima di fare affidamento su di essi nelle elaborazioni successive. Per ulteriori opzioni, come l'esportazione di un intervallo specifico, consulta il tutorial dettagliato su conversione di Excel in DataTable in C#.

Leggere i risultati delle formule e gestire i valori delle celle

Gli snippet in questa sezione presuppongono che sheet faccia riferimento a un foglio di lavoro di una cartella di lavoro caricata, come negli esempi precedenti.

Una cella che contiene una formula ha due cose che potresti voler leggere: la formula stessa e il risultato che produce. Usa HasFormula per verificare se una cella contiene una formula, Formula per ottenere il testo della formula e FormulaValue per ottenere il risultato calcolato. Se hai bisogno di risultati delle formule aggiornati, chiama workbook.CalculateAllValue() dopo aver caricato la cartella di lavoro e prima di leggere FormulaValue.

CellRange cell = sheet.Range["D2"];

if (cell.HasFormula)
{
    Console.WriteLine("Formula: " + cell.Formula);
    Console.WriteLine("Result: " + cell.FormulaValue);
}
else
{
    Console.WriteLine("Value: " + cell.Value);
}

Per maggiori informazioni sull'uso delle formule, consulta Aggiungere o leggere formule e funzioni in Excel.

Le celle con diversi tipi di contenuto possono essere lette tramite proprietà tipizzate:

CellRange priceCell = sheet.Range["C2"];
CellRange dateCell = sheet.Range["E2"];

double price = priceCell.NumberValue;       // numeric value
DateTime date = dateCell.DateTimeValue;     // date value
string text = sheet.Range["A2"].Text;       // text as displayed

Excel memorizza numeri e date in modi diversi rispetto al testo normale, quindi scegli la proprietà che corrisponde al tipo di dati nella cella.

Leggere i formati numerici e i valori visualizzati

Per le celle con formati numerici — percentuali, valuta, date — il valore memorizzato, il codice di formato e il testo formattato possono tutti differire. Una cella che memorizza 0.15 con un formato percentuale viene visualizzata come 15%. Usa Value per il valore non elaborato, NumberFormat per il codice di formato e NumberText per il testo così come appare in Excel:

CellRange cell = sheet.Range["C2"];

Console.WriteLine("Value: " + cell.Value);
Console.WriteLine("Number format: " + cell.NumberFormat);
Console.WriteLine("Formatted text: " + cell.NumberText);

Scegli la proprietà che corrisponde a ciò di cui ha bisogno la tua logica a valle: il valore numerico per i calcoli o il testo formattato per la visualizzazione. Per maggiori informazioni sui formati numerici, consulta Impostare il formato numerico in Excel.

Prima di leggere una cella, puoi verificare se è vuota:

if (string.IsNullOrEmpty(sheet.Range["B5"].Value))
{
    Console.WriteLine("B5 is empty.");
}

Domande frequenti

Posso leggere file Excel in C# senza installare Microsoft Excel?

Sì. Free Spire.XLS legge i file Excel direttamente e non richiede Microsoft Excel o Interop sul computer o server che esegue il tuo codice.

Come posso leggere i risultati delle formule invece delle formule?

Per una singola cella, controlla CellRange.HasFormula e leggi CellRange.FormulaValue. Per leggere un intero foglio di lavoro, chiama ExportDataTable() con computedFormulaValue impostato su true. Vedi Leggere i risultati delle formule e gestire i valori delle celle.

Posso leggere file Excel protetti da password?

Sì. Imposta la password di apertura prima di caricare il file:

Workbook workbook = new Workbook();
workbook.OpenPassword = "your-password";
workbook.LoadFromFile("protected.xlsx");

Quali formati di file Excel supporta Free Spire.XLS?

Free Spire.XLS supporta i formati .xls, .xlsx e .xlsm.

Quali sono i limiti dell'edizione gratuita?

Free Spire.XLS for .NET è un'edizione community per sviluppatori individuali e piccoli progetti. Quando si lavora con il formato .xls, ogni cartella di lavoro è limitata a 5 fogli di lavoro e 200 righe per foglio. Il caricamento e il salvataggio di file .xlsx non sono soggetti a questi limiti. Per capacità superiore o funzionalità avanzate, Spire.XLS for .NET è disponibile come edizione commerciale.

Se hai bisogno di capacità superiore o funzionalità avanzate, Spire.XLS for .NET è l'edizione commerciale — puoi richiedere una licenza di prova gratuita di 30 giorni per valutarla.

Vedi anche

• Convertire Excel in DataTable in C#
• Convertire Excel in CSV e CSV in Excel in C#
• Creare, leggere e aggiornare Excel in C#
• Leggere le proprietà del documento in Excel in C#