¿Cómo creo un archivo de Excel (.XLS y .XLSX) en C # sin instalar Microsoft Office?

¿Cómo puedo crear una hoja de cálculo de Excel con C # sin necesidad de instalar Excel en la máquina que ejecuta el código?

preguntado el 29 de septiembre de 08 a las 20:09

@Mike La pieza "sin necesidad de instalar Excel" no tiene nada que ver con ser profesional. Se trata de dependencias. El texto original de la pregunta estaba redactado como sigue: "Idealmente, me gustaría el código abierto para no tener que agregar dependencias de terceros a mi código, y me gustaría evitar usar Excel directamente para crear el archivo (usando Automatización OLE)". Es lamentable que la pregunta se haya simplificado drásticamente. -

Suponiendo que intentaba hacer algo sin biblioteca o código externo, no puedo hablar por el archivo xls, pero para los archivos xlsx, ¿por qué no empezar por tomar uno existente, renombrarlo a un archivo zip y explorar el contenido? Un poco de ingeniería inversa te dirá bastante. Hay varios archivos xml y rels diferentes en las distintas carpetas y subcarpetas. Intente explorar eso y vea si es algo que pueda replicar o vea si puede encontrar documentación sobre los diversos espacios de nombres / esquemas xml. -

30 Respuestas

Puede utilizar una biblioteca llamada ExcelLibrary. Es una biblioteca gratuita de código abierto publicada en Google Code:

ExcelLibrary

Este parece ser un puerto del PHP ExcelWriter que mencionaste anteriormente. Todavía no escribirá en el nuevo formato .xlsx, pero están trabajando para agregar esa funcionalidad en.

Es muy simple, pequeño y fácil de usar. Además, tiene un DataSetHelper que le permite usar DataSets y DataTables para trabajar fácilmente con datos de Excel.

ExcelLibrary parece seguir funcionando solo para el formato de Excel anterior (archivos .xls), pero es posible que en el futuro agregue compatibilidad con los formatos más nuevos de 2007/2010.

También puedes usar EP Plus, que funciona solo para archivos de formato Excel 2007/2010 (archivos .xlsx). También hay NPOI que funciona con ambos.

Hay algunos errores conocidos con cada biblioteca, como se indica en los comentarios. En general, EPPlus parece ser la mejor opción a medida que pasa el tiempo. También parece estar actualizado y documentado de manera más activa.

Además, como señala @ АртёмЦарионов a continuación, EPPlus tiene soporte para tablas dinámicas y ExcelLibrary puede tener algún soporte (Problema de tabla dinámica en ExcelLibrary)

Aquí hay un par de enlaces para referencia rápida:
ExcelLibrary - GNU menor GPL
EP Plus - GNU (LGPL): ya no se mantiene
EP Plus 5 - Polyform Noncommercial - A partir de mayo de 2020
NPOI - Licencia Apache

Aquí un código de ejemplo para ExcelLibrary:

Aquí hay un ejemplo que toma datos de una base de datos y crea un libro de trabajo a partir de ella. Tenga en cuenta que el código de ExcelLibrary es la única línea en la parte inferior:

//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);

Crear el archivo de Excel es tan fácil como eso. También puede crear archivos de Excel manualmente, pero la funcionalidad anterior es lo que realmente me impresionó.

Respondido el 18 de junio de 20 a las 18:06

ExcelLibrary ha sido reemplazada por el excepcional EPPlus - epplus.codeplex.com. Jan lo actualiza con regularidad. Lo he estado usando y es uno de los mejores proyectos de código abierto con los que hemos trabajado. - Mark A

Cabe señalar que ExcelLibrary tiene muchos problemas de rendimiento cuando se trata de conjuntos de datos grandes (más de 5000 filas con muchas columnas). Actualmente estamos haciendo una gran modificación del código base en el trabajo para que podamos usarlo en un proyecto. - rossis muerto

EPPlus parece mucho menos defectuoso que ExcelLibrary, PERO es GPL y, por lo tanto, solo es una solución para proyectos de código abierto. - Seth

Qué pasa XML cerrado? Puedo resultarle útil en sus proyectos. - amadeo sánchez

Si está satisfecho con el formato xlsx, pruebe mi proyecto GitHub, EP Plus. Comenzó con la fuente de ExcelPackage, pero hoy es una reescritura total. Admite rangos, estilo de celda, gráficos, formas, imágenes, rangos con nombre, autofiltro y muchas otras cosas.

Respondido el 23 de junio de 19 a las 21:06

La licencia ahora es LGPL, notas de la versión aquí: epplus.codeplex.com/releases/view/79802 - Simón D

Los ejemplos fueron útiles. Pude cambiar mi código de usar la biblioteca de interoperabilidad de Microsoft (horriblemente lento) a esta biblioteca (versión 4.x) en un par de horas. Mi punto de referencia escribe un archivo con dos pestañas y aproximadamente 750,000 celdas. Usando la interoperabilidad de MS, tomó 13 minutos. El uso de EPPlus tomó 10 segundos, una aceleración de aproximadamente 80 veces. ¡Muy feliz! - Pablo Chernoch

Para mayor claridad en este hilo, la LGPL permite que el software se vincule sin que ocurra la parte infecciosa de la GPL. Solo necesita abrir los cambios de código fuente que realiza en ClosedXml o si coloca directamente el código fuente (en lugar de hacer referencia a los ensamblados de ClosedXml) dentro de su aplicación, entonces necesita abrir el código fuente de su aplicación. - Chris Marisic

@Paul Chernoch: Completamos hojas grandes de Excel con interoperabilidad muy rápidamente. El secreto es hacer una actualización masiva. Cree un bloque de objeto [,], rellénelo, luego escriba esa matriz en Excel de una vez: excelWorksheet.get_Range (rango) .Value2 = block; - marc meketon

Parece que la licencia se está moviendo de LGPL a la licencia Polyform Noncommercial 1.0.0 - Luke

¿Y qué hay del uso de Open XML SDK 2.0 para Microsoft Office?

Algunos beneficios:

  • No requiere Office instalado
  • Hecho por Microsoft = documentación decente de MSDN
  • Solo un .Net dll para usar en el proyecto
  • SDK viene con muchas herramientas como diff, validator, etc.

enlaces:

Respondido el 25 de Septiembre de 19 a las 18:09

Es importante tener en cuenta que la DLL para esto es un poco más de 5 MB y está limitada a los formatos de Office 2007. Pero ciertamente la solución más fácil y rápida que funciona para mí. - Josh Brown

Solo un aviso de que la v2.5 está disponible y se puede descargar aquí. - Snuffleupagus

El SDK modela el XML en clases, de modo que cada etiqueta XML se asigna a una etiqueta, y luego tienes que construir la jerarquía de clases (cada instancia tiene una colección de instancias / etiquetas secundarias) correctamente. Esto significa que debe conocer la estructura XML de un archivo de Excel, lo cual es muy complicado. Es mucho más fácil usar un contenedor como EPPlus, mencionado anteriormente, que simplifica las cosas. - Tsahi Asher

Puede encontrar una gran muestra de Microsoft Open XML SDK - Open XML Writer en polymathprogrammer.com/2012/08/06/… O vea la solución Stack Overflow stackoverflow.com/questions/11370672/… - Greg

Encontré que el Open XML Writer de Microsoft Open XML SDK es excelente. Usando las soluciones anteriores, (especialmente la muestra de Vincent Tom (Poly Math)), es fácil construir un escritor que transmita grandes conjuntos de datos y escriba registros de una manera similar y no mucho más compleja a lo que haría para CSV; pero que en cambio estás escribiendo xml. Open XML es la mentalidad en la que Microsoft considera sus nuevos formatos de Office. Y siempre puede cambiarles el nombre de archivos .xslx a archivos .zip si tiene ganas de hurgar en su contenido XML. - Greg

He utilizado con éxito los siguientes proyectos de código abierto:

  • ExcelPackage para formatos OOXML (Office 2007)

  • NPOI para formato .XLS (Office 2003). NPOI 2.0 (Beta) también es compatible con XLSX.

Eche un vistazo a las publicaciones de mi blog:

Creación de hojas de cálculo de Excel .XLS y .XLSX en C #

NPOI con tabla de Excel y gráfico dinámico

Respondido 07 Feb 19, 14:02

Una nota sobre NPOI: las referencias de filas y columnas se basan en cero. Funciona bien para completar una plantilla existente. - John M

Puede utilizar OLEDB para crear y manipular archivos de Excel. Mira esto: Leer y escribir Excel usando OLEDB.

Ejemplo típico:

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();
}

EDITAR - Algunos enlaces más:

Respondido 18 Jul 18, 06:07

¿Alguien puede confirmar si esto funciona cuando se ejecuta en x64? Estoy bastante seguro de que Jet solo funciona si su aplicación está compilada o ejecutándose en modo de 32 bits. - Lamar

Acabo de probar esta conexión y falló en un Windows Server 2008 R2 x64 RC, parece que hay que instalar 2007 Office System Driver: Componentes de conectividad de datos [microsoft.com/downloads/… - Chris Richner

Tenga mucho cuidado con esto, es un grupo muy feo (por ejemplo, a veces adivina un tipo de columna y descarta todos los datos que no encajan). - dbkk

Hay que tener mucho cuidado si se utiliza este método. Lo encontré muy inestable para los datos que no están en un formato perfecto. - kenny mann

Como persona que tuvo que usar OleDb en un gran proyecto, digo ¡MANTÉNGASE LEJOS DE ÉL! A veces, no puede recuperar un valor de celda solo porque no pudo entender el formato. No tiene una operación de eliminación. Funciona de forma totalmente diferente e impredecible incluso con el más mínimo cambio de proveedor. Yo diría que opte por una solución comercial probada. - ornitorrinco

La solución comercial, SpreadsheetGear para .NET .

Puede ver ejemplos de ASP.NET (C # y VB) en vivo aquí y descargue una versión de evaluación aquí.

Descargo de responsabilidad: soy propietario de SpreadsheetGear LLC

Respondido 18 Jul 18, 07:07

Tiene un gran producto, pero creo que mucha gente aquí espera soluciones gratuitas. Eso podría explicar los votos negativos. - md1337

Algunas opciones que he usado:

Si XLSX es imprescindible: Paquete de Excel es un buen comienzo, pero se apagó cuando el desarrollador dejó de trabajar en él. ExML tomó de ahí y agregó algunas características. ExML no es una mala opción, todavía lo estoy usando en un par de sitios web de producción.

Sin embargo, para todos mis nuevos proyectos, estoy usando NPOI, el puerto .NET de PDI de Apache. NPOI 2.0 (Alfa) también es compatible con XLSX.

Respondido 18 Jul 18, 07:07

Tenga cuidado con ExcelPackage si necesita admitir XLS. Lo pasé mal y finalmente me cambié a ExcelLibrary. - Jeremy

Definitivamente cierto. ExcelPackage / ExML es solo una buena opción si necesita el soporte XLSX. - Nate

Tenga en cuenta que ExcelPackage tiene un sucesor: EPPlus (epplus.codeplex.com) que admite XLSX. Mi única preocupación, en comparación con el NPOI, por ejemplo, es el rendimiento, por ejemplo, cuando hay muchas columnas. - Pragmateek

Una opción extremadamente ligera puede ser utilizar tablas HTML. Simplemente cree etiquetas de encabezado, cuerpo y tabla en un archivo y guárdelo como un archivo con una extensión .xls. Hay atributos específicos de Microsoft que puede usar para diseñar el resultado, incluidas las fórmulas.

Me doy cuenta de que es posible que no esté codificando esto en una aplicación web, pero aquí hay una ejemplo de la composición de un archivo de Excel a través de una tabla HTML. Esta técnica podría usarse si estuviera codificando una aplicación de consola, una aplicación de escritorio o un servicio.

respondido 13 nov., 19:17

Es tan ad hoc pero funciona (sin mencionar que Excel emite una advertencia al abrir) y es tan simple que merece tener un lugar como solución. Aunque solo para mostrar que puede exportar un archivo de Excel :)) - Luka Ramishvili

Esta solución funcionó bien para mí, solo tenga en cuenta que no puede usar la extensión .xlsx - Jill

Algunas personas de mi organización no pueden abrir archivos de Excel creados de esta manera en Office 2010 y versiones posteriores. No sé cuál es el problema, pero tuve que lanzar mi propia implementación de OpenXML. (ver la respuesta de Sogger) - kristen hamaca

Si está creando archivos de Excel 2007/2010, pruebe este proyecto de código abierto: https://github.com/closedxml/closedxml

Proporciona una forma orientada a objetos para manipular los archivos (similar a VBA) sin lidiar con las molestias de los documentos XML. Puede ser utilizado por cualquier lenguaje .NET como C # y Visual Basic (VB).

ClosedXML le permite crear archivos de Excel 2007/2010 sin la aplicación de Excel. El ejemplo típico es la creación de informes de Excel en un servidor web:

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

Respondido 18 Jul 18, 07:07

Intenté usar esto en un proyecto que crea hojas de Excel bastante grandes. Excelente biblioteca, pero extremadamente pobre en rendimiento. Acabo de hacer una comparación para el proyecto en el que estoy trabajando: ClosedXML (v 0.53.3) tomó 92,489 ms, mientras que EPPlus (v 2.9.03, para pruebas, no podemos usar porque es GPL) tomó 16,500 ms. - Druida

@Druid, la licencia es LGPL, asumiendo que no modifica el código fuente a ClosedXML, es de uso gratuito epplus.codeplex.com/license - Chris Marisic

Puede usar el ExcelXmlWriterExcelXmlWriter.

Funciona bien.

Respondido 18 Jul 18, 07:07

En realidad, es posible que desee consultar las clases de interoperabilidad disponibles en C # (por ejemplo, Microsoft.Office.Interop.Excel. Dice que no OLE (que no lo es), pero las clases de interoperabilidad son muy fáciles de usar. Revisar la Documentación de C # aquí (Interop para Excel comienza en la página 1072 del PDF de C #).

Es posible que se sienta impresionado si no los ha probado.

Tenga en cuenta las postura en este:

Actualmente, Microsoft no recomienda ni admite la automatización de aplicaciones de Microsoft Office desde ninguna aplicación o componente cliente desatendido y no interactivo (incluidos ASP, ASP.NET, DCOM y NT Services), porque Office puede presentar un comportamiento inestable y / o interbloqueo cuando Office se ejecuta en este entorno.

respondido 19 nov., 19:14

Pero debe asegurarse de deshacerse de todo manualmente, de lo contrario, perderá memoria. MagicKat

@Ricky B: Además, en mi experiencia con la interoperabilidad es que usa Excel. Cada vez que lo usamos, si Excel no está instalado en la máquina, obtendríamos excepciones COM. - MagicKat

Con el OLE, incluso con una eliminación muy cuidadosa, eventualmente pierde memoria o falla. Se puede argumentar que esto está bien para aplicaciones / estaciones de trabajo atendidas, pero no se recomienda para servidores (MS tiene una KB que lo indica). Para nuestro servidor, simplemente lo reiniciamos todas las noches. Una vez más, eso funciona bien. - Jennifer Zuak

@Geoffrey: ah OK, me vas a hacer trabajar para ello :) -> support.microsoft.com/kb/257757 Microsoft no recomienda actualmente ni admite la automatización de aplicaciones de Microsoft Office desde ninguna aplicación cliente desatendida y no interactiva ... Jennifer Zuak

Llego a esta discusión después de luchar más de una semana con la interoperabilidad y, a menos que sus necesidades sean muy simples, esto no funcionará. El soporte para formatear su hoja de cálculo es abismal, lo que posiblemente sea la razón para generar un archivo .xls y no solo un archivo .csv plano. Por ejemplo, ¿ha intentado generar más de 911 caracteres en una celda o ha intentado establecer el ancho de las celdas combinadas de manera coherente? Lo hice, y no puedo decirte cuánto odio esta basura ahora ... Hazte un favor y ve con una de las bibliotecas gratuitas mencionadas en esta discusión. - md1337

Aquí hay una biblioteca C # completamente gratuita, que le permite exportar desde una DataSet, DataTable or List<> en un archivo .xlsx genuino de Excel 2007, utilizando las bibliotecas OpenXML:

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

Se proporciona el código fuente completo, sin cargo, junto con instrucciones y una aplicación de demostración.

Después de agregar esta clase a su aplicación, puede exportar su DataSet a Excel en solo una línea de código:

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

No hay nada más simple que eso ...

Y ni siquiera requiere que Excel esté presente en su servidor.

Respondido 09 Jul 16, 18:07

Esto parece un poco engañoso, ya que solicita una donación para obtener todas las funciones. - UrbanEsc

Eso es parcialmente cierto: la versión completamente gratuita generará un archivo .xlsx perfecto para usted, y se proporcionará todo el código fuente. Si dona $ 10 o más a una de esas dos organizaciones benéficas (de las cuales no recibo absolutamente nada), obtendrá una versión "mejor" que muestra cómo dar formato, fechas, etc. Dado el costo de los productos de terceros, creo ¡Vale la pena donar $ 10 a una buena causa! - Mike Gledhill

Podría considerar crear sus archivos usando el Hoja de cálculo XML 2003 formato. Este es un formato XML simple que usa un esquema bien documentado.

Respondido 18 Jul 18, 07:07

Es posible que desee echar un vistazo a GemBox.Hoja de cálculo.

Tienen una versión gratuita con todas las funciones, pero limitada a 150 filas por hoja y 5 hojas por libro de trabajo, si eso se ajusta a sus necesidades.

Todavía no he tenido la necesidad de usarlo, pero parece interesante.

Respondido 18 Jul 18, 07:07

Syncfusion Essential XlsIO puede hacer esto. No depende de la oficina de Microsoft y también tiene soporte específico para diferentes plataformas.

Muestra de código:

//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);

Todo el conjunto de controles está disponible de forma gratuita a través del licencia comunitaria programa si califica (menos de 1 millón de dólares en ingresos). Nota: trabajo para Syncfusion.

Respondido 18 Jul 18, 07:07

Syncfusion No es gratis - Kiquenet

Bueno,

también puede utilizar una biblioteca de terceros como Asponer.

Esta biblioteca tiene la ventaja de que no requiere que Excel esté instalado en su máquina, lo que sería ideal en su caso.

Respondido 26 Oct 12, 05:10

Para ser más precisos, puede utilizar Aspose.Cells para .NET para crear archivos de Excel (XLS, XLSX) en su aplicación .NET. - Shahzad Latif

Sí, puede, si no le importa pagar una tarifa mínima de licencia de $ 999. Pruebe la biblioteca MikesKnowledgeBase ... ¡¡que es $ 999 más barata que esta !! - Mike Gledhill

OpenXML también es una buena alternativa que ayuda a evitar la instalación de MS Excel en el servidor. Open XML SDK 2.0 proporcionado por Microsoft simplifica la tarea de manipular paquetes Open XML y los elementos subyacentes del esquema Open XML dentro de un paquete. La Interfaz de programación de aplicaciones (API) Open XML encapsula muchas tareas comunes que los desarrolladores realizan en paquetes Open XML.

Check this out OpenXML: alternativa que ayuda a evitar la instalación de MS Excel en el servidor

Respondido el 02 de diciembre de 15 a las 13:12

Las diversas bibliotecas XML de Office 2003 disponibles funcionan bastante bien para archivos de Excel más pequeños. Sin embargo, considero que el tamaño de un libro de trabajo grande guardado en formato XML es un problema. Por ejemplo, un libro con el que trabajo que tendría 40 MB en el nuevo formato XLSX (y ciertamente más compacto) se convierte en un archivo XML de 360 ​​MB.

Hasta donde me ha llevado mi investigación, hay dos paquetes comerciales que permiten la salida a los formatos de archivo binarios más antiguos. Ellos son:

Ninguno de los dos es barato (creo que 500 USD y 800 USD respectivamente). pero ambos funcionan independientemente del propio Excel.

Lo que me interesaría es el módulo de salida de Excel para OpenOffice.org. Me pregunto si se pueden portar de Java a .Net.

Respondido 18 Jul 18, 07:07

Este funciona tanto en .net como en java, y no es caro. SmartXLS smartxls.com - liya

Estoy de acuerdo con la generación de hojas de cálculo XML, aquí hay un ejemplo de cómo hacerlo para C # 3 (todos solo escriben blogs sobre esto en VB 9: P) http://www.aaron-powell.com/linq-to-xml-to-excel

Respondido 26 Oct 10, 03:10

Acabo de usar recientemente FlexCel.NET ¡y descubrí que es una biblioteca excelente! No digo eso sobre muchos productos de software. No tiene sentido dar todo el argumento de venta aquí, puede leer todas las funciones en su sitio web.

Es un producto comercial, pero obtiene la fuente completa si lo compra. Así que supongo que podrías compilarlo en tu ensamblaje si realmente quisieras. De lo contrario, es solo un ensamblaje adicional para copiar, sin configuración ni instalación ni nada de eso.

No creo que encuentre ninguna manera de hacer esto sin bibliotecas de terceros, ya que .NET Framework, obviamente, no tiene soporte integrado y la automatización OLE es solo un mundo de dolor.

Respondido 18 Jul 18, 07:07

Escribí un código simple para exportar un conjunto de datos para sobresalir sin usar el objeto de Excel usando System.IO.StreamWriter.

A continuación se muestra el código que leerá todas las tablas del conjunto de datos y las escribirá en las hojas una por una. Recibí ayuda de este artículo.

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();
    }

Respondido 18 Jul 18, 07:07

Sin embargo, como dice el artículo, eso es XML que Excel leerá en lugar de ser un archivo XLS, lo que significa que solo funcionará en Excel y no en otros programas que leen hojas de cálculo. ¡Pero probablemente sea mejor que las respuestas de tabla HTML equivalentes aquí! - Rup

¿Soporta xlsx? OpenXML? - Kiquenet

El tipo es Open XML pero solo puedes escribir un archivo .xls y funciona perfectamente. Tenga cuidado con los espacios en blanco en las etiquetas. Use mi código refactorizado a continuación. - mauricio kenny

Solo quiero agregar otra referencia a una solución de terceros que aborde directamente su problema: http://www.officewriter.com

(Descargo de responsabilidad: trabajo para SoftArtisans, la empresa que fabrica OfficeWriter)

Respondido 23 ago 11, 17:08

IKVM + POI

O puedes usar Interop ...

Respondido el 29 de Septiembre de 08 a las 23:09

Aquí hay una forma de hacerlo con LINQ to XML, completa con código de muestra:

Importe y exporte rápidamente datos de Excel con LINQ to XML

Es un poco complejo, ya que tiene que importar espacios de nombres, etc., pero le permite evitar dependencias externas.

(También, por supuesto, es VB .NET, no C #, pero siempre puede aislar las cosas de VB .NET en su propio proyecto para usar XML Literals y hacer todo lo demás en C #).

Respondido 22 Oct 09, 16:10

Algunos proveedores de componentes de terceros como Infragistics o Syncfusion ofrecen muy buenas capacidades de exportación de Excel que no requieren la instalación de Microsoft Excel.

Dado que estos proveedores también proporcionan componentes de cuadrícula de interfaz de usuario avanzados, estos componentes son particularmente útiles si desea que el estilo y el diseño de una exportación de Excel imiten el estado actual de una cuadrícula en la interfaz de usuario de su aplicación.

Si su exportación está destinada a ejecutarse en el lado del servidor con énfasis en los datos que se exportarán y sin un enlace a la interfaz de usuario, entonces optaría por una de las opciones de código abierto gratuitas (por ejemplo, ExcelLibrary).

Anteriormente estuve involucrado en proyectos que intentaban utilizar la automatización del lado del servidor en la suite de Microsoft Office. Sobre la base de esta experiencia, recomendaría encarecidamente no utilizar ese enfoque.

Respondido 16 Feb 11, 11:02

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);
            }
        }
    }
}

Hola, esta solución es exportar su vista de cuadrícula a su archivo de Excel, podría ayudarlo

Respondido 28 Abr '11, 12:04

No, esto genera HTML marcado como un archivo de Excel en lugar de un verdadero archivo de Excel. Sí, el propio Excel lo abrirá bien, pero otros programas que consumen hojas de cálculo, incluido el visor gratuito de Excel de Microsoft, por ejemplo, no lo aceptarán. Será mejor que cree un archivo de Excel real usando una de las bibliotecas aquí. - Rup

También deberías usar System.Net.Mime.ContentDisposition para generar el texto del encabezado de disposición de contenido en lugar de una cadena adjunta, que se encargará correctamente de los nombres de archivo que contienen espacios, etc. - Rup

GridViewExportUtil solo para Web. ¿Y para Windows Forms, WPF, Console, Service Windows, Unit Test o Addin? - Kiquenet

Puede crear archivos de Excel con un formato agradable utilizando esta biblioteca: http://officehelper.codeplex.com/documentation
Vea la siguiente muestra:

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");
}        

donde la muestra se ve así:

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};
    }
}

respondido 11 nov., 11:13

¿Código obsoleto en codeplex? - Kiquenet

La forma más sencilla y rápida de crear un archivo de Excel desde C # es utilizar la herramienta de productividad Open XML. La herramienta de productividad de Open XML viene con la instalación del SDK de Open XML. La herramienta realiza ingeniería inversa de cualquier archivo de Excel en código C #. El código C # se puede usar para volver a generar ese archivo.

Una descripción general del proceso involucrado es:

  1. Instale el SDK de Open XML con la herramienta.
  2. Cree un archivo de Excel utilizando el último cliente de Excel con el aspecto deseado. Nombralo DesiredLook.xlsx.
  3. Con la herramienta abierta DesiredLook.xlsx y haga clic en el botón Reflejar código cerca de la parte superior. enter image description here
  4. El código C # para su archivo se generará en el panel derecho de la herramienta. Agregue esto a su solución C # y genere archivos con el aspecto deseado.

Como beneficio adicional, este método funciona para cualquier archivo de Word y PowerPoint. Como desarrollador de C #, luego realizará cambios en el código para que se ajuste a sus necesidades.

He desarrollado un aplicación WPF simple en github que se ejecutará en Windows para este propósito. Hay una clase de marcador de posición llamada GeneratedClass donde puedes pegar el código generado. Si retrocede una versión del archivo, generará un archivo de Excel como este:

enter image description here

Respondido el 25 de Septiembre de 17 a las 04:09

Todavía no he probado esta solución Open XML SDK, pero vaya, definitivamente la comprobaré. He trabajado con herramientas como esta durante muchos años y no sabía nada de esta. He publicado mi propio FOSS simple para convertir archivos a XLSX con .NET: github.com/TonyGravagno/NebulaXConvert - TonyG

Alguna automatización útil de Excel en C #, puede encontrarla en el siguiente enlace.

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

Bolton.

respondido 10 nov., 09:05

Mira ejemplos de cómo crear archivos de Excel.

Hay ejemplos en C# y VB.NET

Administra archivos XSL XSLX y CSV Excel.

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

Respondido 12 Abr '11, 08:04

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.