简体中文 繁體中文 English Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français Japanese

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：为庆祝网站一周年，将在5.1日与5.2日开放注册，具体信息请见后续详细公告
04-22 00:04
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

ASP.NET MVC 4项目实战教程构建高效可扩展Web应用程序的最佳实践

威震华夏关云长
SunJu_FaceMall

3万

主题

1132

科技点

3万

积分

白金月票

碾压王

积分
32766

立华奏
发表于 2025-8-23 20:10:36 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

ASP.NET MVC 4是一个强大的Web应用程序框架，它基于Model-View-Controller（MVC）设计模式，使开发人员能够构建可测试、可维护且高效的应用程序。与传统的Web Forms相比，MVC模式提供了更好的控制、更清晰的关注点分离和更易于测试的代码结构。

本教程将带您深入了解ASP.NET MVC 4的核心概念和最佳实践，通过实际示例展示如何构建高效、可扩展的Web应用程序。我们将从基础概念开始，逐步深入到高级主题，包括依赖注入、安全性、性能优化和测试策略。

ASP.NET MVC 4基础

MVC架构概述

Model-View-Controller（MVC）是一种软件设计模式，它将应用程序分为三个主要组件：

• Model（模型）：表示应用程序的数据和业务逻辑。
• View（视图）：负责显示用户界面。
• Controller（控制器）：处理用户输入，与模型交互并选择视图来呈现。

这种分离使得应用程序更易于管理、测试和修改。

ASP.NET MVC 4的核心组件

ASP.NET MVC 4框架包含以下核心组件：

1. 路由系统：将URL映射到控制器和动作方法。
2. 控制器：处理HTTP请求并生成响应。
3. 动作方法：控制器中的方法，用于执行特定操作。
4. 模型绑定：将HTTP请求数据映射到动作方法参数。
5. 视图引擎：生成HTML响应，默认使用Razor视图引擎。
6. 过滤器：提供在请求处理管道中执行额外逻辑的机制。

项目设置与配置

创建ASP.NET MVC 4项目

让我们开始创建一个新的ASP.NET MVC 4项目：

1. 打开Visual Studio。
2. 选择”文件” > “新建” > “项目”。
3. 在”新建项目”对话框中，选择”Web”模板，然后选择”ASP.NET MVC 4 Web应用程序”。
4. 输入项目名称，例如”MvcDemoApp”，然后点击”确定”。
5. 在”新建ASP.NET MVC 4项目”对话框中，选择”Internet应用程序”模板，确保Razor视图引擎被选中，然后点击”确定”。

项目结构分析

创建项目后，您将看到以下主要文件夹和文件：

• App_Data：用于存储数据库文件。
• App_Start：包含应用程序启动时执行的代码，如路由配置、捆绑配置等。
• Content：包含CSS文件和图像等静态内容。
• Controllers：包含控制器类。
• Models：包含模型类。
• Scripts：包含JavaScript文件。
• Views：包含视图文件，每个控制器有一个对应的文件夹。
• Global.asax：包含应用程序级别的事件处理程序。
• Web.config：包含应用程序配置设置。

配置路由

路由是ASP.NET MVC的核心功能之一，它定义了URL如何映射到控制器和动作方法。默认路由配置在App_Start\RouteConfig.cs文件中：
  2. public class RouteConfig
  3. {
  4.     public static void RegisterRoutes(RouteCollection routes)
  5.     {
  6.         routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
  8.         routes.MapRoute(
  9.             name: "Default",
  10.             url: "{controller}/{action}/{id}",
  11.             defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
  12.         );
  13.     }
  14. }
复制代码

这个默认路由模式{controller}/{action}/{id}将URL映射到控制器的动作方法，并传递一个可选的id参数。例如，URL/Home/Index/3将映射到HomeController的Index方法，并传递id值为3。

构建模型层

创建模型类

模型是应用程序的核心，它表示数据和业务逻辑。让我们创建一个简单的产品模型：
  2. public class Product
  3. {
  4.     public int Id { get; set; }
  5.     public string Name { get; set; }
  6.     public string Description { get; set; }
  7.     public decimal Price { get; set; }
  8.     public int CategoryId { get; set; }
  9.     public virtual Category Category { get; set; }
  10. }
  12. public class Category
  13. {
  14.     public int Id { get; set; }
  15.     public string Name { get; set; }
  16.     public string Description { get; set; }
  17.     public virtual ICollection<Product> Products { get; set; }
  18. }
复制代码

使用Entity Framework

Entity Framework (EF) 是一个对象关系映射（ORM）框架，它使开发人员能够使用.NET对象与数据库交互。让我们配置EF来管理我们的产品数据：

首先，创建一个DbContext类：
  2. public class ProductContext : DbContext
  3. {
  4.     public ProductContext() : base("ProductContext")
  5.     {
  6.     }
  8.     public DbSet<Product> Products { get; set; }
  9.     public DbSet<Category> Categories { get; set; }
  11.     protected override void OnModelCreating(DbModelBuilder modelBuilder)
  12.     {
  13.         modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
  14.     }
  15. }
复制代码

然后，在Web.config文件中添加连接字符串：
  2. <connectionStrings>
  3.   <add name="ProductContext"
  4.        connectionString="Data Source=(LocalDb)\v11.0;Initial Catalog=ProductContext;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|\ProductContext.mdf"
  5.        providerName="System.Data.SqlClient" />
  6. </connectionStrings>
复制代码

数据库迁移

Entity Framework Code First迁移允许您随着模型的变化逐步更新数据库架构。要启用迁移，请按照以下步骤操作：

1. 打开包管理器控制台（工具 > NuGet包管理器 > 包管理器控制台）。
2. 运行命令Enable-Migrations。
3. 运行命令Add-Migration InitialCreate以创建初始迁移。
4. 运行命令Update-Database以应用迁移并创建数据库。

当您更改模型类时，可以创建新的迁移并更新数据库：
  2. Add-Migration AddProductPrice
  3. Update-Database
复制代码

构建控制器层

创建控制器

控制器负责处理用户请求，与模型交互并返回视图。让我们创建一个产品控制器：
  2. public class ProductsController : Controller
  3. {
  4.     private ProductContext db = new ProductContext();
  6.     // GET: Products
  7.     public ActionResult Index()
  8.     {
  9.         var products = db.Products.Include(p => p.Category).ToList();
  10.         return View(products);
  11.     }
  13.     // GET: Products/Details/5
  14.     public ActionResult Details(int? id)
  15.     {
  16.         if (id == null)
  17.         {
  18.             return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
  19.         }
  20.         Product product = db.Products.Find(id);
  21.         if (product == null)
  22.         {
  23.             return HttpNotFound();
  24.         }
  25.         return View(product);
  26.     }
  28.     // GET: Products/Create
  29.     public ActionResult Create()
  30.     {
  31.         ViewBag.CategoryId = new SelectList(db.Categories, "Id", "Name");
  32.         return View();
  33.     }
  35.     // POST: Products/Create
  36.     [HttpPost]
  37.     [ValidateAntiForgeryToken]
  38.     public ActionResult Create([Bind(Include = "Id,Name,Description,Price,CategoryId")] Product product)
  39.     {
  40.         if (ModelState.IsValid)
  41.         {
  42.             db.Products.Add(product);
  43.             db.SaveChanges();
  44.             return RedirectToAction("Index");
  45.         }
  47.         ViewBag.CategoryId = new SelectList(db.Categories, "Id", "Name", product.CategoryId);
  48.         return View(product);
  49.     }
  51.     // GET: Products/Edit/5
  52.     public ActionResult Edit(int? id)
  53.     {
  54.         if (id == null)
  55.         {
  56.             return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
  57.         }
  58.         Product product = db.Products.Find(id);
  59.         if (product == null)
  60.         {
  61.             return HttpNotFound();
  62.         }
  63.         ViewBag.CategoryId = new SelectList(db.Categories, "Id", "Name", product.CategoryId);
  64.         return View(product);
  65.     }
  67.     // POST: Products/Edit/5
  68.     [HttpPost]
  69.     [ValidateAntiForgeryToken]
  70.     public ActionResult Edit([Bind(Include = "Id,Name,Description,Price,CategoryId")] Product product)
  71.     {
  72.         if (ModelState.IsValid)
  73.         {
  74.             db.Entry(product).State = EntityState.Modified;
  75.             db.SaveChanges();
  76.             return RedirectToAction("Index");
  77.         }
  78.         ViewBag.CategoryId = new SelectList(db.Categories, "Id", "Name", product.CategoryId);
  79.         return View(product);
  80.     }
  82.     // GET: Products/Delete/5
  83.     public ActionResult Delete(int? id)
  84.     {
  85.         if (id == null)
  86.         {
  87.             return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
  88.         }
  89.         Product product = db.Products.Find(id);
  90.         if (product == null)
  91.         {
  92.             return HttpNotFound();
  93.         }
  94.         return View(product);
  95.     }
  97.     // POST: Products/Delete/5
  98.     [HttpPost, ActionName("Delete")]
  99.     [ValidateAntiForgeryToken]
  100.     public ActionResult DeleteConfirmed(int id)
  101.     {
  102.         Product product = db.Products.Find(id);
  103.         db.Products.Remove(product);
  104.         db.SaveChanges();
  105.         return RedirectToAction("Index");
  106.     }
  108.     protected override void Dispose(bool disposing)
  109.     {
  110.         if (disposing)
  111.         {
  112.             db.Dispose();
  113.         }
  114.         base.Dispose(disposing);
  115.     }
  116. }
复制代码

控制器最佳实践

以下是一些控制器最佳实践：

1. 保持控制器精简：控制器应该只协调模型和视图之间的交互，而不包含业务逻辑。
2. 使用依赖注入：避免在控制器中直接实例化依赖项，而是通过构造函数注入它们。
3. 使用异步操作：对于I/O密集型操作，使用异步动作方法以提高性能和可伸缩性。
4. 正确处理错误：使用try-catch块和错误过滤器来处理异常。
5. 使用模型绑定：利用ASP.NET MVC的模型绑定功能，而不是手动从请求中提取数据。

异步控制器

异步控制器可以提高应用程序的可伸缩性，特别是在处理I/O密集型操作时。以下是一个异步控制器的示例：
  2. public class ProductsController : Controller
  3. {
  4.     private ProductContext db = new ProductContext();
  6.     // GET: Products
  7.     public async Task<ActionResult> Index()
  8.     {
  9.         var products = await db.Products.Include(p => p.Category).ToListAsync();
  10.         return View(products);
  11.     }
  13.     // GET: Products/Details/5
  14.     public async Task<ActionResult> Details(int? id)
  15.     {
  16.         if (id == null)
  17.         {
  18.             return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
  19.         }
  20.         Product product = await db.Products.FindAsync(id);
  21.         if (product == null)
  22.         {
  23.             return HttpNotFound();
  24.         }
  25.         return View(product);
  26.     }
  28.     // ... 其他动作方法
  30.     protected override void Dispose(bool disposing)
  31.     {
  32.         if (disposing)
  33.         {
  34.             db.Dispose();
  35.         }
  36.         base.Dispose(disposing);
  37.     }
  38. }
复制代码

构建视图层

Razor视图引擎

Razor是ASP.NET MVC的默认视图引擎，它提供了一种简洁、优雅的方式来生成HTML。Razor语法使用@符号来从HTML过渡到C#代码。

以下是一个基本的Razor视图示例：
  2. @model IEnumerable<MvcDemoApp.Models.Product>
  4. @{
  5.     ViewBag.Title = "Index";
  6. }
  8. <h2>Products</h2>
  10. <p>
  11.     @Html.ActionLink("Create New", "Create")
  12. </p>
  13. <table class="table">
  14.     <tr>
  15.         <th>
  16.             @Html.DisplayNameFor(model => model.Name)
  17.         </th>
  18.         <th>
  19.             @Html.DisplayNameFor(model => model.Description)
  20.         </th>
  21.         <th>
  22.             @Html.DisplayNameFor(model => model.Price)
  23.         </th>
  24.         <th>
  25.             @Html.DisplayNameFor(model => model.Category.Name)
  26.         </th>
  27.         <th></th>
  28.     </tr>
  30. @foreach (var item in Model) {
  31.     <tr>
  32.         <td>
  33.             @Html.DisplayFor(modelItem => item.Name)
  34.         </td>
  35.         <td>
  36.             @Html.DisplayFor(modelItem => item.Description)
  37.         </td>
  38.         <td>
  39.             @Html.DisplayFor(modelItem => item.Price)
  40.         </td>
  41.         <td>
  42.             @Html.DisplayFor(modelItem => item.Category.Name)
  43.         </td>
  44.         <td>
  45.             @Html.ActionLink("Edit", "Edit", new { id=item.Id }) |
  46.             @Html.ActionLink("Details", "Details", new { id=item.Id }) |
  47.             @Html.ActionLink("Delete", "Delete", new { id=item.Id })
  48.         </td>
  49.     </tr>
  50. }
  52. </table>
复制代码

布局和部分视图

布局类似于Web Forms中的母版页，它定义了网站的整体结构。默认布局位于Views\Shared\_Layout.cshtml：
  2. <!DOCTYPE html>
  3. <html>
  4. <head>
  5.     <meta charset="utf-8" />
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>@ViewBag.Title - My ASP.NET Application</title>
  8.     @Styles.Render("~/Content/css")
  9.     @Scripts.Render("~/bundles/modernizr")
  10. </head>
  11. <body>
  12.     <div class="navbar navbar-inverse navbar-fixed-top">
  13.         <div class="container">
  14.             <div class="navbar-header">
  15.                 <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
  16.                     <span class="icon-bar"></span>
  17.                     <span class="icon-bar"></span>
  18.                     <span class="icon-bar"></span>
  19.                 </button>
  20.                 @Html.ActionLink("Application name", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
  21.             </div>
  22.             <div class="navbar-collapse collapse">
  23.                 <ul class="nav navbar-nav">
  24.                     <li>@Html.ActionLink("Home", "Index", "Home")</li>
  25.                     <li>@Html.ActionLink("About", "About", "Home")</li>
  26.                     <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
  27.                 </ul>
  28.             </div>
  29.         </div>
  30.     </div>
  31.     <div class="container body-content">
  32.         @RenderBody()
  33.         <hr />
  34.         <footer>
  35.             <p>&copy; @DateTime.Now.Year - My ASP.NET Application</p>
  36.         </footer>
  37.     </div>
  39.     @Scripts.Render("~/bundles/jquery")
  40.     @Scripts.Render("~/bundles/bootstrap")
  41.     @RenderSection("scripts", required: false)
  42. </body>
  43. </html>
复制代码

部分视图是可重用的视图片段，它们可以包含在多个视图中。创建部分视图的步骤如下：

1. 在Views\Shared文件夹中，右键单击并选择”添加” > “视图”。
2. 勾选”创建为部分视图”复选框。
3. 输入视图名称，例如_ProductList，然后点击”添加”。

以下是一个部分视图的示例：
  2. @model IEnumerable<MvcDemoApp.Models.Product>
  4. <table class="table">
  5.     <tr>
  6.         <th>
  7.             @Html.DisplayNameFor(model => model.Name)
  8.         </th>
  9.         <th>
  10.             @Html.DisplayNameFor(model => model.Price)
  11.         </th>
  12.         <th></th>
  13.     </tr>
  15. @foreach (var item in Model) {
  16.     <tr>
  17.         <td>
  18.             @Html.DisplayFor(modelItem => item.Name)
  19.         </td>
  20.         <td>
  21.             @Html.DisplayFor(modelItem => item.Price)
  22.         </td>
  23.         <td>
  24.             @Html.ActionLink("Details", "Details", new { id=item.Id })
  25.         </td>
  26.     </tr>
  27. }
  29. </table>
复制代码

要在其他视图中使用这个部分视图，可以使用Html.Partial或Html.RenderPartial方法：
  2. @Html.Partial("_ProductList", Model)
复制代码

强类型视图和HTML助手

强类型视图使用@model指令指定模型类型，这提供了编译时类型检查和IntelliSense支持。HTML助手是生成HTML元素的方法，它们可以分为三类：

1. 标准HTML助手：如Html.TextBox、Html.DropDownList等。
2. 强类型HTML助手：如Html.TextBoxFor、Html.DropDownListFor等，它们使用lambda表达式指定模型属性。
3. 模板化HTML助手：如Html.DisplayFor和Html.EditorFor，它们根据模型属性的数据类型和元数据生成HTML。

以下是一个使用强类型HTML助手的表单示例：
  2. @model MvcDemoApp.Models.Product
  4. @{
  5.     ViewBag.Title = "Create";
  6. }
  8. <h2>Create Product</h2>
  10. @using (Html.BeginForm())
  11. {
  12.     @Html.AntiForgeryToken()
  13.    
  14.     <div class="form-horizontal">
  15.         <h4>Product</h4>
  16.         <hr />
  17.         @Html.ValidationSummary(true, "", new { @class = "text-danger" })
  18.         <div class="form-group">
  19.             @Html.LabelFor(model => model.Name, htmlAttributes: new { @class = "control-label col-md-2" })
  20.             <div class="col-md-10">
  21.                 @Html.EditorFor(model => model.Name, new { htmlAttributes = new { @class = "form-control" } })
  22.                 @Html.ValidationMessageFor(model => model.Name, "", new { @class = "text-danger" })
  23.             </div>
  24.         </div>
  26.         <div class="form-group">
  27.             @Html.LabelFor(model => model.Description, htmlAttributes: new { @class = "control-label col-md-2" })
  28.             <div class="col-md-10">
  29.                 @Html.EditorFor(model => model.Description, new { htmlAttributes = new { @class = "form-control" } })
  30.                 @Html.ValidationMessageFor(model => model.Description, "", new { @class = "text-danger" })
  31.             </div>
  32.         </div>
  34.         <div class="form-group">
  35.             @Html.LabelFor(model => model.Price, htmlAttributes: new { @class = "control-label col-md-2" })
  36.             <div class="col-md-10">
  37.                 @Html.EditorFor(model => model.Price, new { htmlAttributes = new { @class = "form-control" } })
  38.                 @Html.ValidationMessageFor(model => model.Price, "", new { @class = "text-danger" })
  39.             </div>
  40.         </div>
  42.         <div class="form-group">
  43.             @Html.LabelFor(model => model.CategoryId, "CategoryId", htmlAttributes: new { @class = "control-label col-md-2" })
  44.             <div class="col-md-10">
  45.                 @Html.DropDownList("CategoryId", null, htmlAttributes: new { @class = "form-control" })
  46.                 @Html.ValidationMessageFor(model => model.CategoryId, "", new { @class = "text-danger" })
  47.             </div>
  48.         </div>
  50.         <div class="form-group">
  51.             <div class="col-md-offset-2 col-md-10">
  52.                 <input type="submit" value="Create" class="btn btn-default" />
  53.             </div>
  54.         </div>
  55.     </div>
  56. }
  58. <div>
  59.     @Html.ActionLink("Back to List", "Index")
  60. </div>
  62. @section Scripts {
  63.     @Scripts.Render("~/bundles/jqueryval")
  64. }
复制代码

数据访问

Repository模式

Repository模式是一种设计模式，它抽象了数据访问层，使应用程序与数据存储解耦。使用Repository模式可以提高代码的可测试性和可维护性。

首先，定义一个通用的Repository接口：
  2. public interface IRepository<T> where T : class
  3. {
  4.     IEnumerable<T> GetAll();
  5.     T GetById(int id);
  6.     void Add(T entity);
  7.     void Update(T entity);
  8.     void Delete(T entity);
  9.     void Save();
  10. }
复制代码

然后，实现这个接口：
  2. public class Repository<T> : IRepository<T> where T : class
  3. {
  4.     protected ProductContext context;
  5.     protected DbSet<T> dbSet;
  7.     public Repository(ProductContext context)
  8.     {
  9.         this.context = context;
  10.         this.dbSet = context.Set<T>();
  11.     }
  13.     public virtual IEnumerable<T> GetAll()
  14.     {
  15.         return dbSet.ToList();
  16.     }
  18.     public virtual T GetById(int id)
  19.     {
  20.         return dbSet.Find(id);
  21.     }
  23.     public virtual void Add(T entity)
  24.     {
  25.         dbSet.Add(entity);
  26.     }
  28.     public virtual void Update(T entity)
  29.     {
  30.         dbSet.Attach(entity);
  31.         context.Entry(entity).State = EntityState.Modified;
  32.     }
  34.     public virtual void Delete(T entity)
  35.     {
  36.         if (context.Entry(entity).State == EntityState.Detached)
  37.         {
  38.             dbSet.Attach(entity);
  39.         }
  40.         dbSet.Remove(entity);
  41.     }
  43.     public virtual void Save()
  44.     {
  45.         context.SaveChanges();
  46.     }
  47. }
复制代码

接下来，创建特定的Repository接口和实现：
  2. public interface IProductRepository : IRepository<Product>
  3. {
  4.     IEnumerable<Product> GetProductsByCategory(int categoryId);
  5. }
  7. public class ProductRepository : Repository<Product>, IProductRepository
  8. {
  9.     public ProductRepository(ProductContext context) : base(context)
  10.     {
  11.     }
  13.     public IEnumerable<Product> GetProductsByCategory(int categoryId)
  14.     {
  15.         return context.Products.Where(p => p.CategoryId == categoryId).ToList();
  16.     }
  17. }
复制代码

Unit of Work模式

Unit of Work模式维护一个受业务事务影响的对象列表，并协调写入更改和解决并发问题。它通常与Repository模式一起使用。
  2. public interface IUnitOfWork : IDisposable
  3. {
  4.     IProductRepository ProductRepository { get; }
  5.     ICategoryRepository CategoryRepository { get; }
  6.     void Save();
  7. }
  9. public class UnitOfWork : IUnitOfWork
  10. {
  11.     private ProductContext context = new ProductContext();
  12.     private IProductRepository productRepository;
  13.     private ICategoryRepository categoryRepository;
  15.     public IProductRepository ProductRepository
  16.     {
  17.         get
  18.         {
  19.             if (this.productRepository == null)
  20.             {
  21.                 this.productRepository = new ProductRepository(context);
  22.             }
  23.             return productRepository;
  24.         }
  25.     }
  27.     public ICategoryRepository CategoryRepository
  28.     {
  29.         get
  30.         {
  31.             if (this.categoryRepository == null)
  32.             {
  33.                 this.categoryRepository = new CategoryRepository(context);
  34.             }
  35.             return categoryRepository;
  36.         }
  37.     }
  39.     public void Save()
  40.     {
  41.         context.SaveChanges();
  42.     }
  44.     private bool disposed = false;
  46.     protected virtual void Dispose(bool disposing)
  47.     {
  48.         if (!this.disposed)
  49.         {
  50.             if (disposing)
  51.             {
  52.                 context.Dispose();
  53.             }
  54.         }
  55.         this.disposed = true;
  56.     }
  58.     public void Dispose()
  59.     {
  60.         Dispose(true);
  61.         GC.SuppressFinalize(this);
  62.     }
  63. }
复制代码

使用Repository和Unit of Work

现在，我们可以更新控制器以使用Repository和Unit of Work模式：
  2. public class ProductsController : Controller
  3. {
  4.     private IUnitOfWork unitOfWork;
  6.     public ProductsController(IUnitOfWork unitOfWork)
  7.     {
  8.         this.unitOfWork = unitOfWork;
  9.     }
  11.     // GET: Products
  12.     public ActionResult Index()
  13.     {
  14.         var products = unitOfWork.ProductRepository.GetAll();
  15.         return View(products);
  16.     }
  18.     // GET: Products/Details/5
  19.     public ActionResult Details(int? id)
  20.     {
  21.         if (id == null)
  22.         {
  23.             return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
  24.         }
  25.         Product product = unitOfWork.ProductRepository.GetById(id.Value);
  26.         if (product == null)
  27.         {
  28.             return HttpNotFound();
  29.         }
  30.         return View(product);
  31.     }
  33.     // GET: Products/Create
  34.     public ActionResult Create()
  35.     {
  36.         ViewBag.CategoryId = new SelectList(unitOfWork.CategoryRepository.GetAll(), "Id", "Name");
  37.         return View();
  38.     }
  40.     // POST: Products/Create
  41.     [HttpPost]
  42.     [ValidateAntiForgeryToken]
  43.     public ActionResult Create([Bind(Include = "Id,Name,Description,Price,CategoryId")] Product product)
  44.     {
  45.         if (ModelState.IsValid)
  46.         {
  47.             unitOfWork.ProductRepository.Add(product);
  48.             unitOfWork.Save();
  49.             return RedirectToAction("Index");
  50.         }
  52.         ViewBag.CategoryId = new SelectList(unitOfWork.CategoryRepository.GetAll(), "Id", "Name", product.CategoryId);
  53.         return View(product);
  54.     }
  56.     // GET: Products/Edit/5
  57.     public ActionResult Edit(int? id)
  58.     {
  59.         if (id == null)
  60.         {
  61.             return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
  62.         }
  63.         Product product = unitOfWork.ProductRepository.GetById(id.Value);
  64.         if (product == null)
  65.         {
  66.             return HttpNotFound();
  67.         }
  68.         ViewBag.CategoryId = new SelectList(unitOfWork.CategoryRepository.GetAll(), "Id", "Name", product.CategoryId);
  69.         return View(product);
  70.     }
  72.     // POST: Products/Edit/5
  73.     [HttpPost]
  74.     [ValidateAntiForgeryToken]
  75.     public ActionResult Edit([Bind(Include = "Id,Name,Description,Price,CategoryId")] Product product)
  76.     {
  77.         if (ModelState.IsValid)
  78.         {
  79.             unitOfWork.ProductRepository.Update(product);
  80.             unitOfWork.Save();
  81.             return RedirectToAction("Index");
  82.         }
  83.         ViewBag.CategoryId = new SelectList(unitOfWork.CategoryRepository.GetAll(), "Id", "Name", product.CategoryId);
  84.         return View(product);
  85.     }
  87.     // GET: Products/Delete/5
  88.     public ActionResult Delete(int? id)
  89.     {
  90.         if (id == null)
  91.         {
  92.             return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
  93.         }
  94.         Product product = unitOfWork.ProductRepository.GetById(id.Value);
  95.         if (product == null)
  96.         {
  97.             return HttpNotFound();
  98.         }
  99.         return View(product);
  100.     }
  102.     // POST: Products/Delete/5
  103.     [HttpPost, ActionName("Delete")]
  104.     [ValidateAntiForgeryToken]
  105.     public ActionResult DeleteConfirmed(int id)
  106.     {
  107.         Product product = unitOfWork.ProductRepository.GetById(id);
  108.         unitOfWork.ProductRepository.Delete(product);
  109.         unitOfWork.Save();
  110.         return RedirectToAction("Index");
  111.     }
  113.     protected override void Dispose(bool disposing)
  114.     {
  115.         if (disposing)
  116.         {
  117.             unitOfWork.Dispose();
  118.         }
  119.         base.Dispose(disposing);
  120.     }
  121. }
复制代码

实现依赖注入

依赖注入概述

依赖注入（DI）是一种设计模式，它允许我们将依赖项从外部注入到类中，而不是在类内部创建它们。这有助于实现控制反转（IoC），提高代码的可测试性和可维护性。

使用Unity容器

Unity是一个轻量级、可扩展的依赖注入容器。让我们在ASP.NET MVC 4应用程序中配置Unity：

1. 安装Unity NuGet包：Install-Package Unity.Mvc4
2. 在App_Start文件夹中创建UnityConfig.cs文件：

安装Unity NuGet包：
  2. Install-Package Unity.Mvc4
复制代码

在App_Start文件夹中创建UnityConfig.cs文件：
  2. public static class UnityConfig
  3. {
  4.     public static void RegisterComponents()
  5.     {
  6.         var container = new UnityContainer();
  8.         // 注册所有组件
  9.         container.RegisterType<IUnitOfWork, UnitOfWork>();
  10.         container.RegisterType<IProductRepository, ProductRepository>();
  11.         container.RegisterType<ICategoryRepository, CategoryRepository>();
  13.         DependencyResolver.SetResolver(new UnityDependencyResolver(container));
  14.     }
  15. }
复制代码

1. 在Global.asax.cs文件中调用UnityConfig.RegisterComponents()：
  2. protected void Application_Start()
  3. {
  4.     AreaRegistration.RegisterAllAreas();
  5.     FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
  6.     RouteConfig.RegisterRoutes(RouteTable.Routes);
  7.     BundleConfig.RegisterBundles(BundleTable.Bundles);
  8.     AuthConfig.RegisterAuth();
  9.    
  10.     UnityConfig.RegisterComponents();
  11. }
复制代码

依赖注入的好处

使用依赖注入有以下好处：

1. 提高可测试性：可以轻松地用模拟对象替换真实依赖项，使单元测试更容易编写。
2. 降低耦合度：类不再负责创建其依赖项，而是通过构造函数或属性接收它们。
3. 提高可维护性：依赖项的更改不会影响使用它们的类。
4. 提高可重用性：类可以在不同的上下文中重用，只需提供不同的依赖项实现。

安全性最佳实践

身份验证和授权

ASP.NET MVC 4提供了多种身份验证和授权机制：

1. Forms身份验证：基于cookie的身份验证，适用于大多数Web应用程序。
2. Windows身份验证：适用于Intranet应用程序。
3. OAuth和OpenID：用于第三方身份验证，如Facebook、Google等。

以下是如何在ASP.NET MVC 4中实现基于角色的授权：
  2. [Authorize(Roles = "Admin")]
  3. public class AdminController : Controller
  4. {
  5.     // 只有管理员可以访问这些动作方法
  6.     public ActionResult Index()
  7.     {
  8.         return View();
  9.     }
  10. }
  12. public class ProductsController : Controller
  13. {
  14.     // 任何经过身份验证的用户都可以访问
  15.     [Authorize]
  16.     public ActionResult Create()
  17.     {
  18.         return View();
  19.     }
  21.     // 允许匿名访问
  22.     [AllowAnonymous]
  23.     public ActionResult Details(int id)
  24.     {
  25.         return View();
  26.     }
  27. }
复制代码

防止常见攻击

ASP.NET MVC 4默认对Razor视图中的输出进行HTML编码，这有助于防止XSS攻击。但是，在使用Html.Raw方法时要小心：
  2. <!-- 危险：可能导致XSS攻击 -->
  3. @Html.Raw(Model.UserContent)
  5. <!-- 安全：输出被HTML编码 -->
  6. @Model.UserContent
复制代码

ASP.NET MVC 4提供了内置的CSRF保护。在表单中使用@Html.AntiForgeryToken()，并在动作方法上应用[ValidateAntiForgeryToken]特性：
  2. @using (Html.BeginForm())
  3. {
  4.     @Html.AntiForgeryToken()
  5.    
  6.     <!-- 表单字段 -->
  7. }
复制代码
  2. [HttpPost]
  3. [ValidateAntiForgeryToken]
  4. public ActionResult Create(Product product)
  5. {
  6.     // 处理表单提交
  7. }
复制代码

使用参数化查询或ORM（如Entity Framework）来防止SQL注入攻击：
  2. // 危险：容易受到SQL注入攻击
  3. string query = "SELECT * FROM Products WHERE Name = '" + productName + "'";
  5. // 安全：使用参数化查询
  6. string query = "SELECT * FROM Products WHERE Name = @productName";
  7. SqlCommand command = new SqlCommand(query, connection);
  8. command.Parameters.AddWithValue("@productName", productName);
  10. // 更安全：使用Entity Framework
  11. var products = db.Products.Where(p => p.Name == productName).ToList();
复制代码

安全配置

在Web.config文件中，可以配置以下安全设置：
  2. <system.web>
  3.   <!-- 启用SSL/TLS -->
  4.   <httpCookies requireSSL="true" httpOnlyCookies="true" />
  5.   
  6.   <!-- 禁用不必要的HTTP方法 -->
  7.   <httpProtocol>
  8.     <customHeaders>
  9.       <add name="X-Content-Type-Options" value="nosniff" />
  10.       <add name="X-Frame-Options" value="SAMEORIGIN" />
  11.       <add name="X-XSS-Protection" value="1; mode=block" />
  12.     </customHeaders>
  13.   </httpProtocol>
  14.   
  15.   <!-- 配置身份验证 -->
  16.   <authentication mode="Forms">
  17.     <forms loginUrl="~/Account/Login" timeout="2880" requireSSL="true" />
  18.   </authentication>
  19. </system.web>
复制代码

性能优化

缓存策略

缓存是提高Web应用程序性能的有效方法。ASP.NET MVC 4提供了多种缓存选项：

使用[OutputCache]特性缓存控制器的输出：
  2. [OutputCache(Duration = 3600, Location = OutputCacheLocation.Client)]
  3. public ActionResult Index()
  4. {
  5.     var products = db.Products.ToList();
  6.     return View(products);
  7. }
复制代码

使用System.Runtime.Caching.MemoryCache缓存数据：
  2. public ActionResult Index()
  3. {
  4.     var cacheKey = "Products";
  5.     var products = MemoryCache.Default.Get(cacheKey) as List<Product>;
  6.    
  7.     if (products == null)
  8.     {
  9.         products = db.Products.ToList();
  10.         
  11.         var policy = new CacheItemPolicy
  12.         {
  13.             AbsoluteExpiration = DateTimeOffset.Now.AddHours(1)
  14.         };
  15.         
  16.         MemoryCache.Default.Add(cacheKey, products, policy);
  17.     }
  18.    
  19.     return View(products);
  20. }
复制代码

对于大型应用程序，可以使用分布式缓存，如Redis或AppFabric缓存：
  2. public ActionResult Index()
  3. {
  4.     var cacheKey = "Products";
  5.     var products = Cache.Get(cacheKey) as List<Product>;
  6.    
  7.     if (products == null)
  8.     {
  9.         products = db.Products.ToList();
  10.         Cache.Add(cacheKey, products, null, DateTime.Now.AddHours(1),
  11.             Cache.NoSlidingExpiration, CacheItemPriority.Default, null);
  12.     }
  13.    
  14.     return View(products);
  15. }
复制代码

捆绑和缩小

捆绑和缩小是减少HTTP请求数量和文件大小的有效方法。ASP.NET MVC 4提供了内置的捆绑和缩小功能。

在App_Start\BundleConfig.cs文件中配置捆绑：
  2. public class BundleConfig
  3. {
  4.     public static void RegisterBundles(BundleCollection bundles)
  5.     {
  6.         bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
  7.                     "~/Scripts/jquery-{version}.js"));
  9.         bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
  10.                     "~/Scripts/jquery.validate*"));
  12.         bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
  13.                     "~/Scripts/modernizr-*"));
  15.         bundles.Add(new ScriptBundle("~/bundles/bootstrap").Include(
  16.                   "~/Scripts/bootstrap.js",
  17.                   "~/Scripts/respond.js"));
  19.         bundles.Add(new StyleBundle("~/Content/css").Include(
  20.                   "~/Content/bootstrap.css",
  21.                   "~/Content/site.css"));
  22.     }
  23. }
复制代码

在视图中使用捆绑：
  2. @Styles.Render("~/Content/css")
  3. @Scripts.Render("~/bundles/jquery")
  4. @Scripts.Render("~/bundles/bootstrap")
复制代码

异步处理

使用异步控制器和动作方法可以提高应用程序的可伸缩性，特别是在处理I/O密集型操作时：
  2. public async Task<ActionResult> Index()
  3. {
  4.     var products = await db.Products.ToListAsync();
  5.     return View(products);
  6. }
复制代码

优化数据库访问

优化数据库访问可以显著提高应用程序性能：

1. 使用延迟加载和预先加载：根据场景选择适当的加载策略。
2. 避免N+1查询问题：使用Include方法预先加载相关实体。
3. 使用存储过程：对于复杂查询，考虑使用存储过程。
4. 优化索引：确保数据库表有适当的索引。
  2. // 使用Include预先加载相关实体
  3. var products = await db.Products
  4.     .Include(p => p.Category)
  5.     .ToListAsync();
  7. // 使用Select只查询需要的字段
  8. var productNames = await db.Products
  9.     .Where(p => p.Price > 100)
  10.     .Select(p => p.Name)
  11.     .ToListAsync();
复制代码

测试策略

单元测试

单元测试是验证代码单元（如方法或类）是否按预期工作的过程。ASP.NET MVC 4的可测试性设计使得编写单元测试变得容易。

以下是一个使用NUnit和Moq的单元测试示例：
  2. [TestFixture]
  3. public class ProductsControllerTests
  4. {
  5.     private ProductsController controller;
  6.     private IUnitOfWork unitOfWork;
  7.     private IProductRepository productRepository;
  8.     private List<Product> products;
  10.     [SetUp]
  11.     public void Setup()
  12.     {
  13.         // 创建测试数据
  14.         products = new List<Product>
  15.         {
  16.             new Product { Id = 1, Name = "Product 1", Price = 10.00m },
  17.             new Product { Id = 2, Name = "Product 2", Price = 20.00m }
  18.         };
  20.         // 模拟Repository
  21.         productRepository = new Mock<IProductRepository>();
  22.         productRepository.Setup(r => r.GetAll()).Returns(products);
  23.         productRepository.Setup(r => r.GetById(It.IsAny<int>()))
  24.             .Returns<int>(id => products.FirstOrDefault(p => p.Id == id));
  26.         // 模拟UnitOfWork
  27.         unitOfWork = new Mock<IUnitOfWork>();
  28.         unitOfWork.Setup(u => u.ProductRepository).Returns(productRepository.Object);
  30.         // 创建控制器
  31.         controller = new ProductsController(unitOfWork.Object);
  32.     }
  34.     [Test]
  35.     public void Index_ReturnsAllProducts()
  36.     {
  37.         // Act
  38.         var result = controller.Index() as ViewResult;
  39.         var model = result.Model as List<Product>;
  41.         // Assert
  42.         Assert.IsNotNull(result);
  43.         Assert.AreEqual(2, model.Count);
  44.         Assert.AreEqual("Product 1", model[0].Name);
  45.         Assert.AreEqual("Product 2", model[1].Name);
  46.     }
  48.     [Test]
  49.     public void Details_ValidId_ReturnsProduct()
  50.     {
  51.         // Act
  52.         var result = controller.Details(1) as ViewResult;
  53.         var model = result.Model as Product;
  55.         // Assert
  56.         Assert.IsNotNull(result);
  57.         Assert.AreEqual(1, model.Id);
  58.         Assert.AreEqual("Product 1", model.Name);
  59.     }
  61.     [Test]
  62.     public void Details_InvalidId_ReturnsHttpNotFound()
  63.     {
  64.         // Act
  65.         var result = controller.Details(99);
  67.         // Assert
  68.         Assert.IsInstanceOf<HttpNotFoundResult>(result);
  69.     }
  70. }
复制代码

集成测试

集成测试验证多个组件一起工作时是否按预期执行。以下是一个使用Entity Framework的集成测试示例：
  2. [TestFixture]
  3. public class ProductRepositoryIntegrationTests
  4. {
  5.     private ProductContext context;
  6.     private IProductRepository repository;
  8.     [SetUp]
  9.     public void Setup()
  10.     {
  11.         // 创建内存数据库
  12.         Database.DefaultConnectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
  13.         context = new ProductContext("Product_Test");
  14.         context.Database.CreateIfNotExists();
  15.         repository = new ProductRepository(context);
  16.     }
  18.     [TearDown]
  19.     public void TearDown()
  20.     {
  21.         context.Database.Delete();
  22.         context.Dispose();
  23.     }
  25.     [Test]
  26.     public void Add_Product_AddsToDatabase()
  27.     {
  28.         // Arrange
  29.         var product = new Product { Name = "Test Product", Price = 10.00m };
  31.         // Act
  32.         repository.Add(product);
  33.         repository.Save();
  35.         // Assert
  36.         var result = context.Products.FirstOrDefault(p => p.Name == "Test Product");
  37.         Assert.IsNotNull(result);
  38.         Assert.AreEqual(10.00m, result.Price);
  39.     }
  41.     [Test]
  42.     public void GetAll_ReturnsAllProducts()
  43.     {
  44.         // Arrange
  45.         context.Products.Add(new Product { Name = "Product 1", Price = 10.00m });
  46.         context.Products.Add(new Product { Name = "Product 2", Price = 20.00m });
  47.         context.SaveChanges();
  49.         // Act
  50.         var result = repository.GetAll();
  52.         // Assert
  53.         Assert.AreEqual(2, result.Count());
  54.     }
  55. }
复制代码

测试驱动开发（TDD）

测试驱动开发是一种开发方法，它要求在编写代码之前先编写测试。以下是TDD的基本步骤：

1. 编写失败的测试：编写一个测试，验证尚未实现的功能。
2. 编写最少的代码：编写足够的代码使测试通过。
3. 重构：改进代码，同时确保测试仍然通过。

以下是一个使用TDD开发产品搜索功能的示例：
  2. // 步骤1：编写失败的测试
  3. [Test]
  4. public void Search_ByKeyword_ReturnsMatchingProducts()
  5. {
  6.     // Arrange
  7.     var products = new List<Product>
  8.     {
  9.         new Product { Id = 1, Name = "Laptop", Description = "High performance laptop" },
  10.         new Product { Id = 2, Name = "Mouse", Description = "Wireless mouse" },
  11.         new Product { Id = 3, Name = "Keyboard", Description = "Mechanical keyboard" }
  12.     };
  13.    
  14.     var mockRepository = new Mock<IProductRepository>();
  15.     mockRepository.Setup(r => r.GetAll()).Returns(products);
  16.    
  17.     var controller = new ProductsController(mockUnitOfWork.Object);
  18.    
  19.     // Act
  20.     var result = controller.Search("laptop") as ViewResult;
  21.     var model = result.Model as List<Product>;
  22.    
  23.     // Assert
  24.     Assert.AreEqual(1, model.Count);
  25.     Assert.AreEqual("Laptop", model[0].Name);
  26. }
  28. // 步骤2：编写最少的代码使测试通过
  29. public ActionResult Search(string keyword)
  30. {
  31.     var products = unitOfWork.ProductRepository.GetAll();
  32.     var result = products.Where(p => p.Name.Contains(keyword)).ToList();
  33.     return View(result);
  34. }
  36. // 步骤3：重构代码
  37. public ActionResult Search(string keyword)
  38. {
  39.     if (string.IsNullOrEmpty(keyword))
  40.     {
  41.         return RedirectToAction("Index");
  42.     }
  43.    
  44.     var products = unitOfWork.ProductRepository.GetAll();
  45.     var result = products.Where(p =>
  46.         p.Name.Contains(keyword) || p.Description.Contains(keyword)).ToList();
  47.     return View(result);
  48. }
复制代码

部署与维护

部署策略

Visual Studio提供了Web部署功能，可以直接将应用程序部署到IIS服务器：

1. 在解决方案资源管理器中右键单击项目，选择”发布”。
2. 选择”Web部署”作为发布方法。
3. 输入服务器、站点名称和用户凭据。
4. 配置数据库连接字符串和其他设置。
5. 点击”发布”。

创建部署包以便手动部署：

1. 在解决方案资源管理器中右键单击项目，选择”发布”。
2. 选择”Web部署包”作为发布方法。
3. 指定包位置和IIS网站名称。
4. 点击”发布”。
5. 将生成的包复制到目标服务器并运行部署命令。

使用TeamCity、Jenkins或Azure DevOps等工具设置CI/CD流水线：

1. 配置源代码管理（如Git）。
2. 设置构建服务器，在代码提交时自动构建项目。
3. 配置自动测试，确保构建通过所有测试。
4. 设置自动部署到测试环境。
5. 配置批准流程，然后自动部署到生产环境。

监控和日志记录

使用日志记录框架（如NLog或log4net）记录应用程序事件：
  2. public class ProductsController : Controller
  3. {
  4.     private readonly IUnitOfWork unitOfWork;
  5.     private readonly ILogger logger;
  7.     public ProductsController(IUnitOfWork unitOfWork, ILogger logger)
  8.     {
  9.         this.unitOfWork = unitOfWork;
  10.         this.logger = logger;
  11.     }
  13.     public ActionResult Index()
  14.     {
  15.         try
  16.         {
  17.             var products = unitOfWork.ProductRepository.GetAll();
  18.             logger.Info("Retrieved {0} products", products.Count());
  19.             return View(products);
  20.         }
  21.         catch (Exception ex)
  22.         {
  23.             logger.Error(ex, "Error retrieving products");
  24.             throw;
  25.         }
  26.     }
  27. }
复制代码

使用Application Insights或New Relic等工具监控应用程序性能：

1. 安装NuGet包：Install-Package Microsoft.ApplicationInsights.Web
2. 在ApplicationInsights.config文件中配置检测键。
3. 在代码中添加自定义遥测：

安装NuGet包：
  2. Install-Package Microsoft.ApplicationInsights.Web
复制代码

在ApplicationInsights.config文件中配置检测键。

在代码中添加自定义遥测：
  2. public ActionResult Details(int id)
  3. {
  4.     var telemetry = new TelemetryClient();
  5.     var stopwatch = Stopwatch.StartNew();
  6.    
  7.     try
  8.     {
  9.         var product = unitOfWork.ProductRepository.GetById(id);
  10.         if (product == null)
  11.         {
  12.             telemetry.TrackEvent("ProductNotFound", new Dictionary<string, string> { { "ProductId", id.ToString() } });
  13.             return HttpNotFound();
  14.         }
  15.         
  16.         return View(product);
  17.     }
  18.     finally
  19.     {
  20.         stopwatch.Stop();
  21.         telemetry.TrackMetric("ProductDetailsLoadTime", stopwatch.ElapsedMilliseconds);
  22.     }
  23. }
复制代码

维护和更新

定期更新应用程序以修复错误、添加功能或提高性能：

1. 使用版本控制系统（如Git）管理代码。
2. 实施功能切换，以便在不重新部署的情况下启用或禁用功能。
3. 使用数据库迁移管理数据库架构更改。
4. 实施蓝绿部署或金丝雀发布策略，以减少部署风险。

保持应用程序安全：

1. 定期更新NuGet包以修复安全漏洞。
2. 监控安全公告和CVE（常见漏洞和暴露）。
3. 定期进行安全审计和渗透测试。
4. 实施Web应用程序防火墙（WAF）以防止常见攻击。

总结与展望

本教程详细介绍了ASP.NET MVC 4的核心概念和最佳实践，包括：

• MVC架构和ASP.NET MVC 4的核心组件
• 项目设置和配置
• 构建模型、控制器和视图
• 数据访问模式和Entity Framework
• 依赖注入和控制反转
• 安全性最佳实践
• 性能优化技术
• 测试策略和方法
• 部署和维护策略

通过遵循这些最佳实践，您可以构建高效、可扩展且易于维护的ASP.NET MVC 4应用程序。

未来发展方向

虽然ASP.NET MVC 4是一个强大的框架，但Microsoft已经发布了更新的版本，如ASP.NET MVC 5和ASP.NET Core MVC。这些新版本提供了许多改进和新功能，包括：

• 更好的性能和可伸缩性
• 跨平台支持（ASP.NET Core）
• 改进的依赖注入支持
• 标记助手（Tag Helpers）
• 视图组件（View Components）
• 内置的Web API支持

如果您正在开始一个新项目，建议考虑使用ASP.NET Core MVC，它是Microsoft的最新Web开发框架，结合了ASP.NET MVC、Web API和Web Pages的优点。

持续学习资源

要继续学习ASP.NET MVC和相关技术，以下资源可能会有所帮助：

1. Microsoft文档：https://docs.microsoft.com/en-us/aspnet/mvc
2. ASP.NET网站：https://www.asp.net/mvc
3. Pluralsight课程：提供各种ASP.NET MVC课程
4. Stack Overflow：解决特定问题的问答社区
5. GitHub：查看开源ASP.NET MVC项目

通过不断学习和实践，您可以掌握ASP.NET MVC的高级概念和技术，成为一名高效的Web开发人员。
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

关闭

站长推荐上一条 /1 下一条

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
友链交换
友链交换
友链为随机排序，不代表本论坛观点
Telegram

Telegram

Discord

Discord

Tencent QQ

Tencent QQ

手机版|联系我们|小黑屋|TG频道|RSS |网站地图

Powered by Pixtech

© 2025-2026 Pixtech Team.

>