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);
 }

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);
 }

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);
}
 }

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中添加安全标头）

初探CSRF在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';