项目开发中的一些注意事项以及技巧总结 基于Repository模式设计项目架构—你可以参考的项目架构设计 Asp.Net Core中使用RSA加密 EF Core中的多对多映射如何实现？ asp.net core下的如何给网站做安全设置 获取服务端https证书 Js异常捕获
项目开发中的一些注意事项以及技巧总结
1、jquery采用ajax向后端请求时，MVC框架并不能返回View的数据，也就是一般我们使用View()、PartialView()等，只能返回json以及content等，但是一般我们在开发的时候也是使用json返回的，此时如果需要渲染界面或者是加载局部视图，我们可以在ajax的success的事件中使用$.html()来渲染后台给前端传的View()数据。一开始我遇到这个问题的时候还很纳闷，为什么ajax给后端穿了POST之后，不能加载局部页面，后来一想，是不是因为ajax是异步请求的原因，于是我把ajax的同步开关打开了，同时将后台传输的视图数据直接使用$html()就渲染到了前端页面。具体请参考：https://blog.csdn.net/m0_37302219/article/details/78272081
2 、后端MVC架构，一般前端都是使用Razor视图，使用@来加载后台传过来的数据比如ViewData，以及ViewBag等。此时，我建议在后端的C#中，我们给ViewBag赋值了之后，在前端的cshtml页面中这么做：
@{
List<T> xxx = ViewBag.xxx;
T xxx = ViewBag.xxx;
}
然后直接使用显式类型的变量来做处理。
3、EF Core中，尤其要注意多对多的关联属性的使用。如果使用不当就会加载不出来数据，直接会出一个null值，在这里请参考
https://blog.oneunicorn.com/2017/09/25/many-to-many-relationships-in-ef-core-2-0-part-1-the-basics/
认真的跟着这个博客做一遍就可以理解了。
4、EF Core中，当我们使用code First建模方式生成数据库时，如果生成数据库有问题了（当然一般是没有问题的，但是我就遇到了，可能也是我操作不当）我强烈建议，不要删除这个生成有问题的数据库，千万不要觉得删除了之后，可以再生成一遍，会出问题的。具体请看
http://www.cjjjs.com/paper/lkkj/2018711212518513.html
5、EF Core下一对多的关联中，需要注意（我不怎么用过EF，也不知道在EF中是不是很正常，在这里仅仅说EF Core，可能两者在我要说的这点上是一致的）。我们以官方为例：https://docs.microsoft.com/en-us/ef/core/get-started/aspnetcore/existing-db
一个博客(Blog)对应多个文章（Post），一篇文章对应一个博客（Blog）。此时，当我们使用上下文来获取数据库数据时，代码如下：
List<Blog> Blogs = _context.Blogs.ToList();
List<Post> Posts = _context.Posts.ToList(); // 如果不写这句代码，不从数据库里面加载处理关联属性Post的数据，那么Blogs里面的Post关联属性也将会是null值，这点是要特别注意的，只有写了这句代码，Blogs类型的关联属性Post才能有数据。
6、项目中一定要设计好数据库，一般来讲如果有级联关系的，就设置为两个表（这里的级联关系我是这么定义的：假设一个类别下有多条数据，这就是一个级联关系，就像是一个省份下面有多个城市）。在实体方面，我们可以认为是一对多关系，如果是一对多关系，我们就建两个表。设计好了数据表，对我们的开发有着莫大的好处，有时候多加一个字段和少一个字段完全不一样。
7、建议在列表数据中使用ForEach来遍历，也就是一般的List<T>变量，使用List<T>.ForEach来遍历数据处理逻辑
基于Repository模式设计项目架构—你可以参考的项目架构设计
关于Repository模式，直接百度查就可以了，其来源是《企业应用架构模式》。
我们新建一个Infrastructure文件夹，这里就是基础设施部分，EF Core的上下文类以及Repository层都放在这里面。
新建一个IReposotory的接口，其内容就是封装了基本的CRUD:
public interface IRepository<TEntity> where TEntity : class
{
///获取当前实体的查询数据集
IQueryable<TEntity> Entities{get;}
///获取当前实体的数据集
DbSet<TEntity> DbEntities{get;}
/// <summary>
/// Gets all objects from database
/// </summary>
/// <returns></returns>
IQueryable<TEntity> All();
/// <summary>
/// Gets objects from database by filter.
/// </summary>
/// <param name="predicate">Specified a filter</param>
/// <returns></returns>
IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate);
/// <summary>
/// Gets objects from database with filting and paging.
/// </summary>
/// <param name="filter">Specified a filter</param>
/// <param name="total">Returns the total records count of the filter.</param>
/// <param name="index">Specified the page index.</param>
/// <param name="size">Specified the page size</param>
/// <returns></returns>
IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> filter, out int total, int index = 0, int size = 50);
/// <summary>
/// Gets the object(s) is exists in database by specified filter.
/// </summary>
/// <param name="predicate">Specified the filter expression</param>
/// <returns></returns>
bool Contains(Expression<Func<TEntity, bool>> predicate);
/// <summary>
/// Find object by keys.
/// </summary>
/// <param name="keys">Specified the search keys.</param>
/// <returns></returns>
TEntity Find(params object[] keys);
/// <summary>
/// Find object by specified expression.
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
TEntity Find(Expression<Func<TEntity, bool>> predicate);
/// <summary>
/// Create a new object to database.
/// </summary>
/// <param name="t">Specified a new object to create.</param>
/// <returns></returns>
int Create(TEntity t);
/// <summary>
/// Delete the object from database.
/// </summary>
/// <param name="t">Specified a existing object to delete.</param>
void Delete(TEntity t);
/// <summary>
/// Delete objects from database by specified filter expression.
/// </summary>
/// <param name="predicate"></param>
/// <returns></returns>
int Delete(Expression<Func<TEntity, bool>> predicate);
/// <summary>
/// Update object changes and save to database.
/// </summary>
/// <param name="t">Specified the object to save.</param>
/// <returns></returns>
int Update(TEntity t);
/// <summary>
/// Select Single Item by specified expression.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="expression"></param>
/// <returns></returns>
TEntity FirstOrDefault(Expression<Func<TEntity, bool>> expression);
}
创建一个基类，用来实现IRepository接口，同时作其余的Repository的基类
public class BaseRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
protected readonly DbContext Context;
public BaseRepository(DbContext context)
{
Context = context;
}
/// 获取当前实体的查询数据集
public IQueryable<TEntity> Entities
{
get { return Context.Set<TEntity>().AsQueryable(); }
}
/// 获取当前实体
public IQueryable<TEntity> Entities
{
get { return Context.Set<TEntity>(); }
}
public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> expression)
{
return All().FirstOrDefault(expression);
}
public IQueryable<TEntity> All()
{
return Context.Set<TEntity>().AsQueryable();
}
public virtual IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> predicate)
{
return Context.Set<TEntity>().Where<TEntity>(predicate).AsQueryable<TEntity>();
}
public virtual IQueryable<TEntity> Filter(Expression<Func<TEntity, bool>> filter, out int total, int index = 0,
int size = 50)
{
var skipCount = index * size;
var resetSet = filter != null
? Context.Set<TEntity>().Where<TEntity>(filter).AsQueryable()
: Context.Set<TEntity>().AsQueryable();
resetSet = skipCount == 0 ? resetSet.Take(size) : resetSet.Skip(skipCount).Take(size);
total = resetSet.Count();
return resetSet.AsQueryable();
}
public virtual int Create(TEntity TObject)
{
Entities.Add(TObject);
Context.SaveChanges();
}
public virtual int Delete(TEntity TObject)
{
Entities.Remove(TObject);.
Context.SaveChanges();
}
public virtual void Update(TEntity TObject)
{
try
{
var entry = Context.Entry(TObject);
Context.Set<TEntity>().Attach(TObject);
entry.State = EntityState.Modified;
}
catch (OptimisticConcurrencyException ex)
{
throw ex;
}
}
public virtual int Delete(Expression<Func<TEntity, bool>> predicate)
{
var objects = Filter(predicate);
foreach (var obj in objects)
Context.Set<TEntity>().Remove(obj);
return Context.SaveChanges();
}
public bool Contains(Expression<Func<TEntity, bool>> predicate)
{
return Context.Set<TEntity>().Any(predicate);
}
public virtual TEntity Find(params object[] keys)
{
return Context.Set<TEntity>().Find(keys);
}
public virtual TEntity Find(Expression<Func<TEntity, bool>> predicate)
{
return Context.Set<TEntity>().FirstOrDefault<TEntity>(predicate);
}
}
新建一个实体类的接口：
public interface IStudentRepository : IRepository<Student>
{
int AddStudent(Student student);
}
然后我们创建一个实体类的Repository：
public class StudentRepository : BaseRepository<Student>, IStudentRepository
{
private readonly SchoolContext _context;
public StudentRepository(SchoolContext context)
: base(context)
{
_context = context;
}
int AddStudent(Student student)
{
_context.Create(student);
}
}
在这里就已经做好了我们要做的了。接下来的就是注入依赖、在控制器里面的使用了。
我们完全可以自己来定制自己的Repository模式下的项目。其实整个的架构没有什么，我们只是将所有的CRUD操作封装到了IRepository接口里面，然后在BaseRepository中实现了一遍，而且如果你细心的话，你会发现IRepository里面的CRUD操作都是基于已有的扩展方法里面的，就是linq扩展方法的Add等源码，同时我们在BaseRepository类中，提供了DbSet<TEntity>属性以及查询数据集IQueryable<DbSet<TEntity>>，这也是有必要的，可以省却我们很多不必要的代码，因为我们所有的CRUD都是基于这两个的。然后我们基于BaseRepository来实现实体类的Repository，同时继承按需增加的IEntityRepository接口。但是在这里要注意，我们将DbContext的子类都放在了Infrastructure文件夹里面，是因为，一般我们继承自DbContext的子类都是操作数据库的中间类，属于基础设施一块，所以将其放在Infrastructure文件夹比较合适。
参考资料：
MVC实用架构设计（三）——EF-Code First（1）：Repository，UnitOfWork，DbContext
分享基于Entity Framework的Repository模式设计（附源码）
《ASP.NET MVC框架揭秘》源码中的示例项目源码 S1402
EF Core中的多对多映射如何实现？
EF 6.X中的多对多映射是直接使用HasMany-HasMany来做的。但是到了EF Core中，不再直接支持这种方式了，可以是可以使用，但是不推荐，具体使用可以参考《你必须掌握的EntityFramework 6.X与Core 2.0》一文。在这里我就详细的说下如何在EF core下实现。
首先就是实体类的建立：
public class Post
{
public int PostId { get; set; }
public string Title { get; set; }
public ICollection<PostTag> PostTags { get; } = new List<PostTag>();
}
public class Tag
{
public int TagId { get; set; }
public string Text { get; set; }
public ICollection<PostTag> PostTags { get; } = new List<PostTag>();
}
public class PostTag
{
public int PostId { get; set; }
public Post Post { get; set; }
public int TagId { get; set; }
public Tag Tag { get; set; }
}
接下来就是映射了。派生自DbContext的上下文类：
public class MyContext : DbContext
{
public DbSet<Post> Posts { get; set; }
public DbSet<Tag> Tags { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
=> optionsBuilder.UseSqlServer(
@"Server=(localdb)\mssqllocaldb;Database=Test;ConnectRetryCount=0");
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<PostTag>().ToTable("PostTags");
modelBuilder.Entity<PostTag>()
.HasKey(t => new { t.PostId, t.TagId });
}
}
这样就完成了我们的多对多映射了。我们只是通过多建立了一个表，将两个实体类的Id作为联合主键。
在Identity框架中，如果你细心点，你会发现有个userroles表，这个表是就是用来做Users表和Roles表的映射的。那么接下来我们只要新建一个实体类，随后在上下文类中映射到表：
modelBuilder.Entity<UserRoles>.ToTable("userroles");
这样就可以了。然后我们就可以很方便的给用户添加角色了。
参考链接：https://blog.oneunicorn.com/2017/09/25/many-to-many-relationships-in-ef-core-2-0-part-1-the-basics/
asp.net core下的如何给网站做安全设置
首先，我们来看下stack overflow网站的请求头文件：
可以看到一些我们熟悉或是陌生的HTTP头部文件字段。
在这里我们在对HTTP输入流的头部文件中，做一些基本的防护。首先要明确，既然我们是对HTTP头部做处理，那么就需要在Startup.cs类的
Configuration方法中做处理，因为这里就是处理HTTP输入流的。
首先做一些基本的处理，比如中间件和基本的类：
|
1
2
3
4
5
6
7
8
|
public class SecurityHeadersPolicy { public IDictionary<string, string> SetHeaders { get; } = new Dictionary<string, string>(); public ISet<string> RemoveHeaders { get; } = new HashSet<string>();} |
这里的头部信息是我们定义好的，用来增加或是删除头部信息，然后就是我们的中间件：
public class SecurityHeadersMiddleware
{
private readonly RequestDelegate _next;
private readonly SecurityHeadersPolicy _policy;
public SecurityHeadersMiddleware(RequestDelegate next, SecurityHeadersPolicy policy)
{
_next = next;
_policy = policy;
}
public async Task Invoke(HttpContext context)
{
IHeaderDictionary headers = context.Response.Headers;
foreach (var headerValuePair in _policy.SetHeaders)
{
headers[headerValuePair.Key] = headerValuePair.Value;
}
foreach (var header in _policy.RemoveHeaders)
{
headers.Remove(header);
}
await _next(context);
}
}
基于IApplicationBuilder接口做一个中间件的扩展方法：
public static class MiddlewareExtensions
{
public static IApplicationBuilder UseSecurityHeadersMiddleware(this IApplicationBuilder app, SecurityHeadersBuilder builder)
{
SecurityHeaderPolicy policy = builder.Build();
return app.UseMiddleware<SecurityHeadersMiddleware>(policy);
}
}
封装好相关的安全类：
public class SecurityHeadersBuilder
{
private readonly SecurityHeadersPolicy _policy = new SecurityHeadersPolicy();
public SecurityHeadersBuilder AddDefaultSecurePolicy()
{
AddFrameOptionsDeny();
AddXssProtectionBlock();
AddContentTypeOptionsNoSniff();
AddStrictTransportSecurityMaxAge();
RemoveServerHeader();
return this;
}
public SecurityHeadersBuilder AddFrameOptionsDeny()
{
_policy.SetHeaders[FrameOptionsConstants.Header] = FrameOptionsConstants.Deny;
return this;
}
public SecurityHeadersBuilder AddFrameOptionsSameOrigin()
{
_policy.SetHeaders[FrameOptionsConstants.Header] = FrameOptionsConstants.SameOrigin;
return this;
}
public SecurityHeadersBuilder AddFrameOptionsSameOrigin(string uri)
{
_policy.SetHeaders[FrameOptionsConstants.Header] = string.Format(FrameOptionsConstants.AllowFromUri, uri);
return this;
}
public SecurityHeadersBuilder RemoveServerHeader()
{
_policy.RemoveHeaders.Add(ServerConstants.Header);
return this;
}
public SecurityHeadersBuilder AddCustomHeader(string header, string value)
{
_policy.SetHeaders[header] = value;
return this;
}
public SecurityHeadersBuilder RemoveHeader(string header)
{
_policy.RemoveHeaders.Add(header);
return this;
}
public SecurityHeadersPolicy Build()
{
return _policy;
}
}
最后注入到HTTP的输入流中：
app.UseSecurityHeadersMiddleware(new SecurityHeadersBuilder() .AddDefaultSecurePolicy() );
然后我们浏览一下网页，就可以在HTTP的头部信息中看到：
HTTP/1.1 200 OK Content-Type: text/html; charset=utf-8 X-Frame-Options: DENY X-XSS-Protection: 1; mode=block X-Content-Type-Options: nosniff Strict-Transport-Security: max-age=31536000 X-Powered-By: ASP.NET
还有一个就是CSRF的防护，如果之前你用过ASP.NET MVC，在最基本的MVC模板中，可能你会留意到已有的cshtml页面中的form表单有这么一句：
@Html.AntiForgeryToken()
这就是微软在MVC框架中为我们提供的防护CSRF的方法。我们在表单中直接使用上面那句代码就可以了，然后在表单提交的Action方法中：
[ValidateAntiForgeryToken]
[HttpPost]
public IActionResult AntiForm(string message)
{
return Content(message);
}
使用[ValidateAntiForgeryToken]属性，来验证CSRF。
参考链接：
How to add security headers in ASP.NET Core using custom middleware（如何使用自定义中间件在ASP.NET Core中添加安全标头）
代码地址：
https://github.com/RyanOvO/aspnetcore-fileup-demo
获取服务端https证书
最近开发一个需求，涉及获取服务端https证书。一般进行https调用我们都不太关心底层细节，直接使用WebClient或者HttpWebRequest来发送请求，这两种方法都无法获取证书信息，需要用到ServicePoint，这个类用于提供HTTP连接的管理。
写个Demo，拿新浪首页试一下：
using System;
using System.Net;
using System.Security.Cryptography.X509Certificates;
namespace GetServerCertificateDemo
{
class Program
{
static void Main(string[] args)
{
//用WebClient访问新浪首页
var http = new WebClient();
var uri = new Uri("https://www.sina.com.cn");
http.DownloadString(uri);
//通过Uri获取ServicePoint
var servicePoint = ServicePointManager.FindServicePoint(uri);
//取服务端证书，X509Certificate格式，转一下
var serverCert = new X509Certificate2(servicePoint.Certificate);
Console.WriteLine("颁发给：{0}", serverCert.Subject);
Console.WriteLine("颁发者：{0}", serverCert.Issuer);
Console.WriteLine("序列号：{0}", serverCert.SerialNumber);
Console.WriteLine("指 纹：{0}", serverCert.Thumbprint);
Console.WriteLine("起 始：{0}", serverCert.NotBefore);
Console.WriteLine("过 期：{0}", serverCert.NotAfter);
}
}
}
运行看效果：
上半部分是程序运行结果，下面是用Firefox查看的服务端证书信息，各项信息都能对应上。如果程序中涉及多个不同服务器的访问也没关系，关键在于根据Uri获取ServicePoint，然后取到的证书就是此服务器的了。
Js异常捕获
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<script>
function demo(){
try{
alert(str);
}catch(e){
alert(e);
}
}
demo();
</script>
<form>
<input id="txt" type="text"/>
<input id="btn" type="button" onclick="demo1()" value="按钮" />
</form>
<script>
function demo1(){
try{
var e=document.getElementById("txt").value;
if(e==""){
throw "请输入";
}
}catch(e){
alert(e);
}
}
</script>
</body>
</html>
js事件
onLoad 网页加载事件
onUnload 关闭网页事件
反射：获取Class对象的三种方式
数据库_mysql多表操作
数据库_mysql多表操作
多表操作
实际开发中，一个项目通常需要很多张表才能完成。例如：一个商城项目就需要分类表(category)、商品表(products)、订单表(orders)等多张表。且这些表的数据之间存在一定的关系。
1.1 表与表之间的关系
l 一对多关系：
n 常见实例：客户和订单，分类和商品，部门和员工.
n 一对多建表原则：在从表(多方)创建一个字段，字段作为外键指向主表(一方)的主键.
l 多对多关系：
n 常见实例：学生和课程、用户和角色
n 多对多关系建表原则：需要创建第三张表,中间表中至少两个字段，这两个字段分别作为外键指向各自一方的主键.
l 一对一关系：(了解)
n 在实际的开发中应用不多.因为一对一可以创建成一张表.
n 两种建表原则：
u 外键唯一：主表的主键和从表的外键（唯一），形成主外键关系，外键唯一unique。
u 外键是主键：主表的主键和从表的主键，形成主外键关系。
1.2 外键约束
现在我们有两张表“分类表”和“商品表”，为了表明商品属于哪个分类，通常情况下，我们将在商品表上添加一列，用于存放分类cid的信息，此列称为：外键
此时“分类表category”称为：主表，“cid”我们称为主键。“商品表products”称为：从表，category_id称为外键。我们通过主表的主键和从表的外键来描述主外键关系，呈现就是一对多关系。
外键特点：
u 从表外键的值是对主表主键的引用。
u 从表外键类型，必须与主表主键类型一致。
l 声明外键约束
语法：alter table 从表 add [constraint] [外键名称] foreign key (从表外键字段名) references 主表 (主表的主键);
[外键名称]用于删除外键约束的，一般建议“_fk”结尾
altertable 从表 drop foreignkey 外键名称
l 使用外键目的：
n 保证数据完整性
1.3 一对多操作
1.3.1 分析
-
category分类表，为一方，也就是主表，必须提供主键cid
-
products商品表，为多方，也就是从表，必须提供外键category_id
-
1.3.2 实现：分类和商品
###创建分类表
create table category(
cidvarchar(32) PRIMARY KEY ,
cnamevarchar(100) #分类名称
);
# 商品表
CREATE TABLE `products` (
`pid`varchar(32) PRIMARY KEY ,
`name`VARCHAR(40) ,
`price`DOUBLE
);
#添加外键字段
alter table products add column category_id varchar(32);
#添加约束
alter table products add constraint product_fkforeign key (category_id) references category (cid);
1.3.3 操作
#1 向分类表中添加数据
INSERT INTO category (cid ,cname) VALUES('c001','服装');
#2 向商品表添加普通数据,没有外键数据，默认为null
INSERT INTO products (pid,pname) VALUES('p001','商品名称');
#3 向商品表添加普通数据，含有外键信息(数据存放在)
INSERT INTO products (pid ,pname ,category_id)VALUES('p002','商品名称2','c001');
#4 向商品表添加普通数据，含有外键信息(数据不存在) -- 不能异常
INSERT INTO products (pid ,pname ,category_id)VALUES('p003','商品名称2','c999');
#5 删除指定分类(分类被商品使用) -- 执行异常
DELETE FROM category WHERE cid = 'c001';
1.4 多对多
1.4.1 分析
-
商品和订单多对多关系，将拆分成两个一对多。
-
products商品表，为其中一个一对多的主表，需要提供主键pid
-
orders 订单表，为另一个一对多的主表，需要提供主键oid
-
orderitem中间表，为另外添加的第三张表，需要提供两个外键oid和pid
1.4.2 实现：订单和商品
### 商品表[已存在]
### 订单表
create table `orders`(
`oid`varchar(32) PRIMARY KEY ,
`totalprice` double #总计
);
### 订单项表
create table orderitem(
oidvarchar(50),-- 订单id
pidvarchar(50)-- 商品id
);
###---- 订单表和订单项表的主外键关系
alter table `orderitem` add constraintorderitem_orders_fk foreign key (oid) references orders(oid);
###---- 商品表和订单项表的主外键关系
alter table `orderitem` add constraintorderitem_product_fk foreign key (pid) references products(pid);
### 联合主键（可省略）
alter table `orderitem` add primary key (oid,pid);
1.4.3 操作
#1 向商品表中添加数据
INSERT INTO products (pid,pname) VALUES('p003','商品名称');
#2 向订单表中添加数据
INSERT INTO orders (oid ,totalprice)VALUES('x001','998');
INSERT INTO orders (oid ,totalprice)VALUES('x002','100');
#3向中间表添加数据(数据存在)
INSERT INTO orderitem(pid,oid)VALUES('p001','x001');
INSERT INTO orderitem(pid,oid)VALUES('p001','x002');
INSERT INTO orderitem(pid,oid)VALUES('p002','x002');
#4删除中间表的数据
DELETE FROM orderitem WHERE pid='p002' AND oid ='x002';
#5向中间表添加数据(数据不存在) -- 执行异常
INSERT INTO orderitem(pid,oid)VALUES('p002','x003');
#6删除商品表的数据 -- 执行异常
DELETE FROM products WHERE pid = 'p001';
-
