it-swarm.com.de

Optimale Methode zum Lesen einer Excel-Datei (.xls/.xlsx)

Ich weiß, dass es verschiedene Möglichkeiten gibt, eine Excel-Datei zu lesen:

  • Iterop
  • Oledb
  • Open Xml SDK

Kompatibilität ist keine Frage, da das Programm in einer kontrollierten Umgebung ausgeführt wird.

Meine Anforderung:
Eine Datei in eine DataTable/CUstom Entities lesen (ich kann nicht dynamische Eigenschaften/Felder zu einem Objekt machen [Spaltennamen variieren in einer Excel-Datei])

Verwenden Sie DataTable/Custom Entities, um einige Operationen mit den Daten auszuführen.

Aktualisieren Sie DataTable mit den Ergebnissen der Operationen

Schreibe es zurück zu Excel file.

Welches wäre einfacher.

Ratschläge zu benutzerdefinierten Entitäten (wenn Sie einem Objekt dynamisch Eigenschaften/Felder hinzufügen)

54
Ankesh

Werfen Sie einen Blick auf Linq-to-Excel . Es ist ziemlich ordentlich.

var book = new LinqToExcel.ExcelQueryFactory(@"File.xlsx");

var query =
    from row in book.Worksheet("Stock Entry")
    let item = new
    {
        Code = row["Code"].Cast<string>(),
        Supplier = row["Supplier"].Cast<string>(),
        Ref = row["Ref"].Cast<string>(),
    }
    where item.Supplier == "Walmart"
    select item;

Es ermöglicht auch einen stark typisierten Zeilenzugriff.

61
Enigmativity

Bei Verwendung der Abfrage OLE ist das recht einfach (Beispiel: SheetName ist Sheet1 $):

DataTable LoadWorksheetInDataTable(string fileName, string sheetName)
{           
    DataTable sheetData = new DataTable();
    using (OleDbConnection conn = this.returnConnection(fileName))
    {
       conn.Open();
       // retrieve the data using data adapter
       OleDbDataAdapter sheetAdapter = new OleDbDataAdapter("select * from [" + sheetName + "]", conn);
        sheetAdapter.Fill(sheetData);
    }                        
    return sheetData;
}

private OleDbConnection returnConnection(string fileName)
{
    return new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + fileName + "; Jet OLEDB:Engine Type=5;Extended Properties=\"Excel 8.0;\"");
}

Für neuere Excel-Versionen:

return new OleDbConnection("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + filename + ";Extended Properties=Excel 12.0;");

Sie können auch Excel Data Reader ein Open Source-Projekt für CodePlex verwenden. Es funktioniert wirklich gut, um Daten aus Excel-Tabellen zu exportieren. 

Der Beispielcode, der auf dem angegebenen Link angegeben ist:

FileStream stream = File.Open(filePath, FileMode.Open, FileAccess.Read);

//1. Reading from a binary Excel file ('97-2003 format; *.xls)
IExcelDataReader excelReader = ExcelReaderFactory.CreateBinaryReader(stream);
//...
//2. Reading from a OpenXml Excel file (2007 format; *.xlsx)
IExcelDataReader excelReader = ExcelReaderFactory.CreateOpenXmlReader(stream);
//...
//3. DataSet - The result of each spreadsheet will be created in the result.Tables
DataSet result = excelReader.AsDataSet();
//...
//4. DataSet - Create column names from first row
excelReader.IsFirstRowAsColumnNames = true;
DataSet result = excelReader.AsDataSet();

//5. Data Reader methods
while (excelReader.Read())
{
//excelReader.GetInt32(0);
}

//6. Free resources (IExcelDataReader is IDisposable)
excelReader.Close();

Referenz: Wie importiere ich mit Microsoft.Office.Interop.Excel aus Excel in ein DataSet?

20
Furqan Safdar

Versuchen Sie, diesen kostenlosen Weg zu verwenden, https://freenetexcel.codeplex.com

 Workbook workbook = new Workbook();

 workbook.LoadFromFile(@"..\..\parts.xls",ExcelVersion.Version97to2003);
 //Initialize worksheet
 Worksheet sheet = workbook.Worksheets[0];

 DataTable dataTable = sheet.ExportDataTable();
5
Hark.Tenl

Wenn Sie es auf (.xlsx-Dateien im Open Office-XML-Format) einschränken können, wäre die beliebteste Bibliothek wahrscheinlich EPPLus .

Bonus ist, es gibt keine weiteren Abhängigkeiten. Einfach mit nuget installieren:

Install-Package EPPlus
2
davewasthere

Persönlich habe ich das Open-Source & Free ExcelMapper am einfachsten gefunden.

Es bietet eine viel präzisere (dh lesbarere) Möglichkeit zum Lesen von Excel-Dateien als die üblichen Microsoft.Interop & OLE-Abfragen.

1. Gegeben eine Excel-Datei :

enter image description here

2.Erstellen Sie ein Person C # -Objekt:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
}

3.Lesen Sie es mit ExcelMapper

  var fileName = @"C:\Temp\Names.xlsx"; // your Excel file
  List<Person> people = new ExcelMapper(fileName).Fetch<Person>();

Sie können auch aus anderen Arbeitsblättern lesen, indem Sie einfach ein zusätzliches Blattargument eingeben:

  var fileName = @"C:\Temp\Names.xlsx"; // your Excel file
  List<Person> people = new ExcelMapper(fileName).Fetch<Person>("Sheet2");

Sie können es mit NuGet installieren

Install-Package ExcelMapper

Haftungsausschluss: Ich bin nicht mit ExcelMapper verbunden, aber nachdem ich verschiedene Bibliotheken ausprobiert habe, fand ich diese Bibliothek am einfachsten zu bedienen.

instructional video - how to read Excel files in c# Hier ist ein kurzes Video , das das Obige zeigt.

1
Mark H

Versuchen Sie, die Aspose.cells-Bibliothek zu verwenden, sie ist ziemlich gut.

Install-package Aspose.cells

Es gibt Beispielcode:

_using Aspose.Cells;
using System;

namespace ExcelReader
{
    class Program
    {
        static void Main(string[] args)
        {
            // Replace path for your file
            readXLS(@"C:\MyExcelFile.xls"); // or "*.xlsx"
            Console.ReadKey();
        }

        public static void readXLS(string PathToMyExcel)
        {
            //Open your template file.
            Workbook wb = new Workbook(PathToMyExcel);

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

            //Get cells
            Cells cells = worksheet.Cells;

            // Get row and column count
            int rowCount = cells.MaxDataRow;
            int columnCount = cells.MaxDataColumn;

            // Current cell value
            string strCell = "";

            Console.WriteLine(String.Format("rowCount={0}, columnCount={1}", rowCount, columnCount));

            for (int row = 0; row <= rowCount; row++) // Numeration starts from 0 to MaxDataRow
            {
                for (int column = 0; column <= columnCount; column++)  // Numeration starts from 0 to MaxDataColumn
                {
                    strCell = "";
                    strCell = Convert.ToString(cells[row, column].Value);
                    if (String.IsNullOrEmpty(strCell))
                    {
                        continue;
                    }
                    else
                    {
                        // Do your staff here
                        Console.WriteLine(strCell);
                    }
                }
            }
        }
    }
}
_
0
fr0ga

Ich weiß, dass diese Frage vor fast 7 Jahren gestellt wurde, aber es ist immer noch ein Top-Google-Suchergebnis für bestimmte Schlüsselwörter beim Import von Excel-Daten mit C #. Daher wollte ich eine Alternative basierend auf den neuesten technischen Entwicklungen bieten.

Das Importieren von Excel-Daten ist für meine alltäglichen Aufgaben zu einer alltäglichen Aufgabe geworden, sodass ich den Prozess rationalisiert und die Methode in meinem Blog dokumentiert habe: beste Methode zum Lesen der Excel-Datei in c # .

Ich verwende NPOI , da es Excel-Dateien lesen und schreiben kann, ohne dass Microsoft Office installiert ist, und COM + oder Interops nicht verwendet. Das heißt, es kann in der Cloud funktionieren!

Die eigentliche Magie entsteht jedoch durch das Pairing mit dem NPOI Mapper von Donny Tian , da ich damit die Excel-Spalten Eigenschaften in meinen C # -Klassen zuordnen kann, ohne Code schreiben zu müssen. Es ist wunderschön.

Hier ist die Grundidee:

Ich erstelle eine .net-Klasse, die mit den Excel-Spalten übereinstimmt, die mich interessieren:

        class CustomExcelFormat
        {
            [Column("District")]
            public int District { get; set; }

            [Column("DM")]
            public string FullName { get; set; }

            [Column("Email Address")]
            public string EmailAddress { get; set; }

            [Column("Username")]
            public string Username { get; set; }

            public string FirstName
            {
                get
                {
                    return Username.Split('.')[0];
                }
            }

            public string LastName
            {
                get
                {
                    return Username.Split('.')[1];
                }
            }
        }

Beachten Sie, es ermöglicht mir die Zuordnung nach Spaltennamen, wenn ich möchte! 

Wenn ich dann die Excel-Datei verarbeite, muss ich nur noch Folgendes tun:

        public void Execute(string localPath, int sheetIndex)
        {
            IWorkbook workbook;
            using (FileStream file = new FileStream(localPath, FileMode.Open, FileAccess.Read))
            {
                workbook = WorkbookFactory.Create(file);
            }

            var importer = new Mapper(workbook);
            var items = importer.Take<CustomExcelFormat>(sheetIndex);
            foreach(var item in items)
            {
                var row = item.Value;
                if (string.IsNullOrEmpty(row.EmailAddress))
                    continue;

                UpdateUser(row);
            }

            DataContext.SaveChanges();
        }

Zugegebenermaßen ändert mein Code die Excel-Datei selbst nicht. Ich speichere die Daten stattdessen mit Entity Framework in einer Datenbank (deshalb werden in meinem Beispiel "UpdateUser" und "SaveChanges" angezeigt). Aber es gibt bereits eine gute Diskussion über SO, wie Datei mit NPOI speichern/ändern .

0
Dan