All async methods must return Task or Task<T>, never void.
The only exception is event handlers in UI frameworks.
Never call .Result or .Wait() on a Task — always await.
Suffix async method names with Async.
Use CancellationToken as the last parameter for all async methods.

public async void ProcessOrder(Order order)
{
    var user = _userRepository.GetByIdAsync(order.UserId).Result;
    await _paymentService.ChargeAsync(user, order.Total);
    _notificationService.SendAsync(user.Email, "Order processed").Wait();
}

public async Task ProcessOrderAsync(Order order, CancellationToken ct = default)
{
    var user = await _userRepository.GetByIdAsync(order.UserId, ct);
    await _paymentService.ChargeAsync(user, order.Total, ct);
    await _notificationService.SendAsync(user.Email, "Order processed", ct);
}

All service dependencies must be injected through the constructor as interfaces.
Never instantiate services with new inside a class.
Register services in Program.cs or a dedicated extension method.
Use primary constructors (C# 12) or readonly fields assigned in the constructor.

public class OrderService
{
    public async Task<Order> CreateOrderAsync(OrderRequest request)
    {
        var repo = new SqlOrderRepository(new DbContext());
        var gateway = new StripePaymentGateway();
        var notifier = new EmailNotificationService();

        var order = new Order(request.UserId, request.Total);
        await repo.SaveAsync(order);
        await gateway.ChargeAsync(order);
        await notifier.NotifyAsync(order.UserId, "Order created");
        return order;
    }
}

public class OrderService(
    IOrderRepository orderRepository,
    IPaymentGateway paymentGateway,
    INotificationService notificationService)
{
    public async Task<Order> CreateOrderAsync(OrderRequest request, CancellationToken ct = default)
    {
        var order = new Order(request.UserId, request.Total);
        await orderRepository.SaveAsync(order, ct);
        await paymentGateway.ChargeAsync(order, ct);
        await notificationService.NotifyAsync(order.UserId, "Order created", ct);
        return order;
    }
}

// Registration in Program.cs
builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddScoped<IPaymentGateway, StripePaymentGateway>();
builder.Services.AddScoped<INotificationService, EmailNotificationService>();

Use LINQ for filtering, transforming, and aggregating collections.
Reserve foreach for side effects only (logging, sending notifications, mutating external state).
Prefer method syntax (Where, Select, GroupBy) over query syntax.
Never call ToList() in the middle of a LINQ chain — materialize only at the end.

public List<OrderSummary> GetActiveOrderSummaries(List<Order> orders)
{
    var result = new List<OrderSummary>();
    foreach (var order in orders)
    {
        if (order.Status == OrderStatus.Active)
        {
            if (order.Total > 0)
            {
                var summary = new OrderSummary
                {
                    OrderId = order.Id,
                    CustomerName = order.Customer.Name,
                    Total = order.Total
                };
                result.Add(summary);
            }
        }
    }
    result.Sort((a, b) => b.Total.CompareTo(a.Total));
    return result;
}

public List<OrderSummary> GetActiveOrderSummaries(List<Order> orders) =>
    orders
        .Where(o => o.Status == OrderStatus.Active && o.Total > 0)
        .OrderByDescending(o => o.Total)
        .Select(o => new OrderSummary
        {
            OrderId = o.Id,
            CustomerName = o.Customer.Name,
            Total = o.Total,
        })
        .ToList();

Use a Result<T> pattern for operations that can fail due to business rules.
Reserve exceptions for truly exceptional situations (infrastructure failures, bugs).
Never use exceptions for control flow (validation, not-found, permission denied).
Return a discriminated result that the caller must handle explicitly.

public User GetUser(long id)
{
    var user = _dbContext.Users.Find(id);
    if (user == null)
        throw new NotFoundException($"User {id} not found");
    if (!user.IsActive)
        throw new BusinessException("User is deactivated");
    return user;
}

public abstract record GetUserResult
{
    public record Success(User User) : GetUserResult;
    public record NotFound(long UserId) : GetUserResult;
    public record Deactivated(long UserId) : GetUserResult;
}

public GetUserResult GetUser(long id)
{
    var user = _dbContext.Users.Find(id);
    if (user is null)
        return new GetUserResult.NotFound(id);
    if (!user.IsActive)
        return new GetUserResult.Deactivated(id);
    return new GetUserResult.Success(user);
}

// Caller — compiler warns about unhandled cases with pattern matching
var response = _userService.GetUser(id) switch
{
    GetUserResult.Success s => Ok(s.User),
    GetUserResult.NotFound nf => NotFound($"User {nf.UserId} not found"),
    GetUserResult.Deactivated d => BadRequest($"User {d.UserId} is deactivated"),
    _ => StatusCode(500),
};

PascalCase for public members, types, methods, properties, and namespaces.
camelCase for private fields, local variables, and parameters.
Prefix private fields with underscore: _userRepository.
Prefix interfaces with I: IUserService.
Use Async suffix for async methods: GetUserAsync.
Never use Hungarian notation or abbreviations (no strName, no btn, no svc).

public class user_service
{
    private IUserRepository userRepo;

    public async Task<User> getUserById(int user_id)
    {
        var db_result = await userRepo.find(user_id);
        return db_result;
    }
}

public class UserService
{
    private readonly IUserRepository _userRepository;

    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }

    public async Task<User> GetUserByIdAsync(int userId)
    {
        var user = await _userRepository.FindAsync(userId);
        return user;
    }
}

Use record types for DTOs, API contracts, and value objects.
Use required properties for mandatory fields.
Use init-only setters when a record needs incremental construction.
Reserve classes for entities with mutable state and behavior.

public class CreateOrderRequest
{
    public long UserId { get; set; }
    public decimal Total { get; set; }
    public List<string> Items { get; set; }
}

public record CreateOrderRequest(
    long UserId,
    decimal Total,
    IReadOnlyList<string> Items
);

// For responses with optional fields
public record OrderResponse
{
    public required long OrderId { get; init; }
    public required string Status { get; init; }
    public required decimal Total { get; init; }
    public DateTimeOffset? ShippedAt { get; init; }
}