TextDiffLibrary 1.0.2

TextDiffLibrary

TextDiffLibrary is a high-performance text comparison library for .NET 9.0, implementing the Myers diff algorithm with support for both line-level and character-level differences. Ideal for comparing SQL stored procedures, configuration files, or any text content.

✨ Features

• 🚀 Myers Diff Algorithm - Industry-standard, efficient O(ND) complexity
• 📊 Line & Character Level Diffs - Detailed change tracking
• 🎨 Multiple Output Formats:
  • Excel DTO - Side-by-side comparison for spreadsheet export
  • JSON - Structured data for API integration
  • Unified Diff - Git-compatible patch format
  • HTML - Rich visual comparison with syntax highlighting
• ⚙️ Configurable Options:
  • Ignore whitespace/case/empty lines
  • Character-level diff toggle
  • Custom context lines for unified diff
• 💉 Dependency Injection Ready - Built-in DI support with AddTextDiffLibrary()
• 🔧 Async Support - Non-blocking diff computation
• 📝 Strongly Typed - Full C# nullable reference types support

📦 Installation

NuGet Package Manager

Install-Package TextDiffLibrary

.NET CLI

dotnet add package TextDiffLibrary

Package Reference

<PackageReference Include="TextDiffLibrary" Version="1.0.0" />

🚀 Quick Start

1. Setup Dependency Injection

using Microsoft.Extensions.DependencyInjection;
using TextDiffLibrary.Core.Extensions;

var services = new ServiceCollection();
services.AddTextDiffLibrary();
var serviceProvider = services.BuildServiceProvider();

2. Basic Text Comparison

using TextDiffLibrary.Contracts.Interfaces;
using TextDiffLibrary.Contracts.Models;

// Get the differ service
var differ = serviceProvider.GetRequiredService<ITextDiffer>();

// Source and target texts
string sourceText = """
    SELECT * FROM Users
    WHERE Age > 18
    ORDER BY Name
    """;

string targetText = """
    SELECT Name, Email FROM Users
    WHERE Age > 21
    ORDER BY Email
    """;

// Configure comparison options
var options = DiffOptions.CreateDefault(); // or customize

// Create comparison context
var context = ComparisonContext.Create(sourceText, targetText, options);

// Perform comparison
var result = differ.Compare(context);

// Access results
Console.WriteLine($"Total Changes: {result.Statistics.TotalChanges}");
Console.WriteLine($"Added: {result.Statistics.AddedLines}");
Console.WriteLine($"Deleted: {result.Statistics.DeletedLines}");
Console.WriteLine($"Modified: {result.Statistics.ModifiedLines}");

3. Iterate Over Changes

foreach (var line in result.Lines)
{
    Console.WriteLine($"[{line.ChangeType}] Line {line.SourceLineNumber ?? line.TargetLineNumber}");
    
    if (line.ChangeType == ChangeType.Modified && line.CharacterChanges != null)
    {
        foreach (var charChange in line.CharacterChanges)
        {
            Console.WriteLine($"  Char change at pos {charChange.Position}: {charChange.OldValue} → {charChange.NewValue}");
        }
    }
}

🎨 Output Formats

JSON Output

using TextDiffLibrary.Contracts.Interfaces;

var formatterFactory = serviceProvider.GetRequiredService<IFormatterFactory>();

// Use type-safe enum
var jsonFormatter = formatterFactory.GetFormatter<string>(FormatterType.Json);
var json = jsonFormatter.Format(result);

File.WriteAllText("diff-result.json", json);

Unified Diff (Git-compatible)

var unifiedFormatter = formatterFactory.GetFormatter<string>(FormatterType.Unified);
var patch = unifiedFormatter.Format(result);

File.WriteAllText("changes.patch", patch);
// Apply with: git apply changes.patch

HTML Report

var htmlFormatter = formatterFactory.GetFormatter<string>(FormatterType.Html);
var html = htmlFormatter.Format(result);

File.WriteAllText("diff-report.html", html);
Process.Start(new ProcessStartInfo("diff-report.html") { UseShellExecute = true });

Excel DTO (for spreadsheet export)

using TextDiffLibrary.Contracts.DTOs;

var excelFormatter = formatterFactory.GetFormatter<ExcelDiffDto>(FormatterType.Excel);
var excelDto = excelFormatter.Format(result);

foreach (var row in excelDto.Rows)
{
    Console.WriteLine($"{row.Status}: {row.SourceContent} → {row.TargetContent}");
}

⚙️ Configuration Options

DiffOptions

var options = new DiffOptions
{
    IgnoreWhitespace = true,           // Normalize whitespace differences
    IgnoreCase = true,                 // Case-insensitive comparison
    IgnoreEmptyLines = true,           // Skip empty lines
    EnableCharacterLevelDiff = true    // Compute character-level changes for Modified lines
};

Configure via appsettings.json

{
  "TextDiffLibrary": {
    "DefaultIgnoreWhitespace": true,
    "DefaultIgnoreCase": true,
    "DefaultIgnoreEmptyLines": true,
    "DefaultEnableCharacterDiff": true,
    "UnifiedDiffContextLines": 3,
    "EnablePerformanceLogging": false
  }
}

// Program.cs (ASP.NET Core / Web API)
builder.Services.AddTextDiffLibrary(options =>
{
    builder.Configuration.GetSection("TextDiffLibrary").Bind(options);
    options.Validate();
});

🏗️ Architecture

TextDiffLibrary
├── TextDiffLibrary.Contracts     - Interfaces, Models, DTOs
├── TextDiffLibrary.Core          - Myers Algorithm, Services
└── TextDiffLibrary.Formatters    - Output Formatters (JSON, HTML, etc.)

Key Interfaces

• ITextDiffer - Main diff computation service
• ITextNormalizer - Text preprocessing (whitespace, case)
• IMyersDiffEngine - Core Myers diff algorithm
• ICharacterDiffer - Character-level diff for modified lines
• IOutputFormatter<TOutput> - Generic formatter interface
• IFormatterFactory - Formatter resolution (by string or enum)

📚 Advanced Usage

Async Comparison

var result = await differ.CompareAsync(context, cancellationToken);

Custom JSON Serialization Options

builder.Services.AddTextDiffLibrary(options =>
{
    options.JsonSerializerOptions = new JsonSerializerOptions
    {
        WriteIndented = false,
        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    };
});

E2E Workflow with DiffService

using TextDiffLibrary.Core.Services;

var diffService = serviceProvider.GetRequiredService<DiffService>();

// Compute diff and format in one call (uses configured options if null)
var json = diffService.ComputeAndFormat<string>(sourceText, targetText, null, FormatterType.Json);
var html = diffService.ComputeAndFormat<string>(sourceText, targetText, null, FormatterType.Html);

🔧 Customization

Create Custom Formatter

public class MarkdownFormatter : IOutputFormatter<string>
{
    public string Format(DiffResult result)
    {
        var sb = new StringBuilder();
        sb.AppendLine("# Diff Report");
        
        foreach (var line in result.Lines)
        {
            sb.AppendLine($"- **{line.ChangeType}**: {line.SourceContent ?? line.TargetContent}");
        }
        
        return sb.ToString();
    }
}

// Register in DI
services.AddSingleton<MarkdownFormatter>();

📊 Performance

• Algorithm: Myers diff - O(ND) time complexity (N = input size, D = edit distance)
• Memory: O(N) with trace optimization
• Optimizations:
  • String hashing for fast equality checks
  • Early termination for identical files
  • Efficient line pairing with similarity threshold (80%)

Benchmarks (example)

🧪 Testing

The library includes comprehensive test coverage:

• 118+ unit tests covering all components
• Integration tests for E2E workflows
• Edge case handling (empty files, identical files, all changes)

dotnet test
# Test summary: total: 118; failed: 0; succeeded: 118; skipped: 0

📄 License

This project is licensed under the MIT License. See LICENSE for details.

🤝 Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

📝 Changelog

v1.0.0 (2026-01-27)

• ✨ Initial release
• 🚀 Myers diff algorithm implementation
• 📊 Line and character-level diff support
• 🎨 Four output formatters (Excel DTO, JSON, Unified Diff, HTML)
• ⚙️ Configurable comparison options
• 💉 Dependency injection integration
• 🔧 Async support

🔗 Links

• NuGet Package
• GitHub Repository
• Documentation
• Issue Tracker

💡 Use Cases

• 📜 SQL Stored Procedure Comparison - Track changes in database schema
• 🔧 Configuration File Diffs - Monitor application config changes
• 📝 Document Versioning - Compare text document revisions
• 🌐 API Response Validation - Diff JSON/XML responses
• 🧪 Test Result Comparison - Validate test output changes

👥 Authors

Maintained by the TextDiffLibrary contributors.

Happy Diffing! 🎉