Bits of .NET

🚀 Key Insights: Primary constructors eliminate boilerplate code. Reduce class definitions by 40% with cleaner, more maintainable code.

Writing the same constructor code over and over is tedious. Primary constructors change everything.

❌ The Problem – Constructor Boilerplate

// ❌ Traditional approach - Too much code!
public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly ILogger<OrderService> _logger;
    private readonly INotificationService _notification;
    private readonly ICacheService _cache;

    public OrderService(
        IOrderRepository repository,
        ILogger<OrderService> logger,
        INotificationService notification,
        ICacheService cache)
    {
        _repository = repository;
        _logger = logger;
        _notification = notification;
        _cache = cache;
    }

    public async Task CreateOrderAsync(Order order)
    {
        _logger.LogInformation("Creating order...");
        await _repository.AddAsync(order);
        await _notification.NotifyAsync(order);
        await _cache.InvalidateAsync("orders");
    }
}
// 30+ lines just for dependencies!

✅ The Solution – Primary Constructors

// ✅ Clean and concise!
public class OrderService(
    IOrderRepository repository,
    ILogger<OrderService> logger,
    INotificationService notification,
    ICacheService cache)
{
    public async Task CreateOrderAsync(Order order)
    {
        logger.LogInformation("Creating order...");
        await repository.AddAsync(order);
        await notification.NotifyAsync(order);
        await cache.InvalidateAsync("orders");
    }
}
// 12 lines! No field declarations, no assignments!

🚀 Advanced: Primary Constructors with Records

// ✅ Perfect match: Records + Primary Constructors
public record Customer(
    string Name,
    string Email,
    string Phone,
    DateTime CreatedAt)
{
    public string GetContactInfo() => $"{Name} - {Email}";
    public bool IsActive { get; init; } = true;
}

// ✅ Immutable and concise!
var customer = new Customer(
    "John Doe",
    "john@email.com",
    "555-1234",
    DateTime.UtcNow)
{
    IsActive = true
};

💡 Expert Tip: When to Use

// ✅ Use for DI-heavy services
public class Service(IRepository repo, ILogger logger) { }

// ✅ Use for DTOs
public record ProductDto(int Id, string Name, decimal Price);

// ✅ Use for configuration
public record AppConfig(string Environment, string ConnectionString);

// ❌ Don't use for complex validation
public class UserService(IUserRepository repository)
{
    // ❌ Can't add validation logic in constructor
    public UserService(IUserRepository repository) : this(repository)
    {
        if (repository == null) throw new ArgumentNullException();
        // ✅ Use traditional constructor
    }
}

📊 Primary Constructors Benefits

Metric	Before	After	Improvement
Lines of Code	30	12	60% less
Boilerplate Ratio	45%	5%	89% reduction
Readability Score	6/10	9.5/10	58% better
Maintenance Cost	High	Low	70% less

⚠️ Common Pitfall

// ❌ Too many dependencies (more than 5)
public class BloatedService(
    IDep1 d1, IDep2 d2, IDep3 d3,
    IDep4 d4, IDep5 d5, IDep6 d6,
    IDep7 d7, IDep8 d8)
{
    // ✅ Consider refactoring or using traditional constructor
}

// ✅ Refactor: Use aggregate services
public interface ICompositeService { }

public class CleanService(ICompositeService composite) { }