CodeFactory.NDF 10.26141.1

Net Delivery Framework (NDF)

CodeFactory.NDF is a common delivery framework for .NET solutions, providing reusable patterns for managed exception handling, structured logging, and dependency injection loading across libraries and applications.

Supported Frameworks

Features

• ✅ Managed Exception Hierarchy — A structured set of application-safe exceptions derived from a common base class, designed to surface safe messages to end users without leaking internal details.
• ✅ Aggregated Exception Support — Collect and raise multiple managed exceptions together as a single unit.
• ✅ Structured Logging Extensions — Extended ILogger methods that capture member names, line numbers, and entry/exit logging automatically via caller info attributes.
• ✅ Dependency Injection Loader — An abstract base class for library-level DI registration, supporting layered loading of registrations across library hierarchies.

Installation

dotnet add package CodeFactory.NDF

Or via the NuGet Package Manager in Visual Studio by searching for CodeFactory.NDF.

Managed Exceptions

The NDF managed exception system provides a structured, application-safe exception hierarchy. All exceptions derive from ManagedException, which itself extends System.Exception. The intent is to ensure that only safe, user-appropriate messages are surfaced through exceptions, while still allowing inner exceptions to carry full internal diagnostic detail.

Design Principles

• Application-safe messages — Every exception type ships a default message via StandardExceptionMessages (a strongly-typed resource class). These messages are designed to be safe to display to end users.
• Custom messages — Every exception type supports construction with a custom message for more specific scenarios.
• Inner exception chaining — Every exception type accepts an optional internalException parameter, allowing the original lower-level exception to be preserved for logging and diagnostics without leaking it to the caller.
• Aggregation — ManagedExceptions (plural) collects multiple ManagedException instances into a single raised exception, supporting bulk validation or multi-step failure scenarios.

Exception Type Reference

Additional Properties

Structured Logging Extensions

LoggingExtensions adds extension methods to ILogger that automatically capture caller member names and line numbers using [CallerMemberName] and [CallerLineNumber], making structured log output more precise and diagnostics easier.

Key Methods

Usage Example

public class OrderService { private readonly ILogger<OrderService> _logger;
{
    public OrderService(ILogger<OrderService> logger)
    {
        _logger = logger;
    }

    public async Task ProcessOrderAsync(int orderId)
    {
        _logger.EnterLog(LogLevel.Debug);

        try
        {
            // ... processing logic ...
        }
        catch (ManagedException ex)
        {
            _logger.LogError(ex, ex.Message);
            throw;
        }
        finally
        {
            _logger.ExitLog(LogLevel.Debug);
        }
    }
}

Log output will automatically include the MemberName and LineNumber properties, enabling downstream structured log sinks (e.g., Serilog, Application Insights) to capture precise source location data.

Dependency Injection Loader

DependencyInjectionLoader is an abstract base class that provides a standardized pattern for registering services at the library level. It supports a layered loading pipeline:

1. LoadLibraries — Load DI registrations from dependent child libraries (override to compose libraries).
2. LoadManualRegistration — Register services that require manual or conditional configuration (override as needed).
3. LoadRegistration — Primary service registrations for this library (override to register your services).

Usage Example

public class MyLibraryLoader : DependencyInjectionLoader 
{ 

    protected override void LoadLibraries(IServiceCollection services, IConfiguration configuration)
    {
        // Load a dependent library's registrations
        new DependentLibraryLoader().Load(services, configuration);
    }

    protected override void LoadRegistration(IServiceCollection services, IConfiguration configuration) 
    { 
        services.AddScoped<IOrderService, OrderService>(); services.AddSingleton<IOrderRepository, OrderRepository>(); 
    }

}

Registering in your application startup:

var loader = new MyLibraryLoader(); 
loader.Load(builder.Services, builder.Configuration);

Dependencies

Repository & Documentation

• Source Code: https://github.com/CodeFactoryLLC/NDF
• API Documentation: https://codefactoryllc.github.io/NDF

License

Copyright © 2026 CodeFactory, LLC. All rights reserved.

Licensed under the MIT License.