BizzelTech.QuickBooks 1.0.0

BizzelTools Excel Library

A powerful, customizable Excel library for .NET that provides a fluent API for creating and reading Excel documents. Built on top of the DocumentFormat.OpenXml library, BizzelTools.Excel offers an intuitive interface for Excel file manipulation while maintaining full control over the implementation.

🚀 Features

• Fluent API: Easy-to-use, chainable methods for building Excel files
• Full Excel Support: Create, read, and modify Excel (.xlsx) files
• Rich Formatting: Support for fonts, colors, borders, alignment, and number formats
• Formula Support: Add Excel formulas to cells with automatic calculation
• Data Import: Easily import data from collections and arrays
• Worksheet Management: Create, rename, copy, and manage multiple worksheets
• Cell Ranges: Work with individual cells or ranges of cells
• Export Options: Export to Excel or CSV formats
• Type Safety: Strongly typed API with full IntelliSense support
• Comprehensive Testing: Well-tested with unit tests covering all major functionality

📦 Installation

From NuGet Package

dotnet add package BizzelTools.Excel

Or via Package Manager Console in Visual Studio:

Install-Package BizzelTools.Excel

From Source

git clone https://github.com/yourusername/BizzelTools.git
cd BizzelTools
dotnet build

🏁 Quick Start

Creating a Simple Excel File

using BizzelTools.Excel;

// Create a simple workbook
var workbook = Excel.Create()
    .WithProperties(
        title: "My Workbook",
        author: "Your Name")
    .ConfigureWorksheet("Data", ws => ws
        .SetValue("A1", "Hello")
        .SetValue("B1", "World")
        .SetValue("A2", 42)
        .SetValue("B2", DateTime.Now))
    .SaveAs("example.xlsx");

Reading an Excel File

using BizzelTools.Excel;

// Open an existing Excel file
var workbook = Excel.Open("example.xlsx");

// Access worksheets and cells
var worksheet = workbook["Data"];
var cellValue = worksheet["A1"].Value;
Console.WriteLine($"Cell A1 contains: {cellValue}");

📖 Comprehensive Examples

1. Creating Styled Worksheets

var workbook = Excel.Create()
    .ConfigureWorksheet("Sales Report", ws => ws
        // Create headers
        .SetValue("A1", "Product")
        .SetValue("B1", "Price") 
        .SetValue("C1", "Quantity")
        .SetValue("D1", "Total")
        
        // Apply header styling
        .ApplyStyle("A1:D1", style => style
            .Font(bold: true, color: Color.White)
            .BackgroundColor(Color.DarkBlue)
            .CenterHorizontal()
            .Borders(BorderStyle.Thin))
        
        // Add data
        .SetValue("A2", "Widget A")
        .SetValue("B2", 10.50)
        .SetValue("C2", 5)
        .SetFormula("D2", "B2*C2")
        
        // Format currency
        .ApplyStyle("B2:B10", style => style.NumberFormat("$#,##0.00"))
        .ApplyStyle("D2:D10", style => style.NumberFormat("$#,##0.00")))
    .SaveAs("sales_report.xlsx");

2. Importing Data from Collections

var employees = new[]
{
    new { Name = "John Doe", Department = "IT", Salary = 75000 },
    new { Name = "Jane Smith", Department = "HR", Salary = 65000 },
    new { Name = "Bob Johnson", Department = "Finance", Salary = 80000 }
};

var workbook = Excel.Create()
    .ConfigureWorksheet("Employees", ws => ws
        .InsertData(1, 1, employees, includeHeaders: true)
        
        // Style the headers
        .ApplyStyle("A1:C1", style => style
            .Bold()
            .BackgroundColor(Color.LightGray))
        
        // Format salary column
        .ApplyStyle("C2:C4", style => style.NumberFormat("$#,##0")))
    .SaveAs("employees.xlsx");

3. Working with Formulas

var workbook = Excel.Create()
    .ConfigureWorksheet("Calculations", ws => ws
        // Basic arithmetic
        .SetValue("A1", 10)
        .SetValue("A2", 20)
        .SetFormula("A3", "A1+A2")
        
        // Excel functions
        .SetValue("B1", 1)
        .SetValue("B2", 2)
        .SetValue("B3", 3)
        .SetValue("B4", 4)
        .SetValue("B5", 5)
        .SetFormula("B6", "SUM(B1:B5)")
        .SetFormula("B7", "AVERAGE(B1:B5)")
        .SetFormula("B8", "MAX(B1:B5)"))
    .SaveAs("calculations.xlsx");

4. Multiple Worksheets

var workbook = Excel.Create()
    .AddWorksheet("Summary", ws => ws
        .SetValue("A1", "Quarter 1 Summary")
        .SetFormula("A2", "Q1!B10"))  // Reference to Q1 worksheet
    
    .AddWorksheet("Q1", ws => ws
        .SetValue("A1", "Q1 Data")
        .SetValue("B10", 50000))
    
    .AddWorksheet("Q2", ws => ws
        .SetValue("A1", "Q2 Data")
        .SetValue("B10", 75000))
    
    .SaveAs("quarterly_report.xlsx");

5. Advanced Styling

var workbook = Excel.Create()
    .ConfigureWorksheet("Styled Report", ws => ws
        .SetValue("A1", "Company Report")
        .ApplyStyle("A1", style => style
            .Font(name: "Arial", size: 18, bold: true, color: Color.DarkBlue)
            .CenterHorizontal())
        
        .SetValue("A3", "Important Note")
        .ApplyStyle("A3", style => style
            .Font(italic: true, underline: true)
            .FontColor(Color.Red)
            .BackgroundColor(Color.Yellow)
            .Borders(BorderStyle.Double))
        
        .SetValue("A5", "Wrapped Text Example\nThis text will wrap to multiple lines")
        .ApplyStyle("A5", style => style.WrapText(true)))
    .SaveAs("styled_report.xlsx");

🏗️ Architecture

The library is structured with the following main components:

Core Models

• ExcelWorkbook: Represents an Excel workbook containing multiple worksheets
• ExcelWorksheet: Represents a single worksheet with cells and data
• ExcelCell: Represents an individual cell with value, formula, and styling
• ExcelRange: Represents a range of cells for batch operations
• ExcelCellStyle: Defines formatting options for cells

I/O Operations

• ExcelReader: Handles reading Excel files and converting to library objects
• ExcelWriter: Handles writing library objects to Excel files and CSV export

Fluent API

• Excel: Main entry point with static methods
• ExcelWorkbookBuilder: Fluent builder for workbooks
• ExcelWorksheetBuilder: Fluent builder for worksheets
• ExcelStyleBuilder: Fluent builder for cell styles

🧪 Testing

The library includes comprehensive unit tests covering:

• Workbook and worksheet creation and management
• Cell value and formula operations
• Range operations and cell addressing
• Style application and inheritance
• File I/O operations
• Fluent API functionality

Run tests with:

dotnet test

🔧 Building from Source

1. Clone the repository
2. Restore dependencies: dotnet restore
3. Build the solution: dotnet build
4. Run tests: dotnet test
5. Create NuGet package: dotnet pack --configuration Release

📁 Project Structure

BizzelTools/
├── src/
│   └── BizzelTools.Excel/           # Main library
│       ├── Models/                  # Core model classes
│       ├── IO/                      # File I/O operations
│       └── ExcelFluentAPI.cs        # Fluent API implementation
├── tests/
│   └── BizzelTools.Excel.Tests/     # Unit tests
├── samples/
│   └── BizzelTools.Excel.Sample/    # Sample application
└── README.md                        # This file

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests for new functionality
5. Ensure all tests pass
6. Submit a pull request

📋 Requirements

• .NET 8.0 or later
• DocumentFormat.OpenXml 3.0.2 or later

📄 License

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

🙏 Acknowledgments

• Built on top of the DocumentFormat.OpenXml library
• Inspired by popular Excel libraries like EPPlus and ClosedXML
• Designed for developers who need full control over their Excel generation logic

📞 Support

For questions, issues, or feature requests, please open an issue on GitHub or contact the maintainers.

BizzelTools.Excel - Making Excel manipulation simple, powerful, and customizable.