Jak utworzyć plik Excel (.XLS i .XLSX) w C # bez instalowania pakietu Microsoft Office?

Jak mogę utworzyć arkusz kalkulacyjny Excel z C # bez konieczności instalowania programu Excel na komputerze, na którym działa kod?

Możesz użyć biblioteki o nazwie ExcelLibrary. Jest to darmowa biblioteka open source opublikowana w Google Code:

ExcelLibrary

Wygląda to na port programu Excel ExcelWriter, o którym wspomniałeś powyżej. Nie napisze jeszcze w nowym formacie .xlsx, ale pracują nad dodaniem tej funkcji.

Jest bardzo prosty, mały i łatwy w użyciu. Ponadto ma DataSetHelper, który pozwala używać DataSets i DataTables do łatwej pracy z danymi Excel.

Wydaje się, że ExcelLibrary nadal działa tylko dla starszego formatu Excela (pliki .xls), ale może dodawać obsługę w przyszłości dla nowszych formatów 2007/2010.

Możesz także użyć EPPlus , który działa tylko dla plików w formacie Excel 2007/2010 (pliki .xlsx). Istnieje również NPOI, które działa z oboma.

Istnieje kilka znanych błędów w każdej bibliotece, jak zauważono w komentarzach. Podsumowując, EPPlus wydaje się najlepszym wyborem w miarę upływu czasu. Wydaje się, że jest również aktywniej aktualizowany i dokumentowany.

Ponadto, jak zauważa @ АртёмЦарионов poniżej, EPPlus obsługuje tabele przestawne, a ExcelLibrary może mieć pewne wsparcie ( problem z tabelą przestawną w ExcelLibrary )

Oto kilka linków do szybkiego odniesienia:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Licencja Apache

Oto przykładowy kod dla ExcelLibrary:

Oto przykład pobierania danych z bazy danych i tworzenia z niej skoroszytu. Zauważ, że kod ExcelLibrary to pojedynczy wiersz na dole:

//Create the data set and table
DataSet ds = new DataSet("New_DataSet");
DataTable dt = new DataTable("New_DataTable");

//Set the locale for each
ds.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;
dt.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;

//Open a DB connection (in this example with OleDB)
OleDbConnection con = new OleDbConnection(dbConnectionString);
con.Open();

//Create a query and fill the data table with the data from the DB
string sql = "SELECT Whatever FROM MyDBTable;";
OleDbCommand cmd = new OleDbCommand(sql, con);
OleDbDataAdapter adptr = new OleDbDataAdapter();

adptr.SelectCommand = cmd;
adptr.Fill(dt);
con.Close();

//Add the table to the data set
ds.Tables.Add(dt);

//Here's the easy part. Create the Excel worksheet from the data set
ExcelLibrary.DataSetHelper.CreateWorkbook("MyExcelFile.xls", ds);

Utworzenie pliku Excel jest tak proste. Możesz także ręcznie tworzyć pliki Excela, ale powyższa funkcjonalność naprawdę zrobiła na mnie wrażenie.

Jeśli jesteś zadowolony z formatu xlsx, wypróbuj mój projekt GitHub, EPPlus . Zaczęło się od źródła z ExcelPackage, ale dziś jest to całkowite przepisanie. Obsługuje zakresy, stylizację komórek, wykresy, kształty, zdjęcia, nazwane zakresy, AutoFilter i wiele innych rzeczy.

A co z użyciem Open XML SDK 2.0 dla Microsoft Office?

Kilka korzyści:

• Nie wymaga zainstalowanego pakietu Office
• Wykonane przez Microsoft = przyzwoita dokumentacja MSDN
• Tylko jeden dll .Net do użycia w projekcie
• SDK zawiera wiele narzędzi, takich jak diff, walidator itp

Spinki do mankietów:

• Github
• Główne lądowanie MSDN
• Strona początkowa „How Do I ...”
• blogs.MSDN brian_jones ogłasza SDK
• blogs.MSDN brian_jones opisujący zestaw SDK do obsługi dużych plików bez awarii (w przeciwieństwie do metody DOM)

Z powodzeniem wykorzystałem następujące projekty open source:

• Pakiet Excel dla formatów OOXML (Office 2007)

• NPOI dla formatu .XLS (Office 2003). NPOI 2.0 (Beta) obsługuje również XLSX.

Zobacz moje posty na blogu:

Tworzenie arkuszy kalkulacyjnych Excel .XLS i .XLSX w C #

NPOI z tabelą Excel i dynamicznym wykresem

Możesz użyć OLEDB do tworzenia i manipulowania plikami Excel. Sprawdź to: czytanie i pisanie programu Excel za pomocą OLEDB .

Typowy przykład:

using (OleDbConnection conn = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\temp\\test.xls;Extended Properties='Excel 8.0;HDR=Yes'"))
{
  conn.Open();
  OleDbCommand cmd = new OleDbCommand("CREATE TABLE [Sheet1] ([Column1] string, [Column2] string)", conn);
  cmd.ExecuteNonQuery();
}

EDYCJA - Kilka dodatkowych linków:

• Hej, Skrypciarze! Jak czytać z Excela bez korzystania z Excela?
• Jak używać ADO.NET do pobierania i modyfikowania rekordów w skoroszycie programu Excel za pomocą Visual Basic .NET
• Czytanie i pisanie arkuszy kalkulacyjnych Excel za pomocą ADO.NET C # DbProviderFactory

Rozwiązanie komercyjne, SpreadsheetGear dla platformy .NET zrobi .

Można zobaczyć na żywo ASP.NET (C # i VB) próbek tutaj i pobrać wersję próbną tutaj .

Oświadczenie: Jestem właścicielem SpreadsheetGear LLC

Kilka opcji, z których skorzystałem:

Jeśli XLSX jest koniecznością: pakiet Excel jest dobrym początkiem, ale zmarł, gdy programista przestał nad nim pracować. ExML podniósł się stamtąd i dodał kilka funkcji. ExML nie jest złą opcją, wciąż używam go na kilku stronach produkcyjnych.

Jednak do wszystkich moich nowych projektów korzystam z NPOI , portu .NET dla Apache POI . NPOI 2.0 (Alpha) obsługuje również XLSX.

Niezwykle lekką opcją może być użycie tabel HTML. Po prostu utwórz znaczniki head, body i table w pliku i zapisz je jako plik z rozszerzeniem .xls. Istnieją specyficzne dla Microsoft atrybuty, których można użyć do stylizowania wyników, w tym formuły.

Zdaję sobie sprawę, że możesz nie kodować tego w aplikacji internetowej, ale oto przykład kompozycji pliku Excel za pomocą tabeli HTML. Tej techniki można użyć, jeśli kodujesz aplikację konsolową, aplikację komputerową lub usługę.

Jeśli tworzysz pliki programu Excel 2007/2010, wypróbuj ten projekt open source: https://github.com/closedxml/closedxml

Zapewnia obiektowy sposób manipulowania plikami (podobny do VBA) bez radzenia sobie z kłopotami związanymi z dokumentami XML. Może być używany w dowolnym języku .NET, takim jak C # i Visual Basic (VB).

ClosedXML pozwala tworzyć pliki Excel 2007/2010 bez aplikacji Excel. Typowym przykładem jest tworzenie raportów Excel na serwerze WWW:

var workbook = new XLWorkbook();
var worksheet = workbook.Worksheets.Add("Sample Sheet");
worksheet.Cell("A1").Value = "Hello World!";
workbook.SaveAs("HelloWorld.xlsx");

Możesz użyć ExcelXmlWriter .

To działa dobrze.

W rzeczywistości możesz chcieć sprawdzić klasy interop dostępne w C # (np Microsoft.Office.Interop.Excel. Mówisz, że nie ma OLE (co nie jest), ale klasy interop są bardzo łatwe w użyciu. Sprawdź dokumentację C # tutaj (Interop dla programu Excel zaczyna się od strona 1072 C # PDF).

Możesz być pod wrażeniem, jeśli ich nie wypróbowałeś.

Ostrzegamy przed stanowiskiem Microsoftu w tej sprawie:

Firma Microsoft obecnie nie zaleca i nie obsługuje automatyzacji aplikacji pakietu Microsoft Office z dowolnej nienadzorowanej, nieinteraktywnej aplikacji lub komponentu klienta (w tym usług ASP, ASP.NET, DCOM i NT), ponieważ pakiet Office może wykazywać niestabilne zachowanie i / lub zakleszczenie, gdy pakiet Office jest uruchomiony w tym środowisku.

Oto całkowicie darmowa biblioteka C #, która pozwala eksportować z DataSet, DataTablelubList<> do prawdziwego Excel 2007 .xlsx, przy użyciu biblioteki OpenXML:

http://mikesknowledgebase.com/pages/CSharp/ExportToExcel.htm

Pełny kod źródłowy jest dostarczany - bezpłatnie - wraz z instrukcjami i aplikacją demonstracyjną.

Po dodaniu tej klasy do aplikacji możesz wyeksportować swój DataSet do Excela w jednym wierszu kodu:

CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");

Nie ma nic prostszego ...

I nawet nie wymaga obecności Excela na twoim serwerze.

Możesz rozważyć utworzenie swoich plików w formacie XML Spreadsheet 2003 . Jest to prosty format XML wykorzystujący dobrze udokumentowany schemat .

Możesz rzucić okiem na GemBox.Spreadsheet .

Mają darmową wersję ze wszystkimi funkcjami, ale ograniczoną do 150 wierszy na arkusz i 5 arkuszy na skoroszyt, jeśli to odpowiada Twoim potrzebom.

Nie musiałem go jeszcze używać, ale wygląda interesująco.

Syncfusion Essential XlsIO może to zrobić. Nie ma zależności od pakietu Microsoft Office, a także obsługuje określone platformy.

• ASP.NET
• ASP.NET MVC
• UWP
• Xamarin
• Formularze WPF i Windows
• Usługa Windows i operacje wsadowe

Przykładowy kod:

//Creates a new instance for ExcelEngine.
ExcelEngine excelEngine = new ExcelEngine();
//Loads or open an existing workbook through Open method of IWorkbooks
IWorkbook workbook = excelEngine.Excel.Workbooks.Open(fileName);
//To-Do some manipulation|
//To-Do some manipulation
//Set the version of the workbook.
workbook.Version = ExcelVersion.Excel2013;
//Save the workbook in file system as xlsx format
workbook.SaveAs(outputFileName);

Cały pakiet kontroli jest dostępny bezpłatnie w ramach programu licencji społecznościowej , jeśli się kwalifikujesz (dochód poniżej 1 miliona USD). Uwaga: Pracuję dla Syncfusion.

Dobrze,

możesz także użyć biblioteki innej firmy, takiej jak Aspose .

Ta biblioteka ma tę zaletę, że nie wymaga instalacji programu Excel na komputerze, co byłoby idealne w twoim przypadku.

OpenXML jest również dobrą alternatywą, która pomaga uniknąć instalowania MS Excel na serwerze. Open XML SDK 2.0 dostarczony przez Microsoft upraszcza zadanie manipulowania pakietami Open XML i elementami schematu Open XML w pakiecie. Interfejs programowania aplikacji Open API (API) zawiera wiele typowych zadań, które programiści wykonują na pakietach Open XML.

Sprawdź to OpenXML: Alternatywa, która pomaga uniknąć instalowania MS Excel na serwerze

Różne biblioteki XML pakietu Office 2003 działają całkiem dobrze w przypadku mniejszych plików programu Excel. Jednak uważam, że sama wielkość dużego skoroszytu zapisanego w formacie XML jest problemem. Na przykład skoroszyt, z którym pracuję, miałby 40 MB w nowym (i, co prawda bardziej ciasno spakowanym) formacie XLSX, staje się plikiem XML 360 MB.

O ile moje badania mnie zaprowadziły, istnieją dwa komercyjne pakiety, które umożliwiają wyjście do starszych formatów plików binarnych. Oni są:

• Gembox
• ComponentOne Excel

Żadne z nich nie jest tanie (myślę, że odpowiednio 500 USD i 800 USD). ale oba działają niezależnie od samego Excela.

Byłbym ciekawy modułu wyjściowego Excela, takiego jak OpenOffice.org. Zastanawiam się, czy można je przenieść z Javy do .Net.

Zgadzam się na generowanie arkuszy kalkulacyjnych XML, oto przykład, jak to zrobić dla C # 3 (wszyscy po prostu blogują o tym w VB 9: P) http://www.aaron-powell.com/linq-to-xml-to- przewyższać

Niedawno korzystałem z FlexCel.NET i okazało się, że jest to doskonała biblioteka! Nie mówię tego o zbyt wielu produktach. Nie ma sensu podawać tutaj całej oferty sprzedaży, możesz przeczytać wszystkie funkcje na ich stronie internetowej.

Jest to produkt komercyjny, ale jeśli kupisz, otrzymasz pełne źródło. Więc przypuszczam, że mógłbyś go skompilować w swoim zespole, gdybyś naprawdę chciał. W przeciwnym razie jest to tylko jeden dodatkowy zestaw do xcopy - bez konfiguracji lub instalacji lub coś podobnego.

Nie sądzę, że znajdziesz sposób, aby to zrobić bez bibliotek stron trzecich, ponieważ .NET Framework, oczywiście, nie ma wbudowanej obsługi tego, a OLE Automation to po prostu cały świat bólu.

Napisałem prosty kod do eksportowania zestawu danych do programu Excel bez użycia obiektu programu Excel przy użyciu System.IO.StreamWriter.

Poniżej znajduje się kod, który odczyta wszystkie tabele z zestawu danych i zapisze je kolejno w arkuszach. Wziąłem pomoc z tego artykułu .

public static void exportToExcel(DataSet source, string fileName)
{
        const string endExcelXML = "</Workbook>";
        const string startExcelXML = "<xml version>\r\n<Workbook " +
                 "xmlns=\"urn:schemas-microsoft-com:office:spreadsheet\"\r\n" +
                 " xmlns:o=\"urn:schemas-microsoft-com:office:office\"\r\n " +
                 "xmlns:x=\"urn:schemas-    microsoft-com:office:" +
                 "excel\"\r\n xmlns:ss=\"urn:schemas-microsoft-com:" +
                 "office:spreadsheet\">\r\n <Styles>\r\n " +
                 "<Style ss:ID=\"Default\" ss:Name=\"Normal\">\r\n " +
                 "<Alignment ss:Vertical=\"Bottom\"/>\r\n <Borders/>" +
                 "\r\n <Font/>\r\n <Interior/>\r\n <NumberFormat/>" +
                 "\r\n <Protection/>\r\n </Style>\r\n " +
                 "<Style ss:ID=\"BoldColumn\">\r\n <Font " +
                 "x:Family=\"Swiss\" ss:Bold=\"1\"/>\r\n </Style>\r\n " +
                 "<Style     ss:ID=\"StringLiteral\">\r\n <NumberFormat" +
                 " ss:Format=\"@\"/>\r\n </Style>\r\n <Style " +
                 "ss:ID=\"Decimal\">\r\n <NumberFormat " +
                 "ss:Format=\"0.0000\"/>\r\n </Style>\r\n " +
                 "<Style ss:ID=\"Integer\">\r\n <NumberFormat " +
                 "ss:Format=\"0\"/>\r\n </Style>\r\n <Style " +
                 "ss:ID=\"DateLiteral\">\r\n <NumberFormat " +
                 "ss:Format=\"mm/dd/yyyy;@\"/>\r\n </Style>\r\n " +
                 "</Styles>\r\n ";
        System.IO.StreamWriter excelDoc = null;
        excelDoc = new System.IO.StreamWriter(fileName);

        int sheetCount = 1;
        excelDoc.Write(startExcelXML);
        foreach (DataTable table in source.Tables)
        {
            int rowCount = 0;
            excelDoc.Write("<Worksheet ss:Name=\"" + table.TableName + "\">");
            excelDoc.Write("<Table>");
            excelDoc.Write("<Row>");
            for (int x = 0; x < table.Columns.Count; x++)
            {
                excelDoc.Write("<Cell ss:StyleID=\"BoldColumn\"><Data ss:Type=\"String\">");
                excelDoc.Write(table.Columns[x].ColumnName);
                excelDoc.Write("</Data></Cell>");
            }
            excelDoc.Write("</Row>");
            foreach (DataRow x in table.Rows)
            {
                rowCount++;
                //if the number of rows is > 64000 create a new page to continue output
                if (rowCount == 64000)
                {
                    rowCount = 0;
                    sheetCount++;
                    excelDoc.Write("</Table>");
                    excelDoc.Write(" </Worksheet>");
                    excelDoc.Write("<Worksheet ss:Name=\"" + table.TableName + "\">");
                    excelDoc.Write("<Table>");
                }
                excelDoc.Write("<Row>"); //ID=" + rowCount + "
                for (int y = 0; y < table.Columns.Count; y++)
                {
                    System.Type rowType;
                    rowType = x[y].GetType();
                    switch (rowType.ToString())
                    {
                        case "System.String":
                            string XMLstring = x[y].ToString();
                            XMLstring = XMLstring.Trim();
                            XMLstring = XMLstring.Replace("&", "&");
                            XMLstring = XMLstring.Replace(">", ">");
                            XMLstring = XMLstring.Replace("<", "<");
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                           "<Data ss:Type=\"String\">");
                            excelDoc.Write(XMLstring);
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.DateTime":
                            //Excel has a specific Date Format of YYYY-MM-DD followed by  
                            //the letter 'T' then hh:mm:sss.lll Example 2005-01-31T24:01:21.000
                            //The Following Code puts the date stored in XMLDate 
                            //to the format above
                            DateTime XMLDate = (DateTime)x[y];
                            string XMLDatetoString = ""; //Excel Converted Date
                            XMLDatetoString = XMLDate.Year.ToString() +
                                 "-" +
                                 (XMLDate.Month < 10 ? "0" +
                                 XMLDate.Month.ToString() : XMLDate.Month.ToString()) +
                                 "-" +
                                 (XMLDate.Day < 10 ? "0" +
                                 XMLDate.Day.ToString() : XMLDate.Day.ToString()) +
                                 "T" +
                                 (XMLDate.Hour < 10 ? "0" +
                                 XMLDate.Hour.ToString() : XMLDate.Hour.ToString()) +
                                 ":" +
                                 (XMLDate.Minute < 10 ? "0" +
                                 XMLDate.Minute.ToString() : XMLDate.Minute.ToString()) +
                                 ":" +
                                 (XMLDate.Second < 10 ? "0" +
                                 XMLDate.Second.ToString() : XMLDate.Second.ToString()) +
                                 ".000";
                            excelDoc.Write("<Cell ss:StyleID=\"DateLiteral\">" +
                                         "<Data ss:Type=\"DateTime\">");
                            excelDoc.Write(XMLDatetoString);
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Boolean":
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                        "<Data ss:Type=\"String\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Int16":
                        case "System.Int32":
                        case "System.Int64":
                        case "System.Byte":
                            excelDoc.Write("<Cell ss:StyleID=\"Integer\">" +
                                    "<Data ss:Type=\"Number\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.Decimal":
                        case "System.Double":
                            excelDoc.Write("<Cell ss:StyleID=\"Decimal\">" +
                                  "<Data ss:Type=\"Number\">");
                            excelDoc.Write(x[y].ToString());
                            excelDoc.Write("</Data></Cell>");
                            break;
                        case "System.DBNull":
                            excelDoc.Write("<Cell ss:StyleID=\"StringLiteral\">" +
                                  "<Data ss:Type=\"String\">");
                            excelDoc.Write("");
                            excelDoc.Write("</Data></Cell>");
                            break;
                        default:
                            throw (new Exception(rowType.ToString() + " not handled."));
                    }
                }
                excelDoc.Write("</Row>");
            }
            excelDoc.Write("</Table>");
            excelDoc.Write(" </Worksheet>");
            sheetCount++;
        }


        excelDoc.Write(endExcelXML);
        excelDoc.Close();
    }

Po prostu chcę dodać kolejne odniesienie do rozwiązania innej firmy, które bezpośrednio rozwiązuje problem: http://www.officewriter.com

(Uwaga: Pracuję dla SoftArtisans, firmy produkującej OfficeWriter)

IKVM + POI

Lub możesz użyć Interop ...

Oto sposób, aby to zrobić za pomocą LINQ to XML, wraz z przykładowym kodem:

Szybko importuj i eksportuj dane Excel za pomocą LINQ do XML

Jest to trochę skomplikowane, ponieważ musisz zaimportować przestrzenie nazw i tak dalej, ale pozwala uniknąć zewnętrznych zależności.

(Oczywiście jest to również VB .NET, nie C #, ale zawsze możesz wyizolować VB .NET w swoim własnym projekcie, aby używać literałów XML i robić wszystko inne w C #.)

Niektórzy zewnętrzni dostawcy komponentów, tacy jak Infragistics lub Syncfusion, zapewniają bardzo dobre możliwości eksportu do Excela, które nie wymagają instalacji Microsoft Excel.

Ponieważ ci dostawcy zapewniają również zaawansowane komponenty interfejsu użytkownika, komponenty te są szczególnie przydatne, jeśli chcesz, aby styl i układ eksportu programu Excel naśladował bieżący stan siatki w interfejsie użytkownika aplikacji.

Jeśli twój eksport ma być wykonywany po stronie serwera z naciskiem na dane, które mają być eksportowane i bez łącza do interfejsu użytkownika, wybrałbym jedną z bezpłatnych opcji open source (np. ExcelLibrary).

Wcześniej byłem zaangażowany w projekty, które próbowały wykorzystać automatyzację po stronie serwera w pakiecie Microsoft Office. Na podstawie tego doświadczenia zdecydowanie odradzam takie podejście.

public class GridViewExportUtil
{
    public static void Export(string fileName, GridView gv)
    {
        HttpContext.Current.Response.Clear();
        HttpContext.Current.Response.AddHeader(
            "content-disposition", string.Format("attachment; filename={0}", fileName));
        HttpContext.Current.Response.ContentType = "application/ms-excel";

        using (StringWriter sw = new StringWriter())
        {
            using (HtmlTextWriter htw = new HtmlTextWriter(sw))
            {
                //  Create a form to contain the grid
                Table table = new Table();

                //  add the header row to the table
                if (gv.HeaderRow != null)
                {
                    GridViewExportUtil.PrepareControlForExport(gv.HeaderRow);
                    table.Rows.Add(gv.HeaderRow);
                }

                //  add each of the data rows to the table
                foreach (GridViewRow row in gv.Rows)
                {
                    GridViewExportUtil.PrepareControlForExport(row);
                    table.Rows.Add(row);
                }

                //  add the footer row to the table
                if (gv.FooterRow != null)
                {
                    GridViewExportUtil.PrepareControlForExport(gv.FooterRow);
                    table.Rows.Add(gv.FooterRow);
                }

                //  render the table into the htmlwriter
                table.RenderControl(htw);

                //  render the htmlwriter into the response
                HttpContext.Current.Response.Write(sw.ToString());
                HttpContext.Current.Response.End();
            }
        }
    }

    /// <summary>
    /// Replace any of the contained controls with literals
    /// </summary>
    /// <param name="control"></param>
    private static void PrepareControlForExport(Control control)
    {
        for (int i = 0; i < control.Controls.Count; i++)
        {
            Control current = control.Controls[i];
            if (current is LinkButton)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as LinkButton).Text));
            }
            else if (current is ImageButton)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as ImageButton).AlternateText));
            }
            else if (current is HyperLink)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as HyperLink).Text));
            }
            else if (current is DropDownList)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as DropDownList).SelectedItem.Text));
            }
            else if (current is CheckBox)
            {
                control.Controls.Remove(current);
                control.Controls.AddAt(i, new LiteralControl((current as CheckBox).Checked ? "True" : "False"));
            }

            if (current.HasControls())
            {
                GridViewExportUtil.PrepareControlForExport(current);
            }
        }
    }
}

Cześć, tym rozwiązaniem jest wyeksportowanie widoku siatki do pliku programu Excel, który może ci pomóc

Korzystając z tej biblioteki, możesz tworzyć ładnie sformatowane pliki Excela: http://officehelper.codeplex.com/documentation
Zobacz poniższy przykład:

using (ExcelHelper helper = new ExcelHelper(TEMPLATE_FILE_NAME, GENERATED_FILE_NAME))
{
    helper.Direction = ExcelHelper.DirectionType.TOP_TO_DOWN;
    helper.CurrentSheetName = "Sheet1";
    helper.CurrentPosition = new CellRef("C3");

    //the template xlsx should contains the named range "header"; use the command "insert"/"name".
    helper.InsertRange("header");

    //the template xlsx should contains the named range "sample1";
    //inside this range you should have cells with these values:
    //<name> , <value> and <comment>, which will be replaced by the values from the getSample()
    CellRangeTemplate sample1 = helper.CreateCellRangeTemplate("sample1", new List<string> {"name", "value", "comment"}); 
    helper.InsertRange(sample1, getSample());

    //you could use here other named ranges to insert new cells and call InsertRange as many times you want, 
    //it will be copied one after another;
    //even you can change direction or the current cell/sheet before you insert

    //typically you put all your "template ranges" (the names) on the same sheet and then you just delete it
    helper.DeleteSheet("Sheet3");
}        

gdzie próbka wygląda następująco:

private IEnumerable<List<object>> getSample()
{
    var random = new Random();

    for (int loop = 0; loop < 3000; loop++)
    {
        yield return new List<object> {"test", DateTime.Now.AddDays(random.NextDouble()*100 - 50), loop};
    }
}

Najprostszym i najszybszym sposobem utworzenia pliku Excel z C # jest użycie narzędzia Open XML Productivity Tool. Narzędzie Open XML Productivity Tool jest dostarczane z instalacją Open XML SDK. Narzędzie to przekształca dowolny plik Excela w kod C #. Kod C # można następnie wykorzystać do ponownego wygenerowania tego pliku.

Przegląd tego procesu jest następujący:

1. Zainstaluj Open XML SDK za pomocą narzędzia.
2. Utwórz plik Excel za pomocą najnowszego klienta Excel o pożądanym wyglądzie. Nazwij to DesiredLook.xlsx.
3. Przy otwartym narzędziu DesiredLook.xlsxkliknij przycisk Odbij kod u góry.
4. Kod C # dla twojego pliku zostanie wygenerowany w prawym panelu narzędzia. Dodaj to do swojego rozwiązania C # i wygeneruj pliki o pożądanym wyglądzie.

Jako bonus, ta metoda działa dla wszystkich plików Word i PowerPoint. Jako programista C # wprowadzisz zmiany w kodzie, aby dostosować je do swoich potrzeb.

Opracowałem prostą aplikację WPF na github, która w tym celu będzie działać w systemie Windows. Istnieje klasa zastępcza o nazwie, w GeneratedClassktórej można wkleić wygenerowany kod. Jeśli cofniesz jedną wersję pliku, wygeneruje on plik Excel taki jak ten:

Kilka przydatnych automatyzacji programu Excel w języku C # można znaleźć pod następującym linkiem.

http://csharp.net-informations.com/excel/csharp-excel-tutorial.htm

bolton.

Zobacz przykłady tworzenia plików Excel.

Istnieją przykłady w C # i VB.NET

Zarządza plikami XSL XSLX i CSV Excel.

http://www.devtriogroup.com/ExcelJetcell/Samples