Or add the package reference to your .csproj file:

<PackageReference Include="DevKit.Exporter" Version="1.0.0" />

🔧 Configuration

Basic Setup

public void ConfigureServices(IServiceCollection services)
{
    // Add Exporter with default settings
    services.AddExporter();
    
    // Register other services
    services.AddControllers();
}

Advanced Configuration

public void ConfigureServices(IServiceCollection services)
{
    services.AddExporter(options =>
    {
        // Configure default export settings
        options.DefaultExcelSettings = new ExcelExportSettings
        {
            AutoFitColumns = true,
            IncludeHeader = true,
            SheetName = "Export",
            HeaderStyle = new CellStyle
            {
                FontBold = true,
                BackgroundColor = Color.LightGray,
                HorizontalAlignment = HorizontalAlignment.Center
            },
            DataStyle = new CellStyle
            {
                HorizontalAlignment = HorizontalAlignment.Left,
                VerticalAlignment = VerticalAlignment.Center
            }
        };
        
        // Configure CSV settings
        options.DefaultCsvSettings = new CsvExportSettings
        {
            Delimiter = ",",
            IncludeHeader = true,
            Encoding = Encoding.UTF8
        };
        
        // Enable detailed logging
        options.EnableLogging = true;
        
        // Configure default date/time formats
        options.DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
        options.DateFormat = "yyyy-MM-dd";
        options.TimeFormat = "HH:mm:ss";
    });
    
    // Register other services
    services.AddControllers();
}

appsettings.json

{
  "ExporterOptions": {
    "DefaultExcelSettings": {
      "AutoFitColumns": true,
      "IncludeHeader": true,
      "SheetName": "Export",
      "HeaderStyle": {
        "FontBold": true,
        "BackgroundColor": "LightGray",
        "HorizontalAlignment": "Center"
      },
      "DataStyle": {
        "HorizontalAlignment": "Left",
        "VerticalAlignment": "Center"
      }
    },
    "DefaultCsvSettings": {
      "Delimiter": ",",
      "IncludeHeader": true,
      "Encoding": "UTF8"
    },
    "EnableLogging": true,
    "DateTimeFormat": "yyyy-MM-dd HH:mm:ss",
    "DateFormat": "yyyy-MM-dd",
    "TimeFormat": "HH:mm:ss"
  }
}

💻 Usage Examples

1. Basic Excel Export

public class ReportService
{
    private readonly IExcelExporter _excelExporter;
    private readonly ILogger<ReportService> _logger;

    public ReportService(IExcelExporter excelExporter, ILogger<ReportService> logger)
    {
        _excelExporter = excelExporter;
        _logger = logger;
    }

    public async Task<byte[]> ExportToExcelAsync<T>(IEnumerable<T> data, string sheetName = "Export")
    {
        try
        {
            var options = new ExcelExportOptions<T>
            {
                SheetName = sheetName,
                AutoFitColumns = true,
                IncludeHeader = true,
                HeaderStyle = new CellStyle
                {
                    FontBold = true,
                    BackgroundColor = Color.LightBlue,
                    HorizontalAlignment = HorizontalAlignment.Center
                },
                DataStyle = new CellStyle
                {
                    HorizontalAlignment = HorizontalAlignment.Left,
                    VerticalAlignment = VerticalAlignment.Center
                }
            };

            return await _excelExporter.ExportToByteArrayAsync(data, options);
        }
        catch (ExportException ex)
        {
            _logger.LogError(ex, "Error exporting data to Excel");
            throw;
        }
    }
}

2. Advanced Excel Export with Multiple Sheets

public async Task<byte[]> ExportMultipleSheetsAsync(
    IEnumerable<Customer> customers, 
    IEnumerable<Order> orders)
{
    var workbook = new ExcelWorkbook();
    
    // Add first sheet
    var customerSheet = workbook.AddWorksheet("Customers");
    await customerSheet.WriteDataAsync(customers, new ExcelExportOptions<Customer> 
    { 
        AutoFitColumns = true 
    });
    
    // Add second sheet
    var ordersSheet = workbook.AddWorksheet("Orders");
    await ordersSheet.WriteDataAsync(orders, new ExcelExportOptions<Order>
    {
        AutoFitColumns = true,
        IncludeHeader = true,
        HeaderStyle = new CellStyle { FontBold = true }
    });
    
    // Export to byte array
    using var stream = new MemoryStream();
    await workbook.SaveAsAsync(stream);
    return stream.ToArray();
}

3. Custom Column Mapping and Formatting

public async Task<byte[]> ExportWithCustomMapping(IEnumerable<Product> products)
{
    var options = new ExcelExportOptions<Product>
    {
        SheetName = "Products",
        AutoFitColumns = true,
        IncludeHeader = true,
        ColumnMappings = new List<ColumnMapping<Product>>
        {
            new()
            {
                Property = p => p.Id,
                Header = "ID",
                Width = 10,
                Style = new CellStyle { HorizontalAlignment = HorizontalAlignment.Center }
            },
            new()
            {
                Property = p => p.Name,
                Header = "Product Name",
                Width = 30,
                Style = new CellStyle { FontBold = true }
            },
            new()
            {
                Property = p => p.Price,
                Header = "Price (USD)",
                Format = "$#,##0.00",
                Style = new CellStyle 
                { 
                    NumberFormat = NumberFormat.Currency,
                    HorizontalAlignment = HorizontalAlignment.Right
                }
            },
            new()
            {
                Property = p => p.StockQuantity,
                Header = "In Stock",
                Style = new CellStyle { HorizontalAlignment = HorizontalAlignment.Center },
                ConditionalFormats = new List<ConditionalFormat>
                {
                    new()
                    {
                        Condition = cell => (int)cell.Value < 10,
                        Style = new CellStyle { BackgroundColor = Color.LightPink }
                    },
                    new()
                    {
                        Condition = cell => (int)cell.Value == 0,
                        Style = new CellStyle 
                        { 
                            BackgroundColor = Color.Red, 
                            FontColor = Color.White 
                        }
                    }
                }
            },
            new()
            {
                Property = p => p.LastRestocked,
                Header = "Last Restocked",
                Format = "yyyy-MM-dd",
                Style = new CellStyle { HorizontalAlignment = HorizontalAlignment.Center }
            }
        }
    };

    return await _excelExporter.ExportToByteArrayAsync(products, options);
}

4. Exporting to CSV

public async Task<string> ExportToCsvAsync<T>(IEnumerable<T> data, string delimiter = ",")
{
    var options = new CsvExportOptions
    {
        Delimiter = delimiter,
        IncludeHeader = true,
        Encoding = Encoding.UTF8
    };

    return await _csvExporter.ExportToStringAsync(data, options);
}

📚 API Reference

Interfaces

IExcelExporter

Main interface for Excel export operations.

Methods:

• Task<byte[]> ExportToByteArrayAsync<T>(IEnumerable<T> data, ExcelExportOptions<T> options = null)
• Task<Stream> ExportToStreamAsync<T>(IEnumerable<T> data, ExcelExportOptions<T> options = null)
• Task ExportToFileAsync<T>(string filePath, IEnumerable<T> data, ExcelExportOptions<T> options = null)
• Task<ExcelWorkbook> CreateWorkbookAsync<T>(IEnumerable<T> data, ExcelExportOptions<T> options = null)

ICsvExporter

Interface for CSV export operations.

Methods:

• Task<string> ExportToStringAsync<T>(IEnumerable<T> data, CsvExportOptions options = null)
• Task<byte[]> ExportToByteArrayAsync<T>(IEnumerable<T> data, CsvExportOptions options = null)
• Task ExportToFileAsync<T>(string filePath, IEnumerable<T> data, CsvExportOptions options = null)

Models

ExcelExportOptions<T>

Options for exporting data to Excel.

Properties:

• string SheetName - Name of the worksheet (default: "Sheet1")
• bool AutoFitColumns - Whether to auto-fit column widths (default: true)
• bool IncludeHeader - Whether to include column headers (default: true)
• CellStyle HeaderStyle - Style for header cells
• CellStyle DataStyle - Default style for data cells
• IList<ColumnMapping<T>> ColumnMappings - Custom column mappings
• IDictionary<string, string> CustomProperties - Custom document properties
• bool FreezeHeader - Whether to freeze the header row (default: true)
• bool ShowGridLines - Whether to show grid lines (default: true)

CsvExportOptions

Options for exporting data to CSV.

Properties:

• string Delimiter - Field delimiter (default: ",")
• bool IncludeHeader - Whether to include column headers (default: true)
• Encoding Encoding - Text encoding (default: UTF-8)
• string NewLine - Line terminator (default: Environment.NewLine)
• bool QuoteAllFields - Whether to quote all fields (default: false)

🔒 Security Considerations

1. Input Validation

   • Always validate input data before exporting
   • Sanitize user-provided file names and paths
   • Implement proper error handling for file operations

2. Data Protection

   • Be cautious when exporting sensitive data
   • Implement proper access controls
   • Consider encryption for sensitive exports

3. Performance

   • Use streaming for large datasets
   • Implement pagination for very large datasets
   • Consider server-side processing for complex exports

🚀 Performance Tips

1. Batch Processing

   • Process data in batches for large datasets
   • Use streaming when possible to reduce memory usage
   • Consider server-side pagination for web applications

2. Memory Management

   • Dispose of resources properly
   • Use IAsyncDisposable for async operations
   • Consider using ArrayPool<T> for large arrays

3. Caching

   • Cache frequently accessed templates
   • Consider caching generated reports when appropriate
   • Implement proper cache invalidation

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🤝 Contributing

Contributions are welcome! Please read our contributing guidelines for details on our code of conduct and the process for submitting pull requests.

📫 Support

For support, please open an issue in our issue tracker.

Ejemplos Avanzados

Exportación Asíncrona

await data.ExportToCsvAsync("archivo.csv");

Exportación con Filtrado

var filteredData = data.Where(x => x.IsActive)
    .ExportToCsv("archivo_filtrado.csv");

Exportación con Transformación

var transformedData = data.Select(x => new {
    x.Id,
    x.Name,
    FormattedDate = x.CreatedDate.ToString("dd/MM/yyyy")
});

transformedData.ExportToCsv("archivo_transformado.csv");

Soporte y Contribución

Para reportar errores o solicitar características, por favor abre un issue en el repositorio de GitHub.

Licencia

Este proyecto está bajo licencia MIT. Consulta el archivo LICENSE para más detalles.