How Claprec uses layered C# microservices for cleaner code

Claprec’s backend architecture stands out for its disciplined approach to separating concerns while avoiding code duplication. By implementing an N-tier microservice design with bitwise controller inheritance, the team built a system that balances strict organizational rules with practical development efficiency. This method offers a compelling alternative to traditional multiple inheritance limitations in C#.

Microservices in a Dockerized backend

The application runs as a containerized system with six separate services, each handling distinct responsibilities:

• Three backend microservices: the main API service, a real-time service, and a views-processing service
• A dedicated frontend container
• Infrastructure components including Microsoft SQL Server for data storage and RabbitMQ for message brokering

This containerized approach enables isolated scaling, simplified deployment, and easier maintenance. Each microservice communicates through well-defined interfaces, reducing coupling between components. The architecture deliberately avoids monolithic tendencies, allowing teams to update or scale individual services without affecting the entire system.

N-tier structure: enforcing separation of concerns

The main microservice follows a strict N-tier pattern where the depth of the stack varies depending on the operation’s complexity. This design choice ensures that each layer has a single responsibility, making the system easier to debug, test, and extend.

The architecture defines three stack configurations:

• 8-layer stack for entity mutations and CRUD operations, progressing from controller to repository
• 6-layer stack for database-stored enums, simplifying enum-related operations
• 4-layer stack for generic functionality, providing a leaner path for simpler operations

This tiered structure enforces the DRY principle by centralizing common logic while allowing specialized behavior where needed. Developers can mix and match layers depending on an endpoint’s requirements, avoiding unnecessary complexity.

Bitwise inheritance: solving C#’s inheritance gap

C#’s lack of multiple class inheritance presents challenges when building controllers that share common behaviors. Claprec’s solution draws inspiration from Unix file permissions by implementing bitwise controller hierarchy levels. Each CRUD operation type receives a unique bit value that defines its capabilities:

• Level 0 (ReadBasic): Supports basic read operations like paginated listing and single-entity retrieval
• Level 1 (ReadCalculated): Extends Level 0 with endpoints for calculated properties and detailed views
• Level 2 (Delete): Adds deletion capability with built-in existence checks
• Level 4 (Create): Includes entity creation with validation logic
• Level 8 (Update): Provides update functionality with validation and existence verification

This approach allows controllers to inherit only the functionality they need, effectively simulating multiple inheritance through composition. The bitwise system reduces boilerplate while maintaining type safety and clear code structure.

Practical implications for development teams

The architecture demonstrates how disciplined design choices can improve code maintainability without sacrificing performance. By combining N-tier separation with bitwise inheritance, Claprec achieves:

• Reduced duplication through shared base controllers and services
• Clearer code organization with explicit dependencies and responsibilities
• Easier extensibility as new features can be added by composing existing capabilities
• Better testability due to isolated layers and well-defined contracts

While the initial setup requires careful planning, the long-term benefits include faster onboarding for new developers and reduced risk of regression as the system evolves. This architecture positions Claprec well for future scaling and feature expansion.

As microservices continue to dominate backend development, Claprec’s approach offers valuable lessons in balancing architectural ideals with practical constraints. Teams looking to modernize their C# backends would do well to study this implementation as a model for clean, maintainable service design.