SnailAspNetCoreFramework

Introdução do projeto

• Este projeto está posicionado como uma estrutura de desenvolvimento rápido para pequenas e médias empresas baseada no núcleo asp.net, incluindo código completo de back-end e front-end.
• A versão v2.0 está atualmente em desenvolvimento. A versão v1.0 pode ser executada diretamente após a mudança no branch. Para tutoriais, consulte minha série de blogs ou os documentos do projeto.
• Pilha de tecnologia de back-end: asp.net core 3.1, cap, swag, ef core code first, autofac, automapper, nlog, aop
• Pilha de tecnologia front-end: vue-element-admin, componentes brutos do módulo de desenvolvimento rápido, simulação
• Funções implementadas: controle de permissão baseado em função, acordo hierárquico do projeto, geração automática de código, registro, monitoramento de desempenho, aop, etc.

Como executar o projeto

 git clone [email protected]:shengyu-kmust/SnailAspNetCoreFramework.git
git clone [email protected]:shengyu-kmust/Snail.git
cd SnailAspNetCoreFramework
dotnet build

Demonstração do projeto

A seguir está um diagrama de demonstração baseado na versão v1.0

• 1. Baixe e execute o projeto
• 2. Gere projetos automaticamente com base em arquivos de configuração
• 3. Execute o projeto

Introdução ao diretório do projeto

--ApplicationCore // A camada de abstração central adota o modo de arquitetura clara e não depende de outras camadas. Os outros três projetos dependem deste tipo de biblioteca e são responsáveis ​​pelas definições públicas de interfaces, constantes, enumerações, dtos, entidades, etc. .
----Const // Definição de constante, como constantes de configuração, constantes de nome de evento
----Dtos // todos os dtos
----Entidades // Todas as entidades
----Enums // enumeração
----IServices //Definição abstrata da camada de serviço
----Utilitários // Classe de ajuda

--Infraestrutura //A camada de infraestrutura fornece serviços de dados para as camadas superiores (como camada de serviço e camada de aplicação).
----Data/config // Configuração de API fluente do framework de entidade de banco de dados
----EFValueConverter // Conversão entre o tipo de banco de dados entidadeframework e o tipo clr, como conversão de enumeração
----Migrações //Gerar diretório para migração do código do EntityFramework primeiro

--Service // Camada de serviço, usada para implementar a interface de serviço no ApplicationCore, a camada principal para a implementação da lógica da aplicação
----Cache // Implementação do cache, que será removido e extraído para o projeto Snail posteriormente.
----Interceptor //Interceptor implementado por padrão
----BaseService.cs //A classe base de cada serviço contém os métodos comuns de cada serviço, como CRUD
----InitDatabaseService.cs // Responsável pela inicialização dos dados do banco de dados
----InterceptorService.cs //Classe base do interceptador

--Web // Responsável por todo o processamento relacionado de entrada e saída de parâmetros de interface (como verificação de parâmetros, reserva de formato de saída, etc.)
----AutoFacModule // configuração de injeção autofac
----AutoMapperProfiles // configuração do automapper
----ClientApp // Projeto front-end
------build // Diretório de saída gerado pela compilação front-end
------ simulação // simulação de front-end
------src // Código principal do front-end
----CodeGenerater //Módulo T4 e lógica relacionada para geração de código
----ConfigureServicesExtensions // Extensões de injeção do ServiceProvider para evitar gravá-las no arquivo de inicialização
----Controladores //Controladores
----docs // Conjunto de documentos
----Dto // A classe dto será usada apenas na camada web
----Filtro // filtro
---- Hubs // sinalizador
----Permissão //Implementação padrão de permissões
----staticFile // Usado para armazenar arquivos enviados

Design estrutural geral do projeto

DDD é utilizado, mas diferentes tecnologias de DDD devem ser aplicadas de acordo com o tamanho do projeto. De modo geral, ele está dividido nos seguintes projetos.

• Serviço: Camada de serviço, usada para implementar a interface de serviço no ApplicationCore, a camada principal para a implementação da lógica da aplicação
• Camada de infraestrutura: Camada básica. Esta camada é reutilizada em diferentes projetos. Ela se baseia na convenção de interface da camada ApplicationCore para fornecer serviços de dados para as camadas superiores (como a camada de serviço e a camada de aplicativo). Ao mesmo tempo, é implementada a interface universal de acesso a dados do IDAL.
• Camada ApplicationCore: camada lógica de aplicação, modo DDD, contém toda a lógica de negócios e não depende de outras camadas
• Camada Web: Responsável por todo o processamento relacionado de entrada e saída de parâmetros de interface (como verificação de parâmetros, reserva de formato de saída, etc.) e chamadas para a camada Aplicação/DAL.

Permissões e verificação de dados universais

Camada WEB

• Responsável pelo processamento de parâmetros de entrada e saída, interceptação de exceções e cache da web
• Para operações de dados do tipo estatística de consulta, a camada DAL pode ser chamada diretamente.
• A configuração dos ambientes de desenvolvimento e teste pode ser separada

Verificação de parâmetros --implementada

• Usando a interface da Microsoft --implementada

Convenção de saída --implementada

• O código de status HTTP segue a convenção do código de status, 20x é sucesso (a interface foi chamada com sucesso), 40x é erro de solicitação (exceção comercial, não autorizado, etc.), 50x é erro do servidor (exceção do servidor) - implementado
• O conteúdo do resultado retornado está principalmente no formato de dados real exigido pelo front-end, que é um objeto JSON, se for uma mensagem de erro, o conteúdo do erro será retornado. --Alcançou

Tratamento de exceções --implementado

• O tratamento de exceções usa tecnologia Microsoft, consulte https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/error-handling?view=aspnetcore-2.2
• Todas as exceções não serão capturadas
• As exceções de negócios são solicitadas para fora. As exceções do servidor são interceptadas e solicitadas para fora. O formato de saída do prompt segue a convenção de saída.

arrogância - implementado

• Usar NSwagger

Camada ApplicationCore

• Este projeto não depende de nenhum outro projeto, utilize uma arquitetura limpa, consulte: https://docs.microsoft.com/zh-cn/dotnet/standard/modern-web-apps-azure-architecture/common-web- arquiteturas de aplicativos

esconderijo

• A interface ICache implementa redis, memcached, memoryCache, etc. Você pode considerar o uso do easycaching.
• Use AOP para armazenamento em cache para evitar escrever lógica de cache em cada método. easycaching+autofac
• As atualizações de cache são orientadas por eventos e componentes de terceiros são introduzidos. easycaching+cap

Orientado por domínio

Orientado por domínio, se depender de outras camadas, depende da interface da camada correspondente e não da implementação.

AOP - implementado

• Para entrada AOP em logs e caches, considere usar autofac

COI - implementado

• Usar autofac

Tabela de memória --implementada

• Armazene tabelas que mudam com pouca frequência e tenham quantidades relativamente pequenas de dados na memória (não caches, mas objetos) e use o pensamento orientado a eventos para sincronizar os dados mais recentes.

evento

• publicar e assinar
• Use cap para alternar entre aplicativos distribuídos e únicos

Processamento de log --implementado

• Usar nlog

barramento de comando --implementado

• Usar Mediador

Camada DAL

• Responsável por todas as operações relacionadas a dados
• Encapsular interfaces e implementações comuns de acesso a dados, como usar EF para implementar as seguintes funções
• Use a ideia de programação orientada à interface para expandir a camada DAL usando outras tecnologias além da EF no futuro.
• Usando o modo Repositório, na verdade, o próprio EF é um modo Repositório, mas para interceptar e aplicar uniformemente sua própria lógica no nível das operações de acesso ao banco de dados, ele então usa seu próprio Repositório para encapsular o EF
• Consulta de tabela única, paginação
• Consulta relacional simples de múltiplas tabelas, paginação
• CRUD Simples

mapeador automático

• Automapper de referência para atribuição e conversão de objetos
• Implemente a classe objectmapper baseada em expressão para atribuição simples de objetos, compensando as deficiências da configuração complexa e do baixo desempenho do automapper usando reflexão.

Uso de FE

• Log de linguagem SQL de execução do EF ** - implementado **
• Para tipos de enumeração, use a tecnologia ValueConverter da EF para convertê-los automaticamente. É acordado que o tipo armazenado no banco de dados é do tipo string em vez do tipo Int, o que é conveniente para a compreensão**--Implementado**.

comunicação em tempo real

• Usar sinalizador

Seleção de tecnologia

processamento de transação

Use os modos de repositório e unidade de trabalho, mas use o modo de repositório que vem com o EF.

Método de processamento de banco de dados

• Use EF para processamento de dados e não considere outros métodos.

Interface front-end

• Coloque-o no projeto web e use o método spa

preciso fazer

• Injeção de teste de unidade
• A camada de serviço não deve estar na camada web, mas no applicationcore

multilíngue

Vários detalhes técnicos

PAC

• A implementação original do CAP não suporta muito bem o autofac. Neste projeto, o SnailCapConsumerServiceSelector foi escrito para lidar com isso.
• O CAP trata nativamente controladores e não controladores de maneira diferente. Os controladores só precisam adicionar o atributo CapSubscribe ao método, enquanto os controladores precisam implementar a interface ICapSubscribe na classe e adicionar o atributo CapSubscribe ao método.

Como usar

1. git clone este projeto 2. Configure codeGenerate.json 3. Execute este projeto e, após fazer login no swagger, execute a interface codeGenerate 4. Execute add-migration 5. Inicie o projeto

Postagem do tutorial no blog

Blog da série SnailAspNetCoreFramework Framework
1. Introdução e ideias gerais de design de cada projeto e diretório dentro da estrutura - estrutura de desenvolvimento rápido SnailAspNetCoreFramework
2. Verificação de entrada de interface, formato de saída e tratamento de exceções - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
3. Design de permissão universal - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
4. Como fornecer bons documentos de interface (Swagger) para o front-end - SnailAspNetCoreFramework design de back-end da estrutura de desenvolvimento rápido
5. Uso de cache em vários cenários - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
6. Design AOP baseado em castelo e implementação de cache comum, desempenho e interceptador de log - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
7. Introdução à injeção de dependência - autofac - SnailAspNetCoreFramework design de back-end da estrutura de desenvolvimento rápido
8. Por que usar o Eventbus e como usá-lo - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
9. Introdução ao Nlog, o componente de log - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
10.Introdução ao Mediatr - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
11. Design CRUD universal para camadas de controlador, serviço e dal - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
12. Automapper da ferramenta de mapeamento de objetos - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
13. Como monitorar as instruções SQL geradas pelo EF - SnailAspNetCoreFramework design de back-end da estrutura de desenvolvimento rápido
14. Introdução a vários métodos de implantação do núcleo .net - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
15. Sinalizador de comunicação em tempo real - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
16. Como usar o código ef primeiro para iterar continuamente a versão do banco de dados do projeto - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
17. Introdução à função de geração automática de código - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
18. Como monitorar se cada função do projeto está normal (HealthCheck) - Design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
19. Introdução ao hangfire para tarefas agendadas - design de back-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
20. Introdução geral ao front-end - design de front-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
21. Chega de implorar por interfaces de back-end (uso de MOCK) - Design de front-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
22. Controle de permissão de front-end - design de front-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
23. Como evitar escrever repetidamente código CRUD front-end (introdução e uso de vários componentes SnailXXX no front-end) - Design front-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework
24. Introdução à solicitação de proxy - design front-end da estrutura de desenvolvimento rápido SnailAspNetCoreFramework