ASP.NET Core开发经验

最新推荐文章于 2023-07-11 15:02:15 发布

清紫悠悠

最新推荐文章于 2023-07-11 15:02:15 发布

阅读量1.3k

点赞数 7

文章标签： .net c# asp.net 后端

本文链接：https://blog.csdn.net/qq_36833171/article/details/106064619

版权

ASP.NET Core开发经验

ASP.NET Core开发经验

ASP.NET Core开发经验

一、c#语法

异步方法

可通过async、await、Task组成一个支持异步的业务方法，

使用async定义异步方法，await定义异步函数，Task定义异步返回结果

public async Task<IEnumerable<Company>> GetCompaniesAsync(IEnumerable<Guid> companyIds)
        {
            if (companyIds == null)
            {
                throw new ArgumentNullException(nameof(companyIds));
            }

            return await _context.Companies
                .Where(x => companyIds.Contains(x.Id))
                .OrderBy(x => x.Name)
                .ToListAsync();
        }

常见异常

throw new ArgumentNullException(nameof(companyIds));	// 判断方法参数是否为空

Guid类

GUIDglobally unique identifier（全球唯一标识符）

相当于一种算法生成的ID

Guid.Empty()：Guid结构的只读实例，其值为全零。，一般用来判断Guid是否已被赋值

new Guid()：返回由00000000-0000-0000-0000-000000000000组成的Guid对象

Guid.NewGuid()：返回一组由随机数生成的Guid对象

Guid.Parse(string guidString)：将字符串转为Guid对象

Console.WriteLine(Guid.Parse("fc6a01da-c1bc-44c6-a36a-d0fb02550af6"));

二、WebAPI

1. 创建WebAPI项目配置

配置Startup.cs

public class Startup
    {
    		public void ConfigureServices(IServiceCollection services)
        {
          // 添加对内容协商的支持（XML）JSON优先
        	services.AddControllers(setup =>
            {
                setup.ReturnHttpNotAcceptable = true;
            }).AddXmlDataContractSerializerFormatters();
        }
  			public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
          // 添加对异常处理生产环境的简单支持
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler(appBuilder =>
                {
                    appBuilder.Run(async context =>
                    {
                        context.Response.StatusCode = 500;
                        await context.Response.WriteAsync("Unexpected Error");
                    });
                });
            }
          	
          // 将Https转发为Http
          	app.UseHttpsRedirection();
					
            app.UseRouting();

            app.UseAuthorization();
						
          	// 注意：使用路由模版必须在控制器内路由进行单独配置
            app.UseEndpoints(endpoints => { endpoints.MapControllers(); });
        }
    }

注意：使用路由模版必须在控制器内路由进行单独配置

**注意：**如果想要配置内容协商的XML优先，可以配置如下代码

Startup.cs

public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers(setup =>
            {
                setup.ReturnHttpNotAcceptable = true;
              // OutputFormatters中可以添加不同的对内容协商的支持，第一个即为默认的序列号支持
                setup.OutputFormatters
                  .Add(new XmlDataContractSerializerOutputFormatter());
            });
        }

2. 配置WebAPI控制器和一般路由配置

路由配置，写在注解上

简易路由配置

[ApiController]		
[Route("api/companies")]
public class CompaniesController : ControllerBase
{
	[HttpGet("api/companies")]
	public async Task<ActionResult> GetCompanies()
	{
		var companies = await _companyRepository.GetCompaniesAsync();    
		return Ok(companyDtos);
	}
  
  [HttpGet("{companyId}")]
	public async Task<ActionResult> GetCompany(Guid companyId)
	{
		var company = await _companyRepository.GetCompanyAsync(companyId);
    if(company == null)
    {
      return NotFound();
    }      
		return Ok(companyDtos);
	}
}

可选[Route("api/companies")]配置为[Route("api/[controller]")]

这个时候，[controller]与控制器名称保持一致。

可将[HttpGet("{companyId}")]分开写：

[HttpGet]
[Route("{companyId}")]

可全局简化为

[ApiController]		
[Route("api/companies")]
public class CompaniesController : ControllerBase
{
	[HttpGet]
	public async Task<ActionResult> GetCompanies()
	{
		var companies = await _companyRepository.GetCompaniesAsync();    
		return Ok(companyDtos);
	}
  
  [HttpGet]
	public async Task<ActionResult> GetCompany(Guid companyId)
	{
		var company = await _companyRepository.GetCompanyAsync(companyId);
    if(company == null)
    {
      return NotFound();
    }      
		return Ok(companyDtos);
	}
}

3. 配置默认启动页

Properties/launchSettings.json

配置下面的"launchUrl": "api/companies"

"profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "launchUrl": "api/companies",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "RoutineApi2": {
      "commandName": "Project",
      "launchBrowser": true,
      "launchUrl": "api/companies",
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }

4.Enity Model和面向外部的Model

一把情况下，将EF内置的Model，对外输出以及用于接口参数传递的Mode（DTO）分离。

分别创建三个文件夹用来存放三种不同的存放Model的文件夹

RoutineApi2/Entities
- Company.cs
- Employee.cs
- Gender.cs
Models
- CompanyDto.cs
- EmployeeDto.cs
DtoParameters
- CompanyDtoParameters
- EmployeeDtoParameters

三、EF Core相关

1. EFCore创建实体类并完成映射（CodeFirst）

步骤一：建立一对多关系

RoutineApi2/Entities
- Company.cs
- Employee.cs
- Gender.cs

public class Company
    {		
  			// 配置ID
        public Guid Id { get; set; }
        public string Name { get; set; }
        public string Introduction { get; set; }
  			// 添加Employees集合（一对多）
        public ICollection<Employee> Employees { get; set; }
    }

public class Employee
    {
  			// 配置ID
        public Guid Id { get; set; }
        public Guid CompanyId { get; set; }
        public string EmployeeNo { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public Gender Gender { get; set; }
        public DateTime DataOfBirth { get; set; }
  			// 配置外建关联
        public Company Company { get; set; }
    }

public enum Gender
    {
        男 = 1,
        女 = 2
    }

步骤二：添加nuget包：

Microsoft.EntityFrameworkCore.SqlServer

Microsoft.EntityFrameworkCore.Sqlite

Microsoft.EntityFrameworkCore.Tools

步骤三：添加数据源

RoutineApi2/Data/RoutineDbContext.cs

namespace RoutineApi2.Data
{
    public class RoutineDbContext : DbContext
    {	
      	// 默认配置注入
        public RoutineDbContext(DbContextOptions<RoutineDbContext> options) : base(options)
        {}
				
      	//	数据库数据集集注入
        public DbSet<Company> Companies { get; set; }
        public DbSet<Employee> Employees { get; set; }
				
      	// 配置关联和限制
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Company>()
                .Property(x => x.Name).IsRequired().HasMaxLength(100);
            modelBuilder.Entity<Company>()
                .Property(x => x.Introduction).IsRequired().HasMaxLength(500);
            modelBuilder.Entity<Employee>()
                .Property(x => x.EmployeeNo).IsRequired().HasMaxLength(10);
            modelBuilder.Entity<Employee>()
                .Property(x => x.FirstName).IsRequired().HasMaxLength(50);
            modelBuilder.Entity<Employee>()
                .Property(x => x.LastName).IsRequired().HasMaxLength(50);
            modelBuilder.Entity<Employee>()
                .HasOne(x => x.Company)
                .WithMany(x => x.Employees)
              	// 当Employee存在于Company，不可删除Company
                .HasForeignKey(x => x.CompanyId).OnDelete(DeleteBehavior.Restrict); 
          
            // 配置种子数据
            modelBuilder.Entity<Company>().HasData(
                new Company
                {
                    Id = Guid.Parse("25dbd774-ae0e-44d2-94a1-58d5805da533"),
                    Name = "Microsoft",
                    Introduction = "Great Company",
                },
                new Company
                {
                    Id = Guid.Parse("2aea0972-6a03-4f3c-9672-04fa2ca99110"),
                    Name = "Google",
                    Introduction = "Don't be evil"
                    
                },
                new Company
                {
                    Id = Guid.Parse("c6fbfe31-590f-477f-a87a-3c68423909c6"),
                    Name = "Alipapa",
                    Introduction = "Fubao Company"
                }
            );
            modelBuilder.Entity<Employee>().HasData(
                new Employee
                {
                    Id = Guid.Parse("410f4bbe-e109-49d4-932a-e3cfe29f53ed"),
                    CompanyId = Guid.Parse("25dbd774-ae0e-44d2-94a1-58d5805da533"),
                    DataOfBirth = new DateTime(1966,1,2),
                    EmployeeNo = "MSFT231",
                    FirstName = "Nick",
                    LastName = "Carer",
                    Gender = Gender.男
                },
                new Employee
                {
                    Id = Guid.Parse("ba5790e1-765d-4e71-8795-edd24398f8e4"),
                    CompanyId = Guid.Parse("25dbd774-ae0e-44d2-94a1-58d5805da533"),
                    DataOfBirth = new DateTime(1996,2,3),
                    EmployeeNo = "MSFT245",
                    FirstName = "Vince",
                    LastName = "Carter",
                    Gender = Gender.男
                },
                new Employee
                {
                    Id = Guid.Parse("1a5b77ee-9e43-46ba-b1dc-3b5c32c647d4"),
                    CompanyId = Guid.Parse("2aea0972-6a03-4f3c-9672-04fa2ca99110"),
                    DataOfBirth = new DateTime(1986,2,1),
                    EmployeeNo = "MSFT215",
                    FirstName = "Machal",
                    LastName = "Jeckson",
                    Gender = Gender.男
                }
            );
        }
    }
}

步骤四：配置数据库连接字符串

一、SQLServer版本：

appsettings.json

"ConnectionStrings": {
    "DockerDBConnection": "Data Source=127.0.0.1;Initial Catalog=CompanyDB;User ID=sa;Password=<Admin123456>",
    "LocalDockerDBConnection": "Data Source=192.168.1.104;Initial Catalog=CompanyDB;User ID=sa;Password=<Admin123456>",
    "MSDBConnection": "Server=(localdb)\\mssqllocaldb;Database=CompanyDB;Trusted_Connection=True;MultipleActiveResultSets=true",
    "SqlServerConnection": "Data Source = myServerAddress;Initial Catalog = myDataBase;User Id = myUsername;Password = myPassword;"
  }

Startup.cs

public Startup(IConfiguration configuration)
{
	_configuration = configuration;
}

public void ConfigureServices(IServiceCollection services)
{
	// 数据库连接服务
		services.AddDbContextPool<AppDbContent>(
		option => option
      .UseSqlServer(_configuration.GetConnectionString("LocalDockerDBConnection")));
}

二、Sqlite版本

Startup.cs

public void ConfigureServices(IServiceCollection services)
        {
        	services.AddDbContextPool<RoutineDbContext>(
                option =>
                {
                    option.UseSqlite("Data Source=routine.db");
                });
        }

步骤五：创建迁移文件

VSCode开发

Shell下输入

$ dotnet ef migrations add InitialMigration

VS开发

打开程序包控制台

输入命令

$ add-migration

可以看到目录中多出了如下文件

Migrations
- 20200511033121_InitialMigration.cs
- RoutineDbContextModelSnapshot.cs

步骤六：启动程序，执行迁移

步骤七：将数据库连接池装载到服务类中

public class CompanyRepository : ICompanyRepository
{
	private readonly RoutineDbContext _context;
	public CompanyRepository(RoutineDbContext context)
	{
  	_context = context ?? throw new ArgumentException(nameof(context));
  }
}

2. 常用Linq语句汇总

一、查询所有数据

无参数，直接返回所有数据集

public async Task<IEnumerable<Company>> GetCompaniesAsync()
{
	return await _context.Companies.ToListAsync();
}

二、单数据条件查询

单参数，返回单数据

public Task<Company> GetCompanyAsync(Guid companyId)
{
	if (companyId == Guid.Empty)
	{
		throw new ArgumentNullException(nameof(companyId));
	}
  // FirstOrDefaultAsync ： 异步的返回唯一的对象
	return _context.Companies.FirstOrDefaultAsync(x => x.Id == companyId);
}

三、集合参数条件查询

参数为数据集合，返回数据集

public async Task<IEnumerable<Company>> GetCompaniesAsync(IEnumerable<Guid> companyIds)
{
	if (companyIds == null)
	{
  	throw new ArgumentNullException(nameof(companyIds));
	}
  return await _context.Companies
    .Where(x => companyIds.Contains(x.Id))
		.OrderBy(x => x.Name)
		.ToListAsync();
}

四、多参数条件查询

参数：多参数，返回：单数据对象

public async Task<Employee> GetEmployeesAsync(Guid companyId, Guid employeeId)
{
	if (companyId == Guid.Empty)
  {
		throw new ArgumentNullException(nameof(companyId));
	}
  
  if (companyId == Guid.Empty)
  {
  	throw new ArgumentNullException(nameof(companyId));
  }
	
  // 多条件查询
  return await _context.Employees
                .FirstOrDefaultAsync(x => x.CompanyId == companyId && x.Id == employeeId);
        }

五、添加数据到数据库

public void AddCompany(Company company)
{
	if (company == null)
	{
  	throw new ArgumentNullException(nameof(company));
	}
  
  // 对传入数据进行处理
  	company.Id = Guid.NewGuid();
    foreach (var employee in company.Employees)
    {
    	employee.Id = Guid.NewGuid();   
    }
   	
  // 添加数据
		_context.Companies.Add(company);
}

六、更新数据

public void UpdateCompany(Company company)
{
	// _context.Entry(company).State = EntityState.Modified; 可不写
}

七、删除数据

public void DeleteCompany(Company company)
{
	if (company == null)
  {
  	throw new ArgumentNullException(nameof(company));
  }
  // 删除数据
	_context.Companies.Remove(company);
}

八、验证数据是否存在数据库

 public async Task<bool> CompanyIsExistsAsync(Guid companyId)
{
	if (companyId == Guid.Empty)
  {
  	throw new ArgumentNullException(nameof(companyId));
	}
	return await _context.Companies.AnyAsync(x => x.Id == companyId);
}

九、保存数据库集合

public async Task<bool> SaveAsync()
{
	return await _context.SaveChangesAsync() >= 0;
}

十、复杂查询（过滤），模糊查询（搜索）

public async Task<IEnumerable<Employee>> 
  					// 公司ID（查询条件），职员性别（过滤），模糊查询（搜索）q
            GetEmployeesAsync(Guid companyId, string genderDisplay,string q)
        {
            if (companyId == Guid.Empty)
            {
                throw new ArgumentNullException(nameof(companyId));
            }
						
  					// 如果传入的过滤和检索条件都为空，常规简答查询
            if (string.IsNullOrWhiteSpace(genderDisplay) && string.IsNullOrWhiteSpace(q))
            {
                return await _context.Employees
                    .Where(x => x.CompanyId == companyId)
                    .OrderBy(x => x.EmployeeNo)
                    .ToListAsync();
            }
            
  					// 先进行简单查询保存结果为items
            var items = 
                _context.Employees.Where(x => x.CompanyId == companyId);
						
            if (!string.IsNullOrWhiteSpace(genderDisplay))
            {
              	// Trim()去除两边的空格
                genderDisplay = genderDisplay.Trim();
              	// 将传入参数转为Enum类型
                var gender = Enum.Parse<Gender>(genderDisplay);

                items = items.Where(x => x.Gender == gender);
            }

            if (!string.IsNullOrWhiteSpace(q))
            {
                q = q.Trim();
              	// 任意那一个匹配都行||或
                items = items.Where(x => x.EmployeeNo.Contains(q)
                                         || x.FirstName.Contains(q)
                                         || x.LastName.Contains(q)
                                         );
            }
  
            return await items.OrderBy(x => x.EmployeeNo)
                .ToListAsync();
        }

十一、将对象传入作为查询的参数列表

DtoParameters/CompanyDtoParameters.cs

public class CompanyDtoParameters
{
		public string CompanyName { get; set; }
  	public string SearchTerm { get; set; }
}

public async Task<IEnumerable<Company>> GetCompaniesAsync(CompanyDtoParameters parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException(nameof(parameters));
            }

            if (string.IsNullOrWhiteSpace(parameters.CompanyName) && 
                string.IsNullOrWhiteSpace(parameters.SearchTerm))
            {
                return await _context.Companies.ToListAsync();
            }
						
  					// 将数据库连接字符串集合临时保存一下，这里不会触发查询方法
            var queryExpression = _context.Companies as IQueryable<Company>;
            if (!string.IsNullOrWhiteSpace(parameters.CompanyName))
            {
                parameters.CompanyName = parameters.CompanyName.Trim();
                queryExpression = queryExpression
                    .Where(x => x.Name == parameters.CompanyName);
            }

            if (!string.IsNullOrWhiteSpace(parameters.SearchTerm))
            {
                parameters.SearchTerm = parameters.SearchTerm.Trim();
              	// 模糊查询
                queryExpression = queryExpression
                    .Where(x => x.Name.Contains(parameters.SearchTerm)
                    || x.Introduction.Contains(parameters.SearchTerm));
            }
            
            // 到这里才真正查询数据库
            return await queryExpression.ToListAsync();
        }

！！！经验

常用方法汇总：

一、参数传入后要判断是否为空

// 传入类型为Guid
if (companyId == Guid.Empty)
{
		throw new ArgumentNullException(nameof(companyId));
}
// 传入类型为对象
if (companyIds == null)
{
		throw new ArgumentNullException(nameof(companyIds));
}
// 传入类型为string
if (string.IsNullOrWhiteSpace(genderDisplay) && string.IsNullOrWhiteSpace(q)){}

二、查询结果唯一，用FirstOrDefaultAsync()，一种特殊的Where

return _context.Companies.FirstOrDefaultAsync(x => x.Id == companyId);

三、查询结果不唯一，用Where

四、查询结果需要排序，可以使用OrderBy()和OrderByDescending()，排序依据即位参数

return await _context.Companies
  							.Where(x => companyIds.Contains(x.Id))
                .OrderBy(x => x.Name)
                .ToListAsync();

五、参数尽量先Trim去除多余的空格再进行查询操作

六、判断数据是否存在于数据库，可以使用AnyAsync方法，类似于Where，但是它返回的是个Bool类型

return await _context.Companies.AnyAsync(x => x.Id == companyId);

七、增删和删除数据可以使用DBSet.Add(Object)和DBSet.Remove(Object)

四、AutoMapper

当频繁需要对DTO进行数据映射的时候，就需要new大量的DTO对象，这样的代码就是冗余的。

可以使用AutoMapper完成对DTO的自动映射。

步骤一、添加AutoMapper的Nuget包

AutoMapper.Extensions.Microsoft.DependencyInjection

步骤二、在Startup的ConfigureService注册Mapper容器，注册默认配置

services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());

步骤三、配置Mapper映射

创建Profiles文件夹

Profiles
- RoutineApi2/Profiles/CompanyProfile.cs
- RoutineApi2/Profiles/EmployeeProfile.cs

源类型：

public class Company
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public string Introduction { get; set; }
        public ICollection<Employee> Employees { get; set; }
    }

public class Employee
    {
        public Guid Id { get; set; }
        public Guid CompanyId { get; set; }
        public string EmployeeNo { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public Gender Gender { get; set; }
        public DateTime DataOfBirth { get; set; }
        public Company Company { get; set; }
    }

public enum Gender
    {
        男 = 1,
        女 = 2
    }

public class CompanyDto
    {
        public Guid Id { get; set; }
        public string CompanyName { get; set; }
    }

public class EmployeeDto
    {
        public Guid Id { get; set; }
        public Guid CompanyId { get; set; }
        public string EmployeeNo { get; set; }
        public string Name { get; set; }
        public Gender GenderDisplay { get; set; }
        public int Age { get; set; } 
    }

配置Mapper

public class CompanyProfile : Profile
    {
        public CompanyProfile()
        {
            // 原类型和目标类型
            CreateMap<Company, CompanyDto>()
                .ForMember(
                    dest => dest.CompanyName,
                    opt 
                        => opt.MapFrom(src => src.Name));
        }  
    }

public class EmployeeProfile : Profile
    {
        public EmployeeProfile()
        {
            CreateMap<Employee, EmployeeDto>()
                .ForMember(
                    dest
                        => dest.Name,
                    opt
                        => opt.MapFrom(src
                            => $"{src.FirstName} {src.LastName}"))
                .ForMember(
                    dest
                        => dest.GenderDisplay,
                    opt
                        => opt.MapFrom(src
                            => src.Gender.ToString()))
                .ForMember(
                    dest
                        => dest.Age,
                    opt
                        => opt.MapFrom(src
                            => DateTime.Now.Year - src.DataOfBirth.Year));
        }
    }

步骤五、添加Mapper到控制器

public class CompaniesController : ControllerBase
    {
        private readonly ICompanyRepository _companyRepository;
        private readonly IMapper _mapper; 

        public CompaniesController(ICompanyRepository companyRepository, IMapper mapper)
        {
            _companyRepository = companyRepository ??
                                 throw new ArgumentNullException(nameof(companyRepository));
            _mapper = mapper ?? throw new ArgumentException(nameof(mapper));
        }
        
        [HttpGet]
        [HttpHead]
        public async Task<ActionResult<IEnumerable<CompanyDto>>> 
            GetCompanies([FromQuery]CompanyDtoParameters parameters)
        {
            var companies = await _companyRepository.GetCompaniesAsync(parameters);
						
          	// 自动完成映射，参数即为源Model，泛型即为目标类型
            var companyDtos = _mapper.Map<IEnumerable<CompanyDto>>(companies);
            
            return Ok(companyDtos);
        }
  		
  		 [HttpGet("{companyId}")]
       public async Task<ActionResult<CompanyDto>> GetCompany(Guid companyId)
       {
            var company = await _companyRepository.GetCompanyAsync(companyId);
            
            if (company == null)
            {
                return NotFound();
            }
            return Ok(_mapper.Map<CompanyDto>(company));
       }
	}

清紫悠悠

关注

7
点赞
踩
9

收藏

觉得还不错? 一键收藏
1
评论
ASP.NET Core开发经验

ASP.NET Core开发经验一、c#语法异步方法可通过async、await、Task组成一个支持异步的业务方法，使用async定义异步方法，await定义异步函数，Task定义异步返回结果public async Task<IEnumerable<Company>> GetCompaniesAsync(IEnumerable<Guid> companyIds) { if (companyIds == null)
复制链接

扫一扫