高级 C# 编程：工程师开发最佳实践

郑子铭

发布于 2025-02-10 19:48:02

10300

代码可运行

文章被收录于专栏：DotNet NB && CloudNativeDotNet NB && CloudNative

运行总次数：0

代码可运行

精通C#不仅仅在于理解它的语法——更在于运用高级技术去解决复杂的现实世界中的难题。作为一名有着实际操作经验的资深软件工程师，我见识过对C#高级特性的细致入微的了解是如何提升代码质量、可维护性以及性能的。本指南将深入探讨C#在实际应用中的情况，这些应用在企业开发中有着切实的影响。从高级面向对象编程原则到性能优化，这些技术和最佳实践对于任何严谨的开发人员来说都是必不可少的。

1. 面向对象编程：超越基础

正确运用封装

封装在C#中是基础，但有效地运用它需要精心构建结构。让我们来看一个现实世界中的常见场景：构建一个支付处理系统。

以下是一个使用封装来保护数据并确保正确处理依赖关系的示例实现：

public classPaymentProcessor
{
    privatereadonlyILogger _logger;
    privatereadonlyIPaymentGateway _paymentGateway;
    privatereadonlydecimal _maxTransactionAmount;

    publicPaymentProcessor(ILogger logger,IPaymentGateway paymentGateway)
    {
        _logger = logger??thrownewArgumentNullException(nameof(logger));
        _paymentGateway = paymentGateway??thrownewArgumentNullException(nameof(paymentGateway));
        _maxTransactionAmount =10000M;// 在生产环境中可配置
    }

    publicasyncTask<PaymentResult>ProcessPaymentAsync(PaymentRequest request)
    {
        ValidateRequest(request);
        
        try
        {
            var result =await _paymentGateway.ProcessAsync(request);
            _logger.LogInformation($"Payment processed: {request.TransactionId}");
            return result;
        }
        catch(Exception ex)
        {
            _logger.LogError(ex,$"Payment failed: {request.TransactionId}");
            throw;
        }
    }

    privatevoidValidateRequest(PaymentRequest request)
    {
        if(request.Amount > _maxTransactionAmount)
            thrownewBusinessException("金额超出最大交易限额");
    }
}

继承与组合：做出正确选择

选择组合而非继承通常能增强灵活性。以下展示了在实际中如何运用这种方法：

// 基于组合的方法
publicclassEnhancedPaymentProcessor
{
    privatereadonlyPaymentProcessor _baseProcessor;
    privatereadonlyIFraudDetector _fraudDetector;

    publicEnhancedPaymentProcessor(
        PaymentProcessor baseProcessor,
        IFraudDetector fraudDetector)
    {
        _baseProcessor = baseProcessor;
        _fraudDetector = fraudDetector;
    }

    publicasyncTask<PaymentResult>ProcessWithFraudCheckAsync(PaymentRequest request)
    {
        await _fraudDetector.ValidateTransactionAsync(request);
        returnawait _baseProcessor.ProcessPaymentAsync(request);
    }
}

在这种方法中，EnhancedPaymentProcessor类使用组合来添加欺诈检测功能，同时又不会使各个类紧密耦合在一起。

2. 接口设计：企业应用程序的最佳实践

接口对于可维护的应用程序至关重要。以下是在设计接口时如何考虑内聚性以及接口隔离原则（Interface Segregation Principle，简称ISP）的方法。

应用接口隔离原则

不要使用一个宽泛的接口，而是将功能分解为更小、更专注的接口：

// 宽泛的接口（不理想）
publicinterfaceIOrderProcessor
{
    Task<Order>CreateOrderAsync(OrderRequest request);
    Task<OrderStatus>GetStatusAsync(string orderId);
    Task<Order>UpdateOrderAsync(string orderId,OrderUpdateRequest request);
    TaskCancelOrderAsync(string orderId);
    Task<IEnumerable<Order>>GetOrderHistoryAsync(string customerId);
    Task<Invoice>GenerateInvoiceAsync(string orderId);
}

// 更好的做法——按职责分离接口
publicinterfaceIOrderCreator
{
    Task<Order>CreateOrderAsync(OrderRequest request);
}

publicinterfaceIOrderManager
{
    Task<OrderStatus>GetStatusAsync(string orderId);
    Task<Order>UpdateOrderAsync(string orderId,OrderUpdateRequest request);
    TaskCancelOrderAsync(string orderId);
}

publicinterfaceIOrderHistory
{
    Task<IEnumerable<Order>>GetOrderHistoryAsync(string customerId);
}

publicinterfaceIInvoiceGenerator
{
    Task<Invoice>GenerateInvoiceAsync(string orderId);
}

这种设计使系统保持模块化，更易于维护。

3. 实用的反射：何时以及如何使用它

反射功能强大，但由于其性能开销，应该谨慎使用。以下是一个使用反射来动态映射配置值的示例。

public classConfigurationMapper
{
    publicTMapConfiguration<T>(Dictionary<string, string> configValues)whereT:new()
    {
        var result =newT();
        var properties =typeof(T).GetProperties()
           .Where(p => p.CanWrite && p.GetCustomAttribute<ConfigurationAttribute>()!=null);

        foreach(var property in properties)
        {
            var attribute = property.GetCustomAttribute<ConfigurationAttribute>();
            if(configValues.TryGetValue(attribute.Key,outstringvalue))
            {
                var convertedValue = Convert.ChangeType(value, property.PropertyType);
                property.SetValue(result, convertedValue);
            }
        }

        return result;
    }
}

通过将反射限制在配置映射方面的使用，我们在获得灵活性的同时，不会对性能产生重大影响。

4. 错误处理最佳实践

在生产应用程序中，错误处理至关重要。以下是一种用于结构化错误管理的模式。

public classResult<T>
{
    publicbool Success {get;}
    publicT Data {get;}
    publicstring Error {get;}
    publicException Exception {get;}

    privateResult(bool success,T data,string error,Exception exception =null)
    {
        Success = success;
        Data = data;
        Error = error;
        Exception = exception;
    }

    publicstaticResult<T>Ok(T data)=>newResult<T>(true, data,null);
    publicstaticResult<T>Fail(string error)=>newResult<T>(false,default, error);
    publicstaticResult<T>Fail(Exception ex)=>newResult<T>(false,default, ex.Message, ex);
}

// 使用示例
publicclassUserService
{
    publicasyncTask<Result<User>>CreateUserAsync(UserCreateRequest request)
    {
        try
        {
            var validationResult =awaitValidateRequestAsync(request);
            if(!validationResult.Success)
                return Result<User>.Fail(validationResult.Error);

            var user =await _userRepository.CreateAsync(request);
            return Result<User>.Ok(user);
        }
        catch(Exception ex)
        {
            _logger.LogError(ex,"创建用户失败");
            return Result<User>.Fail(ex);
        }
    }
}

使用Result类可以使响应标准化，清晰地表明操作是成功还是失败。

5. 性能优化技巧

性能至关重要，特别是对于高需求的应用程序而言。缓存是优化数据库或API调用的一种有用技术。

public classCachedRepository<T>whereT:class, IEntity
{
    privatereadonlyIMemoryCache _cache;
    privatereadonlyIRepository<T> _repository;
    privatereadonlyTimeSpan _cacheDuration;

    publicCachedRepository(
        IMemoryCache cache,
        IRepository<T> repository,
        TimeSpan? cacheDuration =null)
    {
        _cache = cache;
        _repository = repository;
        _cacheDuration = cacheDuration?? TimeSpan.FromMinutes();
    }

    publicasyncTask<T>GetByIdAsync(string id)
    {
        var cacheKey =$"{typeof(T).Name}:{id}";
        
        returnawait _cache.GetOrCreateAsync(cacheKey,async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = _cacheDuration;
            returnawait _repository.GetByIdAsync(id);
        });
    }
}

这个CachedRepository类实现了缓存功能，以减轻底层数据源的负载，提高频繁请求时的性能。

精通C#意味着不仅要理解它的特性，还要知道在现实场景中何时以及如何有效地运用它们。关键要点包括：