Introducing Apiand, The Agile ASP.NET Framework

Features that elevate your API development

Designed with modern developers in mind, our framework provides everything you need to build sophisticated APIs with less code and more confidence.

.NET Aspire

Uses .NET Aspire to power developer experience, providing Cloud native capabilities and a streamlined development

Multiple Architectures

Support for multiple software architecture and open to contributions. Choose the architecture that fits your project needs.

Powerful CLI Tools

Quickly generate software components with simple commands.

Automated Workflows

Intelligent dependency injection and streamlined development workflows.

Built on .NET

Leverages the full power of the .NET ecosystem. Use the tools, libraries and frameworks you already know and love.

Built-in Observability

Integrated logging, tracing, and monitoring for deep insights into your API behavior.

Persistence Flexibility

Built-in support for multiple database types with standardized access patterns.

Modular Design

Plug-and-play components and services for maximum reusability and maintainability.

Elegant and expressive code

Write clean, maintainable C# code that expresses your business logic clearly. Focus on what matters, while we handle the boilerplate.

UserService.cs

// Define a UserService with Apiand
[Service]
public class UserService : IUserService
{
    private readonly IUserRepository _userRepository;
    private readonly IAuthService _authService;
    private readonly ILogger<UserService> _logger;
    
    public UserService(
        IUserRepository userRepository,
        IAuthService authService,
        ILogger<UserService> logger)
    {
        _userRepository = userRepository;
        _authService = authService;
        _logger = logger;
    }
    
    public async Task<UserDto> CreateUserAsync(CreateUserDto userData)
    {
        _logger.LogInformation("Creating user with email {Email}", userData.Email);
        
        // Validate email uniqueness
        if (await _userRepository.ExistsAsync(u => u.Email == userData.Email))
        {
            throw new DomainException("User with this email already exists", "USER_EXISTS");
        }
        
        // Hash password securely
        string hashedPassword = _authService.HashPassword(userData.Password);
        
        // Create and save user entity
        var user = new User
        {
            Email = userData.Email,
            PasswordHash = hashedPassword,
            Name = userData.Name,
            Roles = new[] { Role.User }
        };
        
        await _userRepository.AddAsync(user);
        await _userRepository.SaveChangesAsync();
        
        // Generate auth token
        string token = _authService.GenerateToken(user);
        
        return UserMapper.ToDto(user, token);
    }
}

Focus on business logic, not boilerplate

Our framework handles the complex infrastructure concerns like dependency injection, validation, error handling, and persistence, letting you focus on what your API needs to do.

• Automatic dependency injection wiring
• Built-in logging and tracing
• Standardized exception handling
• Clean architecture patterns

Choose your architectural style

One framework supporting multiple architectural patterns. Select the approach that best fits your project's needs.

Domain-Driven Design

Perfect for complex business domains with rich models and clearly defined boundaries

• Entities & Value Objects
• Aggregates & Repositories
• Domain Events
• Bounded Contexts

Modular Monolith + Vertical Slice

Roadmap

Combines modular organization with feature-focused vertical slices for maintainable monoliths

• Feature Encapsulation
• Reduced Cross-Module Dependencies
• Independent Feature Development
• Schema Isolation

Single Layer

Simple straightforward one layer app for quick and easy development

• Fast Development
• Simple Deployment
• Easy to Reason About
• Reduced Complexity

Microservices

Distributed architecture for large-scale systems with independent deployable services

• Service Boundaries
• Event-Based Communication
• Independent Deployment
• Scalability

Powerful CLI tools at your fingertips

Speed up development with an intelligent command-line interface that generates code, creates components, and scaffolds project structures.

Create a new API project

Scaffolds a new API project with Domain-Driven Design architecture

CLI

apiand

Generate a service

Adds a new service with interface and dependency injection

CLI

apiand

Add a new endpoint

Creates a new endpoint with payload, response and service integration

CLI

apiand

Generate domain entities

Creates a domain entity with specified attributes and validation

CLI

apiand

terminal

$

apiand

new ddd --project-name my-awesome-api

✓ Parsing command...

✓ Validating options...

✓ Generating files...

Product Roadmap

This roadmap reflects our current development priorities and planned features. The sequence and scope of upcoming features may change based on community feedback and evolving requirements.

Core Framework

Solid foundation with modularity, DI container, and developer-first APIs

CLI Tooling

Generate services, components and connect your architecture seamlessly

Multi-Architecture Templates

Current Focus

DDD, Hexagonal, CQRS and microservice patterns out of the box

VS Studio / Rider plugins

Short-term

Add a UI wrapper for the CLI as a plugin for your IDE of preference

Cloud-Native Integration

Medium-term

Seamless deployment to major cloud providers with zero configuration

Enterprise Features

Long-term

Advanced logging, tracing, metrics and documentation generation