Indiko.Common.Runtime.Abstractions 2.1.1

Indiko.Common.Runtime.Abstractions

Runtime abstractions for application bootstrapping and startup configuration in the Indiko framework.

Overview

This package provides base classes and interfaces for implementing custom bootstrappers and startup classes, enabling standardized application initialization patterns.

Features

• Base Bootstrapper: Abstract base class for application bootstrapping with lifecycle management
• Singleton Pattern: Built-in lazy singleton implementation for bootstrapper instances
• Startup Abstractions: Interfaces for defining application startup configuration
• Type-Safe Constraints: Generic constraints ensuring proper startup class implementations
• Async Support: Asynchronous application initialization and execution

Installation

dotnet add package Indiko.Common.Runtime.Abstractions

Key Components

IBaseStartup

Base interface for startup classes that configure application services and middleware.

public interface IBaseStartup
{
    // Marker interface for startup classes
}

IServiceBootstrapper<TStartupConstraint>

Interface for bootstrappers that initialize applications with specific startup types.

BaseBootstrapper<TBootstrapper, TStartupConstraint>

Abstract base class providing bootstrapping functionality with singleton pattern and lifecycle management.

Usage Example

Creating a Custom Bootstrapper

using Indiko.Common.Runtime.Abstractions;
using Indiko.Common.Runtime.Abstractions.Interfaces;

// Define your startup interface
public interface IWebStartup : IBaseStartup
{
    void ConfigureServices(IServiceCollection services);
    void Configure(IApplicationBuilder app);
}

// Implement the bootstrapper
public class WebBootstrapper : BaseBootstrapper<WebBootstrapper, IWebStartup>
{
    public override async Task<int> RunAsync<TStartup>(string[] args)
        where TStartup : class, IWebStartup
    {
        try
        {
            var builder = WebApplication.CreateBuilder(args);
            
            var startup = Activator.CreateInstance<TStartup>();
            startup.ConfigureServices(builder.Services);
            
            var app = builder.Build();
            startup.Configure(app);
            
            await app.RunAsync();
            return 0;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Application failed: {ex.Message}");
            return 1;
        }
    }
}

// Implement the startup class
public class Startup : IWebStartup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        // ... configure services
    }
    
    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints => endpoints.MapControllers());
        // ... configure middleware
    }
}

// Use the bootstrapper
class Program
{
    static async Task<int> Main(string[] args)
    {
        return await WebBootstrapper.Instance.RunAsync<Startup>(args);
    }
}

Benefits

1. Separation of Concerns: Clean separation between bootstrapping logic and application configuration
2. Reusability: Bootstrapper can be reused across multiple applications with different startup classes
3. Type Safety: Generic constraints ensure startup classes implement required interfaces
4. Singleton Pattern: Built-in singleton ensures only one bootstrapper instance per application
5. Error Handling: Robust error handling during instance creation and initialization

Architecture

The bootstrapper pattern follows these principles:

1. Lazy Initialization: Bootstrapper instances are created only when first accessed
2. Generic Constraints: Type safety through generic parameters and constraints
3. Async First: Async/await support throughout the lifecycle
4. Extensibility: Abstract methods allow custom initialization logic

Target Framework

• .NET 10

Dependencies

None - this is a zero-dependency abstraction package.

License

See LICENSE file in the repository root.

Related Packages

• Indiko.Common.Abstractions - Core abstractions and base types
• Indiko.Hosting.Abstractions - Hosting-specific abstractions
• Indiko.Hosting.Web - Web application hosting implementation