C#中依赖注入常见问题：生命周期管理、循环依赖与动态解析实战

04310

在C#开发中，依赖注入(DI)是现代应用程序的核心架构模式，但很多开发者在实际使用过程中都会遇到各种棘手问题。本文将针对依赖注入中的典型故障场景，提供具体的错误现象、原因分析和解决方案。

图片[1]-C#中依赖注入常见问题：生命周期管理、循环依赖与动态解析实战

一、服务生命周期管理错误

1. Scoped服务在Singleton中解析导致内存泄漏

错误现象：

System.InvalidOperationException: Cannot consume scoped service 'MyApp.Services.IScopedService' from singleton 'MyApp.Services.SingletonService'.
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteValidator.ValidateScope(ServiceCallSite scopedCallSite, ServiceCallSite singletonCallSite)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteValidator.ValidateCallSite(ServiceCallSite callSite)

问题场景：

// 错误代码：Singleton服务中注入Scoped服务
public class SingletonService
{
    private readonly IScopedService _scopedService;  // 这是Scoped生命周期
    
    public SingletonService(IScopedService scopedService)  // 依赖注入
    {
        _scopedService = scopedService;
    }
    
    public void ProcessData()
    {
        _scopedService.DoSomething();  // 这里可能使用过期的DbContext
    }
}

// 服务注册
services.AddSingleton<SingletonService>();  // Singleton
services.AddScoped<IScopedService, ScopedService>();  // Scoped

问题分析：

  • Singleton服务在应用程序整个生命周期内只创建一次
  • Scoped服务在每个请求范围内创建一次，请求结束后释放
  • Singleton持有Scoped服务引用会导致Scoped服务无法及时释放
  • 如果Scoped服务包含DbContext，会导致数据库连接泄漏

解决方案：

// 方案1：使用IServiceProvider在方法内解析Scoped服务
public class CorrectSingletonService
{
    private readonly IServiceProvider _serviceProvider;
    
    public CorrectSingletonService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public void ProcessData()
    {
        using var scope = _serviceProvider.CreateScope();
        var scopedService = scope.ServiceProvider.GetRequiredService<IScopedService>();
        scopedService.DoSomething();  // 正确：每个调用创建新的Scoped实例
    }
}

// 方案2：重构设计，避免生命周期冲突
public class RefactoredService
{
    private readonly Func<IScopedService> _scopedServiceFactory;
    
    public RefactoredService(Func<IScopedService> scopedServiceFactory)
    {
        _scopedServiceFactory = scopedServiceFactory;
    }
    
    public void ProcessData()
    {
        var scopedService = _scopedServiceFactory();  // 工厂模式创建新实例
        scopedService.DoSomething();
    }
}

// 方案3：使用IServiceScopeFactory
public class ScopeAwareService
{
    private readonly IServiceScopeFactory _scopeFactory;
    
    public ScopeAwareService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }
    
    public async Task ProcessDataAsync()
    {
        using var scope = _scopeFactory.CreateScope();
        var scopedService = scope.ServiceProvider.GetRequiredService<IScopedService>();
        await scopedService.DoSomethingAsync();
    }
}

2. DbContext在多线程中被并发访问

错误现象：

System.InvalidOperationException: A second operation was started on this context instance before a previous operation completed. This is usually caused by different threads using the same instance of DbContext.
   at Microsoft.EntityFrameworkCore.Internal.ConcurrencyDetector.EnterCriticalSection()
   at Microsoft.EntityFrameworkCore.Query.Internal.SingleQueryingEnumerable`1.AsyncEnumerator.MoveNextAsync()

问题场景：

// 错误：DbContext被注册为Singleton
services.AddSingleton<MyDbContext>();  // 错误！DbContext应该是Scoped

// 或者在Singleton服务中使用DbContext
public class BackgroundService
{
    private readonly MyDbContext _dbContext;  // 注入的DbContext
    
    public async Task ProcessBatchAsync()
    {
        var tasks = Enumerable.Range(0, 10).Select(async i =>
        {
            // 多个线程同时使用同一个DbContext实例
            var data = await _dbContext.Users.FindAsync(i);
            // 并发访问导致异常
        });
        
        await Task.WhenAll(tasks);
    }
}

解决方案：

// 正确注册DbContext
services.AddDbContext<MyDbContext>(options =>
{
    options.UseSqlServer(connectionString);
});  // 默认是Scoped生命周期

// 多线程场景下的正确用法
public class SafeBackgroundService
{
    private readonly IServiceScopeFactory _scopeFactory;
    
    public SafeBackgroundService(IServiceScopeFactory scopeFactory)
    {
        _scopeFactory = scopeFactory;
    }
    
    public async Task ProcessBatchAsync()
    {
        var tasks = Enumerable.Range(0, 10).Select(async i =>
        {
            // 每个任务创建独立的Scope和DbContext
            using var scope = _scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService<MyDbContext>();
            
            var data = await dbContext.Users.FindAsync(i);
            // 每个线程使用独立的DbContext实例
        });
        
        await Task.WhenAll(tasks);
    }
}

二、循环依赖问题

1. 构造函数循环依赖

错误现象：

System.InvalidOperationException: A circular dependency was detected for the service of type 'MyApp.Services.IServiceA'.
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteVisitor.VisitCallSiteMain(ServiceCallSite callSite)
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteRuntimeResolver.Resolver(ServiceCallSite callSite, ServiceProviderEngineScope scope)

问题场景：

// 循环依赖：ServiceA → ServiceB → ServiceA
public class ServiceA : IServiceA
{
    private readonly IServiceB _serviceB;
    
    public ServiceA(IServiceB serviceB)  // 依赖ServiceB
    {
        _serviceB = serviceB;
    }
}

public class ServiceB : IServiceB  
{
    private readonly IServiceA _serviceA;  // 依赖ServiceA
    
    public ServiceB(IServiceA serviceA)
    {
        _serviceA = serviceA;  // 循环依赖！
    }
}

// 服务注册
services.AddScoped<IServiceA, ServiceA>();
services.AddScoped<IServiceB, ServiceB>();

解决方案：

// 方案1：使用属性注入打破循环
public class ServiceA : IServiceA
{
    // 使用属性注入而不是构造函数注入
    [FromKeyedServices("serviceB")]
    public IServiceB ServiceB { get; set; }
    
    public void DoWork()
    {
        ServiceB?.Execute();  // 使用时才解析依赖
    }
}

public class ServiceB : IServiceB  
{
    private readonly IServiceA _serviceA;
    
    public ServiceB(IServiceA serviceA)  // 只保留单向依赖
    {
        _serviceA = serviceA;
    }
}

// 注册时使用属性注入
services.AddScoped<IServiceA, ServiceA>()
    .AddPropertyInjection();  // 需要相应的扩展方法

// 方案2：使用工厂方法延迟解析
public class ServiceA : IServiceA
{
    private readonly Lazy<IServiceB> _serviceB;
    
    public ServiceA(Lazy<IServiceB> serviceB)  // Lazy延迟加载
    {
        _serviceB = serviceB;
    }
    
    public void DoWork()
    {
        _serviceB.Value.Execute();  // 实际使用时才创建
    }
}

// 方案3：重构设计，提取公共逻辑
public interface ICommonService { }

public class CommonService : ICommonService
{
    // 提取两个服务都需要的基础功能
}

public class ServiceA : IServiceA
{
    private readonly ICommonService _commonService;
    
    public ServiceA(ICommonService commonService)
    {
        _commonService = commonService;
    }
}

public class ServiceB : IServiceB  
{
    private readonly ICommonService _commonService;
    
    public ServiceB(ICommonService commonService)
    {
        _commonService = commonService;
    }
}

// 方案4：使用方法注入
public class ServiceA : IServiceA
{
    public void DoWork(IServiceB serviceB)  // 通过参数传入依赖
    {
        serviceB.Execute();
    }
}

public class ServiceB : IServiceB  
{
    private readonly IServiceA _serviceA;
    
    public ServiceB(IServiceA serviceA)
    {
        _serviceA = serviceA;
    }
}

2. 复杂对象图的循环依赖

错误现象：

System.InvalidOperationException: Circular dependency detected: 
MyApp.Controllers.HomeController → MyApp.Services.IUserService → MyApp.Repositories.IUserRepository → MyApp.Services.INotificationService → MyApp.Services.IUserService

解决方案：

// 使用Mediator模式解耦
public class UserService : IUserService
{
    private readonly IMediator _mediator;
    private readonly IUserRepository _userRepository;
    
    public UserService(IUserRepository userRepository, IMediator mediator)
    {
        _userRepository = userRepository;
        _mediator = mediator;  // 通过中介者发送通知
    }
    
    public async Task CreateUserAsync(User user)
    {
        await _userRepository.AddAsync(user);
        
        // 通过事件通知，而不是直接依赖INotificationService
        await _mediator.Publish(new UserCreatedEvent(user));
    }
}

public class NotificationService : INotificationHandler<UserCreatedEvent>
{
    public async Task Handle(UserCreatedEvent notification, CancellationToken cancellationToken)
    {
        // 处理用户创建通知
        await SendWelcomeEmail(notification.User);
    }
}

// 注册MediatR
services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()));

三、动态服务解析失败

1. 在Program.cs或Startup中解析服务

错误现象：

System.InvalidOperationException: Cannot resolve scoped service 'MyApp.Services.IMyService' from root provider.
   at Microsoft.Extensions.DependencyInjection.ServiceLookup.CallSiteValidator.ValidateResolution(ServiceCallSite callSite, ServiceProviderEngineScope scope, Type serviceType)

问题场景：

// 错误：在配置阶段解析Scoped服务
var serviceProvider = services.BuildServiceProvider();
var myService = serviceProvider.GetRequiredService<IMyService>();  // 抛出异常！

// 或者在Program.cs中
var app = builder.Build();
var service = app.Services.GetRequiredService<IMyService>();  // 可能有问题

解决方案：

// 正确方式1：在应用程序启动后解析
var app = builder.Build();

// 创建Scope来解析Scoped服务
using var scope = app.Services.CreateScope();
var myService = scope.ServiceProvider.GetRequiredService<IMyService>();
myService.Initialize();

// 正确方式2：使用IHostApplicationLifetime
public class StartupService
{
    private readonly IMyService _myService;
    
    public StartupService(IMyService myService)
    {
        _myService = myService;
    }
    
    public void Initialize()
    {
        _myService.Initialize();
    }
}

// 在Program.cs中
var app = builder.Build();

// 通过中间件或HostedService触发初始化
app.Services.GetRequiredService<StartupService>().Initialize();

// 正确方式3：使用IHostedService进行初始化
public class DataInitializerService : IHostedService
{
    private readonly IServiceProvider _serviceProvider;
    
    public DataInitializerService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        using var scope = _serviceProvider.CreateScope();
        var myService = scope.ServiceProvider.GetRequiredService<IMyService>();
        await myService.InitializeAsync();
    }
    
    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}

2. 基于条件的服务解析失败

错误现象：

System.InvalidOperationException: No service for type 'MyApp.Services.IPaymentService' has been registered.
   at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType)

问题场景：

// 尝试解析未注册的服务
public class PaymentProcessor
{
    private readonly IServiceProvider _serviceProvider;
    
    public PaymentProcessor(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public void ProcessPayment(string paymentMethod)
    {
        // 根据条件解析不同的服务
        var serviceType = paymentMethod switch
        {
            "CreditCard" => typeof(ICreditCardPaymentService),
            "PayPal" => typeof(IPayPalPaymentService),
            _ => throw new ArgumentException("Unsupported payment method")
        };
        
        var paymentService = _serviceProvider.GetRequiredService(serviceType);  // 可能失败
        paymentService.Process();
    }
}

解决方案：

// 方案1：使用工厂模式注册
services.AddTransient<ICreditCardPaymentService, CreditCardPaymentService>();
services.AddTransient<IPayPalPaymentService, PayPalPaymentService>();

// 注册工厂
services.AddTransient<PaymentServiceFactory>();
services.AddTransient<Func<string, IPaymentService>>(serviceProvider => paymentMethod =>
{
    return paymentMethod switch
    {
        "CreditCard" => serviceProvider.GetRequiredService<ICreditCardPaymentService>(),
        "PayPal" => serviceProvider.GetRequiredService<IPayPalPaymentService>(),
        _ => throw new ArgumentException($"Unsupported payment method: {paymentMethod}")
    };
});

// 使用工厂
public class PaymentProcessor
{
    private readonly Func<string, IPaymentService> _paymentServiceFactory;
    
    public PaymentProcessor(Func<string, IPaymentService> paymentServiceFactory)
    {
        _paymentServiceFactory = paymentServiceFactory;
    }
    
    public void ProcessPayment(string paymentMethod)
    {
        var paymentService = _paymentServiceFactory(paymentMethod);
        paymentService.Process();
    }
}

// 方案2：使用命名服务
services.AddTransient<IPaymentService, CreditCardPaymentService>("CreditCard");
services.AddTransient<IPaymentService, PayPalPaymentService>("PayPal");

public class PaymentProcessor
{
    private readonly IEnumerable<IPaymentService> _paymentServices;
    
    public PaymentProcessor(IEnumerable<IPaymentService> paymentServices)
    {
        _paymentServices = paymentServices;
    }
    
    public void ProcessPayment(string paymentMethod)
    {
        var paymentService = _paymentServices
            .FirstOrDefault(s => s.GetType().Name.StartsWith(paymentMethod));
            
        if (paymentService == null)
            throw new ArgumentException($"Unsupported payment method: {paymentMethod}");
            
        paymentService.Process();
    }
}

// 方案3：使用Keyed Services (.NET 8+)
services.AddKeyedTransient<IPaymentService, CreditCardPaymentService>("CreditCard");
services.AddKeyedTransient<IPaymentService, PayPalPaymentService>("PayPal");

public class PaymentProcessor
{
    private readonly IServiceProvider _serviceProvider;
    
    public PaymentProcessor(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
    
    public void ProcessPayment(string paymentMethod)
    {
        var paymentService = _serviceProvider.GetRequiredKeyedService<IPaymentService>(paymentMethod);
        paymentService.Process();
    }
}

四、服务注册配置错误

1. 未注册服务异常

错误现象：

System.InvalidOperationException: Unable to resolve service for type 'MyApp.Services.IUnregisteredService' while attempting to activate 'MyApp.Controllers.HomeController'.
   at Microsoft.Extensions.DependencyInjection.ActivatorUtilities.GetService(IServiceProvider sp, Type type, Type requiredBy, Boolean isDefaultParameterRequired)

解决方案：

// 自动注册所有实现类
public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddApplicationServices(this IServiceCollection services)
    {
        var assembly = Assembly.GetExecutingAssembly();
        
        // 自动注册所有实现了ITransientService的类
        var transientTypes = assembly.GetTypes()
            .Where(t => t.IsClass && !t.IsAbstract && typeof(ITransientService).IsAssignableFrom(t))
            .ToList();
            
        foreach (var type in transientTypes)
        {
            var interfaceType = type.GetInterfaces()
                .First(i => i != typeof(ITransientService));
            services.AddTransient(interfaceType, type);
        }
        
        // 自动注册所有以"Service"结尾的类
        var serviceTypes = assembly.GetTypes()
            .Where(t => t.IsClass && !t.IsAbstract && t.Name.EndsWith("Service"))
            .ToList();
            
        foreach (var type in serviceTypes)
        {
            var interfaceName = $"I{type.Name}";
            var interfaceType = type.GetInterfaces()
                .FirstOrDefault(i => i.Name == interfaceName);
                
            if (interfaceType != null)
            {
                services.AddScoped(interfaceType, type);
            }
            else
            {
                services.AddScoped(type);  // 注册具体类
            }
        }
        
        return services;
    }
}

// 标记接口
public interface ITransientService { }

// 使用扩展方法
services.AddApplicationServices();

2. 泛型服务注册错误

错误现象：

System.ArgumentException: Cannot instantiate implementation type 'MyApp.Services.GenericRepository`1[TEntity]' for service type 'MyApp.Repositories.IRepository`1[TEntity]'.

解决方案：

// 正确注册泛型服务
services.AddScoped(typeof(IRepository<>), typeof(GenericRepository<>));

// 或者使用工厂方法
services.AddTransient(typeof(IRepository<>), serviceProvider =>
{
    var repositoryType = typeof(GenericRepository<>);
    var entityType = typeof(TEntity);  // 需要运行时确定
    
    // 动态创建泛型类型
    var concreteType = repositoryType.MakeGenericType(entityType);
    return ActivatorUtilities.CreateInstance(serviceProvider, concreteType);
});

// 使用开放泛型注册
public class GenericRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
    private readonly MyDbContext _context;
    
    public GenericRepository(MyDbContext context)
    {
        _context = context;
    }
    
    public async Task<TEntity> GetByIdAsync(int id)
    {
        return await _context.Set<TEntity>().FindAsync(id);
    }
}

// 具体实体的特殊注册
services.AddScoped<IUserRepository, UserRepository>();  // 覆盖泛型注册

五、调试和诊断技巧

1. 服务容器诊断工具

public static class ServiceDiagnostics
{
    public static void AnalyzeServiceContainer(IServiceProvider serviceProvider)
    {
        if (serviceProvider is ServiceProvider microsoftProvider)
        {
            // 使用反射访问内部方法（生产环境慎用）
            var field = typeof(ServiceProvider).GetField("_callSiteFactory", 
                BindingFlags.Instance | BindingFlags.NonPublic);
                
            if (field?.GetValue(microsoftProvider) is CallSiteFactory callSiteFactory)
            {
                var callSiteCacheField = typeof(CallSiteFactory).GetField("_callSiteCache",
                    BindingFlags.Instance | BindingFlags.NonPublic);
                    
                if (callSiteCacheField?.GetValue(callSiteFactory) is ConcurrentDictionary<Type, ServiceCallSite> cache)
                {
                    Console.WriteLine("=== 服务容器分析 ===");
                    foreach (var kvp in cache)
                    {
                        Console.WriteLine($"{kvp.Key.Name} -> {kvp.Value?.ImplementationType?.Name}");
                    }
                }
            }
        }
    }
    
    public static void ValidateServiceLifetimes(IServiceCollection services)
    {
        var serviceTypes = services.GroupBy(s => s.ServiceType);
        
        foreach (var group in serviceTypes)
        {
            if (group.Count() > 1)
            {
                Console.WriteLine($"警告: {group.Key.Name} 有多个实现:");
                foreach (var service in group)
                {
                    Console.WriteLine($"  - {service.ImplementationType?.Name} ({service.Lifetime})");
                }
            }
        }
    }
    
    public static void CheckForPotentialProblems(IServiceCollection services)
    {
        var singletonServices = services.Where(s => s.Lifetime == ServiceLifetime.Singleton).ToList();
        var scopedServices = services.Where(s => s.Lifetime == ServiceLifetime.Scoped).ToList();
        
        // 检查Singleton服务是否依赖Scoped服务
        foreach (var singleton in singletonServices)
        {
            // 这里需要更复杂的分析来检测依赖关系
            // 实际项目中可以使用编译时分析工具
        }
    }
}

// 在Startup中使用诊断
public void ConfigureServices(IServiceCollection services)
{
    // 注册服务...
    
    // 诊断
    ServiceDiagnostics.ValidateServiceLifetimes(services);
    ServiceDiagnostics.CheckForPotentialProblems(services);
}

2. 依赖注入调试中间件

public class DependencyInjectionDebugMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<DependencyInjectionDebugMiddleware> _logger;
    
    public DependencyInjectionDebugMiddleware(RequestDelegate next, ILogger<DependencyInjectionDebugMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context, IServiceProvider serviceProvider)
    {
        // 记录请求开始时的服务解析
        LogServiceResolutions(serviceProvider, "RequestStart");
        
        try
        {
            await _next(context);
        }
        finally
        {
            // 记录请求结束时的服务状态
            LogServiceResolutions(serviceProvider, "RequestEnd");
        }
    }
    
    private void LogServiceResolutions(IServiceProvider serviceProvider, string phase)
    {
        if (_logger.IsEnabled(LogLevel.Debug))
        {
            _logger.LogDebug("=== DI Debug {Phase} ===", phase);
            
            // 这里可以添加具体的调试逻辑
            // 比如记录特定服务的实例哈希码来跟踪生命周期
        }
    }
}

// 注册中间件（仅开发环境）
if (app.Environment.IsDevelopment())
{
    app.UseMiddleware<DependencyInjectionDebugMiddleware>();
}

总结

依赖注入是现代C#应用程序的核心基础设施，正确的使用能够显著提升代码的可测试性和可维护性。关键问题解决要点：

  1. 生命周期匹配：确保服务生命周期正确匹配，避免Singleton持有Scoped服务
  2. 打破循环依赖：通过设计模式重构、属性注入或中介者模式解决循环依赖
  3. 安全解析服务：在正确的时机和Scope中解析服务，避免根容器解析Scoped服务
  4. 灵活服务注册：使用工厂模式、命名服务或Keyed Services处理条件性服务解析
  5. 自动化诊断：建立服务注册验证和运行时诊断机制

通过遵循这些最佳实践，可以构建健壮、可维护的依赖注入架构，避免常见的DI陷阱。

© 版权声明
1 本网站名称： VC博客
2 本站永久网址：vcvcc.cc
3 本站资源如有解压密码，则为：vcvcc.cc
4 本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长 QQ378214732进行删除处理。
5 本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
6 本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
7 本站资源大都存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。
8 如无特别声明本文即为原创文章仅代表个人观点，版权归《VC博客》所有，欢迎转载，转载请保留原文链接。
THE END
C#
# C## 循环依赖# 依赖注入# ServiceProvider# 生命周期# ASP.NET Core
喜欢就支持一下吧
点赞10 分享
VC的头像-Vc博客SVIP
吾爱破解Ollydbg-Vc博客
吾爱破解Ollydbg
吾爱破解Ollydbg
1年前 3381
palworld幻兽帕鲁服务端更新教程-Vc博客
palworld幻兽帕鲁服务端更新教程
palworld幻兽帕鲁服务端更新教程
1年前 806
通过插件实现阿里云盘免费最高画质·远离标清的痛苦-Vc博客
通过插件实现阿里云盘免费最高画质·远离标清的痛苦
通过插件实现阿里云盘免费最高画质·远离标清的痛苦
1年前 771
免费看知乎小说，三个知乎盐选文章/小说免费搬运网站！-Vc博客
免费看知乎小说，三个知乎盐选文章/小说免费搬运网站！
免费看知乎小说，三个知乎盐选文章/小说免费搬运网站！
1年前 716
阿奇索对接鹈鹕权益直冲教程-Vc博客
阿奇索对接鹈鹕权益直冲教程
阿奇索对接鹈鹕权益直冲教程
1年前 478
2024WPS正版授权、政企版长期有效-Vc博客
2024WPS正版授权、政企版长期有效
2024WPS正版授权、政企版长期有效
1年前 428
相关推荐
C#多线程锁竞争性能瓶颈：从Monitor到ReaderWriterLockSlim实战-Vc博客
C#多线程锁竞争性能瓶颈：从Monitor到ReaderWriterLockSlim实战
C#多线程锁竞争性能瓶颈：从Monitor到ReaderWriterLockSlim实战
3天前 54
C#异常处理陷阱：滥用try-catch导致异常被静默吞没的诊断与修复-Vc博客
C#异常处理陷阱：滥用try-catch导致异常被静默吞没的诊断与修复
C#异常处理陷阱：滥用try-catch导致异常被静默吞没的诊断与修复
前天 45
C#中依赖注入常见问题：生命周期管理、循环依赖与动态解析实战-Vc博客
C#中依赖注入常见问题：生命周期管理、循环依赖与动态解析实战
C#中依赖注入常见问题：生命周期管理、循环依赖与动态解析实战
昨天 43
C# Task异步操作中的资源泄漏与CancellationToken正确使用模式-Vc博客
C# Task异步操作中的资源泄漏与CancellationToken正确使用模式
C# Task异步操作中的资源泄漏与CancellationToken正确使用模式
前天 42
C#中Configuration配置系统常见问题：多环境配置、热重载与类型安全访问-Vc博客
C#中Configuration配置系统常见问题：多环境配置、热重载与类型安全访问
C#中Configuration配置系统常见问题：多环境配置、热重载与类型安全访问
昨天 42
C#异步编程陷阱：从死锁规避到性能优化的完整指南-Vc博客
C#异步编程陷阱：从死锁规避到性能优化的完整指南
C#异步编程陷阱：从死锁规避到性能优化的完整指南
4天前 41
评论 抢沙发

请登录后发表评论

    暂无评论内容

文章作者Author of the article
用户封面
VC的头像-Vc博客SVIP
表情包自动生成器：用Python打造你的专属斗图神器
Python函数深度解析：参数传递、作用域与Lambda表达式实战
Python制作ASCII艺术生成器：从图片到字符画的奇妙转换
Python异常处理完全指南：从基础try-except到自定义异常体系
Python面向对象编程深度解析：类与对象、继承与多态实战指南
Python完全新手入门指南：从环境搭建到第一个程序