如何在实现 C# 非泛型接口泛型属性时跳过传递类型？

Question

I'm using a ' Clean Architecture ' solution template, and I believe it's very promising, however, I'm facing a problem in separating the ApplicationUser class derived from IdentityUser since they are both parts of the infrastructure layer and I've got a dependency on it on the core layer 'Domain' when defining an Account Entity referencing ApplicationUser , so as I'm doing the references in one-way from inside to outside I can't use it down there, so I passed a generic type but I still can't implement the ApplicationDbContext in the infrastructure, any thoughts?

Account.cs

using MacSys.Domain.Common;
using System;
using System.Collections.Generic;
using System.Text;

namespace MacSys.Domain.Entities
{
    public class Account<T> : LocaleEntityBase
    {
        public Account()
        {
            ApplicationUsers = new List<T>();
        }
        public City City { get; set; }
        public string PhoneNumber { get; set; }
        public IList<T> ApplicationUsers { get; set; }
    }
}

IApplicationDbContext.cs

using MacSys.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using System.Threading;
using System.Threading.Tasks;

namespace App.Application.Common.Interfaces
{
    public interface IApplicationDbContext
    {
        DbSet<Country> Countries { get; set; }
        DbSet<City> Cities { get; set; }
        DbSet<AccountType> AccountTypes { get; set; }
        DbSet<Configuration> Configurations { get; set; }
        DbSet<Account<??>> Accounts { get; set; }

        Task<int> SaveChangesAsync(CancellationToken cancellationToken);
    }
}

ApplicationDbContext.cs

using App.Application.Common.Interfaces;
using App.Domain.Entities;
using App.Infrastructure.Identity;
using Microsoft.EntityFrameworkCore;
using System.Reflection;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using App.Infrastructure.Identity.ApplicationGroups;

namespace App.Infrastructure.Persistence
{
    public class ApplicationDbContext : IdentityDbContext<ApplicationUser, 
        ApplicationRole,
        string>, IApplicationDbContext
    {
        private readonly ICurrentUserService _currentUserService;
        private readonly IDateTime _dateTime;

        public ApplicationDbContext(
            DbContextOptions options,
            ICurrentUserService currentUserService,
            IDateTime dateTime) : base(options)
        {
            _currentUserService = currentUserService;
            _dateTime = dateTime;
        }

        public DbSet<Country> Countries { get; set; }
        public DbSet<City> Cities { get; set; }
        public DbSet<AccountType> AccountTypes { get; set; }
        public DbSet<Configuration> Configurations { get; set; }
        public DbSet<Account<ApplicationUser>> Accounts { get; set; }

    }
}

I'm having the error in the ApplicationDbContext class implementation since I can't find a relation between both properties without making dual references between projects.

Answer 1

One common approach to separating your domain from the framework would be by not coupling them at all. You actually do not have to have all your entities in the same database context, and you do not need to make your account entity inherit from ApplicationUser either.

Instead, what you can do is completely separate these two concerns: Use the standard IdentityDbContext with its IdentityUser as the primary user identity for authentication and authorization . But maintain a separate Account entity for your domain. You can even share the same user id to get a one-to-one mapping. If you then put the Account and the rest of the domain model into its own database context, then your domain entities are completely separate from the auth framework layer of your application.