Lectura y escritura de archivos DBF

Aspose.Cells provides full support for reading and writing DBF (dBASE) files. You can load existing dBASE III and dBASE IV files into a Workbook object, manipulate the data using the rich Aspose.Cells API, and save the workbook back to the DBF format for use with legacy database applications.

Introducción

DBF (DataBase File) es un formato de archivo de base de datos heredado introducido originalmente por dBASE a principios de la década de 1980. A pesar de la antigüedad del formato, los archivos DBF todavía se utilizan ampliamente en muchas industrias para almacenar datos estructurados, particularmente en contabilidad, SIG y otras aplicaciones especializadas. Aspose.Cells le permite integrar estos archivos heredados en flujos de trabajo modernos de hojas de cálculo .NET sin problemas. La biblioteca admite tanto la lectura como la escritura de archivos DBF, lo que le permite:

• Importar datos desde archivos DBF existentes a objetos Workbook de Aspose.Cells para su posterior procesamiento o conversión a otros formatos.
• Crear nuevos archivos DBF desde cero o transformando datos desde otros formatos de hojas de cálculo.
• Mantener las definiciones de campos, los tipos de datos y las estructuras de registros al transferir datos dentro y fuera del formato DBF. Los archivos DBF también se pueden abrir directamente en Microsoft Excel y otras aplicaciones de hojas de cálculo, lo que los convierte en un puente conveniente entre los sistemas heredados y las herramientas modernas de hojas de cálculo.

Versiones y características de DBF compatibles

Aspose.Cells supports the following DBF format versions:

• dBASE III — La variante original y más ampliamente compatible del formato DBF.
• dBASE IV — Una versión extendida que admite tipos de datos adicionales y tamaños de campo mayores.

Características admitidas

La biblioteca proporciona soporte integral para las siguientes operaciones:

• Leer datos DBF en un objeto Workbook, con todos los registros y definiciones de campos conservados.
• Escribir los datos del libro de trabajo de vuelta al formato DBF para exportarlos a aplicaciones compatibles con dBASE.
• Manejar tipos de datos comunes utilizados en archivos DBF, incluidos los campos de carácter, numérico, fecha y lógico.
• Conservar las definiciones de campo, como el nombre, el tipo y la longitud del campo, durante las operaciones de lectura/escritura.

Limitaciones y consideraciones

Cuando trabaje con archivos DBF, tenga en cuenta las siguientes restricciones:

• El número máximo de campos por archivo es 128.
• El tamaño máximo de registro es 4000 bytes.
• Los nombres de campo están limitado a 10 caracteres, deben estar en mayúsculas y no pueden contener espacios.
• Los valores de fecha en los archivos DBF se almacenan en formato YYYYMMDD.
• La codificación de caracteres puede variar según la aplicación de origen (comúnmente Windows-1252 o páginas de códigos OEM).

Lectura de un archivo DBF

Aspose.Cells facilita la carga de datos desde un archivo DBF a un objeto Workbook. La biblioteca utiliza la clase LoadOptions para especificar el formato de origen, lo que garantiza que los datos se interpreten correctamente durante el proceso de carga.

Lectura de un archivo DBF con Aspose.Cells

Para leer un archivo DBF, debe crear una instancia de LoadOptions, establecer su propiedad LoadFormat en LoadFormat.Dbf y pasarla al constructor Workbook junto con la ruta del archivo. Una vez cargado, los datos son accesibles a través de la colección Worksheets, donde puede iterar a través de las celdas, extraer valores o manipular los datos según sea necesario. El siguiente ejemplo demuestra cómo cargar un archivo DBF existente en Aspose.Cells, acceder a su primera hoja de cálculo y leer los valores de las celdas.

using System;
using System.IO;
using System.Text;
using Aspose.Cells;
string dataDir = "Data/";
string filePath = Path.Combine(dataDir, "example.dbf");
LoadOptions loadOptions = new LoadOptions(LoadFormat.Dbf);
Workbook workbook = new Workbook(filePath, loadOptions);
Worksheet worksheet = workbook.Worksheets[0];
Cells cells = worksheet.Cells;
StringBuilder sb = new StringBuilder();
int maxRow = cells.MaxDataRow;
int maxCol = cells.MaxDataColumn;
for (int i = 0; i <= maxRow; i++)
{
    for (int j = 0; j <= maxCol; j++)
    {
        Cell cell = cells[i, j];
        string value = cell.StringValue;
        sb.Append("|").Append(value);
    }
    sb.Append("|").AppendLine();
}
Console.WriteLine(sb.ToString());
string outputPath = Path.Combine(dataDir, "output.xlsx");
workbook.Save(outputPath, SaveFormat.Xlsx);
Console.WriteLine("DBF file loaded successfully. Converted XLSX saved at: " + outputPath);

You can open DBF files directly in Microsoft Excel by selecting the file in the Open dialog. Excel will treat the DBF file as a spreadsheet, displaying its records in a tabular layout. This is useful for quickly verifying the data after reading or writing it with Aspose.Cells.

Escritura de un archivo DBF

Escribir datos en un archivo DBF sigue un patrón similar al de guardar cualquier otro formato de hoja de cálculo con Aspose.Cells. Crea o carga un Workbook, rellena la hoja de cálculo con datos y, a continuación, llama al método Save especificando SaveFormat.Dbf como formato de destino.

Escritura de un archivo DBF con Aspose.Cells

Para crear un archivo DBF, siga estos pasos:

1. Cree una nueva instancia de Workbook.
2. Acceda a la primera hoja de cálculo desde la colección Worksheets.
3. Rellene la hoja de cálculo con sus datos, incluidos los encabezados en la primera fila y los registros en las filas siguientes.
4. Llame al método Workbook.Save, pasando la ruta del archivo y SaveFormat.Dbf como parámetros. El siguiente ejemplo demuestra cómo crear un nuevo archivo DBF desde cero. Rellena una hoja de cálculo con datos de muestra que contienen diferentes tipos de datos (cadenas, números y fechas) para ilustrar cómo se manejan los tipos de campo al exportar al formato DBF.

using System;
using System.IO;
using Aspose.Cells;
string outputDir = @"C:\Output\";
string filePath = Path.Combine(outputDir, "output.dbf");
if (!Directory.Exists(outputDir))
{
    Directory.CreateDirectory(outputDir);
}
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
Cells cells = worksheet.Cells;
// Encabezados de columna
cells[0, 0].PutValue("ID");
cells[0, 1].PutValue("Name");
cells[0, 2].PutValue("Department");
cells[0, 3].PutValue("Salary");
cells[0, 4].PutValue("HireDate");
// Fila de datos 1
cells[1, 0].PutValue(101);
cells[1, 1].PutValue("John Smith");
cells[1, 2].PutValue("Engineering");
cells[1, 3].PutValue(75000.50);
cells[1, 4].PutValue(new DateTime(2020, 3, 15));
// Fila de datos 2
cells[2, 0].PutValue(102);
cells[2, 1].PutValue("Jane Doe");
cells[2, 2].PutValue("Marketing");
cells[2, 3].PutValue(68000.75);
cells[2, 4].PutValue(new DateTime(2019, 7, 22));
// Fila de datos 3
cells[3, 0].PutValue(103);
cells[3, 1].PutValue("Bob Johnson");
cells[3, 2].PutValue("Finance");
cells[3, 3].PutValue(82000.00);
cells[3, 4].PutValue(new DateTime(2021, 1, 10));
// Fila de datos 4
cells[4, 0].PutValue(104);
cells[4, 1].PutValue("Alice Brown");
cells[4, 2].PutValue("Human Resources");
cells[4, 3].PutValue(71000.25);
cells[4, 4].PutValue(new DateTime(2018, 11, 5));
// Fila de datos 5
cells[5, 0].PutValue(105);
cells[5, 1].PutValue("Charlie Wilson");
cells[5, 2].PutValue("Operations");
cells[5, 3].PutValue(79500.80);
cells[5, 4].PutValue(new DateTime(2022, 5, 30));
// Establecer anchos de columna para mejor legibilidad
worksheet.Cells.SetColumnWidth(0, 8);
worksheet.Cells.SetColumnWidth(1, 20);
worksheet.Cells.SetColumnWidth(2, 20);
worksheet.Cells.SetColumnWidth(3, 12);
worksheet.Cells.SetColumnWidth(4, 14);
workbook.Save(filePath, SaveFormat.Dbf);

When writing data to a DBF file, ensure that your data conforms to the format’s limitations. Field names should be no longer than 10 characters and should not contain spaces. Records exceeding 4000 bytes in total will not be saved correctly. Dates should be valid date values that can be represented in the YYYYMMDD format.

Consideraciones sobre tipos de datos y formato

Al transferir datos entre Aspose.Cells y el formato DBF, es importante comprender cómo se asignan los tipos de datos entre los dos sistemas para garantizar la integridad de los datos.

Tipos de celda a tipos de campo DBF

Los valores de celda de Aspose.Cells se convierten automáticamente a los tipos de campo DBF apropiados al guardar:

• Las cadenas se asignan a campos de carácter (C).
• Los valores numéricos (enteros y decimales) se asignan a campos numéricos (N).
• Los valores de fecha se asignan a campos de fecha (D) en formato YYYYMMDD.
• Los valores booleanos se asignan a campos lógicos (L).

Codificación

Los archivos DBF pueden utilizar diferentes codificaciones de caracteres según la aplicación que los creó. Aspose.Cells maneja la codificación de forma transparente en la mayoría de los casos, pero si encuentra problemas de visualización de caracteres, es posible que deba verificar la codificación del archivo de origen.

Reglas de nombres de campo

Los nombres de campo DBF deben cumplir con las siguientes reglas:

• Longitud máxima de 10 caracteres.
• Deben comenzar con una letra.
• No pueden contener espacios ni caracteres especiales.
• Se almacenan en mayúsculas independientemente del caso utilizado en la entrada.

Verificación del resultado

Después de escribir un archivo DBF, puede verificar el resultado abriéndolo en Microsoft Excel o en cualquier aplicación compatible con dBASE. Los datos deben aparecer en un diseño tabular con los nombres de campo como encabezados de columna, y los registros rellenados según los datos proporcionados.

Conversión entre DBF y otros formatos

Uno de los casos de uso más prácticos de la lectura y escritura de archivos DBF con Aspose.Cells es la conversión de datos entre el formato DBF y formatos modernos de hojas de cálculo como XLSX, XLS o CSV. Dado que Aspose.Cells admite una amplia gama de formatos, puede cargar fácilmente un archivo DBF y volver a guardarlo en cualquier otro formato compatible, o viceversa.