Arena 1.0.0

Arena

Build distributed systems, not distributed complexity.

Arena is an opinionated infrastructure framework for building modern .NET microservices. It provides a consistent programming model for service-to-service communication, messaging, resiliency, service integration, and application infrastructure so teams can focus on business logic instead of boilerplate.

Arena is designed around production-ready practices and embraces event-driven architecture, asynchronous messaging, and clean service boundaries.

Why Arena?

Building microservices often means repeatedly solving the same infrastructure problems:

• Configuring MassTransit and RabbitMQ
• Creating resilient HTTP clients
• Handling retries and transient failures
• Standardizing request/response messaging
• Publishing integration events
• Managing service contracts
• Dependency injection configuration
• Distributed communication patterns
• Consistent conventions across services

Arena packages these concerns into reusable components so every service follows the same architecture.

Features

Messaging

• Event publishing
• Event subscriptions
• Request/Response messaging
• Command messaging
• Automatic consumer registration
• Queue conventions
• Exchange conventions
• Message serialization
• Correlation support

Service Infrastructure

• Convention-based configuration
• Dependency Injection extensions
• Service registration helpers
• Modular architecture
• Shared abstractions
• Common infrastructure components

Developer Experience

• Minimal setup
• Clean APIs
• Opinionated defaults
• Extensible architecture
• XML documentation
• Source Link support

Installation

dotnet add package Arena

Architecture

Arena encourages an event-driven architecture where services remain autonomous while communicating through contracts.

                +----------------+
                |  Identity      |
                +----------------+
                      │
             UserCreated Event
                      │
      ┌───────────────┼───────────────┐
      │               │               │
      ▼               ▼               ▼
+-------------+ +-------------+ +-------------+
| Notification| | Registration| |  Billing    |
+-------------+ +-------------+ +-------------+

Each service owns:

• Its own database
• Its own business logic
• Its own deployment lifecycle

Services communicate through messages instead of direct database access.

Philosophy

Arena follows several design principles:

• Convention over configuration
• Event-first communication
• Loose coupling
• High cohesion
• Production-ready defaults
• Infrastructure should disappear into the background
• Business logic should remain independent of transport technologies

Roadmap

• Messaging infrastructure
• Dependency injection extensions
• RabbitMQ integration
• MassTransit integration
• Distributed tracing
• Outbox support
• Inbox support

Contributing

Contributions are welcome.

If you'd like to improve Arena:

1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Open a Pull Request

Please ensure all tests pass before submitting changes.

License

Arena is released under the MIT License.

See the LICENSE file for details.

Vision

Arena exists to make building distributed .NET applications simple, consistent, and maintainable.

Instead of every service solving the same infrastructure challenges differently, Arena provides a unified foundation so development teams can concentrate on delivering business value while relying on proven, production-ready infrastructure.