¿Cómo creo un archivo de Excel (.XLS y .XLSX) en C# sin instalar Microsoft Office?[cerrado]
https://stackoverflow.com/questions/151005
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿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?
Solución
Puede usar una biblioteca llamada ExcelLibrary. Es una biblioteca gratuita de código abierto publicada en Google Code:
Esto parece ser un puerto de PHP ExcelWriter que mencionó anteriormente. Todavía no escribirá en el nuevo formato .xlsx, pero están trabajando para agregar esa funcionalidad.
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 anterior de Excel (archivos .xls), pero puede estar agregando soporte en el futuro para los nuevos formatos 2007/2010.
También puede usar EPPlus , 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. Parece que también se actualiza y documenta más activamente.
Además, como lo señala @ & # 1040; & # 1088; & # 1090; & # 1105; & # 1084; & # 1062; & # 1072 ; & # 1088; & # 1080; & # 1086; & # 1085; & # 1086; & # 1074; a continuación, EPPlus tiene soporte para tablas dinámicas y ExcelLibrary puede tener algo de soporte ( Problema de tabla dinámica en ExcelLibrary )
Aquí hay un par de enlaces para referencia rápida:
ExcelLibrary - GNU Lesser GPL
EPPlus - GNU Lesser General Public License (LGPL)
NPOI - Licencia de Apache
Aquí hay 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 línea única 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 Excel es tan fácil como eso. También puede crear manualmente archivos de Excel, pero la funcionalidad anterior es lo que realmente me impresionó.
Otros consejos
Si está satisfecho con el formato xlsx, pruebe mi proyecto GitHub, EPPlus . Comenzó con la fuente de ExcelPackage, pero hoy es una reescritura total. Admite rangos, estilos de celdas, gráficos, formas, imágenes, rangos con nombre, Autofiltro y muchas otras cosas.
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.
Echa un vistazo a las publicaciones de mi blog:
¿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 una .Net dll para usar en el proyecto
- SDK viene con muchas herramientas como diff, validator, etc.
Enlaces:
- Descargar SDK
- Aterrizaje principal de MSDN
- " ¿Cómo hago .. . " página de inicio
- blogs.MSDN brian_jones anunciando SDK
- blogs.MSDN brian_jones describe SDK manejando archivos grandes sin fallar (a diferencia del método DOM)
Puede usar OLEDB para crear y manipular archivos de Excel. Compruebe esto: Lectura y escritura de 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:
La solución comercial, SpreadsheetGear para .NET lo hará.
Puede ver muestras de ASP.NET (C # y VB) en vivo aquí y descargue un versión de evaluación aquí .
Descargo de responsabilidad: soy dueño de SpreadsheetGear LLC
Algunas opciones que he usado:
Si XLSX es imprescindible: ExcelPackage es un buen comienzo, pero murió cuando el desarrollador deja de trabajar en eso. ExML recogió desde allí y agregó algunas características. ExML no es una mala opción, todavía la 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 Apache POI . NPOI 2.0 (Alpha) también es compatible con XLSX.
Una opción extremadamente ligera puede ser usar 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 la salida, incluidas las fórmulas.
Me doy cuenta de que es posible que no esté codificando esto en una aplicación web, pero aquí hay un ejemplo de la composición de un archivo 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.
Puede usar ExcelXmlWriter .
Funciona bien.
Si está creando archivos 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 usado por cualquier lenguaje .NET como C # y Visual Basic (VB).
ClosedXML le permite crear archivos Excel 2007/2010 sin Excel solicitud. El ejemplo típico es crear informes de Excel en una web servidor:
var workbook = new XLWorkbook(); var worksheet = workbook.Worksheets.Add("Sample Sheet"); worksheet.Cell("A1").Value = "Hello World!"; workbook.SaveAs("HelloWorld.xlsx");
Es posible que desee consultar las clases de interoperabilidad . Dices que no hay OLE (que no es así), pero las clases de interoperabilidad son muy fáciles de usar.
Puede que te impresione si no los has probado.
Tenga en cuenta que postura sobre esto:
Microsoft no recomienda actualmente, y no admite, Automatización de aplicaciones de Microsoft Office desde cualquier desatendido, componente o aplicación cliente no interactiva (incluido ASP, ASP.NET, DCOM y NT Services), porque Office puede exhibir inestabilidad comportamiento y / o punto muerto cuando Office se ejecuta en este entorno.
Aquí hay una biblioteca C # completamente gratuita, que le permite exportar desde DataSet, DataTable o List<> a un archivo .xlsx de Excel 2007 original, utilizando las bibliotecas OpenXML:
http://mikesknowledgebase.com/pages/CSharp/ExportToExcel.htm
Se proporciona el código fuente completo, sin cargo, junto con las 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 una sola línea de código:
CreateExcelFile.CreateExcelDocument(myDataSet, "C:\\Sample.xlsx");
No se vuelve mucho más simple que eso ...
Y ni siquiera requiere que Excel esté presente en su servidor.
Podría considerar crear sus archivos usando el XML Spreadsheet 2003 . Este es un formato XML simple que utiliza un esquema bien documentado .
Es posible que desee echar un vistazo a GemBox.Spreadsheet .
Tienen una versión gratuita con todas las funciones, pero limitada a 150 filas por hoja y 5 hojas por libro, si eso se ajusta a sus necesidades.
Todavía no he tenido necesidad de usarlo, pero parece interesante.
Syncfusion Essential XlsIO puede hacer esto. No depende de Microsoft Office y también tiene soporte específico para diferentes plataformas.
- ASP.NET
- ASP.NET MVC
- UWP
- Xamarin
- WPF y formularios Windows Forms
- Servicio de Windows y operaciones basadas en lotes
Ejemplo 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 programa licencia comunitaria si califica ( menos de 1 millón de dólares en ingresos). Nota: Trabajo para Syncfusion.
Bueno,
también puede usar una biblioteca de terceros como Aspose .
Esta biblioteca tiene la ventaja de que no requiere la instalación de Excel en su máquina, lo que sería ideal en su caso.
Las diversas bibliotecas XML de Office 2003 disponibles funcionan bastante bien para archivos Excel más pequeños.Sin embargo, considero que el gran tamaño de un libro grande guardado en formato XML es un problema.Por ejemplo, un libro con el que trabajo que ocuparía 40 MB en el nuevo (y ciertamente más compacto) formato XLSX 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 formatos de archivos 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 gustaría saber es el módulo de salida de Excel para empresas como OpenOffice.org.Me pregunto si se pueden migrar de Java a .Net.
OpenXML también es una buena alternativa que ayuda a evitar la instalación de MS Excel en el servidor. El Open XML SDK 2.0 proporcionado por Microsoft simplifica la tarea de manipular los 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.
Mira esto OpenXML: Alternativa que ayuda a evitar la instalación de MS Excel en el servidor
Estoy de acuerdo en generar hojas de cálculo XML, aquí hay un ejemplo de cómo hacerlo para C # 3 (todo el mundo lo escribe en VB 9: P) http://www.aaron-powell.com/linq-to-xml-to-excel
Recientemente he usado FlexCel.NET ¡y me pareció una excelente biblioteca! No digo eso sobre demasiados productos de software. No tiene sentido dar todo el argumento de venta aquí, puede leer todas las características en su sitio web.
Es un producto comercial, pero obtienes la fuente completa si lo compras. Así que supongo que podría compilarlo en su ensamblaje si realmente quisiera. De lo contrario, es solo un ensamblaje adicional para xcopy: sin configuración ni instalación ni nada de eso.
No creo que encuentre ninguna manera de hacerlo sin bibliotecas de terceros, ya que .NET Framework, obviamente, no tiene soporte incorporado para ello y OLE Automation es solo un mundo de dolor.
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 compañía que fabrica OfficeWriter)
He escrito un código simple para exportar el conjunto de datos a Excel sin usar el objeto 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();
}
Aquí hay una manera de hacerlo con LINQ to XML, completa con un código de muestra:
Importar y exportar rápidamente datos de Excel con LINQ to XML
Es un poco complejo, ya que debe importar espacios de nombres, etc., pero le permite evitar cualquier dependencia externa.
(Además, por supuesto, es VB .NET, no C #, pero siempre puede aislar el material VB .NET en su propio proyecto para usar XML Literals y hacer todo lo demás en C #.)
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 avanzados de cuadrícula de interfaz de usuario, 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 a exportar y sin enlace a la interfaz de usuario, entonces elegiría una de las opciones gratuitas de código abierto (por ejemplo, ExcelLibrary).
He participado anteriormente en proyectos que intentaron utilizar la automatización del lado del servidor en el conjunto de aplicaciones de Microsoft Office. En base a esta experiencia, recomendaría encarecidamente este enfoque.
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
Puede crear archivos Excel bien formateados usando esta biblioteca:
http://officehelper.codeplex.com/documentation
Vea a continuación la 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};
}
}
La forma más sencilla y rápida de crear un archivo Excel desde C# es utilizar la herramienta de productividad Open XML.La herramienta de productividad 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#.Luego, el código C# se puede utilizar para volver a generar ese archivo.
Una descripción general del proceso involucrado es:
- Instale el SDK de Open XML con la herramienta.
- Cree un archivo de Excel utilizando el último cliente de Excel con el aspecto deseado.Nombralo
DesiredLook.xlsx. - Con la herramienta abierta
DesiredLook.xlsxy haga clic en el botón Reflejar código cerca de la parte superior.
- 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#, realizará cambios en el código para adaptarlo 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:
Alguna automatización de Excel útil en C #, puede encontrarla en el siguiente enlace.
http://csharp.net-informations.com/excel/ csharp-excel-tutorial.htm
bolton.
Mira ejemplos de cómo crear archivos de Excel.
Hay ejemplos en C # y VB.NET
Administra los archivos XSL XSLX y CSV Excel.
