Registro: como usar o ASP.NET Core e o EnityFramework Core para separar operações e entidades do banco de dados

Resumo do Prefácio:

　　Existe uma estrutura de site existente, incluindo um projeto principal WebApp, um projeto de andaime A que inclui a interface IIdentityUser. AuthenticationService, o serviço usado para manipular a autenticação do usuário, está localizado no espaço para nome B. Usuário da entidade para salvar dados: Item de localização IIdentityUser C. A relação entre os projetos é que B e C dependem do projeto A.

 

Requisitos:

　　Agora existe um novo projeto D, nesse projeto existe um DUser: IIdentityUser. Como lidar com isso é a maneira mais elegante de salvar usuários no DUser sem adicionar referências e modificar o projeto B.

 

Exemplo real:

　　No ASP.NET CORE, existe algo chamado IdentityServer. Existe isso: ele escreveu um código semelhante ao IdentityServerBuilder.AddService <TUser, TRole> (), como alcançá-lo?

 

Solução:

　　1. Crie uma nova classe genérica (essa classe pode ser marcada como interna e a externa não precisa entender ou acessar):

public class UserContext <TUser> em 
        que TUser: class, IIdentityUser, new () 
    { 
        public YourContext dbContext; 
        public UserContext (YourContext ctx) => dbContext = ctx; 

        public DbSet <TUser> Usuários 
        { 
            get 
            { 
                return dbContext.Set <TUser> (); 
            } 
        } 

        public void SaveChanges () 
        { 
            dbContext.SaveChanges (); 
        } 
    }

　　2. Crie um novo serviço para operação (observe que todas as operações necessárias estão escritas neste e esta interface será exposta no futuro)

classe pública UserService <TUser>: IUserService em 
        que TUser: class, IIdentityUser, new () 
    { 
        private UserContext <TUser> dbContext; 
        public UserService (YourContext ctx, provedor IServiceProvider) 
        { 
            dbContext = new PermissionContext <TUser> (ctx.DbContext); 
        } 
　　　　　
　　　public TUser GetUserById (ID do guia) 
　　　{ 
　　　　  return dbContext.Users.FirstOrDefault (e => e.ID == id); 
　　　} 
    }

　　

　　3. Adicione uma seringa

    classe estática pública AuthenticationInject 
    { 
        IServiceCollection estático público AddAuthenticationContext <TUser> (este serviço IServiceCollection) em 
            que TUser: IIdentityUser 
        { 
            var serviceType = typeof (UserService <>). MakeGenericType (typeof (TUser)); 
            services.AddSingleton (typeof (IUserService), serviceType); 

            serviços de devolução; 
        } 
    }

　　Ponto técnico: use o método MakeGenericType para carregar dinamicamente instâncias de classe genéricas. Se o tipo for UserService <TUser, TRole>, ele será gravado como typeof (UserService <,>). MakeGenericType (typeof (T1), typeof (T2))

　　Até agora, dividimos o nome do tipo da classe genérica na variável Então você pode jogar 10.000 padrões.

　　4. No WebApp, injete variáveis ​​relacionadas

        // Este método é chamado pelo tempo de execução. Use este método para adicionar serviços ao contêiner. 
        // Para obter mais informações sobre como configurar seu aplicativo, visite https://go.microsoft.com/fwlink/?LinkID=398940 
        public void ConfigureServices (serviços IServiceCollection) 
        { 
            services.AddAuthenticationContext <DUser> (); 
        }

　　

　　Analisar dependências:

　　Projeto de execução O WebApp depende dos projetos A, B, D, B e D dependem apenas de A. Ainda mais, pode ser dissociado novamente. Altere a função AddAuthenticationContext da função genérica para AddAuthenticationContext (Type userType) e você pode ir além e alterá-la para AddAuthenticationContext (tipo de string) para obter o tipo através da reflexão e configuração, de modo a desacoplar os projetos A e D.

　　Capacidade de expansão:

　　No futuro, haverá novos projetos E, EUser. Você só precisa desassociar D e A e associar E e A. Basta modificar a função AddAuthenticationContext para atender aos requisitos. Obviamente, se você quiser estar de bom humor, pode até se envolver em um código de descoberta automática (como esse no meu projeto, que analisa automaticamente o objeto IIdentityUser e o anexa ao Contexto. Um atributo é usado para marcar qual usuário usar para este projeto). Mesmo que você esteja de bom humor, você pode configurá-lo e, de qualquer forma, colocar o EF Core em 10.000 poses.