A comprehensive messaging and component framework for building scalable, maintainable microservices and distributed systems in C#/.NET.

Conduit is a plugin-based messaging framework that provides:

• Component-Based Architecture: Dynamic discovery and lifecycle management of pluggable components
• CQRS Pattern: First-class support for Commands, Queries, and Events
• Pipeline Processing: Flexible behavior chain for message processing
• Multi-Transport Support: AMQP/RabbitMQ, gRPC, TCP, and Kafka adapters
• Enterprise Features: Saga orchestration, security, resilience patterns, and metrics
• Hot Reload: Dynamic component loading and unloading without restart

Conduit/
├── src/
│   ├── Conduit.Api/                 # Core interfaces and contracts
│   ├── Conduit.Core/                # Framework implementation
│   ├── Conduit.Common/              # Shared utilities
│   ├── Conduit.Pipeline/            # Pipeline framework
│   ├── Conduit.Components/          # Component system
│   ├── Conduit.Messaging/           # Message bus and routing
│   ├── Conduit.Saga/                # Distributed transaction orchestration
│   ├── Conduit.Security/            # Authentication and authorization
│   ├── Conduit.Resilience/          # Circuit breakers and retry policies
│   ├── Conduit.Persistence/         # Database adapters
│   ├── Conduit.Serialization/       # Multi-format serialization
│   ├── Conduit.Transports/          # Transport implementations
│   │   ├── Conduit.Transports.Core/
│   │   ├── Conduit.Transports.Amqp/
│   │   ├── Conduit.Transports.Grpc/
│   │   └── Conduit.Transports.Tcp/
│   └── Conduit.Application/         # Application host
├── tests/                           # Unit and integration tests
├── examples/                        # Example implementations
└── docker/                          # Docker configuration

• .NET 8 SDK
• Docker (optional, for running infrastructure)

# Clone the repository
git clone https://github.com/conduit/conduit-dotnet.git
cd Conduit

# Build the solution
dotnet build

# Run tests
dotnet test

# Run with Docker
docker-compose up -d

using Conduit.Api;

[Component("my-component", "My Component", "1.0.0")]
public class MyComponent : IPluggableComponent
{
    public string Id => "my-component";
    public string Name => "My Component";
    public string Version => "1.0.0";
    public string Description => "A sample component";

    public async Task OnAttachAsync(ComponentContext context, CancellationToken cancellationToken)
    {
        // Initialize component
        context.Logger.LogInformation("Component attached");
    }

    public IEnumerable<IBehaviorContribution> ContributeBehaviors()
    {
        // Return behaviors to add to the pipeline
        yield break;
    }

    public IEnumerable<MessageHandlerRegistration> RegisterHandlers()
    {
        // Register command, event, and query handlers
        yield return MessageHandlerRegistration.ForCommand<CreateOrderCommand, CreateOrderCommandHandler>();
    }
}

public class CreateOrderCommand : ICommand<OrderCreatedResult>
{
    public string CustomerId { get; set; }
    public List<OrderItem> Items { get; set; }
}

// Send command
var result = await messageBus.SendAsync(new CreateOrderCommand
{
    CustomerId = "123",
    Items = new List<OrderItem> { ... }
});

public class OrderCreatedEvent : IEvent
{
    public string OrderId { get; set; }
    public string CustomerId { get; set; }
    public decimal TotalAmount { get; set; }
}

// Publish event
await messageBus.PublishAsync(new OrderCreatedEvent
{
    OrderId = "456",
    CustomerId = "123",
    TotalAmount = 99.99m
});

public class GetOrderQuery : IQuery<Order>
{
    public string OrderId { get; set; }
}

// Execute query
var order = await messageBus.QueryAsync(new GetOrderQuery { OrderId = "456" });

Components are the building blocks of the Conduit framework. They can:

• Contribute behaviors to the message pipeline
• Register message handlers
• Provide services to other components
• Expose features for discovery

The message pipeline processes all messages through a chain of behaviors. Components contribute behaviors that can:

• Validate messages
• Add security context
• Log and collect metrics
• Transform messages
• Handle errors

The central message bus handles:

• Command routing (one handler)
• Event publishing (multiple handlers)
• Query execution (one handler)
• Pipeline execution

• Dynamic component discovery
• Hot reload support
• Dependency management
• Isolation levels

• CQRS pattern implementation
• Request-response for commands/queries
• Pub-sub for events
• Message correlation and causation tracking

• Behavior chain pattern
• Ordered behavior placement
• Interceptors and middleware
• Conditional behavior execution

• Authentication and authorization
• Security context propagation
• Audit logging
• Encryption support

• Circuit breaker pattern
• Retry policies with backoff
• Timeout management
• Bulkhead isolation

• Metrics collection (Prometheus compatible)
• Distributed tracing support
• Structured logging
• Health checks

• Multiple database support (PostgreSQL, MongoDB, Redis)
• Caching abstraction
• Transaction management
• Repository pattern

• AMQP/RabbitMQ
• gRPC
• TCP/Sockets
• Kafka (planned)

Configuration is handled through appsettings.json:

{
  "Conduit": {
    "Components": {
      "DiscoveryPath": "./components",
      "EnableHotReload": true
    },
    "Messaging": {
      "DefaultTimeout": 30000,
      "MaxRetries": 3
    },
    "Transports": {
      "Amqp": {
        "ConnectionString": "amqp://localhost:5672"
      }
    }
  }
}

• Getting Started Guide
• Component Development
• Message Patterns
• Pipeline Configuration
• API Reference

See the /examples directory for complete examples:

• OrderService: CQRS implementation with event sourcing
• NotificationService: Event-driven notifications
• GatewayService: API gateway with routing

We welcome contributions! Please see CONTRIBUTING.md for details.

This project is licensed under the Business Source License 1.1 - see the LICENSE file for details.

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Documentation: https://docs.conduit.io

This is a C# port of the original Java Conduit framework, maintaining architectural compatibility while leveraging .NET ecosystem features.