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

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

掌握ASP.NET项目开发核心技能实战案例全程解析与经验分享

威震华夏关云长
SunJu_FaceMall

3万

主题

166

科技点

3万

积分

大区版主

碾压王

积分
32106
发表于 2025-8-23 19:50:36 | 显示全部楼层 |阅读模式 [标记阅至此楼]

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

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

x
1. ASP.NET概述与发展历程

ASP.NET是微软推出的用于构建Web应用程序的开发框架，自2002年首次发布以来，经历了多个版本的演进。从最初的ASP.NET Web Forms，到ASP.NET MVC，再到如今的ASP.NET Core，这个框架不断适应着Web开发的变化和需求。

1.1 ASP.NET的演进

• ASP.NET Web Forms：最初的ASP.NET版本，提供了事件驱动的编程模型，类似于Windows Forms开发。
• ASP.NET MVC：引入了模型-视图-控制器架构模式，提供了更好的控制和可测试性。
• ASP.NET Web API：专门用于构建HTTP服务的框架，便于创建RESTful服务。
• ASP.NET Core：跨平台、高性能的开源框架，整合了MVC、Web API和Web Pages的功能。

1.2 ASP.NET Core的优势

ASP.NET Core作为当前最新的版本，具有以下优势：

• 跨平台支持：可在Windows、macOS和Linux上运行
• 高性能：经过优化的运行时和请求处理管道
• 模块化设计：只包含需要的功能，减少应用体积
• 开源：社区驱动的开发模式
• 统一编程模型：同时支持MVC和Web API

2. ASP.NET项目开发的核心技能

2.1 C#编程基础

C#是ASP.NET开发的主要语言，掌握C#的基础知识是必要的：
  2. // 基本语法示例
  3. public class HelloWorld
  4. {
  5.     public static void Main(string[] args)
  6.     {
  7.         Console.WriteLine("Hello, ASP.NET Core!");
  8.         
  9.         // 变量声明与使用
  10.         string message = "Welcome to ASP.NET Core development";
  11.         int version = 6;
  12.         
  13.         Console.WriteLine($"{message} - Version {version}");
  14.     }
  15. }
复制代码

2.2 依赖注入

依赖注入(DI)是ASP.NET Core的核心概念，有助于实现松耦合的代码：
  2. // 定义服务接口
  3. public interface IMessageService
  4. {
  5.     string GetMessage();
  6. }
  8. // 实现服务
  9. public class HelloWorldMessageService : IMessageService
  10. {
  11.     public string GetMessage()
  12.     {
  13.         return "Hello from DI!";
  14.     }
  15. }
  17. // 在Startup.cs中注册服务
  18. public void ConfigureServices(IServiceCollection services)
  19. {
  20.     services.AddScoped<IMessageService, HelloWorldMessageService>();
  21. }
  23. // 在控制器中使用依赖注入
  24. public class HomeController : Controller
  25. {
  26.     private readonly IMessageService _messageService;
  27.    
  28.     public HomeController(IMessageService messageService)
  29.     {
  30.         _messageService = messageService;
  31.     }
  32.    
  33.     public IActionResult Index()
  34.     {
  35.         ViewBag.Message = _messageService.GetMessage();
  36.         return View();
  37.     }
  38. }
复制代码

2.3 中间件(Middleware)

中间件是处理HTTP请求和响应的组件，它们构成一个管道：
  2. // 自定义中间件示例
  3. public class RequestTimeMiddleware
  4. {
  5.     private readonly RequestDelegate _next;
  6.    
  7.     public RequestTimeMiddleware(RequestDelegate next)
  8.     {
  9.         _next = next;
  10.     }
  11.    
  12.     public async Task Invoke(HttpContext context)
  13.     {
  14.         var startTime = DateTime.UtcNow;
  15.         
  16.         // 调用管道中的下一个中间件
  17.         await _next(context);
  18.         
  19.         var endTime = DateTime.UtcNow;
  20.         var duration = endTime - startTime;
  21.         
  22.         // 将请求处理时间添加到响应头
  23.         context.Response.Headers["X-Response-Time-Ms"] = duration.TotalMilliseconds.ToString();
  24.     }
  25. }
  27. // 在Startup.cs中配置中间件管道
  28. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  29. {
  30.     // 使用自定义中间件
  31.     app.UseMiddleware<RequestTimeMiddleware>();
  32.    
  33.     // 其他内置中间件
  34.     app.UseStaticFiles();
  35.     app.UseRouting();
  36.     app.UseEndpoints(endpoints =>
  37.     {
  38.         endpoints.MapControllerRoute(
  39.             name: "default",
  40.             pattern: "{controller=Home}/{action=Index}/{id?}");
  41.     });
  42. }
复制代码

2.4 实体框架(EF) Core

Entity Framework Core是ASP.NET Core中的ORM框架，用于数据访问：
  2. // 定义实体模型
  3. public class Product
  4. {
  5.     public int Id { get; set; }
  6.     public string Name { get; set; }
  7.     public decimal Price { get; set; }
  8.     public string Description { get; set; }
  9.     public int CategoryId { get; set; }
  10.     public Category Category { get; set; }
  11. }
  13. public class Category
  14. {
  15.     public int Id { get; set; }
  16.     public string Name { get; set; }
  17.     public List<Product> Products { get; set; }
  18. }
  20. // 定义DbContext
  21. public class AppDbContext : DbContext
  22. {
  23.     public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
  24.     {
  25.     }
  26.    
  27.     public DbSet<Product> Products { get; set; }
  28.     public DbSet<Category> Categories { get; set; }
  29.    
  30.     protected override void OnModelCreating(ModelBuilder modelBuilder)
  31.     {
  32.         // 配置实体关系
  33.         modelBuilder.Entity<Product>()
  34.             .HasOne(p => p.Category)
  35.             .WithMany(c => c.Products)
  36.             .HasForeignKey(p => p.CategoryId);
  37.     }
  38. }
  40. // 在Startup.cs中注册DbContext
  41. public void ConfigureServices(IServiceCollection services)
  42. {
  43.     services.AddDbContext<AppDbContext>(options =>
  44.         options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
  45. }
复制代码

2.5 身份认证与授权

ASP.NET Core提供了强大的身份认证和授权系统：
  2. // 在Startup.cs中配置身份认证
  3. public void ConfigureServices(IServiceCollection services)
  4. {
  5.     services.AddDbContext<AppDbContext>(options =>
  6.         options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
  7.    
  8.     services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
  9.         .AddEntityFrameworkStores<AppDbContext>();
  10.    
  11.     services.AddRazorPages();
  12.    
  13.     // 添加基于策略的授权
  14.     services.AddAuthorization(options =>
  15.     {
  16.         options.AddPolicy("RequireAdminRole", policy =>
  17.             policy.RequireRole("Admin"));
  18.         
  19.         options.AddPolicy("AtLeast18", policy =>
  20.             policy.Requirements.Add(new MinimumAgeRequirement(18)));
  21.     });
  22. }
  24. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  25. {
  26.     // ... 其他中间件
  27.    
  28.     app.UseAuthentication();
  29.     app.UseAuthorization();
  30.    
  31.     // ... 路由配置
  32. }
  34. // 自定义授权要求
  35. public class MinimumAgeRequirement : IAuthorizationRequirement
  36. {
  37.     public int MinimumAge { get; }
  38.    
  39.     public MinimumAgeRequirement(int minimumAge)
  40.     {
  41.         MinimumAge = minimumAge;
  42.     }
  43. }
  45. public class MinimumAgeHandler : AuthorizationHandler<MinimumAgeRequirement>
  46. {
  47.     protected override Task HandleRequirementAsync(
  48.         AuthorizationHandlerContext context,
  49.         MinimumAgeRequirement requirement)
  50.     {
  51.         var dateOfBirthClaim = context.User.FindFirst(c => c.Type == ClaimTypes.DateOfBirth);
  52.         
  53.         if (dateOfBirthClaim == null)
  54.         {
  55.             return Task.CompletedTask;
  56.         }
  57.         
  58.         var dateOfBirth = Convert.ToDateTime(dateOfBirthClaim.Value);
  59.         int calculatedAge = DateTime.Today.Year - dateOfBirth.Year;
  60.         
  61.         if (dateOfBirth > DateTime.Today.AddYears(-calculatedAge))
  62.         {
  63.             calculatedAge--;
  64.         }
  65.         
  66.         if (calculatedAge >= requirement.MinimumAge)
  67.         {
  68.             context.Succeed(requirement);
  69.         }
  70.         
  71.         return Task.CompletedTask;
  72.     }
  73. }
  75. // 在控制器或操作上应用授权
  76. [Authorize(Policy = "RequireAdminRole")]
  77. public class AdminController : Controller
  78. {
  79.     public IActionResult Index()
  80.     {
  81.         return View();
  82.     }
  83.    
  84.     [Authorize(Policy = "AtLeast18")]
  85.     public IActionResult AdultContent()
  86.     {
  87.         return View();
  88.     }
  89. }
复制代码

3. 实战案例：构建一个电子商务网站

3.1 项目规划与架构设计

在开始开发之前，我们需要规划项目的整体架构。我们将采用分层架构，包括：

• 表示层(Presentation Layer)：MVC控制器和视图
• 应用服务层(Application Service Layer)：业务逻辑
• 领域层(Domain Layer)：核心业务模型和逻辑
• 基础设施层(Infrastructure Layer)：数据访问和外部服务集成

3.2 创建项目结构

首先，我们创建一个ASP.NET Core MVC项目：
  2. dotnet new mvc -n ECommerceApp
  3. cd ECommerceApp
复制代码

然后，我们添加必要的类库项目：
  2. # 创建领域层
  3. dotnet new classlib -n ECommerceApp.Domain
  4. # 创建应用服务层
  5. dotnet new classlib -n ECommerceApp.Application
  6. # 创建基础设施层
  7. dotnet new classlib -n ECommerceApp.Infrastructure
复制代码

3.3 实现领域模型

在ECommerceApp.Domain项目中，我们定义核心业务实体：
  2. // ECommerceApp.Domain/Entities/Product.cs
  3. namespace ECommerceApp.Domain.Entities
  4. {
  5.     public class Product
  6.     {
  7.         public int Id { get; set; }
  8.         public string Name { get; set; }
  9.         public string Description { get; set; }
  10.         public decimal Price { get; set; }
  11.         public string ImageUrl { get; set; }
  12.         public int StockQuantity { get; set; }
  13.         public int CategoryId { get; set; }
  14.         public Category Category { get; set; }
  15.         public bool IsFeatured { get; set; }
  16.         public DateTime CreatedAt { get; set; }
  17.         public DateTime? UpdatedAt { get; set; }
  18.     }
  19. }
  21. // ECommerceApp.Domain/Entities/Category.cs
  22. namespace ECommerceApp.Domain.Entities
  23. {
  24.     public class Category
  25.     {
  26.         public int Id { get; set; }
  27.         public string Name { get; set; }
  28.         public string Description { get; set; }
  29.         public string ImageUrl { get; set; }
  30.         public List<Product> Products { get; set; }
  31.     }
  32. }
  34. // ECommerceApp.Domain/Entities/Customer.cs
  35. using System.Collections.Generic;
  37. namespace ECommerceApp.Domain.Entities
  38. {
  39.     public class Customer
  40.     {
  41.         public int Id { get; set; }
  42.         public string FirstName { get; set; }
  43.         public string LastName { get; set; }
  44.         public string Email { get; set; }
  45.         public string PhoneNumber { get; set; }
  46.         public List<Address> Addresses { get; set; }
  47.         public List<Order> Orders { get; set; }
  48.     }
  49. }
  51. // ECommerceApp.Domain/Entities/Order.cs
  52. using System.Collections.Generic;
  54. namespace ECommerceApp.Domain.Entities
  55. {
  56.     public class Order
  57.     {
  58.         public int Id { get; set; }
  59.         public DateTime OrderDate { get; set; }
  60.         public decimal TotalAmount { get; set; }
  61.         public string Status { get; set; }
  62.         public int CustomerId { get; set; }
  63.         public Customer Customer { get; set; }
  64.         public int ShippingAddressId { get; set; }
  65.         public Address ShippingAddress { get; set; }
  66.         public List<OrderItem> OrderItems { get; set; }
  67.     }
  68. }
  70. // ECommerceApp.Domain/Entities/OrderItem.cs
  71. namespace ECommerceApp.Domain.Entities
  72. {
  73.     public class OrderItem
  74.     {
  75.         public int Id { get; set; }
  76.         public int ProductId { get; set; }
  77.         public Product Product { get; set; }
  78.         public int Quantity { get; set; }
  79.         public decimal UnitPrice { get; set; }
  80.         public int OrderId { get; set; }
  81.         public Order Order { get; set; }
  82.     }
  83. }
  85. // ECommerceApp.Domain/Entities/Address.cs
  86. namespace ECommerceApp.Domain.Entities
  87. {
  88.     public class Address
  89.     {
  90.         public int Id { get; set; }
  91.         public string Street { get; set; }
  92.         public string City { get; set; }
  93.         public string State { get; set; }
  94.         public string PostalCode { get; set; }
  95.         public string Country { get; set; }
  96.         public int CustomerId { get; set; }
  97.         public Customer Customer { get; set; }
  98.     }
  99. }
复制代码

3.4 实现数据访问层

在ECommerceApp.Infrastructure项目中，我们实现数据访问：
  2. // ECommerceApp.Infrastructure/Data/AppDbContext.cs
  3. using ECommerceApp.Domain.Entities;
  4. using Microsoft.EntityFrameworkCore;
  6. namespace ECommerceApp.Infrastructure.Data
  7. {
  8.     public class AppDbContext : DbContext
  9.     {
  10.         public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
  11.         {
  12.         }
  13.         
  14.         public DbSet<Product> Products { get; set; }
  15.         public DbSet<Category> Categories { get; set; }
  16.         public DbSet<Customer> Customers { get; set; }
  17.         public DbSet<Order> Orders { get; set; }
  18.         public DbSet<OrderItem> OrderItems { get; set; }
  19.         public DbSet<Address> Addresses { get; set; }
  20.         
  21.         protected override void OnModelCreating(ModelBuilder modelBuilder)
  22.         {
  23.             // 配置Product实体
  24.             modelBuilder.Entity<Product>()
  25.                 .Property(p => p.Price)
  26.                 .HasColumnType("decimal(18,2)");
  27.             
  28.             modelBuilder.Entity<Product>()
  29.                 .HasOne(p => p.Category)
  30.                 .WithMany(c => c.Products)
  31.                 .HasForeignKey(p => p.CategoryId)
  32.                 .OnDelete(DeleteBehavior.Restrict);
  33.             
  34.             // 配置Order实体
  35.             modelBuilder.Entity<Order>()
  36.                 .Property(o => o.TotalAmount)
  37.                 .HasColumnType("decimal(18,2)");
  38.             
  39.             modelBuilder.Entity<Order>()
  40.                 .HasOne(o => o.Customer)
  41.                 .WithMany(c => c.Orders)
  42.                 .HasForeignKey(o => o.CustomerId)
  43.                 .OnDelete(DeleteBehavior.Restrict);
  44.             
  45.             modelBuilder.Entity<Order>()
  46.                 .HasOne(o => o.ShippingAddress)
  47.                 .WithMany()
  48.                 .HasForeignKey(o => o.ShippingAddressId)
  49.                 .OnDelete(DeleteBehavior.Restrict);
  50.             
  51.             // 配置OrderItem实体
  52.             modelBuilder.Entity<OrderItem>()
  53.                 .Property(oi => oi.UnitPrice)
  54.                 .HasColumnType("decimal(18,2)");
  55.             
  56.             modelBuilder.Entity<OrderItem>()
  57.                 .HasOne(oi => oi.Product)
  58.                 .WithMany()
  59.                 .HasForeignKey(oi => oi.ProductId)
  60.                 .OnDelete(DeleteBehavior.Restrict);
  61.             
  62.             modelBuilder.Entity<OrderItem>()
  63.                 .HasOne(oi => oi.Order)
  64.                 .WithMany(o => o.OrderItems)
  65.                 .HasForeignKey(oi => oi.OrderId)
  66.                 .OnDelete(DeleteBehavior.Cascade);
  67.             
  68.             // 配置Address实体
  69.             modelBuilder.Entity<Address>()
  70.                 .HasOne(a => a.Customer)
  71.                 .WithMany(c => c.Addresses)
  72.                 .HasForeignKey(a => a.CustomerId)
  73.                 .OnDelete(DeleteBehavior.Cascade);
  74.         }
  75.     }
  76. }
  78. // ECommerceApp.Infrastructure/Repositories/Repository.cs
  79. using ECommerceApp.Domain.Entities;
  80. using Microsoft.EntityFrameworkCore;
  81. using System;
  82. using System.Collections.Generic;
  83. using System.Linq;
  84. using System.Linq.Expressions;
  85. using System.Threading.Tasks;
  87. namespace ECommerceApp.Infrastructure.Repositories
  88. {
  89.     public class Repository<T> : IRepository<T> where T : class
  90.     {
  91.         protected readonly AppDbContext _context;
  92.         protected readonly DbSet<T> _dbSet;
  93.         
  94.         public Repository(AppDbContext context)
  95.         {
  96.             _context = context;
  97.             _dbSet = context.Set<T>();
  98.         }
  99.         
  100.         public async Task<T> GetByIdAsync(int id)
  101.         {
  102.             return await _dbSet.FindAsync(id);
  103.         }
  104.         
  105.         public async Task<IEnumerable<T>> GetAllAsync()
  106.         {
  107.             return await _dbSet.ToListAsync();
  108.         }
  109.         
  110.         public async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate)
  111.         {
  112.             return await _dbSet.Where(predicate).ToListAsync();
  113.         }
  114.         
  115.         public async Task AddAsync(T entity)
  116.         {
  117.             await _dbSet.AddAsync(entity);
  118.         }
  119.         
  120.         public void Update(T entity)
  121.         {
  122.             _dbSet.Attach(entity);
  123.             _context.Entry(entity).State = EntityState.Modified;
  124.         }
  125.         
  126.         public void Delete(T entity)
  127.         {
  128.             if (_context.Entry(entity).State == EntityState.Detached)
  129.             {
  130.                 _dbSet.Attach(entity);
  131.             }
  132.             _dbSet.Remove(entity);
  133.         }
  134.         
  135.         public async Task SaveChangesAsync()
  136.         {
  137.             await _context.SaveChangesAsync();
  138.         }
  139.     }
  140. }
  142. // ECommerceApp.Infrastructure/Repositories/IRepository.cs
  143. using System;
  144. using System.Collections.Generic;
  145. using System.Linq.Expressions;
  146. using System.Threading.Tasks;
  148. namespace ECommerceApp.Infrastructure.Repositories
  149. {
  150.     public interface IRepository<T> where T : class
  151.     {
  152.         Task<T> GetByIdAsync(int id);
  153.         Task<IEnumerable<T>> GetAllAsync();
  154.         Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate);
  155.         Task AddAsync(T entity);
  156.         void Update(T entity);
  157.         void Delete(T entity);
  158.         Task SaveChangesAsync();
  159.     }
  160. }
  162. // ECommerceApp.Infrastructure/Repositories/ProductRepository.cs
  163. using ECommerceApp.Domain.Entities;
  164. using Microsoft.EntityFrameworkCore;
  165. using System.Collections.Generic;
  166. using System.Threading.Tasks;
  168. namespace ECommerceApp.Infrastructure.Repositories
  169. {
  170.     public class ProductRepository : Repository<Product>, IProductRepository
  171.     {
  172.         public ProductRepository(AppDbContext context) : base(context)
  173.         {
  174.         }
  175.         
  176.         public async Task<IEnumerable<Product>> GetFeaturedProductsAsync()
  177.         {
  178.             return await _dbSet
  179.                 .Include(p => p.Category)
  180.                 .Where(p => p.IsFeatured)
  181.                 .ToListAsync();
  182.         }
  183.         
  184.         public async Task<IEnumerable<Product>> GetProductsByCategoryAsync(int categoryId)
  185.         {
  186.             return await _dbSet
  187.                 .Include(p => p.Category)
  188.                 .Where(p => p.CategoryId == categoryId)
  189.                 .ToListAsync();
  190.         }
  191.         
  192.         public async Task<Product> GetProductWithDetailsAsync(int id)
  193.         {
  194.             return await _dbSet
  195.                 .Include(p => p.Category)
  196.                 .FirstOrDefaultAsync(p => p.Id == id);
  197.         }
  198.     }
  199. }
  201. // ECommerceApp.Infrastructure/Repositories/IProductRepository.cs
  202. using ECommerceApp.Domain.Entities;
  203. using System.Collections.Generic;
  204. using System.Threading.Tasks;
  206. namespace ECommerceApp.Infrastructure.Repositories
  207. {
  208.     public interface IProductRepository : IRepository<Product>
  209.     {
  210.         Task<IEnumerable<Product>> GetFeaturedProductsAsync();
  211.         Task<IEnumerable<Product>> GetProductsByCategoryAsync(int categoryId);
  212.         Task<Product> GetProductWithDetailsAsync(int id);
  213.     }
  214. }
复制代码

3.5 实现应用服务层

在ECommerceApp.Application项目中，我们实现业务逻辑：
  2. // ECommerceApp.Application/Services/ProductService.cs
  3. using ECommerceApp.Domain.Entities;
  4. using ECommerceApp.Infrastructure.Repositories;
  5. using System.Collections.Generic;
  6. using System.Threading.Tasks;
  8. namespace ECommerceApp.Application.Services
  9. {
  10.     public class ProductService : IProductService
  11.     {
  12.         private readonly IProductRepository _productRepository;
  13.         
  14.         public ProductService(IProductRepository productRepository)
  15.         {
  16.             _productRepository = productRepository;
  17.         }
  18.         
  19.         public async Task<Product> GetProductByIdAsync(int id)
  20.         {
  21.             return await _productRepository.GetProductWithDetailsAsync(id);
  22.         }
  23.         
  24.         public async Task<IEnumerable<Product>> GetAllProductsAsync()
  25.         {
  26.             return await _productRepository.GetAllAsync();
  27.         }
  28.         
  29.         public async Task<IEnumerable<Product>> GetFeaturedProductsAsync()
  30.         {
  31.             return await _productRepository.GetFeaturedProductsAsync();
  32.         }
  33.         
  34.         public async Task<IEnumerable<Product>> GetProductsByCategoryAsync(int categoryId)
  35.         {
  36.             return await _productRepository.GetProductsByCategoryAsync(categoryId);
  37.         }
  38.         
  39.         public async Task AddProductAsync(Product product)
  40.         {
  41.             product.CreatedAt = System.DateTime.Now;
  42.             await _productRepository.AddAsync(product);
  43.             await _productRepository.SaveChangesAsync();
  44.         }
  45.         
  46.         public async Task UpdateProductAsync(Product product)
  47.         {
  48.             product.UpdatedAt = System.DateTime.Now;
  49.             _productRepository.Update(product);
  50.             await _productRepository.SaveChangesAsync();
  51.         }
  52.         
  53.         public async Task DeleteProductAsync(int id)
  54.         {
  55.             var product = await _productRepository.GetByIdAsync(id);
  56.             if (product != null)
  57.             {
  58.                 _productRepository.Delete(product);
  59.                 await _productRepository.SaveChangesAsync();
  60.             }
  61.         }
  62.     }
  63. }
  65. // ECommerceApp.Application/Services/IProductService.cs
  66. using ECommerceApp.Domain.Entities;
  67. using System.Collections.Generic;
  68. using System.Threading.Tasks;
  70. namespace ECommerceApp.Application.Services
  71. {
  72.     public interface IProductService
  73.     {
  74.         Task<Product> GetProductByIdAsync(int id);
  75.         Task<IEnumerable<Product>> GetAllProductsAsync();
  76.         Task<IEnumerable<Product>> GetFeaturedProductsAsync();
  77.         Task<IEnumerable<Product>> GetProductsByCategoryAsync(int categoryId);
  78.         Task AddProductAsync(Product product);
  79.         Task UpdateProductAsync(Product product);
  80.         Task DeleteProductAsync(int id);
  81.     }
  82. }
  84. // ECommerceApp.Application/Services/OrderService.cs
  85. using ECommerceApp.Domain.Entities;
  86. using ECommerceApp.Infrastructure.Repositories;
  87. using System;
  88. using System.Collections.Generic;
  89. using System.Linq;
  90. using System.Threading.Tasks;
  92. namespace ECommerceApp.Application.Services
  93. {
  94.     public class OrderService : IOrderService
  95.     {
  96.         private readonly IRepository<Order> _orderRepository;
  97.         private readonly IRepository<OrderItem> _orderItemRepository;
  98.         private readonly IProductService _productService;
  99.         
  100.         public OrderService(
  101.             IRepository<Order> orderRepository,
  102.             IRepository<OrderItem> orderItemRepository,
  103.             IProductService productService)
  104.         {
  105.             _orderRepository = orderRepository;
  106.             _orderItemRepository = orderItemRepository;
  107.             _productService = productService;
  108.         }
  109.         
  110.         public async Task<Order> GetOrderByIdAsync(int id)
  111.         {
  112.             return await _orderRepository.GetByIdAsync(id);
  113.         }
  114.         
  115.         public async Task<IEnumerable<Order>> GetOrdersByCustomerIdAsync(int customerId)
  116.         {
  117.             return await _orderRepository.FindAsync(o => o.CustomerId == customerId);
  118.         }
  119.         
  120.         public async Task<Order> CreateOrderAsync(int customerId, int shippingAddressId, Dictionary<int, int> productQuantities)
  121.         {
  122.             var orderItems = new List<OrderItem>();
  123.             decimal totalAmount = 0;
  124.             
  125.             foreach (var item in productQuantities)
  126.             {
  127.                 var product = await _productService.GetProductByIdAsync(item.Key);
  128.                 if (product == null || product.StockQuantity < item.Value)
  129.                 {
  130.                     throw new Exception($"Product {item.Key} is not available in sufficient quantity.");
  131.                 }
  132.                
  133.                 var orderItem = new OrderItem
  134.                 {
  135.                     ProductId = item.Key,
  136.                     Quantity = item.Value,
  137.                     UnitPrice = product.Price
  138.                 };
  139.                
  140.                 orderItems.Add(orderItem);
  141.                 totalAmount += orderItem.Quantity * orderItem.UnitPrice;
  142.                
  143.                 // Update product stock
  144.                 product.StockQuantity -= item.Value;
  145.                 await _productService.UpdateProductAsync(product);
  146.             }
  147.             
  148.             var order = new Order
  149.             {
  150.                 CustomerId = customerId,
  151.                 ShippingAddressId = shippingAddressId,
  152.                 OrderDate = DateTime.Now,
  153.                 TotalAmount = totalAmount,
  154.                 Status = "Pending",
  155.                 OrderItems = orderItems
  156.             };
  157.             
  158.             await _orderRepository.AddAsync(order);
  159.             await _orderRepository.SaveChangesAsync();
  160.             
  161.             return order;
  162.         }
  163.         
  164.         public async Task UpdateOrderStatusAsync(int orderId, string status)
  165.         {
  166.             var order = await _orderRepository.GetByIdAsync(orderId);
  167.             if (order != null)
  168.             {
  169.                 order.Status = status;
  170.                 _orderRepository.Update(order);
  171.                 await _orderRepository.SaveChangesAsync();
  172.             }
  173.         }
  174.     }
  175. }
  177. // ECommerceApp.Application/Services/IOrderService.cs
  178. using ECommerceApp.Domain.Entities;
  179. using System.Collections.Generic;
  180. using System.Threading.Tasks;
  182. namespace ECommerceApp.Application.Services
  183. {
  184.     public interface IOrderService
  185.     {
  186.         Task<Order> GetOrderByIdAsync(int id);
  187.         Task<IEnumerable<Order>> GetOrdersByCustomerIdAsync(int customerId);
  188.         Task<Order> CreateOrderAsync(int customerId, int shippingAddressId, Dictionary<int, int> productQuantities);
  189.         Task UpdateOrderStatusAsync(int orderId, string status);
  190.     }
  191. }
复制代码

3.6 实现控制器和视图

在主项目中，我们实现MVC控制器和视图：
  2. // ECommerceApp/Controllers/HomeController.cs
  3. using ECommerceApp.Application.Services;
  4. using Microsoft.AspNetCore.Mvc;
  5. using System.Threading.Tasks;
  7. namespace ECommerceApp.Controllers
  8. {
  9.     public class HomeController : Controller
  10.     {
  11.         private readonly IProductService _productService;
  12.         
  13.         public HomeController(IProductService productService)
  14.         {
  15.             _productService = productService;
  16.         }
  17.         
  18.         public async Task<IActionResult> Index()
  19.         {
  20.             var featuredProducts = await _productService.GetFeaturedProductsAsync();
  21.             return View(featuredProducts);
  22.         }
  23.         
  24.         public IActionResult About()
  25.         {
  26.             return View();
  27.         }
  28.         
  29.         public IActionResult Contact()
  30.         {
  31.             return View();
  32.         }
  33.         
  34.         public IActionResult Privacy()
  35.         {
  36.             return View();
  37.         }
  38.         
  39.         [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
  40.         public IActionResult Error()
  41.         {
  42.             return View(new ErrorViewModel { RequestId = System.Diagnostics.Activity.Current?.Id ?? HttpContext.TraceIdentifier });
  43.         }
  44.     }
  45. }
  47. // ECommerceApp/Controllers/ProductsController.cs
  48. using ECommerceApp.Application.Services;
  49. using Microsoft.AspNetCore.Mvc;
  50. using System.Threading.Tasks;
  52. namespace ECommerceApp.Controllers
  53. {
  54.     public class ProductsController : Controller
  55.     {
  56.         private readonly IProductService _productService;
  57.         
  58.         public ProductsController(IProductService productService)
  59.         {
  60.             _productService = productService;
  61.         }
  62.         
  63.         // GET: Products
  64.         public async Task<IActionResult> Index()
  65.         {
  66.             var products = await _productService.GetAllProductsAsync();
  67.             return View(products);
  68.         }
  69.         
  70.         // GET: Products/Details/5
  71.         public async Task<IActionResult> Details(int id)
  72.         {
  73.             var product = await _productService.GetProductByIdAsync(id);
  74.             if (product == null)
  75.             {
  76.                 return NotFound();
  77.             }
  78.             
  79.             return View(product);
  80.         }
  81.         
  82.         // GET: Products/Create
  83.         public IActionResult Create()
  84.         {
  85.             return View();
  86.         }
  87.         
  88.         // POST: Products/Create
  89.         [HttpPost]
  90.         [ValidateAntiForgeryToken]
  91.         public async Task<IActionResult> Create([Bind("Name,Description,Price,ImageUrl,StockQuantity,CategoryId,IsFeatured")] Product product)
  92.         {
  93.             if (ModelState.IsValid)
  94.             {
  95.                 await _productService.AddProductAsync(product);
  96.                 return RedirectToAction(nameof(Index));
  97.             }
  98.             return View(product);
  99.         }
  100.         
  101.         // GET: Products/Edit/5
  102.         public async Task<IActionResult> Edit(int id)
  103.         {
  104.             var product = await _productService.GetProductByIdAsync(id);
  105.             if (product == null)
  106.             {
  107.                 return NotFound();
  108.             }
  109.             return View(product);
  110.         }
  111.         
  112.         // POST: Products/Edit/5
  113.         [HttpPost]
  114.         [ValidateAntiForgeryToken]
  115.         public async Task<IActionResult> Edit(int id, [Bind("Id,Name,Description,Price,ImageUrl,StockQuantity,CategoryId,IsFeatured,CreatedAt")] Product product)
  116.         {
  117.             if (id != product.Id)
  118.             {
  119.                 return NotFound();
  120.             }
  121.             
  122.             if (ModelState.IsValid)
  123.             {
  124.                 await _productService.UpdateProductAsync(product);
  125.                 return RedirectToAction(nameof(Index));
  126.             }
  127.             return View(product);
  128.         }
  129.         
  130.         // GET: Products/Delete/5
  131.         public async Task<IActionResult> Delete(int id)
  132.         {
  133.             var product = await _productService.GetProductByIdAsync(id);
  134.             if (product == null)
  135.             {
  136.                 return NotFound();
  137.             }
  138.             
  139.             return View(product);
  140.         }
  141.         
  142.         // POST: Products/Delete/5
  143.         [HttpPost, ActionName("Delete")]
  144.         [ValidateAntiForgeryToken]
  145.         public async Task<IActionResult> DeleteConfirmed(int id)
  146.         {
  147.             await _productService.DeleteProductAsync(id);
  148.             return RedirectToAction(nameof(Index));
  149.         }
  150.     }
  151. }
  153. // ECommerceApp/Controllers/CartController.cs
  154. using ECommerceApp.Application.Services;
  155. using Microsoft.AspNetCore.Http;
  156. using Microsoft.AspNetCore.Mvc;
  157. using System.Collections.Generic;
  158. using System.Linq;
  159. using System.Threading.Tasks;
  161. namespace ECommerceApp.Controllers
  162. {
  163.     public class CartController : Controller
  164.     {
  165.         private readonly IProductService _productService;
  166.         
  167.         public CartController(IProductService productService)
  168.         {
  169.             _productService = productService;
  170.         }
  171.         
  172.         // 获取购物车
  173.         private Dictionary<int, int> GetCart()
  174.         {
  175.             var cart = HttpContext.Session.GetObject<Dictionary<int, int>>("Cart");
  176.             if (cart == null)
  177.             {
  178.                 cart = new Dictionary<int, int>();
  179.                 HttpContext.Session.SetObject("Cart", cart);
  180.             }
  181.             return cart;
  182.         }
  183.         
  184.         // 保存购物车
  185.         private void SaveCart(Dictionary<int, int> cart)
  186.         {
  187.             HttpContext.Session.SetObject("Cart", cart);
  188.         }
  189.         
  190.         // GET: Cart
  191.         public async Task<IActionResult> Index()
  192.         {
  193.             var cart = GetCart();
  194.             var cartItems = new List<CartItemViewModel>();
  195.             
  196.             foreach (var item in cart)
  197.             {
  198.                 var product = await _productService.GetProductByIdAsync(item.Key);
  199.                 if (product != null)
  200.                 {
  201.                     cartItems.Add(new CartItemViewModel
  202.                     {
  203.                         Product = product,
  204.                         Quantity = item.Value
  205.                     });
  206.                 }
  207.             }
  208.             
  209.             return View(cartItems);
  210.         }
  211.         
  212.         // POST: Cart/Add/5
  213.         [HttpPost]
  214.         public IActionResult Add(int id, int quantity = 1)
  215.         {
  216.             var cart = GetCart();
  217.             
  218.             if (cart.ContainsKey(id))
  219.             {
  220.                 cart[id] += quantity;
  221.             }
  222.             else
  223.             {
  224.                 cart.Add(id, quantity);
  225.             }
  226.             
  227.             SaveCart(cart);
  228.             
  229.             return RedirectToAction("Index");
  230.         }
  231.         
  232.         // POST: Cart/Update/5
  233.         [HttpPost]
  234.         public IActionResult Update(int id, int quantity)
  235.         {
  236.             var cart = GetCart();
  237.             
  238.             if (cart.ContainsKey(id))
  239.             {
  240.                 if (quantity > 0)
  241.                 {
  242.                     cart[id] = quantity;
  243.                 }
  244.                 else
  245.                 {
  246.                     cart.Remove(id);
  247.                 }
  248.             }
  249.             
  250.             SaveCart(cart);
  251.             
  252.             return RedirectToAction("Index");
  253.         }
  254.         
  255.         // POST: Cart/Remove/5
  256.         [HttpPost]
  257.         public IActionResult Remove(int id)
  258.         {
  259.             var cart = GetCart();
  260.             
  261.             if (cart.ContainsKey(id))
  262.             {
  263.                 cart.Remove(id);
  264.             }
  265.             
  266.             SaveCart(cart);
  267.             
  268.             return RedirectToAction("Index");
  269.         }
  270.         
  271.         // POST: Cart/Clear
  272.         [HttpPost]
  273.         public IActionResult Clear()
  274.         {
  275.             HttpContext.Session.Remove("Cart");
  276.             return RedirectToAction("Index");
  277.         }
  278.     }
  279.    
  280.     // 购物车项视图模型
  281.     public class CartItemViewModel
  282.     {
  283.         public Product Product { get; set; }
  284.         public int Quantity { get; set; }
  285.     }
  286. }
复制代码

3.7 实现视图

以下是一些关键视图的示例：
  2. <!-- ECommerceApp/Views/Home/Index.cshtml -->
  3. @model IEnumerable<ECommerceApp.Domain.Entities.Product>
  5. @{
  6.     ViewData["Title"] = "Home";
  7. }
  9. <div class="text-center">
  10.     <h1 class="display-4">Welcome to ECommerceApp</h1>
  11.     <p>Check out our featured products below.</p>
  12. </div>
  14. <div class="row">
  15.     @foreach (var product in Model)
  16.     {
  17.         <div class="col-md-4 mb-4">
  18.             <div class="card h-100">
  19.                 <img src="@product.ImageUrl" class="card-img-top" alt="@product.Name">
  20.                 <div class="card-body">
  21.                     <h5 class="card-title">@product.Name</h5>
  22.                     <p class="card-text">@product.Description</p>
  23.                     <p class="card-text"><strong>Price: @product.Price.ToString("C")</strong></p>
  24.                     <a asp-controller="Products" asp-action="Details" asp-route-id="@product.Id" class="btn btn-primary">View Details</a>
  25.                 </div>
  26.             </div>
  27.         </div>
  28.     }
  29. </div>
复制代码
  2. <!-- ECommerceApp/Views/Products/Details.cshtml -->
  3. @model ECommerceApp.Domain.Entities.Product
  5. @{
  6.     ViewData["Title"] = "Product Details";
  7. }
  9. <div class="container">
  10.     <div class="row">
  11.         <div class="col-md-6">
  12.             <img src="@Model.ImageUrl" class="img-fluid" alt="@Model.Name">
  13.         </div>
  14.         <div class="col-md-6">
  15.             <h2>@Model.Name</h2>
  16.             <p class="text-muted">Category: @Model.Category.Name</p>
  17.             <h3 class="text-primary">@Model.Price.ToString("C")</h3>
  18.             <p>@Model.Description</p>
  19.             <p>Stock: @Model.StockQuantity units available</p>
  20.             
  21.             <form asp-controller="Cart" asp-action="Add" method="post">
  22.                 <input type="hidden" name="id" value="@Model.Id" />
  23.                 <div class="form-group">
  24.                     <label for="quantity">Quantity:</label>
  25.                     <input type="number" id="quantity" name="quantity" class="form-control" value="1" min="1" max="@Model.StockQuantity" />
  26.                 </div>
  27.                 <button type="submit" class="btn btn-primary">Add to Cart</button>
  28.             </form>
  29.         </div>
  30.     </div>
  31. </div>
复制代码
  2. <!-- ECommerceApp/Views/Cart/Index.cshtml -->
  3. @model IEnumerable<ECommerceApp.Controllers.CartItemViewModel>
  5. @{
  6.     ViewData["Title"] = "Shopping Cart";
  7. }
  9. <h2>Shopping Cart</h2>
  11. @if (!Model.Any())
  12. {
  13.     <div class="alert alert-info">
  14.         Your cart is empty.
  15.     </div>
  16. }
  17. else
  18. {
  19.     <table class="table">
  20.         <thead>
  21.             <tr>
  22.                 <th>Product</th>
  23.                 <th>Price</th>
  24.                 <th>Quantity</th>
  25.                 <th>Total</th>
  26.                 <th>Actions</th>
  27.             </tr>
  28.         </thead>
  29.         <tbody>
  30.             @foreach (var item in Model)
  31.             {
  32.                 <tr>
  33.                     <td>
  34.                         <div class="d-flex align-items-center">
  35.                             <img src="@item.Product.ImageUrl" style="width: 50px; height: 50px; object-fit: cover;" alt="@item.Product.Name" />
  36.                             <div class="ml-2">
  37.                                 <a asp-controller="Products" asp-action="Details" asp-route-id="@item.Product.Id">@item.Product.Name</a>
  38.                             </div>
  39.                         </div>
  40.                     </td>
  41.                     <td>@item.Product.Price.ToString("C")</td>
  42.                     <td>
  43.                         <form asp-action="Update" method="post" class="form-inline">
  44.                             <input type="hidden" name="id" value="@item.Product.Id" />
  45.                             <input type="number" name="quantity" value="@item.Quantity" min="1" max="@item.Product.StockQuantity" class="form-control form-control-sm" style="width: 70px;" />
  46.                             <button type="submit" class="btn btn-sm btn-outline-primary ml-1">Update</button>
  47.                         </form>
  48.                     </td>
  49.                     <td>@((item.Product.Price * item.Quantity).ToString("C"))</td>
  50.                     <td>
  51.                         <form asp-action="Remove" method="post">
  52.                             <input type="hidden" name="id" value="@item.Product.Id" />
  53.                             <button type="submit" class="btn btn-sm btn-danger">Remove</button>
  54.                         </form>
  55.                     </td>
  56.                 </tr>
  57.             }
  58.         </tbody>
  59.         <tfoot>
  60.             <tr>
  61.                 <td colspan="3" class="text-right"><strong>Total:</strong></td>
  62.                 <td><strong>@Model.Sum(i => i.Product.Price * i.Quantity).ToString("C")</strong></td>
  63.                 <td></td>
  64.             </tr>
  65.         </tfoot>
  66.     </table>
  67.    
  68.     <div class="d-flex justify-content-between">
  69.         <form asp-action="Clear" method="post">
  70.             <button type="submit" class="btn btn-outline-danger">Clear Cart</button>
  71.         </form>
  72.         
  73.         <a asp-controller="Checkout" asp-action="Index" class="btn btn-primary">Proceed to Checkout</a>
  74.     </div>
  75. }
复制代码

3.8 配置依赖注入

在Startup.cs中配置依赖注入：
  2. // ECommerceApp/Startup.cs
  3. using ECommerceApp.Application.Services;
  4. using ECommerceApp.Infrastructure.Data;
  5. using ECommerceApp.Infrastructure.Repositories;
  6. using Microsoft.AspNetCore.Builder;
  7. using Microsoft.AspNetCore.Hosting;
  8. using Microsoft.EntityFrameworkCore;
  9. using Microsoft.Extensions.Configuration;
  10. using Microsoft.Extensions.DependencyInjection;
  11. using Microsoft.Extensions.Hosting;
  13. namespace ECommerceApp
  14. {
  15.     public class Startup
  16.     {
  17.         public Startup(IConfiguration configuration)
  18.         {
  19.             Configuration = configuration;
  20.         }
  22.         public IConfiguration Configuration { get; }
  24.         // This method gets called by the runtime. Use this method to add services to the container.
  25.         public void ConfigureServices(IServiceCollection services)
  26.         {
  27.             services.AddDbContext<AppDbContext>(options =>
  28.                 options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
  30.             // 注册仓储
  31.             services.AddScoped<IProductRepository, ProductRepository>();
  32.             services.AddScoped<IRepository<Order>, Repository<Order>>();
  33.             services.AddScoped<IRepository<OrderItem>, Repository<OrderItem>>();
  34.             services.AddScoped<IRepository<Customer>, Repository<Customer>>();
  35.             services.AddScoped<IRepository<Address>, Repository<Address>>();
  36.             services.AddScoped<IRepository<Category>, Repository<Category>>();
  38.             // 注册应用服务
  39.             services.AddScoped<IProductService, ProductService>();
  40.             services.AddScoped<IOrderService, OrderService>();
  42.             services.AddControllersWithViews();
  43.             services.AddRazorPages();
  45.             // 添加Session支持
  46.             services.AddDistributedMemoryCache();
  47.             services.AddSession(options =>
  48.             {
  49.                 options.IdleTimeout = System.TimeSpan.FromMinutes(30);
  50.                 options.Cookie.HttpOnly = true;
  51.                 options.Cookie.IsEssential = true;
  52.             });
  53.         }
  55.         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
  56.         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  57.         {
  58.             if (env.IsDevelopment())
  59.             {
  60.                 app.UseDeveloperExceptionPage();
  61.             }
  62.             else
  63.             {
  64.                 app.UseExceptionHandler("/Home/Error");
  65.                 // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
  66.                 app.UseHsts();
  67.             }
  68.             app.UseHttpsRedirection();
  69.             app.UseStaticFiles();
  71.             app.UseRouting();
  73.             app.UseSession();
  75.             app.UseAuthentication();
  76.             app.UseAuthorization();
  78.             app.UseEndpoints(endpoints =>
  79.             {
  80.                 endpoints.MapControllerRoute(
  81.                     name: "default",
  82.                     pattern: "{controller=Home}/{action=Index}/{id?}");
  83.                 endpoints.MapRazorPages();
  84.             });
  85.         }
  86.     }
  87. }
复制代码

3.9 添加Session扩展方法

为了在Session中存储复杂对象，我们需要添加扩展方法：
  2. // ECommerceApp/Extensions/SessionExtensions.cs
  3. using Microsoft.AspNetCore.Http;
  4. using System.Text.Json;
  6. namespace ECommerceApp.Extensions
  7. {
  8.     public static class SessionExtensions
  9.     {
  10.         public static void SetObject<T>(this ISession session, string key, T value)
  11.         {
  12.             session.SetString(key, JsonSerializer.Serialize(value));
  13.         }
  15.         public static T GetObject<T>(this ISession session, string key)
  16.         {
  17.             var value = session.GetString(key);
  18.             return value == null ? default(T) : JsonSerializer.Deserialize<T>(value);
  19.         }
  20.     }
  21. }
复制代码

4. 开发过程中的经验分享

4.1 架构设计经验

1. 分层架构的重要性：清晰的分层架构有助于代码的维护和扩展。在我们的电子商务网站中，我们将应用分为表示层、应用服务层、领域层和基础设施层，每一层都有明确的职责。
2. 依赖注入的使用：依赖注入是实现松耦合设计的关键。通过构造函数注入，我们可以轻松地替换实现，便于单元测试和维护。
3. 仓储模式的应用：仓储模式抽象了数据访问逻辑，使业务逻辑层不直接依赖于数据访问技术。这样，我们可以轻松地切换数据存储方式，而不影响业务逻辑。

分层架构的重要性：清晰的分层架构有助于代码的维护和扩展。在我们的电子商务网站中，我们将应用分为表示层、应用服务层、领域层和基础设施层，每一层都有明确的职责。

依赖注入的使用：依赖注入是实现松耦合设计的关键。通过构造函数注入，我们可以轻松地替换实现，便于单元测试和维护。

仓储模式的应用：仓储模式抽象了数据访问逻辑，使业务逻辑层不直接依赖于数据访问技术。这样，我们可以轻松地切换数据存储方式，而不影响业务逻辑。

4.2 性能优化经验

1. 异步编程：在ASP.NET Core中，使用异步方法可以显著提高应用程序的吞吐量。特别是在I/O操作中，如数据库访问和外部API调用，异步编程可以释放线程来处理其他请求。
2. 缓存策略：对于不经常变化的数据，使用缓存可以减少数据库访问次数，提高响应速度。ASP.NET Core提供了多种缓存选项，包括内存缓存、分布式缓存和响应缓存。
3. EF Core性能优化：使用AsNoTracking()进行只读查询批量操作减少数据库往返选择性加载需要的字段使用编译查询提高重复查询的性能
4. 使用AsNoTracking()进行只读查询
5. 批量操作减少数据库往返
6. 选择性加载需要的字段
7. 使用编译查询提高重复查询的性能

异步编程：在ASP.NET Core中，使用异步方法可以显著提高应用程序的吞吐量。特别是在I/O操作中，如数据库访问和外部API调用，异步编程可以释放线程来处理其他请求。

缓存策略：对于不经常变化的数据，使用缓存可以减少数据库访问次数，提高响应速度。ASP.NET Core提供了多种缓存选项，包括内存缓存、分布式缓存和响应缓存。

EF Core性能优化：

• 使用AsNoTracking()进行只读查询
• 批量操作减少数据库往返
• 选择性加载需要的字段
• 使用编译查询提高重复查询的性能
  2. // 使用AsNoTracking()进行只读查询
  3. public async Task<IEnumerable<Product>> GetAllProductsAsync()
  4. {
  5.     return await _context.Products
  6.         .AsNoTracking()
  7.         .ToListAsync();
  8. }
  10. // 批量插入示例
  11. public async Task BulkInsertProductsAsync(IEnumerable<Product> products)
  12. {
  13.     await _context.Products.AddRangeAsync(products);
  14.     await _context.SaveChangesAsync();
  15. }
  17. // 选择性加载字段
  18. public async Task<IEnumerable<Product>> GetProductNamesAsync()
  19. {
  20.     return await _context.Products
  21.         .Select(p => new Product { Id = p.Id, Name = p.Name })
  22.         .ToListAsync();
  23. }
  25. // 编译查询示例
  26. private static readonly Func<AppDbContext, int, Task<Product>> GetProductByIdCompiled =
  27.     EF.CompileAsyncQuery((AppDbContext context, int id) =>
  28.         context.Products.FirstOrDefault(p => p.Id == id));
  30. public async Task<Product> GetProductByIdAsync(int id)
  31. {
  32.     return await GetProductByIdCompiled(_context, id);
  33. }
复制代码

4.3 安全性经验

1. 输入验证：始终验证用户输入，防止SQL注入、XSS和其他安全漏洞。ASP.NET Core提供了内置的验证特性，可以轻松地实现验证。
  2. public class Product
  3. {
  4.     public int Id { get; set; }
  5.    
  6.     [Required(ErrorMessage = "Product name is required.")]
  7.     [StringLength(100, ErrorMessage = "Product name cannot exceed 100 characters.")]
  8.     public string Name { get; set; }
  9.    
  10.     [StringLength(500, ErrorMessage = "Description cannot exceed 500 characters.")]
  11.     public string Description { get; set; }
  12.    
  13.     [Range(0.01, 10000, ErrorMessage = "Price must be between 0.01 and 10000.")]
  14.     public decimal Price { get; set; }
  15.    
  16.     [Url(ErrorMessage = "Please enter a valid URL.")]
  17.     public string ImageUrl { get; set; }
  18.    
  19.     [Range(0, int.MaxValue, ErrorMessage = "Stock quantity cannot be negative.")]
  20.     public int StockQuantity { get; set; }
  21. }
复制代码

1. 身份认证和授权：使用ASP.NET Core Identity进行用户管理，并实现基于角色的访问控制和基于策略的授权。
2. HTTPS使用：在生产环境中始终使用HTTPS，确保数据传输的安全性。
3. 敏感数据保护：使用ASP.NET Core的数据保护API来保护敏感数据，如密码、连接字符串等。

身份认证和授权：使用ASP.NET Core Identity进行用户管理，并实现基于角色的访问控制和基于策略的授权。

HTTPS使用：在生产环境中始终使用HTTPS，确保数据传输的安全性。

敏感数据保护：使用ASP.NET Core的数据保护API来保护敏感数据，如密码、连接字符串等。
  2. // 在Startup.cs中配置数据保护
  3. public void ConfigureServices(IServiceCollection services)
  4. {
  5.     services.AddDataProtection()
  6.         .PersistKeysToFileSystem(new DirectoryInfo(@"c:\keys"))
  7.         .ProtectKeysWithDpapi();
  8. }
复制代码

4.4 测试经验

1. 单元测试：为业务逻辑编写单元测试，确保代码的正确性。使用xUnit、NUnit或MSTest等测试框架，以及Moq等模拟框架。
  2. // ProductService单元测试示例
  3. using ECommerceApp.Application.Services;
  4. using ECommerceApp.Domain.Entities;
  5. using ECommerceApp.Infrastructure.Repositories;
  6. using Moq;
  7. using System.Collections.Generic;
  8. using System.Threading.Tasks;
  9. using Xunit;
  11. namespace ECommerceApp.Tests
  12. {
  13.     public class ProductServiceTests
  14.     {
  15.         [Fact]
  16.         public async Task GetProductByIdAsync_ShouldReturnProduct()
  17.         {
  18.             // Arrange
  19.             var mockRepo = new Mock<IProductRepository>();
  20.             var productId = 1;
  21.             var expectedProduct = new Product { Id = productId, Name = "Test Product" };
  22.             
  23.             mockRepo.Setup(repo => repo.GetProductWithDetailsAsync(productId))
  24.                 .ReturnsAsync(expectedProduct);
  25.             
  26.             var service = new ProductService(mockRepo.Object);
  27.             
  28.             // Act
  29.             var result = await service.GetProductByIdAsync(productId);
  30.             
  31.             // Assert
  32.             Assert.NotNull(result);
  33.             Assert.Equal(productId, result.Id);
  34.             Assert.Equal("Test Product", result.Name);
  35.         }
  36.         
  37.         [Fact]
  38.         public async Task AddProductAsync_ShouldSetCreatedAt()
  39.         {
  40.             // Arrange
  41.             var mockRepo = new Mock<IProductRepository>();
  42.             var service = new ProductService(mockRepo.Object);
  43.             var product = new Product { Name = "New Product" };
  44.             
  45.             // Act
  46.             await service.AddProductAsync(product);
  47.             
  48.             // Assert
  49.             Assert.NotEqual(default(DateTime), product.CreatedAt);
  50.             mockRepo.Verify(repo => repo.AddAsync(product), Times.Once);
  51.             mockRepo.Verify(repo => repo.SaveChangesAsync(), Times.Once);
  52.         }
  53.     }
  54. }
复制代码

1. 集成测试：使用ASP.NET Core的测试服务器进行集成测试，验证组件之间的交互。
  2. // 集成测试示例
  3. using Microsoft.AspNetCore.Mvc.Testing;
  4. using System.Net.Http;
  5. using System.Threading.Tasks;
  6. using Xunit;
  8. namespace ECommerceApp.Tests
  9. {
  10.     public class HomeControllerIntegrationTests : IClassFixture<WebApplicationFactory<Startup>>
  11.     {
  12.         private readonly WebApplicationFactory<Startup> _factory;
  13.         
  14.         public HomeControllerIntegrationTests(WebApplicationFactory<Startup> factory)
  15.         {
  16.             _factory = factory;
  17.         }
  18.         
  19.         [Fact]
  20.         public async Task IndexPage_ReturnsSuccessAndCorrectContentType()
  21.         {
  22.             // Arrange
  23.             var client = _factory.CreateClient();
  24.             
  25.             // Act
  26.             var response = await client.GetAsync("/");
  27.             
  28.             // Assert
  29.             response.EnsureSuccessStatusCode(); // Status Code 200-299
  30.             Assert.Equal("text/html; charset=utf-8",
  31.                 response.Content.Headers.ContentType.ToString());
  32.         }
  33.     }
  34. }
复制代码

1. 测试驱动开发(TDD)：考虑采用TDD方法，先编写测试，然后实现功能，这样可以确保代码的可测试性和高质量。

5. 常见问题及解决方案

5.1 数据库迁移问题

问题：在开发过程中，数据库模型变更后如何更新数据库结构？

解决方案：使用Entity Framework Core的迁移功能：
  2. # 添加迁移
  3. dotnet ef migrations add AddNewPropertyToProduct
  5. # 更新数据库
  6. dotnet ef database update
复制代码

如果需要回滚到之前的迁移：
  2. # 回滚到特定迁移
  3. dotnet ef database update PreviousMigrationName
  5. # 删除最后一个迁移（如果尚未应用到数据库）
  6. dotnet ef migrations remove
复制代码

5.2 依赖注入生命周期问题

问题：如何选择正确的服务生命周期（Scoped、Singleton、Transient）？

解决方案：理解不同生命周期的含义和适用场景：

• Transient：每次请求都会创建一个新的实例。适用于轻量级、无状态服务。
• Scoped：每个作用域（如每个HTTP请求）创建一个实例。适用于EF DbContext和每个请求需要保持状态的服务。
• Singleton：整个应用程序生命周期中只创建一个实例。适用于全局配置、日志服务等。

示例：
  2. public void ConfigureServices(IServiceCollection services)
  3. {
  4.     // DbContext应该是Scoped的
  5.     services.AddDbContext<AppDbContext>(options =>
  6.         options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
  7.    
  8.     // 仓储通常也是Scoped的，与DbContext保持一致
  9.     services.AddScoped<IProductRepository, ProductRepository>();
  10.    
  11.     // 应用服务通常也是Scoped的
  12.     services.AddScoped<IProductService, ProductService>();
  13.    
  14.     // 日志服务通常是Singleton的
  15.     services.AddSingleton<ILoggerService, LoggerService>();
  16.    
  17.     // 某些工具类可能是Transient的
  18.     services.AddTransient<IEmailService, EmailService>();
  19. }
复制代码

5.3 跨域资源共享(CORS)问题

问题：当前端应用与后端API不在同一个域时，如何处理跨域请求？

解决方案：配置CORS策略：
  2. // 在Startup.cs中配置CORS
  3. public void ConfigureServices(IServiceCollection services)
  4. {
  5.     services.AddCors(options =>
  6.     {
  7.         options.AddPolicy("AllowSpecificOrigin",
  8.             builder =>
  9.             {
  10.                 builder.WithOrigins("https://example.com", "https://www.example.com")
  11.                     .AllowAnyHeader()
  12.                     .AllowAnyMethod();
  13.             });
  14.     });
  15. }
  17. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  18. {
  19.     // ... 其他中间件
  20.    
  21.     app.UseCors("AllowSpecificOrigin");
  22.    
  23.     // ... 其他中间件
  24. }
复制代码

5.4 性能问题：N+1查询

问题：在使用EF Core时，如何避免N+1查询问题？

解决方案：使用Include和ThenInclude进行预加载：
  2. // 错误示例：会导致N+1查询问题
  3. var orders = _context.Orders.ToList();
  4. foreach (var order in orders)
  5. {
  6.     // 每个order都会触发一次数据库查询
  7.     var customer = _context.Customers.Find(order.CustomerId);
  8.     // ...
  9. }
  11. // 正确示例：使用Include预加载相关实体
  12. var orders = _context.Orders
  13.     .Include(o => o.Customer)
  14.     .Include(o => o.OrderItems)
  15.         .ThenInclude(oi => oi.Product)
  16.     .ToList();
复制代码

5.5 内存泄漏问题

问题：在ASP.NET Core应用中，如何避免内存泄漏？

解决方案：

1. 正确处理IDisposable资源：确保实现了IDisposable接口的服务被正确释放。
  2. public class MyService : IDisposable
  3. {
  4.     private readonly IDisposable _resource;
  5.    
  6.     public MyService()
  7.     {
  8.         _resource = new SomeDisposableResource();
  9.     }
  10.    
  11.     public void Dispose()
  12.     {
  13.         _resource?.Dispose();
  14.     }
  15. }
复制代码

1. 避免静态引用：静态变量会一直存在于应用程序的整个生命周期，可能导致内存泄漏。
2. 取消长时间运行的操作：使用CancellationToken来取消长时间运行的操作。

避免静态引用：静态变量会一直存在于应用程序的整个生命周期，可能导致内存泄漏。

取消长时间运行的操作：使用CancellationToken来取消长时间运行的操作。
  2. public async Task<long> ProcessDataAsync(CancellationToken cancellationToken)
  3. {
  4.     var result = 0L;
  5.    
  6.     for (int i = 0; i < int.MaxValue; i++)
  7.     {
  8.         // 检查是否已请求取消
  9.         cancellationToken.ThrowIfCancellationRequested();
  10.         
  11.         // 执行一些计算
  12.         result += i;
  13.         
  14.         // 定期检查取消请求
  15.         if (i % 1000 == 0)
  16.         {
  17.             await Task.Delay(10, cancellationToken);
  18.         }
  19.     }
  20.    
  21.     return result;
  22. }
复制代码

1. 使用内存分析工具：使用dotMemory、ANTS Memory Profiler等工具来检测内存泄漏。

6. 最佳实践和进阶建议

6.1 代码组织和结构

1. 遵循SOLID原则：单一职责原则(SRP)：每个类应该只有一个改变的理由。开放封闭原则(OCP)：软件实体应该对扩展开放，对修改封闭。里氏替换原则(LSP)：子类型必须能够替换其基类型。接口隔离原则(ISP)：客户端不应该依赖于它不使用的接口。依赖倒置原则(DIP)：高层模块不应该依赖于低层模块，两者都应该依赖于抽象。
2. 单一职责原则(SRP)：每个类应该只有一个改变的理由。
3. 开放封闭原则(OCP)：软件实体应该对扩展开放，对修改封闭。
4. 里氏替换原则(LSP)：子类型必须能够替换其基类型。
5. 接口隔离原则(ISP)：客户端不应该依赖于它不使用的接口。
6. 依赖倒置原则(DIP)：高层模块不应该依赖于低层模块，两者都应该依赖于抽象。
7. 使用CQRS模式：对于复杂的应用程序，考虑使用命令查询职责分离(CQRS)模式，将读取和写入操作分开。

遵循SOLID原则：

• 单一职责原则(SRP)：每个类应该只有一个改变的理由。
• 开放封闭原则(OCP)：软件实体应该对扩展开放，对修改封闭。
• 里氏替换原则(LSP)：子类型必须能够替换其基类型。
• 接口隔离原则(ISP)：客户端不应该依赖于它不使用的接口。
• 依赖倒置原则(DIP)：高层模块不应该依赖于低层模块，两者都应该依赖于抽象。

使用CQRS模式：对于复杂的应用程序，考虑使用命令查询职责分离(CQRS)模式，将读取和写入操作分开。
  2. // 查询服务
  3. public interface IProductQueryService
  4. {
  5.     Task<Product> GetProductByIdAsync(int id);
  6.     Task<IEnumerable<Product>> GetAllProductsAsync();
  7.     Task<IEnumerable<Product>> GetProductsByCategoryAsync(int categoryId);
  8. }
  10. // 命令服务
  11. public interface IProductCommandService
  12. {
  13.     Task<int> CreateProductAsync(CreateProductCommand command);
  14.     Task UpdateProductAsync(UpdateProductCommand command);
  15.     Task DeleteProductAsync(int id);
  16. }
  18. // 命令示例
  19. public class CreateProductCommand
  20. {
  21.     public string Name { get; set; }
  22.     public string Description { get; set; }
  23.     public decimal Price { get; set; }
  24.     public string ImageUrl { get; set; }
  25.     public int StockQuantity { get; set; }
  26.     public int CategoryId { get; set; }
  27.     public bool IsFeatured { get; set; }
  28. }
复制代码

1. 使用领域驱动设计(DDD)：对于复杂的业务领域，考虑使用DDD方法，将业务逻辑集中在领域模型中。
  2. // 领域实体示例
  3. public class Order : Entity
  4. {
  5.     private readonly List<OrderItem> _orderItems = new List<OrderItem>();
  6.    
  7.     public DateTime OrderDate { get; private set; }
  8.     public decimal TotalAmount { get; private set; }
  9.     public string Status { get; private set; }
  10.     public int CustomerId { get; private set; }
  11.     public Customer Customer { get; private set; }
  12.     public int ShippingAddressId { get; private set; }
  13.     public Address ShippingAddress { get; private set; }
  14.     public IReadOnlyCollection<OrderItem> OrderItems => _orderItems.AsReadOnly();
  15.    
  16.     // 私有构造函数，通过工厂方法创建
  17.     private Order() { }
  18.    
  19.     public static Order Create(int customerId, int shippingAddressId)
  20.     {
  21.         return new Order
  22.         {
  23.             CustomerId = customerId,
  24.             ShippingAddressId = shippingAddressId,
  25.             OrderDate = DateTime.Now,
  26.             Status = "Pending",
  27.             TotalAmount = 0
  28.         };
  29.     }
  30.    
  31.     public void AddOrderItem(Product product, int quantity)
  32.     {
  33.         if (product == null)
  34.             throw new ArgumentNullException(nameof(product));
  35.             
  36.         if (quantity <= 0)
  37.             throw new ArgumentException("Quantity must be greater than zero", nameof(quantity));
  38.             
  39.         var orderItem = new OrderItem(product, quantity);
  40.         _orderItems.Add(orderItem);
  41.         
  42.         UpdateTotalAmount();
  43.     }
  44.    
  45.     public void UpdateTotalAmount()
  46.     {
  47.         TotalAmount = _orderItems.Sum(oi => oi.TotalPrice);
  48.     }
  49.    
  50.     public void Confirm()
  51.     {
  52.         if (Status != "Pending")
  53.             throw new InvalidOperationException("Only pending orders can be confirmed");
  54.             
  55.         Status = "Confirmed";
  56.     }
  57.    
  58.     public void Ship()
  59.     {
  60.         if (Status != "Confirmed")
  61.             throw new InvalidOperationException("Only confirmed orders can be shipped");
  62.             
  63.         Status = "Shipped";
  64.     }
  65.    
  66.     public void Cancel()
  67.     {
  68.         if (Status == "Shipped" || Status == "Delivered")
  69.             throw new InvalidOperationException("Cannot cancel shipped or delivered orders");
  70.             
  71.         Status = "Cancelled";
  72.     }
  73. }
复制代码

6.2 性能优化最佳实践

1. 响应缓存：对于不经常变化的数据，使用响应缓存减少服务器负载。
  2. [ResponseCache(Duration = 60, Location = ResponseCacheLocation.Client)]
  3. public IActionResult FeaturedProducts()
  4. {
  5.     var products = _productService.GetFeaturedProducts();
  6.     return View(products);
  7. }
复制代码

1. 压缩响应：启用响应压缩减少网络传输时间。
  2. public void ConfigureServices(IServiceCollection services)
  3. {
  4.     services.AddResponseCompression(options =>
  5.     {
  6.         options.EnableForHttps = true;
  7.         options.Providers.Add<BrotliCompressionProvider>();
  8.         options.Providers.Add<GzipCompressionProvider>();
  9.     });
  10. }
  12. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  13. {
  14.     app.UseResponseCompression();
  15.     // ...
  16. }
复制代码

1. 使用缓存标记：使用缓存标记实现缓存失效。
  2. public void ConfigureServices(IServiceCollection services)
  3. {
  4.     services.AddOutputCache(options =>
  5.     {
  6.         options.AddBasePolicy(builder => builder
  7.             .With(c => c.HttpContext.Request.Path.StartsWithSegments("/products"))
  8.             .Tag("products"));
  9.     });
  10. }
  12. // 在控制器中使用
  13. [OutputCache(Tags = new[] { "products" })]
  14. public IActionResult Details(int id)
  15. {
  16.     var product = _productService.GetProductById(id);
  17.     return View(product);
  18. }
  20. // 在更新产品时使缓存失效
  21. public IActionResult Update(Product product)
  22. {
  23.     _productService.UpdateProduct(product);
  24.     _outputCache.EvictByTagAsync("products");
  25.     return RedirectToAction(nameof(Index));
  26. }
复制代码

6.3 安全性最佳实践

1. 使用HTTPS和HSTS：确保所有通信都通过HTTPS进行，并启用HTTP严格传输安全。
  2. public void ConfigureServices(IServiceCollection services)
  3. {
  4.     services.AddHsts(options =>
  5.     {
  6.         options.Preload = true;
  7.         options.IncludeSubDomains = true;
  8.         options.MaxAge = TimeSpan.FromDays(365);
  9.     });
  10. }
  12. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  13. {
  14.     if (env.IsDevelopment())
  15.     {
  16.         app.UseDeveloperExceptionPage();
  17.     }
  18.     else
  19.     {
  20.         app.UseExceptionHandler("/Error");
  21.         app.UseHsts();
  22.     }
  23.    
  24.     app.UseHttpsRedirection();
  25.     // ...
  26. }
复制代码

1. 实施CSRF保护：使用ASP.NET Core内置的防伪令牌功能。
  2. // 在Startup.cs中配置
  3. public void ConfigureServices(IServiceCollection services)
  4. {
  5.     services.AddAntiforgery(options =>
  6.     {
  7.         options.HeaderName = "X-XSRF-TOKEN";
  8.         options.Cookie.SameSite = SameSiteMode.Strict;
  9.         options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
  10.     });
  11. }
  13. // 在表单中包含防伪令牌
  14. <form method="post">
  15.     @Html.AntiForgeryToken()
  16.     <!-- 表单字段 -->
  17. </form>
  19. // 在AJAX请求中包含防伪令牌
  20. function getCookie(name) {
  21.     const value = `; ${document.cookie}`;
  22.     const parts = value.split(`; ${name}=`);
  23.     if (parts.length === 2) return parts.pop().split(';').shift();
  24. }
  26. fetch('/api/products', {
  27.     method: 'POST',
  28.     headers: {
  29.         'Content-Type': 'application/json',
  30.         'RequestVerificationToken': getCookie('XSRF-TOKEN')
  31.     },
  32.     body: JSON.stringify(data)
  33. });
复制代码

1. 安全配置：使用安全头增强应用程序安全性。
  2. public void ConfigureServices(IServiceCollection services)
  3. {
  4.     services.AddHsts(options =>
  5.     {
  6.         options.Preload = true;
  7.         options.IncludeSubDomains = true;
  8.         options.MaxAge = TimeSpan.FromDays(365);
  9.     });
  10. }
  12. public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
  13. {
  14.     // ... 其他中间件
  15.    
  16.     app.Use(async (context, next) =>
  17.     {
  18.         context.Response.Headers.Add("X-Content-Type-Options", "nosniff");
  19.         context.Response.Headers.Add("X-Frame-Options", "DENY");
  20.         context.Response.Headers.Add("X-XSS-Protection", "1; mode=block");
  21.         context.Response.Headers.Add("Referrer-Policy", "strict-origin-when-cross-origin");
  22.         context.Response.Headers.Add("Content-Security-Policy",
  23.             "default-src 'self'; " +
  24.             "script-src 'self' 'unsafe-inline' https://cdnjs.cloudflare.com; " +
  25.             "style-src 'self' 'unsafe-inline' https://cdnjs.cloudflare.com; " +
  26.             "img-src 'self' data: https://picsum.photos; " +
  27.             "font-src 'self' https://cdnjs.cloudflare.com; " +
  28.             "connect-src 'self'; " +
  29.             "frame-ancestors 'none';");
  30.         
  31.         await next();
  32.     });
  33.    
  34.     // ... 其他中间件
  35. }
复制代码

6.4 DevOps和部署最佳实践

1. CI/CD管道：设置持续集成和持续部署管道，自动化构建、测试和部署过程。
  2. # Azure Pipelines示例
  3. trigger:
  4. - main
  6. pool:
  7.   vmImage: 'windows-latest'
  9. variables:
  10.   solution: '**/*.sln'
  11.   buildPlatform: 'Any CPU'
  12.   buildConfiguration: 'Release'
  14. steps:
  15. - task: NuGetToolInstaller@1
  17. - task: NuGetCommand@2
  18.   inputs:
  19.     restoreSolution: '$(solution)'
  21. - task: VSBuild@1
  22.   inputs:
  23.     solution: '$(solution)'
  24.     msbuildArgs: '/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true /p:PackageLocation="$(build.artifactStagingDirectory)"'
  25.     platform: '$(buildPlatform)'
  26.     configuration: '$(buildConfiguration)'
  28. - task: VSTest@2
  29.   inputs:
  30.     platform: '$(buildPlatform)'
  31.     configuration: '$(buildConfiguration)'
  33. - task: PublishBuildArtifacts@1
  34.   inputs:
  35.     pathtoPublish: '$(Build.ArtifactStagingDirectory)'
  36.     artifactName: 'drop'
复制代码

1. 容器化部署：使用Docker容器化应用程序，简化部署和环境一致性。
  2. # Dockerfile示例
  3. FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
  4. WORKDIR /app
  5. EXPOSE 80
  6. EXPOSE 443
  8. FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
  9. WORKDIR /src
  10. COPY ["ECommerceApp/ECommerceApp.csproj", "ECommerceApp/"]
  11. COPY ["ECommerceApp.Domain/ECommerceApp.Domain.csproj", "ECommerceApp.Domain/"]
  12. COPY ["ECommerceApp.Application/ECommerceApp.Application.csproj", "ECommerceApp.Application/"]
  13. COPY ["ECommerceApp.Infrastructure/ECommerceApp.Infrastructure.csproj", "ECommerceApp.Infrastructure/"]
  14. RUN dotnet restore "ECommerceApp/ECommerceApp.csproj"
  15. COPY . .
  16. WORKDIR "/src/ECommerceApp"
  17. RUN dotnet build "ECommerceApp.csproj" -c Release -o /app/build
  19. FROM build AS publish
  20. RUN dotnet publish "ECommerceApp.csproj" -c Release -o /app/publish
  22. FROM base AS final
  23. WORKDIR /app
  24. COPY --from=publish /app/publish .
  25. ENTRYPOINT ["dotnet", "ECommerceApp.dll"]
复制代码

1. 监控和日志记录：实现全面的监控和日志记录策略，以便及时发现和解决问题。
  2. // 在Startup.cs中配置日志记录
  3. public void ConfigureServices(IServiceCollection services)
  4. {
  5.     services.AddLogging(loggingBuilder =>
  6.     {
  7.         loggingBuilder.AddConsole();
  8.         loggingBuilder.AddDebug();
  9.         loggingBuilder.AddEventSourceLogger();
  10.         
  11.         if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Production")
  12.         {
  13.             loggingBuilder.AddApplicationInsights();
  14.         }
  15.     });
  16. }
  18. // 在控制器中使用日志记录
  19. public class ProductsController : Controller
  20. {
  21.     private readonly ILogger<ProductsController> _logger;
  22.    
  23.     public ProductsController(ILogger<ProductsController> logger)
  24.     {
  25.         _logger = logger;
  26.     }
  27.    
  28.     public IActionResult Details(int id)
  29.     {
  30.         try
  31.         {
  32.             _logger.LogInformation("Getting product details for ID: {ProductId}", id);
  33.             
  34.             var product = _productService.GetProductById(id);
  35.             if (product == null)
  36.             {
  37.                 _logger.LogWarning("Product not found for ID: {ProductId}", id);
  38.                 return NotFound();
  39.             }
  40.             
  41.             return View(product);
  42.         }
  43.         catch (Exception ex)
  44.         {
  45.             _logger.LogError(ex, "Error getting product details for ID: {ProductId}", id);
  46.             return StatusCode(500, "An error occurred while processing your request.");
  47.         }
  48.     }
  49. }
复制代码

7. 总结

通过本文的实战案例和经验分享，我们深入探讨了ASP.NET项目开发的核心技能，从基础概念到高级技术，从代码实现到最佳实践。我们构建了一个完整的电子商务网站，涵盖了产品管理、购物车功能、订单处理等核心功能，并分享了在开发过程中的经验教训和解决方案。

ASP.NET Core作为一个强大、灵活的框架，为Web开发提供了丰富的功能和工具。通过掌握其核心技能，如依赖注入、中间件、Entity Framework Core、身份认证和授权等，开发者可以构建高性能、安全、可维护的Web应用程序。

在实际开发中，我们需要注重代码质量、性能优化、安全性和可维护性，遵循最佳实践，不断学习和探索新的技术和方法。希望本文的内容能够帮助读者更好地理解和掌握ASP.NET项目开发的核心技能，在实际项目中取得成功。
解析, 全程, 实战
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

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

本版积分规则

友情链接

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

加入Discord频道

加入QQ社群

加入QQ社群

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

Powered by Pixtech

© 2025-2026 Pixtech Team.