پارامتر کمال: تسلط بر استدلال های موقعیتی و نامگذاری شده در مدرن .NET

public class UserProfile
{
    public void UpdateProfile(string username, string email, int age, bool isActive)
    {
        // Implementation
    }
}

// Usage with positional parameters
var profile = new UserProfile();
profile.UpdateProfile("johndoe", "john@example.com", 32, true);

public class MessageFormatter
{
    public string Format(string message)
    {
        return $"INFO: {message}";
    }

    public string Format(string message, bool isError)
    {
        return isError ? $"ERROR: {message}" : $"INFO: {message}";
    }

    public string Format(string message, string category, int priority)
    {
        return $"{category}({priority}): {message}";
    }
}

public class Calculator
{
    public int Sum(params int[] numbers)
    {
        int result = 0;
        foreach (var num in numbers)
        {
            result += num;
        }
        return result;
    }
}

// Usage
var calc = new Calculator();
int result1 = calc.Sum(1, 2, 3);        // Passes 3 arguments
int result2 = calc.Sum(10, 20, 30, 40); // Passes 4 arguments

public class NotificationService
{
    public void SendNotification(string recipient, string subject, string body, bool isUrgent = false, string[] attachments = null)
    {
        // Implementation
    }
}

// Usage with named parameters
var notifier = new NotificationService();
notifier.SendNotification(
    recipient: "user@example.com",
    subject: "Meeting Reminder",
    body: "Don't forget our meeting tomorrow",
    isUrgent: true
);

public class ReportGenerator
{
    public string GenerateReport(
        string title,
        DateTime startDate,
        DateTime endDate,
        bool includeCharts = true,
        string format = "PDF",
        int compressionLevel = 0,
        bool encrypt = false
    )
    {
        // Implementation
        return $"Report generated: {title} ({format})";
    }
}

// Usage examples
var generator = new ReportGenerator();

// Only providing required parameters, using defaults for the rest
string report1 = generator.GenerateReport(
    title: "Sales Report",
    startDate: new DateTime(2023, 1, 1),
    endDate: new DateTime(2023, 3, 31)
);

// Providing required parameters and selectively overriding some defaults
string report2 = generator.GenerateReport(
    title: "Financial Analysis",
    startDate: new DateTime(2023, 1, 1),
    endDate: new DateTime(2023, 12, 31),
    format: "Excel",
    encrypt: true
);

public class UserManager
{
    public List FilterUsers(List users, Func predicate)
    {
        return users.Where(predicate).ToList();
    }
}

var manager = new UserManager();
var filteredUsers = manager.FilterUsers(
    users: allUsers,
    predicate: user => user.Age > 18 && user.IsActive
);

public void ConfigureService(string name, int timeout, bool isEnabled)
{
    // Implementation
}

// Valid in C# 7.2 and later
ConfigureService(name: "AuthService", 30, isEnabled: true);

public void ScheduleAppointment(DateTime dateTime, string patientName, bool isEmergency = false)
{
    // Implementation
}

// Usage
ScheduleAppointment(DateTime.Now.AddDays(1), "John Smith", isEmergency: true);

public void ProcessOrder(string orderId, double amount, string currency = "USD", bool expediteShipping = false)
{
    // Implementation
}

// Usage
ProcessOrder("ORD-12345", 299.99, expediteShipping: true);

public class OrderService
{
    private readonly IRepository _orderRepository;
    private readonly IPaymentProcessor _paymentProcessor;
    private readonly ILogger _logger;

    public OrderService(
        IRepository orderRepository,
        IPaymentProcessor paymentProcessor,
        ILogger logger)
    {
        _orderRepository = orderRepository;
        _paymentProcessor = paymentProcessor;
        _logger = logger;
    }

    // Service methods
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Register dependencies
        services.AddScoped, OrderRepository>();
        services.AddSingleton();
        services.AddTransient();

        // Register with factory method and named parameters
        services.AddSingleton(sp => new ConfigurationService(
            environment: "Production",
            useCache: true,
            logger: sp.GetRequiredService>()
        ));
    }
}

[Fact]
public void ProcessOrder_ValidOrder_ReturnsOrderConfirmation()
{
    // Arrange
    var mockRepository = new Mock>();
    var mockProcessor = new Mock();
    var mockLogger = new Mock>();

    var orderService = new OrderService(
        orderRepository: mockRepository.Object,
        paymentProcessor: mockProcessor.Object,
        logger: mockLogger.Object
    );

    var testOrder = new Order { /* Test data */ };

    // Act
    var result = orderService.ProcessOrder(testOrder);

    // Assert
    Assert.NotNull(result);
    Assert.Equal("Confirmed", result.Status);
}

// Record with positional parameters
public record Person(string FirstName, string LastName, int Age);

// Usage
var person = new Person("John", "Doe", 30);

// Deconstruction
var (firstName, lastName, age) = person;

public class SmtpOptions
{
    public string Server { get; set; }
    public int Port { get; set; }
    public bool UseSsl { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
}

public class EmailService
{
    private readonly SmtpOptions _options;

    public EmailService(IOptions options)
    {
        _options = options.Value;
    }

    // Service methods
}

// Registration
services.Configure(configuration.GetSection("Smtp"));

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddCustomAuthentication(
        this IServiceCollection services,
        string authority = null,
        bool requireHttpsMetadata = true,
        string apiName = null,
        string apiSecret = null)
    {
        // Implementation
        return services;
    }
}

// Usage
services.AddCustomAuthentication(
    authority: "https://auth.example.com",
    apiName: "api1",
    requireHttpsMetadata: false
);