C# (WinForms-App) eksport zbioru danych do Excela

Poniższa strona pokazuje, jak wyeksportować zestaw danych (lub DataTable lub listę) do " oryginalnego " Excel 2007 .plik xlsx.

Używa bibliotek OpenXML , więc nie musisz mieć zainstalowanego Excela na swoim serwerze.

MikesKnowledgeBase-ExportToExcel

Cały kod źródłowy jest dostarczany, bezpłatnie , a także jako aplikacja demonstracyjna.

To bardzo łatwe dodawanie do własnych aplikacji, po prostu trzeba wywołać jedną funkcję, przekazując nazwę pliku Excel i źródło danych:

DataSet ds = CreateSampleData();
string excelFilename = "C:\\Sample.xlsx";
CreateExcelFile.CreateExcelDocument(ds, excelFilename);

Tworzenie plików excel w aplikacjach. NET jest dość powszechne i podobne pytania zadawano już kilka razy. Na przykład tutaj i Tutaj. Ostatnie pytanie dotyczy czytania plików Excela, ale większość sugerowanych rozwiązań powinna działać w obie strony.

using XL = Microsoft.Office.Interop.Excel;
using System.Reflection;

public static void Datasource(DataTable dt)
        {

            XL.Application oXL;

            XL._Workbook oWB;

            XL._Worksheet oSheet;

            XL.Range oRng;


            try
            {
                oXL = new XL.Application();

                Application.DoEvents();

                oXL.Visible = false;

                //Get a new workbook.

                oWB = (XL._Workbook)(oXL.Workbooks.Add(Missing.Value));

                oSheet = (XL._Worksheet)oWB.ActiveSheet;

                //System.Data.DataTable dtGridData=ds.Tables[0];


                int iRow = 2;

                if (dt.Rows.Count > 0)
                {


                    for (int j = 0; j < dt.Columns.Count; j++)
                    {

                        oSheet.Cells[1, j + 1] = dt.Columns[j].ColumnName;

                    }

                    // For each row, print the values of each column.

                    for (int rowNo = 0; rowNo < dt.Rows.Count; rowNo++)
                    {

                        for (int colNo = 0; colNo < dt.Columns.Count; colNo++)
                        {

                            oSheet.Cells[iRow, colNo + 1] = dt.Rows[rowNo][colNo].ToString();

                        }
                        iRow++;

                    }

                    iRow++;

                }

                oRng = oSheet.get_Range("A1", "IV1");

                oRng.EntireColumn.AutoFit();

                oXL.Visible = true;

            }

            catch (Exception theException)
            {

                throw theException;

            }
            finally
            {
                oXL = null;

                oWB = null;

                oSheet = null;

                oRng = null;
            }

        }

Import from Excel to datatable

 DataTable dtTable = new DataTable();
            DataColumn col = new DataColumn("Rfid");
            dtTable.Columns.Add(col);
            DataRow drRow;

                Microsoft.Office.Interop.Excel.Application ExcelObj =
                    new Microsoft.Office.Interop.Excel.Application();
                Microsoft.Office.Interop.Excel.Workbook theWorkbook =
                        ExcelObj.Workbooks.Open(txt_FilePath.Text, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                                                Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                                                Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
                Microsoft.Office.Interop.Excel.Sheets sheets = theWorkbook.Worksheets;
                try
                {
                    for (int sht = 1; sht <= sheets.Count; sht++)
                   {
                        Microsoft.Office.Interop.Excel.Worksheet worksheet =
                                (Microsoft.Office.Interop.Excel.Worksheet)sheets.get_Item(sht);

                        for (int i = 2; i <= worksheet.UsedRange.Rows.Count; i++)
                        {
                            Microsoft.Office.Interop.Excel.Range range = worksheet.get_Range("A" + i.ToString(), "B" + i.ToString());
                            System.Array myvalues = (System.Array)range.Cells.Value2;
                            String name = Convert.ToString(myvalues.GetValue(1, 1));
                            if (string.IsNullOrEmpty(name) == false)
                            {
                                drRow = dtTable.NewRow();
                                drRow["Rfid"] = name;
                                dtTable.Rows.Add(drRow);
                            }
                        }
                        Marshal.ReleaseComObject(worksheet);
                        worksheet = null;
                    }
                return dtTable;

            }
            catch
            {
                throw;
            }
            finally
            {
               // Marshal.ReleaseComObject(worksheet);
                Marshal.ReleaseComObject(sheets);
                Marshal.ReleaseComObject(theWorkbook);
                Marshal.ReleaseComObject(ExcelObj);
                //worksheet = null;
                sheets = null;
                theWorkbook = null;
                ExcelObj = null;
            }

To był post z naprawdę pomocną najlepszą odpowiedzią, ale okazało się, że brakowało, ponieważ nie było prostego sposobu na importowanie pliku XML z powrotem do datatable. Skończyło się na tym, że musiałem napisać swój własny i pomyślałem, że podzielę się nim tutaj, na wypadek, gdyby ktoś inny był w tej samej łodzi (google było wyjątkowo nieprzydatne w tym zakresie): {]}

public static DataTable ImportExcelXML(string Filename)
    {
        //create a new dataset to load in the XML file
        DataSet DS = new DataSet();
        //Read the XML file into the dataset
        DS.ReadXml(Filename);
        //Create a new datatable to store the raw Data
        DataTable Raw = new DataTable();
        //assign the raw data from the file to the datatable
        Raw = DS.Tables["Data"];
        //count the number of columns in the XML file
        int ColumnNumber = Raw.Columns.Count;
        //create a datatable to store formatted Import Data
        DataTable ImportData = new DataTable();
        //create a string list to store the cell data of each row
        List<string> RowData = new List<string>();
        //loop through each row in the raw data table
        for (int Counter = 0; Counter < Raw.Rows.Count; Counter++)
        {
            //if the data in the row is a colum header
            if (Counter < ColumnNumber)
            {
                //add the column name to our formatted datatable
                ImportData.Columns.Add(Raw.Rows[Counter].ItemArray.GetValue(1).ToString());
            }
            else
            {
                //if the row # (1 row = 1 cell from the excel file) from the raw datatable is divisable evenly by the number of columns in the formated import datatable AND this is not the 1st row of the raw table data after the headers
                if ((Counter % ColumnNumber == 0) && (Counter != ColumnNumber))
                {
                    //add the row we just built to the formatted import datatable
                    ImportData.Rows.Add(GenerateRow(ImportData, RowData));
                    //clear rowdata list in preperation for the next row
                    RowData.Clear();
                }
                //add the current cell data value from the raw datatable to the string list of cell values for the next row to be added to the formatted input datatable
                RowData.Add(Raw.Rows[Counter].ItemArray.GetValue(1).ToString());
            }
        }
        //add the final row
        ImportData.Rows.Add(GenerateRow(ImportData, RowData));

        return ImportData;
    }

    public static DataRow GenerateRow(DataTable ImportData, List<string> RowData)
    {
        //create a counter to keep track of the column position during row composition
        int ColumnPosition = 0;
        //make a new datarow based on the schema of the formated import datatable
        DataRow NewRow = ImportData.NewRow();
        //for each string cell value collected for the RowData list for this row
        foreach (string CellData in RowData)
        {
            //add the cell value to the new datarow
            NewRow[ImportData.Columns[ColumnPosition].ColumnName] = CellData;
            //incriment column position in the new row
            ColumnPosition++;
        }
        //return the generated row
        return NewRow;
    }

Kod ma problem z wartościami null.

 public void WriteExcelAutoStyledCell(object value)
    {
        //solve null values
        if (value is DBNull) return;

Dodałbym to do komentarzy, ale jestem nowy w stosie, więc nie mogę skomentować. Korzystanie z lc.rozwiązanie dodałem kolejną funkcję, która sprawdza znaki łańcuchów pod kątem nieprawidłowych znaków XML. Kiedy eksportowałem do Excela, czasami pojawiały się znaki, które powodowały, że eksport nie powiódł się.

Będziesz musiał zmodyfikować jedną z funkcji, która jest w kodzie lc.

public void WriteExcelAutoStyledCell(object value)
    {
        if (_writer == null) throw new InvalidOperationException("Cannot write after closing.");
        string newValue = string.Empty;

        try
        {
            //write the <ss:Cell> and <ss:Data> tags for something
            if (value is Int16 || value is Int32 || value is Int64 || value is SByte ||
                value is UInt16 || value is UInt32 || value is UInt64 || value is Byte)
            {
                WriteExcelStyledCell(value, CellStyle.Number);
            }
            else if (value is Single || value is Double || value is Decimal) //we'll assume it's a currency
            {
                WriteExcelStyledCell(value, CellStyle.Currency);
            }
            else if (value is DateTime)
            {
                //check if there's no time information and use the appropriate style
                WriteExcelStyledCell(value, ((DateTime)value).TimeOfDay.CompareTo(new TimeSpan(0, 0, 0, 0, 0)) == 0 ? CellStyle.ShortDate : CellStyle.DateTime);
            }
            else
            {
                newValue = CheckXmlCompatibleValues(value.ToString()).ToString();
                WriteExcelStyledCell(newValue, CellStyle.General);
            }
        }
        catch (Exception thisException)
        {
            throw new InvalidOperationException(thisException.Message.ToString());
        }
    }

I dodać tę funkcję do klasy 'ExcelWriter'

public string CheckXmlCompatibleValues(string value)
    {
        string newValue = string.Empty;
        bool found = false;

        foreach (char c in value)
        {
            if (XmlConvert.IsXmlChar(c))
                newValue += c.ToString();
            else
                found = true;
        }

        return newValue.ToString();
    }

Lc. Dzięki za kod!

Microsoft ma wbudowane rozwiązanie do importowania / eksportowania plików Excel. Nie jest to najprostsza biblioteka, ale ogólnie działa lepiej niż inne wymienione powyżej.

Wymagana do tego Biblioteka znajduje się w pakiecie Office i można ją znaleźć na liście zestawów frameworków w firmie Microsoft.Biuro.Interop.Excel.

Oto przykładowy kod:

using Excel = Microsoft.Office.Interop.Excel;

Excel.Application app = new Excel.Application();

//Open existing workbook
//Excel.Workbook workbook = xlApp.Workbooks.Open(fileName);

//Create new workbook
Excel.Workbook workbook = app.Workbooks.Add();

Excel.Worksheet worksheet = workbook.ActiveSheet;

worksheet.Cells[1,1] = "Hello world!"; // Indexes start at 1, because Excel
workbook.SaveAs("C:\\MyWorkbook.xlsx");
workbook.Close();
app.Quit();