.net core项目中自定义服务的实现方式步骤实用指南

作者：袖梨 2026-09-07

平时做技术实践时，很多问题不是概念不会，而是细节没串起来。拿“.net core项目中自定义服务的实现方法步骤”来说，它看着像小点，放到项目里常会牵出环境、配置、兼容性和维护成本。下面按实际采用顺序，把思路、关键写法和容易踩坑的地方讲清楚，便于大家直接对照操作。

.NET Core项目中自定义服务的实现步骤详解
导语
核心概念解释
采用场景
实现步骤
- 1. 新建服务接口
- 2. 实现服务类
- 3. 注册服务
- 4. 注入采用服务
高级用法
- 服务工厂注册
- 多实现服务
优缺点分析
实战案例：缓存服务实现
- 1. 定义缓存接口
- 2. 实现内存缓存服务
- 3. 注册服务
- 4. 采用示例
小结

.NET Core项目中自定义服务的实现步骤详解

导语

在这个场景下，在.NET Core开发里，依赖注入(DI)是一个核心功能，它允许我们以松耦合的方式组织代码。自定义服务是实现业务逻辑的重要组件，下面会系统梳理在.NET Core项目中新建和采用自定义服务的完整步骤，包括核心概念、采用场景和实战示例。

核心概念解释

自定义服务从实现思路看，是指开发者根据业务需求新建的特定功能类，这些类借助.NET Core的依赖注入系统进行管理。服务通常分为：

瞬时服务(Transient)：每次请求都新建新实例
作用域服务(Scoped)：同一请求内共享实例
单例服务(Singleton)：整个应用生命周期共享一个实例

采用场景

自定义服务适用来以下场景：

封装业务逻辑
数据访问层抽象
第三方服务集成
跨组件共享功能
单元测试模拟

实现步骤

1. 新建服务接口

public interface IEmailService
{
    Task SendEmailAsync(string to, string subject, string body);
}

2. 实现服务类

public class EmailService : IEmailService
{
    private readonly ILogger<EmailService> _logger;
    public EmailService(ILogger<EmailService> logger)
    {
        _logger = logger;
    }
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        _logger.LogInformation($"准备发送邮件到: {to}");
        // 实际发送邮件逻辑
        await Task.Delay(100); // 模拟异步操作
        _logger.LogInformation($"邮件发送成功: {subject}");
    }
}

3. 注册服务

在Startup.cs或Program.cs中注册服务：

// 瞬态服务
builder.Services.AddTransient<IEmailService, EmailService>();
// 作用域服务
// builder.Services.AddScoped<IEmailService, EmailService>();
// 单例服务
// builder.Services.AddSingleton<IEmailService, EmailService>();

4. 注入采用服务

在控制器中采用：

[ApiController]
[Route("api/[controller]")]
public class NotificationController : ControllerBase
{
    private readonly IEmailService _emailService;
    public NotificationController(IEmailService emailService)
    {
        _emailService = emailService;
    }
    [HttpPost("send")]
    public async Task<IActionResult> SendEmail([FromBody] EmailRequest request)
    {
        await _emailService.SendEmailAsync(request.To, request.Subject, request.Body);
        return Ok();
    }
}

高级用法

服务工厂注册

builder.Services.AddTransient<IEmailService>(provider => 
{
    var logger = provider.GetRequiredService<ILogger<EmailService>>();
    return new EmailService(logger);
});

多实现服务

public interface IMessageService { }
public class SmsService : IMessageService { }
public class PushService : IMessageService { }
// 注册
builder.Services.AddTransient<IMessageService, SmsService>();
builder.Services.AddTransient<IMessageService, PushService>();
// 获取所有实现
public class NotificationService
{
    private readonly IEnumerable<IMessageService> _messageServices;
    public NotificationService(IEnumerable<IMessageService> messageServices)
    {
        _messageServices = messageServices;
    }
}

优缺点分析

优点： - 松耦合设计，易于维护 - 便于单元测试 - 生命周期管理自动化 - 促进关注点分离

缺点： - 学习曲线较陡 - 过度采用会导致依赖关系复杂 - 调试可能更困难

实战案例：缓存服务实现

1. 定义缓存接口

public interface ICacheService
{
    T Get<T>(string key);
    void Set<T>(string key, T value, TimeSpan? expiry = null);
    void Remove(string key);
}

2. 实现内存缓存服务

public class MemoryCacheService : ICacheService
{
    private readonly IMemoryCache _cache;
    public MemoryCacheService(IMemoryCache cache)
    {
        _cache = cache;
    }
    public T Get<T>(string key)
    {
        return _cache.Get<T>(key);
    }
    public void Set<T>(string key, T value, TimeSpan? expiry = null)
    {
        var options = new MemoryCacheEntryOptions();
        if (expiry.HasValue)
        {
            options.SetAbsoluteExpiration(expiry.Value);
        }
        _cache.Set(key, value, options);
    }
    public void Remove(string key)
    {
        _cache.Remove(key);
    }
}

3. 注册服务

builder.Services.AddMemoryCache();
builder.Services.AddSingleton&lt;ICacheService, MemoryCacheService&gt;();

4. 采用示例

public class ProductService
{
    private readonly ICacheService _cache;
    private readonly IProductRepository _repository;
    public ProductService(ICacheService cache, IProductRepository repository)
    {
        _cache = cache;
        _repository = repository;
    }
    public async Task<Product> GetProductByIdAsync(int id)
    {
        string cacheKey = $"product_{id}";
        var product = _cache.Get<Product>(cacheKey);
        if (product == null)
        {
            product = await _repository.GetByIdAsync(id);
            if (product != null)
            {
                _cache.Set(cacheKey, product, TimeSpan.FromMinutes(10));
            }
        }
        return product;
    }
}