无私分享：从入门到精通ASP.NET MVC｜从0开始搭框架做项目（10）——部门管理、岗位管理和员工管理

// 部门模型（自引用树形结构）
public class Department
{
    public int Id { get; set; }
    [Required(ErrorMessage = "部门名称不能为空")]
    [StringLength(50, ErrorMessage = "部门名称最长50字符")]
    public string Name { get; set; }
    public int? ParentId { get; set; } // 父部门ID（ nullable表示根部门）
    public bool IsEnabled { get; set; } = true; // 是否启用
 
    // 导航属性
    public virtual Department Parent { get; set; } // 父部门
    public virtual ICollection<Department> Children { get; set; } = new List<Department>(); // 子部门
    public virtual ICollection<Position> Positions { get; set; } = new List<Position>(); // 关联岗位
}
 
// 岗位模型
public class Position
{
    public int Id { get; set; }
    [Required(ErrorMessage = "岗位名称不能为空")]
    [StringLength(50)]
    public string Name { get; set; }
    public int DepartmentId { get; set; } // 所属部门ID
    public bool IsEnabled { get; set; } = true;
 
    // 导航属性
    public virtual Department Department { get; set; }
    public virtual ICollection<Employee> Employees { get; set; } = new List<Employee>(); // 关联员工
}
 
// 员工模型
public class Employee
{
    public int Id { get; set; }
    [Required(ErrorMessage = "员工姓名不能为空")]
    [StringLength(50)]
    public string Name { get; set; }
    [StringLength(10)]
    public string Gender { get; set; } // 男/女/其他
    [DataType(DataType.Date, ErrorMessage = "出生日期格式错误")]
    public DateTime BirthDate { get; set; }
    public int DepartmentId { get; set; } // 所属部门ID
    public string AvatarPath { get; set; } // 头像路径（相对路径）
 
    // 导航属性
    public virtual Department Department { get; set; }
    public virtual ICollection<Position> Positions { get; set; } = new List<Position>(); // 关联岗位
}

public class AppDbContext : DbContext
{
    public AppDbContext() : base("DefaultConnection") { }
 
    public DbSet<Department> Departments { get; set; }
    public DbSet<Position> Positions { get; set; }
    public DbSet<Employee> Employees { get; set; }
 
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        // 1. 部门自引用关系（父-子）
        modelBuilder.Entity<Department>()
            .HasOptional(d => d.Parent) // 父部门可选（根部门无父部门）
            .WithMany(d => d.Children) // 一个父部门对应多个子部门
            .HasForeignKey(d => d.ParentId)
            .WillCascadeOnDelete(false); // 禁止删除父部门时自动删除子部门
 
        // 2. 员工与岗位的多对多关系（中间表EmployeePosition）
        modelBuilder.Entity<Employee>()
            .HasMany(e => e.Positions)
            .WithMany(p => e.Employees)
            .Map(m =>
            {
                m.ToTable("EmployeePosition"); // 中间表名
                m.MapLeftKey("EmployeeId"); // 员工ID
                m.MapRightKey("PositionId"); // 岗位ID
            });
 
        base.OnModelCreating(modelBuilder);
    }
}

public interface IRepository<TEntity> where TEntity : class
{
    // 主键查询
    TEntity GetById(int id);
    // 异步主键查询
    Task<TEntity> GetByIdAsync(int id);
    // 获取全部数据（返回IQueryable支持延迟执行）
    IQueryable<TEntity> GetAll();
    // 条件查询
    IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);
    // 新增
    void Add(TEntity entity);
    // 批量新增
    void AddRange(IEnumerable<TEntity> entities);
    // 更新
    void Update(TEntity entity);
    // 删除
    void Delete(TEntity entity);
    // 按主键删除
    void Delete(int id);
}

public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
{
    protected readonly AppDbContext _context;
    protected readonly DbSet<TEntity> _dbSet;
 
    public Repository(AppDbContext context)
    {
        _context = context;
        _dbSet = context.Set<TEntity>();
    }
 
    public TEntity GetById(int id) => _dbSet.Find(id);
 
    public async Task<TEntity> GetByIdAsync(int id) => await _dbSet.FindAsync(id);
 
    public IQueryable<TEntity> GetAll() => _dbSet.AsQueryable();
 
    public IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> predicate) => _dbSet.Where(predicate);
 
    public void Add(TEntity entity) => _dbSet.Add(entity);
 
    public void AddRange(IEnumerable<TEntity> entities) => _dbSet.AddRange(entities);
 
    public void Update(TEntity entity)
    {
        _dbSet.Attach(entity);
        _context.Entry(entity).State = EntityState.Modified;
    }
 
    public void Delete(TEntity entity)
    {
        if (_context.Entry(entity).State == EntityState.Detached)
            _dbSet.Attach(entity);
        _dbSet.Remove(entity);
    }
 
    public void Delete(int id) => Delete(GetById(id));
}

public interface IService<TEntity> where TEntity : class
{
    Task<TEntity> GetByIdAsync(int id);
    Task<IEnumerable<TEntity>> GetAllAsync(bool includeDisabled = false);
    Task AddAsync(TEntity entity);
    Task UpdateAsync(TEntity entity);
    Task DeleteAsync(int id);
}

public class BaseService<TEntity> : IService<TEntity> where TEntity : class
{
    protected readonly IRepository<TEntity> _repository;
 
    public BaseService(IRepository<TEntity> repository)
    {
        _repository = repository;
    }
 
    public async Task<TEntity> GetByIdAsync(int id) => await _repository.GetByIdAsync(id);
 
    public async Task<IEnumerable<TEntity>> GetAllAsync(bool includeDisabled = false)
    {
        var query = _repository.GetAll();
        if (!includeDisabled && typeof(TEntity).GetProperty("IsEnabled") != null)
        {
            // 过滤未启用的数据（仅针对有IsEnabled属性的实体）
            query = query.Where(e => (bool)typeof(TEntity).GetProperty("IsEnabled").GetValue(e));
        }
        return await query.ToListAsync();
    }
 
    public async Task AddAsync(TEntity entity)
    {
        _repository.Add(entity);
        await _context.SaveChangesAsync(); // 注意：后续会用Unit of Work统一管理事务
    }
 
    // 其他方法类似，此处省略...
}

Install-Package Autofac.Mvc5
Install-Package Autofac.Extras.DynamicProxy

protected void Application_Start()
{
    // 1. 创建容器构建器
    var builder = new ContainerBuilder();
 
    // 2. 注册MVC控制器（按程序集扫描）
    builder.RegisterControllers(typeof(MvcApplication).Assembly);
 
    // 3. 注册DbContext（生命周期：请求范围）
    builder.RegisterType<AppDbContext>().AsSelf().InstancePerRequest();
 
    // 4. 注册仓储（泛型）
    builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)).InstancePerRequest();
 
    // 5. 注册服务（按程序集扫描）
    builder.RegisterAssemblyTypes(typeof(DepartmentService).Assembly)
        .Where(t => t.Name.EndsWith("Service"))
        .AsImplementedInterfaces()
        .InstancePerRequest();
 
    // 6. 构建容器并设置MVC依赖解析器
    var container = builder.Build();
    DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
 
    // 其他MVC初始化代码...
}

public class DepartmentController : Controller
{
    private readonly IDepartmentService _departmentService;
 
    // 构造函数注入服务
    public DepartmentController(IDepartmentService departmentService)
    {
        _departmentService = departmentService;
    }
 
    // GET: 部门列表页
    public ActionResult Index() => View();
 
    // GET: 新增部门页面
    public async Task<ActionResult> Create()
    {
        // 获取所有启用的部门作为父部门选项
        var departments = await _departmentService.GetAllAsync();
        ViewBag.ParentId = new SelectList(departments, "Id", "Name");
        return View();
    }
 
    // POST: 提交新增部门
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<ActionResult> Create(Department department)
    {
        if (ModelState.IsValid)
        {
            try
            {
                await _departmentService.AddAsync(department);
                return RedirectToAction("Index");
            }
            catch (ArgumentException ex)
            {
                ModelState.AddModelError("", ex.Message); // 显示业务错误
            }
        }
        // 重新加载父部门选项
        ViewBag.ParentId = new SelectList(await _departmentService.GetAllAsync(), "Id", "Name", department.ParentId);
        return View(department);
    }
 
    // AJAX: 获取部门树形结构（用于ZTree）
    [HttpGet]
    public async Task<JsonResult> GetDepartmentTree()
    {
        var treeData = await _departmentService.GetDepartmentTreeAsync();
        return Json(treeData, JsonRequestBehavior.AllowGet);
    }
}

<link rel="stylesheet" href="~/Scripts/ztree/css/zTreeStyle/zTreeStyle.css" />
<script src="~/Scripts/ztree/jquery.ztree.all.min.js"></script>

@{ ViewBag.Title = "部门管理"; }
 
<div class="panel panel-default">
    <div class="panel-heading">
        <h3 class="panel-title">部门树形结构</h3>
        <a href="@Url.Action("Create")" class="btn btn-primary btn-sm pull-right">新增部门</a>
    </div>
    <div class="panel-body">
        <div id="departmentTree" class="ztree"></div>
    </div>
</div>
 
@section Scripts {
    <script>
        $(function () {
            // ZTree配置（简单数据模式）
            var setting = {
                data: {
                    simpleData: {
                        enable: true, // 启用简单数据格式（pId关联父节点）
                        pIdKey: "parentId" // 父节点ID的字段名
                    }
                },
                callback: {
                    onClick: function (event, treeId, treeNode) {
                        // 点击节点触发的操作（如加载子部门的岗位）
                        console.log("点击了部门：" + treeNode.name);
                    }
                }
            };
 
            // AJAX加载树数据
            $.getJSON("@Url.Action("GetDepartmentTree")", function (data) {
                $.fn.zTree.init($("#departmentTree"), setting, data);
            });
        });
    </script>
}

public async Task<IEnumerable<DepartmentTreeDto>> GetDepartmentTreeAsync()
{
    var departments = await _repository.GetAll()
        .Where(d => d.IsEnabled)
        .ToListAsync();
 
    // 递归构建树结构（根部门：ParentId为null）
    var rootDepartments = departments.Where(d => !d.ParentId.HasValue);
    return BuildTree(rootDepartments, departments);
}
 
// 递归构建子节点
private List<DepartmentTreeDto> BuildTree(IEnumerable<Department> parentDepartments, List<Department> allDepartments)
{
    var treeNodes = new List<DepartmentTreeDto>();
    foreach (var parent in parentDepartments)
    {
        var node = new DepartmentTreeDto
        {
            id = parent.Id,
            name = parent.Name,
            parentId = parent.ParentId,
            children = BuildTree(allDepartments.Where(d => d.ParentId == parent.Id), allDepartments)
        };
        treeNodes.Add(node);
    }
    return treeNodes;
}
 
// DTO：用于返回树形结构数据（避免暴露实体全部属性）
public class DepartmentTreeDto
{
    public int id { get; set; }
    public string name { get; set; }
    public int? parentId { get; set; }
    public List<DepartmentTreeDto> children { get; set; }
}

public async Task AddAsync(Department department)
{
    // 1. 校验父部门
    if (department.ParentId.HasValue)
    {
        var parent = await _repository.GetByIdAsync(department.ParentId.Value);
        if (parent == null || !parent.IsEnabled)
            throw new ArgumentException("父部门不存在或已禁用");
    }
 
    // 2. 校验循环引用（递归检查父部门链）
    if (await IsCircularReferenceAsync(department.Id, department.ParentId ?? 0))
        throw new ArgumentException("不能将部门设置为自身或子部门的子节点");
 
    _repository.Add(department);
    await _unitOfWork.SaveChangesAsync();
}
 
// 递归检查循环引用
private async Task<bool> IsCircularReferenceAsync(int departmentId, int parentId)
{
    if (parentId == 0) return false;
 
    var parent = await _repository.GetByIdAsync(parentId);
    if (parent == null) return false;
 
    // 如果父部门是当前部门，存在循环引用
    if (parent.Id == departmentId) return true;
 
    // 递归检查父部门的父部门
    return await IsCircularReferenceAsync(departmentId, parent.ParentId ?? 0);
}

[HttpPost]
public async Task<JsonResult> BatchUpdateStatus(List<int> positionIds, bool isEnabled)
{
    try
    {
        var positions = await _repository.Find(p => positionIds.Contains(p.Id)).ToListAsync();
        foreach (var position in positions)
        {
            position.IsEnabled = isEnabled;
            _repository.Update(position);
        }
        await _unitOfWork.SaveChangesAsync();
        return Json(new { success = true, message = "操作成功" });
    }
    catch (Exception ex)
    {
        return Json(new { success = false, message = ex.Message });
    }
}

<!-- 前端开关组件 -->
<input type="checkbox" class="status-toggle" data-id="@position.Id" @(position.IsEnabled ? "checked" : "")>
 
<!-- AJAX请求 -->
<script>
    $(".status-toggle").change(function () {
        var positionId = $(this).data("id");
        var isEnabled = $(this).is(":checked");
 
        $.post("@Url.Action("UpdateStatus")", { positionId: positionId, isEnabled: isEnabled }, function (res) {
            if (res.success) {
                alert("状态更新成功");
            } else {
                alert("状态更新失败：" + res.message);
            }
        });
    });
</script>

// PositionController的Create方法
public async Task<ActionResult> Create()
{
    var departments = await _departmentService.GetAllAsync();
    ViewBag.DepartmentId = new SelectList(departments, "Id", "Name");
    return View();
}

<!-- 岗位创建视图（Create.cshtml） -->
<div class="form-group">
    @Html.LabelFor(model => model.DepartmentId, "所属部门", new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        @Html.DropDownListFor(model => model.DepartmentId, ViewBag.DepartmentId as SelectList, "请选择部门", new { @class = "form-control" })
        @Html.ValidationMessageFor(model => model.DepartmentId)
    </div>
</div>

[HttpPost]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Create(Employee employee, HttpPostedFileBase avatar)
{
    if (ModelState.IsValid)
    {
        try
        {
            // 1. 处理头像上传
            if (avatar != null && avatar.ContentLength > 0)
            {
                var uploadDir = Server.MapPath("~/Uploads/Avatars");
                if (!Directory.Exists(uploadDir))
                    Directory.CreateDirectory(uploadDir);
 
                // 生成唯一文件名（避免覆盖）
                var fileName = $"{DateTime.Now:yyyyMMdd_HHmmss}_{Path.GetFileNameWithoutExtension(avatar.FileName)}{Path.GetExtension(avatar.FileName)}";
                var filePath = Path.Combine(uploadDir, fileName);
                avatar.SaveAs(filePath);
 
                // 保存相对路径到数据库
                employee.AvatarPath = $"~/Uploads/Avatars/{fileName}";
            }
 
            // 2. 处理岗位关联（接收前端传递的岗位ID列表）
            var positionIds = Request.Form.GetValues("PositionIds")?.Select(int.Parse) ?? new List<int>();
            employee.Positions = await _positionService.GetByIdsAsync(positionIds);
 
            // 3. 保存员工数据
            await _employeeService.AddAsync(employee);
            return RedirectToAction("Index");
        }
        catch (ArgumentException ex)
        {
            ModelState.AddModelError("", ex.Message);
        }
    }
 
    // 重新加载部门和岗位选项
    ViewBag.DepartmentId = new SelectList(await _departmentService.GetAllAsync(), "Id", "Name", employee.DepartmentId);
    ViewBag.PositionIds = new MultiSelectList(await _positionService.GetAllAsync(), "Id", "Name");
    return View(employee);
}

public class Employee
{
    [Required(ErrorMessage = "员工姓名不能为空")]
    [StringLength(50, ErrorMessage = "姓名最长50字符")]
    public string Name { get; set; }
}

<div class="form-group">
    @Html.LabelFor(model => model.Name, new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        @Html.EditorFor(model => model.Name, new { @class = "form-control" })
        @Html.ValidationMessageFor(model => model.Name, "", new { @class = "text-danger" })
    </div>
</div>

public interface IUnitOfWork : IDisposable
{
    IRepository<Department> DepartmentRepository { get; }
    IRepository<Position> PositionRepository { get; }
    IRepository<Employee> EmployeeRepository { get; }
    Task<int> SaveChangesAsync();
}
 
public class UnitOfWork : IUnitOfWork
{
    private readonly AppDbContext _context;
    private IRepository<Department> _departmentRepository;
    private IRepository<Position> _positionRepository;
    private IRepository<Employee> _employeeRepository;
 
    public UnitOfWork(AppDbContext context)
    {
        _context = context;
    }
 
    public IRepository<Department> DepartmentRepository => _departmentRepository ??= new Repository<Department>(_context);
    public IRepository<Position> PositionRepository => _positionRepository ??= new Repository<Position>(_context);
    public IRepository<Employee> EmployeeRepository => _employeeRepository ??= new Repository<Employee>(_context);
 
    public async Task<int> SaveChangesAsync() => await _context.SaveChangesAsync();
 
    public void Dispose() => _context.Dispose();
}

public class EmployeeService : BaseService<Employee>
{
    private readonly IUnitOfWork _unitOfWork;
 
    public EmployeeService(IUnitOfWork unitOfWork) : base(unitOfWork.EmployeeRepository)
    {
        _unitOfWork = unitOfWork;
    }
 
    public async Task AddAsync(Employee employee, List<int> positionIds)
    {
        // 1. 新增员工
        _unitOfWork.EmployeeRepository.Add(employee);
 
        // 2. 关联岗位
        var positions = await _unitOfWork.PositionRepository.GetAll()
            .Where(p => positionIds.Contains(p.Id))
            .ToListAsync();
        employee.Positions = positions;
 
        // 3. 统一提交事务
        await _unitOfWork.SaveChangesAsync();
    }
}