在哪里可以在.NET 6中注册工作单位服务？

Question

我想知道如何在.NET 6中注册单元服务。

在.NET核心的早期版本中，可以在startup.cs文件中注册一个单元服务，如下所示。

services.AddTransient<IUnitOfWork, UnitOfWork>();

在.NET 6中，startup.cs和program.cs文件被合并。

是否可以在program.cs中注册服务？如果可能的话，那怎么做？

Answer 1

让我们从你的问题开始

"Is it possible to register the service in program.cs?"

是的，在service中注册program.cs是绝对可能的。

"If possible, then how?"

下面是Program.cs在asp.net 6上的示例：

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();

Note: 它几乎类似于asp.net core 3.2或asp.net 5，我们以前在startup.cs文件中就这样做过。在asp.net 6 program.cs文件中也需要做同样的事情，只是方式有点不同。

如果您需要有关asp.net 6 的完整示例，则可以查看下面的详细信息答案：

Model:

我将使用User模型在dotnet 6示例中构建UnitOfWork

public class User
    {
        public Guid Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Email { get; set; }
    }

ApplicationDbContext:

public class ApplicationDbContext: DbContext
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }
        public DbSet<User> User { get; set; }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            //  base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<User>().ToTable("User");
        }
       
    }

注： 您应该在您的数据库上类似的SQL Table，以使更容易在这里我提供的数据库脚本以及。

SQL Script:

CREATE TABLE [User]
(
    Id UNIQUEIDENTIFIER PRIMARY KEY default NEWID(),
    [FirstName] [varchar](50) NULL,
    [LastName] [varchar](50) NULL,
    [Email] [varchar](50) NULL,
 
)
INSERT INTO [User] ([FirstName], [LastName], [Email])
VALUES ( 'FirstTestName', 'FirstLastName', 'testemail.@outlook.com');

IGenericRepository:

public interface IGenericRepository<T> where T : class
    {
        Task<IEnumerable<T>> All();
        Task<T> GetById(Guid id);
        Task<bool> Add(T entity);
        Task<bool> Delete(Guid id);
        Task<bool> Upsert(T entity);
        Task<IEnumerable<T>> Find(Expression<Func<T, bool>> predicate);
    }

GenericRepository:

public class GenericRepository<T> : IGenericRepository<T> where T : class
    {
        protected ApplicationDbContext context;
        internal DbSet<T> dbSet;
        public readonly ILogger _logger;

        public GenericRepository(
            ApplicationDbContext context,
            ILogger logger)
        {
            this.context = context;
            this.dbSet = context.Set<T>();
            _logger = logger;
        }

        public virtual async Task<T> GetById(Guid id)
        {
            return await dbSet.FindAsync(id);
        }

        public virtual async Task<bool> Add(T entity)
        {
            await dbSet.AddAsync(entity);
            return true;
        }

        public virtual Task<bool> Delete(Guid id)
        {
            throw new NotImplementedException();
        }

        public virtual Task<IEnumerable<T>> All()
        {
            throw new NotImplementedException();
        }

        public async Task<IEnumerable<T>> Find(Expression<Func<T, bool>> predicate)
        {
            return await dbSet.Where(predicate).ToListAsync();
        }

        public virtual Task<bool> Upsert(T entity)
        {
            throw new NotImplementedException();
        }
    }

IUnitOfWork:

public interface IUnitOfWork
    {
        IUserRepository Users { get; }

        Task CompleteAsync();
    }

UnitOfWork:

public class UnitOfWork : IUnitOfWork, IDisposable
    {
        private readonly ApplicationDbContext _context;
        private readonly ILogger _logger;

        public IUserRepository Users { get; private set; }

        public UnitOfWork(ApplicationDbContext context, ILoggerFactory loggerFactory)
        {
            _context = context;
            _logger = loggerFactory.CreateLogger("logs");

            Users = new UserRepository(context, _logger);
        }
        
        public async Task CompleteAsync()
        {
            await _context.SaveChangesAsync();
        }

        public void Dispose()
        {
            _context.Dispose();
        }
    }

UserRepository:

    public class UserRepository : GenericRepository<User>, IUserRepository
    {
        public UserRepository(ApplicationDbContext context, ILogger logger) : base(context, logger) { }

        public override async Task<IEnumerable<User>> All()
        {
            try
            {
                return await dbSet.ToListAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "{Repo} All function error", typeof(UserRepository));
                return new List<User>();
            }
        }
}

UnitOfWorkUsersController:

[ApiController]
public class UnitOfWorkUsersController : ControllerBase
{
    private readonly ILogger<UnitOfWorkUsersController> _logger;
    private readonly IUnitOfWork _unitOfWork;

    public UnitOfWorkUsersController(
        ILogger<UnitOfWorkUsersController> logger,
        IUnitOfWork unitOfWork)
    {
        _logger = logger;
        _unitOfWork = unitOfWork;
    }

    [HttpGet]
    public async Task<IActionResult> Get()
    {
        var users = await _unitOfWork.Users.All();
        return Ok(users);
    }

}

Program.cs:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(x => x.UseSqlServer(connectionString));

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Output:

​

​

​

​

希望以上步骤引导您相应。如果你还需要more details you can have a look our official document

Answer 2

新的.Net 6是前一个.Net 5的简化版本。

您可以在项目根目录中的Program.cs文件中执行依赖项注入。

示例：

你应该用这条线

var builder = WebApplication.CreateBuilder(args);

如果尚未声明，请创建以下变量：

var app = builder.Build();

然后，您可以使用"app.Services“属性与服务交互。

app.Services.GetServices(typeof(MyService));

或者您可以使用自己的中间件。

app.MyMiddleware();

有关迁移示例，请参阅这 Microsoft文档页。