Structure de projet de l'architecture d'entreprise avec mvc et service (.NET)

Question

Je suis nouveau dans l'architecture d'entreprise, mais quand je comprends bien, il est composé de 3 niveaux. Je travaille sur le projet de l'école à la plate-forme .net et j'ai cette structure:

• niveau de données - Bibliothèque de classes avec des modèles de données qui sont la cartographie à databas relationnelles
• niveau Business - Bibliothèque de classes où j'ai quelques classes qui fournissent fonctionnalité de l'application
• Présentation niveau - Je suppose que dans ce niveau je pourrais projet de MVC, mais je ne suis pas sûr.

Lorsque j'ai cette structure, où puis-je stocker quelques API WEB ou WCF? Pourrait de droit dans le niveau des affaires? Ou pouvez-vous me conseiller, où j'ai trouvé l'exemple réel d'EA avec le service et le mvc? Merci

Answer 1

Vous avez en fait quatre couches:

• Présentation
• service Couche
• couche de domaine
• couche de données

La convention de nommage peut être un peu différent, mais la idée est la séparation du principal. Une idée qui permet à la couche de service d'exécuter une logique métier, sans connaître l'invocation de la couche de données.

Vous renverrait comme:

• Présentation - (référence au service, domaine, données)
• couche de service - (Domaine de référence, données)
• couche de domaine - (pas de référence)
• couche de données - (référence domaine)

Ainsi, votre couche de présentation fera référence à tous, donc quand vous construisez votre dépendance Conteneurs d'injection, vous pouvez référencer correctement tout au long.

Vous pouvez regarder ce project comme exemple. De comment interagir entre.

Présentation:

using Microsoft.AspNetCore.Mvc; 
using Service_Layer; 

namespace Address_Book.Controllers 
{ 
    [Route("api/[controller]")] 
    public class PeopleController : Controller 
    { 
     #region Dependencies: 

     private readonly IPeopleService peopleService; 

     #endregion 

     #region Constructor: 

     public PeopleController(IPeopleService peopleService) 
     { 
      this.peopleService = peopleService; 
     } 

     #endregion 

     [HttpGet] 
     public JsonResult Get() 
     { 
      var branches = peopleService.GetBranches(); 
      return Json(branches); 
     } 

     [HttpGet("{id}")] 
     public JsonResult Get(int id) 
     { 
      var people = peopleService.GetEmployees(id); 
      return Json(people); 
     } 
    } 
} 

Service Layer:

using Data_Layer.Factory; 
using Domain_Layer.Entity; 
using System.Collections.Generic; 
using System.Data; 
using System.Data.SqlClient; 

namespace Service_Layer 
{ 
    public class PeopleService : IPeopleService 
    { 
     private readonly IEmployeeFactory factory; 

     private const string getBranches = "..."; 
     private const string getPeople = "..." 
     #region Constructor: 

     public PeopleService(IEmployeeFactory factory) 
     { 
      this.factory = factory; 
     } 

     #endregion 

     public IEnumerable<BranchModel> GetBranches() 
     { 
      using (var context = factory.Create()) 
       return context.List<BranchModel>(getBranches, CommandType.Text); 
     } 

     public IEnumerable<EmployeeModel> GetEmployees(int branchId) 
     { 
      using (var context = factory.Create()) 
       return context.List<EmployeeModel>(getPeople, CommandType.Text, new SqlParameter() { ParameterName = "BranchNum", SqlDbType = SqlDbType.Int, Value = branchId }); 
     } 
    } 

    #region Declaration of Intent: 

    public interface IPeopleService 
    { 
     IEnumerable<BranchModel> GetBranches(); 

     IEnumerable<EmployeeModel> GetEmployees(int branchId); 
    } 

    #endregion 
} 

couche de données:

using Data_Layer.Repository; 
using System; 
using System.Collections.Generic; 
using System.Data; 
using System.Data.SqlClient; 
using Data_Layer.Helper; 

namespace Data_Layer.Context 
{ 
    public class EmployeeContext : DbCommand, IEmployeeRepository 
    { 
     private bool disposed = false; 
     private string dbConnection; 

     #region Constructor: 

     public EmployeeContext(string dbConnection) 
     { 
      this.dbConnection = dbConnection; 
     } 

     #endregion 

     public IEnumerable<TEntity> List<TEntity>(string query, CommandType commandType, params SqlParameter[] parameters) where TEntity : class, new() 
     { 
      using (var connection = new SqlConnection(dbConnection)) 
      using (var command = new SqlCommand(query, connection)) 
      { 
       connection.Open(); 
       command.CommandType = commandType; 

       foreach (var parameter in parameters) 
        command.Parameters.Add(parameter); 

       return BuildEntity(command, new TEntity()); 
      } 
     } 

     #region Dispose: 

     public void Dispose() 
     { 
      Dispose(true); 
      GC.SuppressFinalize(true); 
     } 

     protected virtual void Dispose(bool disposing) 
     { 
      if (!disposed) 
       disposed = true; 
     } 

     ~EmployeeContext() { Dispose(false); } 

     #endregion 
    } 
} 

Vous w Mal besoin de regarder le projet, la couche de données et la couche de service sont appelées via Dependency Injection, que j'ai créé une méthode d'extension pour le fichier Startup.cs, mais c'est ainsi qu'ils interagissent. Si vous avez des questions n'hésitez pas à demander, je suis dans le chat C# quotidiennement.