DocumentIO — Building a Unified API for 7 Document Formats in C#

// ❌ What I almost did
if (path.EndsWith(".docx")) {
    using var doc = WordprocessingDocument.Open(path, false);
    foreach (var para in doc.MainDocumentPart.Document.Body.Descendants<Paragraph>())
        sb.AppendLine(para.InnerText);
} else if (path.EndsWith(".xlsx")) {
    using var wb = new XLWorkbook(path);
    // ...50 more lines
} else if (path.EndsWith(".pdf")) {
    // ...70 more lines
} // ... ad infinitum

┌─────────────────────────────────────────┐
│  ChatCompletions · MMO · DocumentProc   │
└────────────────────┬────────────────────┘
                     │ ImportAsync / ExportAsync
                     ▼
┌─────────────────────────────────────────┐
│  DocumentIOFacade                       │
│  - Format detection (ext → enum)        │
│  - Adapter resolution (DI lookup)       │
│  - Result normalization (ex → result)   │
└────────────────────┬────────────────────┘
                     │ IDocumentAdapter
                     ▼
┌──────┬──────┬──────┬──────┬──────┬──────┐
│ Docx │ Xlsx │  Pdf │  Md  │  Txt │ Csv  │
└───┬──┴───┬──┴───┬──┴───┬──┴───┬──┴───┬──┘
    │      │      │      │      │      │
    ▼      ▼      ▼      ▼      ▼      ▼
OpenXml ClosedXml PdfSharp Markdig File

public class DocumentIOFacade
{
    public Task<ImportResult> ImportAsync(string filePath, CancellationToken ct = default);
    public Task<ExportResult> ExportAsync(DocumentFormat format, ExportRequest req, CancellationToken ct = default);
    public static DocumentFormat InferFormatFromPath(string path);
}

public interface IDocumentAdapter
{
    DocumentFormat Format { get; }
    Task<ImportResult> ImportAsync(string filePath, CancellationToken ct);
    Task<ExportResult> ExportAsync(ExportRequest request, CancellationToken ct);
}

public class MarkdownAdapter : IDocumentAdapter
{
    public DocumentFormat Format => DocumentFormat.Markdown;

    public async Task<ImportResult> ImportAsync(string filePath, CancellationToken ct)
    {
        var text = await File.ReadAllTextAsync(filePath, ct);
        return ImportResult.Success(text, wordCount: text.Split(' ').Length);
    }

    public async Task<ExportResult> ExportAsync(ExportRequest request, CancellationToken ct)
    {
        await File.WriteAllTextAsync(request.TargetPath, request.Content, ct);
        return ExportResult.Success();
    }
}

public class DocxAdapter : IDocumentAdapter
{
    public DocumentFormat Format => DocumentFormat.Docx;

    public async Task<ImportResult> ImportAsync(string filePath, CancellationToken ct)
    {
        try
        {
            using var doc = WordprocessingDocument.Open(filePath, false);
            var body = doc.MainDocumentPart?.Document.Body;
            if (body is null)
                return ImportResult.Failure("Empty document");

            var sb = new StringBuilder();
            foreach (var para in body.Descendants<Paragraph>())
                sb.AppendLine(para.InnerText);

            return ImportResult.Success(sb.ToString());
        }
        catch (Exception ex)
        {
            return ImportResult.Failure($"OpenXml error: {ex.Message}");
        }
    }

    // Export: markdown → OOXML paragraphs
    // (similar pattern, ~60 lines)
}

// ❌ Coupling nightmare
try { /* import */ }
catch (OpenXmlPackageException ex) { }
catch (PdfReaderException ex) { }
catch (InvalidOperationException ex) when (ex.Message.Contains("sheet")) { }
// ...10 more exception types

// ✅ One check, done
var result = await documentIO.ImportAsync(path);
if (!result.Success)
    logger.LogWarning("Import failed: {Error}", result.ErrorMessage);
public record ImportResult
{
    public bool Success { get; init; }
    public string? Text { get; init; }
    public int WordCount { get; init; }
    public string? ErrorMessage { get; init; }

    public static ImportResult Success(string text, int wordCount = 0) => new()
        { Success = true, Text = text, WordCount = wordCount };

    public static ImportResult Failure(string error) => new()
        { Success = false, ErrorMessage = error };
}

public static DocumentFormat InferFormatFromPath(string path) =>
    Path.GetExtension(path).ToLowerInvariant() switch
    {
        ".docx"               => DocumentFormat.Docx,
        ".xlsx" or ".xlsm"    => DocumentFormat.Xlsx,
        ".pdf"                => DocumentFormat.Pdf,
        ".md" or ".markdown"  => DocumentFormat.Markdown,
        ".txt" or ".log"      => DocumentFormat.Text,
        ".csv" or ".tsv"      => DocumentFormat.Csv,
        ".json"               => DocumentFormat.Json,
        _                     => DocumentFormat.Unknown
    };