Exportar datos a Excel en C#

En este artículo, le mostraré cómo exportar datos a Excel en C# y VB.NET desde varias fuentes de datos, como una matriz, una colección de objetos personalizados, DataTable, DataView, DataGrid, GridView, HTML, JSON y CSV.

• Exportar matriz a Excel en C#
  • Exportar ArrayList a Excel
  • Exportar colección de objetos personalizados a Excel
• Copie filas y columnas de un archivo de Excel a otro
• Exportar DataTable a Excel en C#
  • Exportar datos de columnas de datos selectivas a Excel
  • Exportar vista de datos a Excel
• Exportar datos de DataGrid y GridView a Excel
• Exportar datos con formato HTML a Excel
  • Exportar archivo HTML a Excel
• Exportar datos JSON a Excel en C#
• Exportar datos CSV a Excel en C#

Exportar datos a Excel en C# con Aspose.Cells API

Aspose.Cells for .NET es una poderosa API de manipulación de hojas de cálculo que le permite crear, editar o convertir archivos de Excel dentro de aplicaciones .NET. Los métodos fáciles de usar de la API le permiten realizar funciones de automatización de Excel sin problemas en unas pocas líneas de código. NuGet es la forma más sencilla de descargar e instalar Aspose.Cells API para .NET. Abra la ventana Administrar paquetes NuGet y escriba “Aspose.Cells” en el cuadro de texto de búsqueda para encontrar el paquete Aspose.Cells .NET. Finalmente, haga clic en el botón Instalar para instalar la última versión del paquete.

Exportar matriz a Excel en C#

Podemos exportar una matriz (unidimensional o bidimensional) de un tipo de referencia o tipo de valor a un documento de Excel. Usamos el método ImportArray de la colección Cells para exportar datos a una hoja de cálculo desde una matriz. Las versiones sobrecargadas del método ImportArray son las siguientes.

Una sobrecarga típica toma los siguientes parámetros:

• Array, el objeto de matriz del que está exportando contenido.
• Número de fila, el número de fila de la primera celda (de base cero) a la que se exportarán los datos.
• Número de columna, el número de columna de la primera celda (de base cero) a la que se exportarán los datos.
• Es vertical, un valor booleano que especifica si exportar los datos vertical u horizontalmente.

Los siguientes son los pasos para exportar una matriz a un archivo de Excel en C#.

• Cree un objeto Libro de trabajo. Una clase Libro de trabajo representa un archivo de Microsoft Excel.
• Obtenga una referencia a la hoja de trabajo deseada. La clase Workbook contiene una colección Worksheets que permite el acceso a cada hoja de trabajo en un archivo de Excel.
• Llame al método ImportArray de una colección Cells para exportar una matriz a la hoja de trabajo en la fila y columna especificadas. La clase Worksheet proporciona una colección Cells.
• Guarde el archivo de Excel usando el método Workbook.Save(string).

El siguiente ejemplo de código muestra cómo exportar una matriz de String a un archivo de Excel en C#.

// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Creating an array containing names as string values
string[] names = new string[] { "Laurence Chen", "Roman Korchagin", "Kyle Huang" };

// Exporting the array of names to first row and first column vertically
worksheet.Cells.ImportArray(names, 0, 0, true);

// Saving the Excel file
workbook.Save("StringsArray.xlsx");

De manera similar, podemos exportar una matriz bidimensional a un archivo de Excel. El siguiente ejemplo de código muestra cómo exportar una matriz bidimensional a un archivo de Excel en C#.

// Creating a two-dimensional array of integers
int[,] array2D = new int[4, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } };

// Exporting a two-dimensional array at the first row and first column of the worksheet
worksheet.Cells.ImportArray(array2D, 0, 0);

Exportar ArrayList a Excel en C#

Para exportar datos de una ArrayList a una hoja de trabajo, llame al método ImportArrayList de la colección Cells. El método ImportArrayList toma los siguientes parámetros:

• La lista de matrices representa el objeto ArrayList que está exportando.
• El número de fila representa el número de fila de la primera celda a la que se exportarán los datos.
• El número de columna representa el número de columna de la primera celda a la que se exportarán los datos.
• Es vertical un valor booleano que especifica si se exportan los datos vertical u horizontalmente.

El siguiente ejemplo de código muestra cómo exportar un ArrayList a un archivo de Excel en C#.

// Instantiating a Workbook object
Workbook workbook = new Workbook();

// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Instantiating an ArrayList object
ArrayList list = new ArrayList();

// Add few names to the list as string values
list.Add("Laurence Chen");
list.Add("Roman Korchagin");
list.Add("Kyle Huang");
list.Add("Tommy Wang");

// Exporting the contents of ArrayList vertically at the first row and first column of the worksheet. 
worksheet.Cells.ImportArrayList(list, 0, 0, true);

// Saving the Excel file
workbook.Save("ArrayListExport.xlsx");

Exportar colección de objetos personalizados a Excel en C#

Para exportar datos de una colección de objetos personalizados a una hoja de trabajo, usamos el método ImportCustomObjects. Hay dos versiones sobrecargadas de este método.

1. Importar objetos personalizados (ICollection list, String[] propertyNames, Boolean isPropertyNameShown, Int32 firstRow, Int32 firstColumn, Int32 rowNumber, Boolean inserts, String dateFormatString, Boolean convertStringToNumber)
2. Importar objetos personalizados (lista ICollection, primera fila Int32, primera columna Int32, opciones ImportTableOptions)

Exploraremos cada método sobrecargado uno por uno. La descripción de los parámetros del primer método sobrecargado se da a continuación:

• lista La colección de los objetos personalizados.
• propertyNames Nombres de las propiedades del objeto a exportar. Si es nulo, se exportarán todas las propiedades.
• isPropertyNameShown Indica si los nombres de propiedad se exportarán a la primera fila.
• firstRow El número de fila de la primera celda a la que exportar.
• firstColumn El número de columna de la primera celda a la que exportar.
• rowNumber Número de objetos que se van a exportar.
• insertRows Indica si se agregan filas adicionales para ajustar los datos.
• dateFormatString Cadena de formato de fecha para celdas.
• convertStringToNumber Indica si este método intentará convertir una cadena en un número.

En el siguiente ejemplo, exportamos una lista de objetos Person a un documento de Excel en C#. Tenga en cuenta que estamos exportando solo dos propiedades (Nombre y Edad) de un objeto Persona.

// Instantiate a new Workbook
Workbook book = new Workbook();
// Obtaining the reference of the worksheet
Worksheet sheet = book.Worksheets[0];

// Define List
List<Person> list = new List<Person>();

list.Add(new Person("Mike", 25, "Software Engineer"));
list.Add(new Person("Steve", 30, "Doctor"));
list.Add(new Person("Billy", 35, "Teacher"));

// We pick only Name and Age columns, not all, to export to the worksheet         
sheet.Cells.ImportCustomObjects((System.Collections.ICollection)list,
    new string[] { "Name", "Age" }, // propertyNames
    true, // isPropertyNameShown
    0, // firstRow
    0, // firstColumn
    list.Count, // Number of objects to be exported
    true, // insertRows
    null, // dateFormatString
    false); // convertStringToNumber

// Save the Excel file
book.Save("ExportedCustomObjects.xlsx");
       
public class Person
{
    public string Name { get; set; }

    public int Age { get; set; }

    public string Occupation { get; set; }

    public Person(string name, int age, string occupation)
    {
        Age = age;
        Name = name;
        Occupation = occupation;
    }
}

Ahora exploramos el segundo método sobrecargado de ImportCustomObjects. La descripción de los parámetros del método se da a continuación:

• lista La lista de objetos personalizados.
• firstRow El número de fila de la primera celda a la que exportar.
• firstColumn El número de columna de la primera celda a la que exportar.
• opciones ImportTableOptions objeto.

El parámetro ImportTableOptions proporciona varias opciones para exportar datos a celdas. Algunos de ellos se dan a continuación:

• CheckMergedCells ¿Un documento de Excel contiene celdas combinadas?
• ColumnIndexes Matriz entera de índices de columna (basado en 0) para exportar desde el origen de datos. nulo significa que se deben exportar todas las columnas.
• ConvertGridStyle Indica si aplicar el estilo de la vista de cuadrícula a las celdas.
• ConvertNumericData Un valor booleano que indica si el valor de la cadena debe convertirse en un valor numérico o de fecha.
• DateFormat Obtiene o establece una cadena de formato de fecha para las celdas con valores de fecha y hora exportados.
• DefaultValues El valor predeterminado para la celda de la tabla es nulo.
• InsertRows Indica si se deben agregar nuevas filas para exportar registros de datos.
• IsFieldNameShown Indica si se deben exportar los nombres de campo.
• IsFormulas Indica si los datos son fórmulas.
• IsHtmlString Indica si los datos contienen etiquetas HTML. Si establecemos el valor en verdadero, el formato HTML se mantendrá mientras se exportan los datos a un documento de Excel.
• NumberFormats Obtiene o establece los formatos de número
• ShiftFirstRowDown Indica si la primera fila debe desplazarse hacia abajo al insertar filas.
• TotalColumns Obtiene o establece el recuento total de columnas para exportar desde un origen de datos. -1 significa todas las columnas de la fuente de datos dada.
• TotalRows Obtiene o establece el recuento total de filas para exportar desde el origen de datos. -1 significa todas las filas de la fuente de datos dada.

En el siguiente ejemplo, estamos exportando datos de una colección de objetos a una hoja de trabajo que contiene celdas combinadas. Estamos configurando el valor de la propiedad ImportTableOptions.CheckMergedCells en verdadero ya que el documento de Excel contiene celdas combinadas.

// Opening an existing Workbook.
Workbook workbook = new Workbook("SampleMergedTemplate.xlsx");
List<Product> productList = new List<Product>();

// Creating a collection of Products
for (int i = 0; i < 3; i++)
{
    Product product = new Product
    {
        ProductId = i,
        ProductName = "Test Product - " + i
    };
    productList.Add(product);
}

ImportTableOptions tableOptions = new ImportTableOptions();
// Set CheckMergedCells property to true
tableOptions.CheckMergedCells = true;
tableOptions.IsFieldNameShown = false;

//Export data to excel template (in second row, first column) 
workbook.Worksheets[0].Cells.ImportCustomObjects((ICollection)productList, 1, 0, tableOptions);
workbook.Save("SampleMergedTemplate_out.xlsx", SaveFormat.Xlsx);

public class Product
{
    public int ProductId { get; set; }

    public string ProductName { get; set; }
}

Copia filas y columnas de un archivo de Excel a otro en C#

Podemos copiar filas y columnas mediante programación de un documento de Excel a otro. Cuando se copia una fila (o columna), también se copian los datos contenidos en ella, incluidas fórmulas (con referencias actualizadas) y valores, comentarios, formato, celdas ocultas, imágenes y otros objetos de dibujo. También podemos copiar filas y columnas dentro de la misma hoja de trabajo o en diferentes hojas de trabajo en un documento de Excel. Aspose.Cells proporciona los siguientes métodos para copiar filas y columnas.

• CopyRow(Celdas sourceCells, int sourceRowIndex, int destinationRowIndex) Copies data of a single row.
• CopyRows(Cells sourceCells, int sourceRowIndex, int DestinationRowIndex, int RowNumber) Copies data of multiple rows.
• CopyColumn(Celdas sourceCells, int sourceColumnIndex, int destinationColumnIndex) Copies data of a single column.
• CopyColumns(Cells sourceCells, int sourceColumnIndex, int destinationColumnIndex, int columnNumber) Copies data of multiple columns.

El siguiente código de ejemplo muestra cómo copiar filas de un documento de Excel a otro en C#.

// Open the source excel file.
Workbook srcWorkbook = new Workbook("Source_Workbook.xlsx");

// Instantiate the destination excel file.
Workbook destWorkbook = new Workbook();

// Get the first worksheet of the source workbook.
Worksheet srcWorksheet = srcWorkbook.Worksheets[0];

// Get the first worksheet of the destination workbook.
Worksheet desWorksheet = destWorkbook.Worksheets[0];

// Copy all the rows of the first worksheet of source Workbook to
// the first worksheet of destination Workbook.
desWorksheet.Cells.CopyRows(srcWorksheet.Cells, 0, 0, srcWorksheet.Cells.MaxDisplayRange.RowCount);

// Save the excel file.
destWorkbook.Save("Destination_Workbook.xlsx");

El siguiente código de ejemplo muestra cómo copiar filas específicas de un documento de Excel a otro.

// Open the source excel file.
Workbook srcWorkbook = new Workbook("Source_Workbook.xlsx");

// Instantiate the destination excel file.
Workbook destWorkbook = new Workbook();

// Get the first worksheet of the source workbook.
Worksheet srcWorksheet = srcWorkbook.Worksheets[0];

// Get the first worksheet of the destination workbook.
Worksheet desWorksheet = destWorkbook.Worksheets[0];

// Copy the second row of the source Workbook to the first row of destination Workbook.
desWorksheet.Cells.CopyRow(srcWorksheet.Cells, 1, 0);

// Copy the fourth row of the source Workbook to the second row of destination Workbook.
desWorksheet.Cells.CopyRow(srcWorksheet.Cells, 3, 1);

// Save the excel file.
destWorkbook.Save("Destination_Workbook.xlsx");

De manera similar, podemos copiar los datos de las columnas de un documento de Microsoft Excel a otro utilizando el método CopyColumn o CopyColumns.

Exportar DataTable a Excel en C#

Los datos de objetos ADO.NET como DataTable, DataColumn y DataView se pueden exportar a hojas de cálculo de Excel. Para exportar datos de un DataTable, llamamos al método ImportData de la colección Cells. Hay muchas versiones sobrecargadas del método ImportData pero usamos lo siguiente:

public int ImportData(
	DataTable table,
	int firstRow,
	int firstColumn,
	ImportTableOptions options
)

La descripción de los parámetros se da a continuación:

• table DataTable objeto que se exportará.
• firstRow El número de fila de la primera celda a la que exportar.
• firstColumn El número de columna de la primera celda a la que exportar.
• optionsType ImportTableOptions objeto.

En el siguiente ejemplo de código, estamos creando un objeto DataTable que tiene tres columnas y dos filas. Y exportarlo a una hoja de cálculo de Excel.

// Instantiating a Workbook object            
Workbook workbook = new Workbook();

// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];

// Instantiating a "Products" DataTable object
DataTable dataTable = new DataTable("Products");

// Adding columns to the DataTable object
dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

// Creating an empty row in the DataTable object
DataRow dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Creating another empty row in the DataTable object
dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Setting IsFieldNameShown property to true will add column names // of the DataTable to the worksheet as a header row
ImportTableOptions tableOptions = new ImportTableOptions();
tableOptions.IsFieldNameShown = true;

// Exporting the contents of DataTable at the first row and first column.
worksheet.Cells.ImportData(dataTable, 0, 0, tableOptions);

// Saving the Excel file
workbook.Save("DataTable_Eport.xlsx");

Exportar datos de columnas de datos selectivas a Excel en C#

Podemos exportar columnas de datos selectivas de un DataTable o DataView a un documento de Excel. Como se discutió anteriormente, el método ImportData acepta un argumento de tipo ImportTableOptions. La clase ImportTableOptions tiene una propiedad ColumnIndexes que acepta una matriz de índices de columnas (basado en cero) que queremos exportar. En el siguiente ejemplo de código, estamos exportando solo dos columnas de datos de una tabla de datos a una hoja de cálculo de Excel.

// Instantiating a "Products" DataTable object
DataTable dataTable = new DataTable("Products");

// Adding columns to the DataTable object
dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

// Creating an empty row in the DataTable object
DataRow dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Creating another empty row in the DataTable object
dr = dataTable.NewRow();

// Adding data to the row
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;

// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);

// Instantiate a new Workbook
Workbook book = new Workbook();

Worksheet sheet = book.Worksheets[0];

// Create export options
ImportTableOptions importOptions = new ImportTableOptions();
// Sets the columns (0-based) to export from data source.
// null means all columns should be exported.
importOptions.ColumnIndexes = new int[] { 0, 1 };
importOptions.IsFieldNameShown = true;

// Exporting the values of 1st and 2nd columns of the data table
sheet.Cells.ImportData(dataTable, 0, 0, importOptions);

book.Save("DataColumsExport.xlsx");

Exportar datos de DataView a Excel en C#

Un DataView es una vista en un DataTable que se puede personalizar para presentar un subconjunto de datos del DataTable. Usamos la siguiente versión sobrecargada del método ImportData para exportar datos de DataView a un documento de Excel.

public int ImportData(
	DataView dataView,
	int firstRow,
	int firstColumn,
	ImportTableOptions options
)

Sabemos que hay dos formas de crear un DataView. Podemos usar el constructor DataView, o podemos crear una referencia a la propiedad DefaultView de DataTable. En el siguiente ejemplo de código, estamos usando la forma posterior de crear un DataView.

worksheet.Cells.ImportData(dataTable.DefaultView, 0, 0, options);

Exportar datos de DataGrid y GridView a Excel en C#

La biblioteca Aspose.Cells nos permite exportar datos de los controles de Microsoft Grid como DataGrid y GridView a una hoja de cálculo de Excel. Proporciona el método ImportDataGrid para exportar datos de un DataGrid y el método ImportGridView para exportar datos de un GridView.

Hay muchas versiones sobrecargadas del método ImportDataGrid pero una sobrecarga típica toma los siguientes parámetros:

• dataGrid, el objeto DataGrid del que estamos exportando contenido.
• firstRow, el número de fila de la primera celda a la que se exportarán los datos.
• firstColumn, el número de columna de la primera celda a la que se exportarán los datos.
• insertRows, una propiedad booleana que indica si se deben agregar filas adicionales a la hoja de trabajo para ajustar los datos.
• importStyle, una propiedad booleana que indica si se debe exportar el estilo de celda.

El siguiente ejemplo de código muestra cómo exportar datos de DataGrid a un archivo de Excel en C#.

// Create a DataTable object and set it as the DataSource of the DataGrid.
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

DataRow dr = dataTable.NewRow();
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;
dataTable.Rows.Add(dr);

dr = dataTable.NewRow();
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;
dataTable.Rows.Add(dr);

// Now take care of DataGrid
DataGrid dg = new DataGrid();
dg.DataSource = dataTable;
dg.DataBind();

// We have a DataGrid object with some data in it.
// Lets export it to an Excel worksheet.

// Creat a new workbook
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Exporting the contents of the DataGrid to the worksheet
worksheet.Cells.ImportDataGrid(dg, 0, 0, false);

// Save it as Excel file
workbook.Save("ExportDataGrid.xlsx");

Exportar datos con formato HTML a Excel en C#

Aspose.Cells le permite exportar datos con formato HTML a una hoja de cálculo de Excel. La API analiza el texto con formato HTML mientras exporta datos y convierte el HTML en valores de celda con formato. En el siguiente código de ejemplo, DataTable contiene texto con formato HTML y lo estamos exportando a un documento de Excel usando el método ImportData.

// Prepare a DataTable with some HTML formatted values
DataTable dataTable = new DataTable("Products");

dataTable.Columns.Add("Product ID", typeof(int));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(int));

DataRow dr = dataTable.NewRow();
dr[0] = 1;
// Make text italicize
dr[1] = "<i>Aniseed</i> Syrup";
dr[2] = 15;
dataTable.Rows.Add(dr);

dr = dataTable.NewRow();
dr[0] = 2;
// Make text bold
dr[1] = "<b>Boston Crab Meat</b>";
dr[2] = 123;
dataTable.Rows.Add(dr);

// Create export options
ImportTableOptions exportOptions = new ImportTableOptions();
exportOptions.IsFieldNameShown = true;
// Set IsHtmlString property to true as the data contains HTML tags. 
exportOptions.IsHtmlString = true;

// Create workbook
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

worksheet.Cells.ImportData(dataTable, 0, 0, exportOptions);

workbook.Save("HTMLFormattedData_Out.xlsx");

Exportar archivo HTML a Excel en C#

Aspose.Cells nos permite exportar un archivo HTML a Excel. El archivo HTML debe estar orientado a Microsoft Excel, es decir, MS-Excel debería poder abrirlo.

// An HTML file
string filePath = "Book1.html";

// Instantiate LoadOptions specified by the LoadFormat.
HtmlLoadOptions loadOptions = new HtmlLoadOptions(LoadFormat.Html);

// Create a Workbook object and open the HTML file.
Workbook wb = new Workbook(filePath, loadOptions);

// Save the file as Excel Document
wb.Save("Book1_out.xlsx");

Exportar datos JSON a Excel en C#

A veces tenemos la necesidad de exportar datos JSON a un documento de Excel. Con Aspose.Cells podemos hacer esto fácilmente con unas pocas líneas de código. Aspose.Cells proporciona una clase JsonUtility que tiene un método ImportData para exportar datos JSON a un documento de Excel. El método ImportData acepta el objeto JsonLayoutOptions como parámetro. La clase JsonLayoutOptions representa las opciones del diseño JSON y tiene las siguientes propiedades.

• ArrayAsTable: Indicates whether the array should be processed as a table.
• ConvertNumericOrDate: Gets or sets a value that indicates whether the string in JSON is to be converted to numeric or date.
• DateFormat: Gets and sets the format of the date value.
• IgnoreArrayTitle: Indicates whether to ignore the title if the property of the object is an array.
• IgnoreNull: Indicates whether the null value should be ignored.
• IgnoreObjectTitle: Indicates whether to ignore the title if the property of the object is an object.
• NumberFormat: Gets and sets the format of the numeric value.
• TitleStyle: Gets and sets the style of the title.

En el siguiente código de ejemplo, estamos exportando datos JSON a un archivo de Excel en C#.

// Instantiating a Workbook object
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

// Read JSON file
string jsonInput = File.ReadAllText("Sample.json");

// Set Styles
CellsFactory factory = new CellsFactory();
Style style = factory.CreateStyle();
style.HorizontalAlignment = TextAlignmentType.Center;
style.Font.Color = System.Drawing.Color.BlueViolet;
style.Font.IsBold = true;

// Set JsonLayoutOptions
JsonLayoutOptions options = new JsonLayoutOptions();
options.TitleStyle = style;
options.ArrayAsTable = true;

// Export JSON Data
JsonUtility.ImportData(jsonInput, worksheet.Cells, 0, 0, options);

// Save Excel file
workbook.Save("ExportingJsonData.xlsx");

{
  "quiz": {
    "sport": {
      "q1": {
        "question": "Which one is correct team name in NBA?",
        "answer": "Huston Rocket"
      }
    },
    "maths": {
      "q1": {
        "question": "5 + 7 = ?",
        "answer": "12"
      },
      "q2": {
        "question": "12 - 8 = ?",
        "answer": "4"
      }
    }
  }
}

Exportar datos CSV a Excel en C#

Un archivo de valores separados por comas (CSV) es un archivo de texto delimitado que usa una coma para separar los valores. Un archivo CSV generalmente almacena datos tabulares (números y texto) en texto sin formato, en cuyo caso cada línea tendrá la misma cantidad de campos.

El siguiente ejemplo de código muestra cómo podemos abrir un archivo CSV y guardarlo como un archivo de Excel usando la biblioteca Aspose.Cells.

// Instantiate LoadOptions with CSV LoadFormat.
LoadOptions loadOptions = new LoadOptions(LoadFormat.CSV);

// Open CSV file as a Workbook object
Workbook wb = new Workbook("Business-Price.csv", loadOptions);

// Save the file as an Excel Documnt
wb.Save("CSVAsAnExcelDocument.xlsx");

Conclusión

En esta publicación, ha visto con qué facilidad puede exportar datos a Excel en C# desde Array, DataTable, DataView, DataGrid y GridView. También ha visto cómo exportar datos HTML, JSON, CSV a una hoja de cálculo de Excel. Consulte la documentación para obtener más información sobre estas y otras funciones que ofrece la API de Aspose.Cells. Si tiene alguna pregunta, no dude en comunicarse con nosotros a través de nuestro Foro de soporte.

Ver también

• Cree archivos de MS Excel mediante programación en C# sin MS Office
• Importar datos de JSON a la hoja de cálculo de Excel en C# .NET