1     /// <summary>
  2     /// New Object Expression
  3     /// 合并NewExpression使用.
  4     /// </summary>
  5     public class NewObjectExpression : Expression, IArgumentProvider
  6     {
  7         private IList<Expression> arguments;
  8
  9         /// <summary>
 10         /// 构造方法
 11         /// </summary>
 12         /// <param name="constructor"></param>
 13         /// <param name="arguments"></param>
 14         /// <param name="members"></param>
 15         internal NewObjectExpression(ConstructorInfo constructor, IList<Expression> arguments, List<MemberInfo> members)
 16         {
 17             this.Constructor = constructor;
 18             this.arguments = arguments;
 19             this.Members = members;
 20
 21             if (members != null)
 22             {
 23                 List<string> nameList = members.Select(member => member.Name).ToList();
 24                 for (int i = 0; i < nameList.Count; i++)
 25                 {
 26                     if (!string.IsNullOrEmpty(ExpressionString))
 27                     {
 28                         ExpressionString += "," + nameList[i];
 29                     }
 30                     else
 31                     {
 32                         ExpressionString = nameList[i];
 33                     }
 34                 }
 35             }
 36         }
 37
 38         /// <summary>
 39         /// Gets the static type of the expression that this <see cref="Expression" /> represents. (Inherited from <see cref="Expression"/>.)
 40         /// </summary>
 41         /// <returns>The <see cref="Type"/> that represents the static type of the expression.</returns>
 42         public override Type Type
 43         {
 44             get { return Constructor.DeclaringType; }
 45         }
 46
 47         /// <summary>
 48         /// Returns the node type of this <see cref="Expression" />. (Inherited from <see cref="Expression" />.)
 49         /// </summary>
 50         /// <returns>The <see cref="ExpressionType"/> that represents this expression.</returns>
 51         public sealed override ExpressionType NodeType
 52         {
 53             get { return ExpressionType.New; }
 54         }
 55
 56         /// <summary>
 57         /// Gets the called constructor.
 58         /// </summary>
 59         public ConstructorInfo Constructor { get; }
 60
 61         /// <summary>
 62         /// Gets the arguments to the constructor.
 63         /// </summary>
 64         public ReadOnlyCollection<Expression> Arguments
 65         {
 66             get { return (ReadOnlyCollection<Expression>)arguments; }
 67         }
 68
 69         Expression IArgumentProvider.GetArgument(int index)
 70         {
 71             return arguments[index];
 72         }
 73
 74         int IArgumentProvider.ArgumentCount
 75         {
 76             get
 77             {
 78                 return arguments.Count;
 79             }
 80         }
 81
 82         /// <summary>
 83         /// ExpressionString
 84         /// </summary>
 85         public string ExpressionString { get; private set; } = "";
 86
 87         public ConstructorInfo Constructor1 => Constructor;
 88
 89         public List<MemberInfo> Members { get; set; }
 90
 91         /// <summary>
 92         /// 更新members
 93         /// </summary>
 94         /// <param name="arguments"></param>
 95         /// <param name="members"></param>
 96         /// <returns></returns>
 97         public NewObjectExpression Update(IList<Expression> arguments, List<MemberInfo> members)
 98         {
 99             if (arguments != null)
100             {
101                 this.arguments = arguments;
102             }
103             if (Members != null)
104             {
105                 this.Members = members;
106                 ExpressionString = "";
107                 List<string> nameList = members.Select(member => member.Name).ToList();
108                 for (int i = 0; i < nameList.Count; i++)
109                 {
110                     if (!string.IsNullOrEmpty(ExpressionString))
111                     {
112                         ExpressionString += "," + nameList[i];
113                     }
114                     else
115                     {
116                         ExpressionString = nameList[i];
117                     }
118                 }
119             }
120             return this;
121         }
122     }

  1     /// <summary>
  2     /// Expression 扩展
  3     /// </summary>
  4     public static class ExpressionExpand
  5     {
  6         /// <summary>
  7         /// Expression And
  8         /// NewExpression 合并
  9         /// </summary>
 10         /// <param name="expr"></param>
 11         /// <returns></returns>
 12         public static Expression<Func<T, object>> Add<T>(this Expression<Func<T, object>> expr, Expression<Func<T, object>> expandExpr)
 13         {
 14             Expression<Func<T, object>> result = null;
 15             ParameterExpression parameter = Expression.Parameter(typeof(T), "p");
 16             List<MemberInfo> memberInfoList = new List<MemberInfo>();
 17             #region 处理原expr
 18             if (expr.Body is NewExpression)
 19             {   // t=>new{t.Id,t.Name}
 20                 NewExpression newExp = expr.Body as NewExpression;
 21                 if (newExp.Members != null)
 22                 {
 23                     memberInfoList = newExp.Members.ToList();
 24                 }
 25             }
 26             else if (expr.Body is NewObjectExpression)
 27             {
 28                 NewObjectExpression newExp = expr.Body as NewObjectExpression;
 29                 if (newExp.Members != null)
 30                 {
 31                     memberInfoList = newExp.Members.ToList();
 32                 }
 33             }
 34             else if (expr.Body is UnaryExpression)
 35             {   //t=>t.Id
 36                 UnaryExpression unaryExpression = expr.Body as UnaryExpression;
 37                 MemberExpression memberExp = unaryExpression.Operand as MemberExpression;
 38                 memberInfoList.Add(memberExp.Member);
 39             }
 40             #endregion
 41
 42             #region 处理扩展expr
 43             if (expandExpr.Body is NewExpression)
 44             {   // t=>new{t.Id,t.Name}
 45                 NewExpression newExp = expandExpr.Body as NewExpression;
 46                 for (int i = 0; i < newExp.Members.Count; i++)
 47                 {
 48                     MemberExpression memberExp = Expression.Property(parameter, newExp.Members[i].Name);
 49                     if (!memberInfoList.Any(member => member.Name == newExp.Members[i].Name))
 50                     {
 51                         memberInfoList.Add(newExp.Members[i]);
 52                     }
 53                 }
 54             }
 55             else if (expr.Body is NewObjectExpression)
 56             {
 57                 NewObjectExpression newExp = expr.Body as NewObjectExpression;
 58                 if (newExp.Members != null && newExp.Members.Count > 0)
 59                 {
 60                     for (int i = 0; i < newExp.Members.Count; i++)
 61                     {
 62                         MemberExpression memberExp = Expression.Property(parameter, newExp.Members[i].Name);
 63                         if (!memberInfoList.Any(member => member.Name == newExp.Members[i].Name))
 64                         {
 65                             memberInfoList.Add(newExp.Members[i]);
 66                         }
 67                     }
 68                 }
 69             }
 70             else if (expandExpr.Body is UnaryExpression)
 71             {   //t=>t.Id
 72                 UnaryExpression unaryExpression = expandExpr.Body as UnaryExpression;
 73                 MemberExpression memberExp = unaryExpression.Operand as MemberExpression;
 74                 if (!memberInfoList.Any(exp => exp.Name == memberExp.Member.Name))
 75                 {
 76                     memberInfoList.Add(memberExp.Member);
 77                 }
 78             }
 79             #endregion
 80             NewObjectExpression newObjExpression = new NewObjectExpression(typeof(object).GetConstructors()[0], null, memberInfoList);
 81             result = Expression.Lambda<Func<T, object>>(newObjExpression, parameter);
 82             return result;
 83         }
 84
 85         /// <summary>
 86         /// Expression Remove
 87         /// NewExpression 合并
 88         /// </summary>
 89         /// <param name="expr"></param>
 90         /// <returns></returns>
 91         public static Expression<Func<T, object>> Remove<T>(this Expression<Func<T, object>> expr, Expression<Func<T, object>> expandExpr)
 92         {
 93             Expression<Func<T, object>> result = null;
 94             ParameterExpression parameter = Expression.Parameter(typeof(T), "p");
 95             List<MemberInfo> memberInfoList = new List<MemberInfo>();
 96             List<MemberInfo> removeMemberInfoList = new List<MemberInfo>();
 97             #region 处理原expr
 98             if (expr.Body is NewExpression)
 99             {   // t=>new{t.Id,t.Name}
100                 NewExpression newExp = expr.Body as NewExpression;
101                 if (newExp.Members != null)
102                 {
103                     memberInfoList = newExp.Members.ToList();
104                 }
105             }
106             else if (expr.Body is NewObjectExpression)
107             {
108                 NewObjectExpression newExp = expr.Body as NewObjectExpression;
109                 if (newExp.Members != null)
110                 {
111                     memberInfoList = newExp.Members.ToList();
112                 }
113             }
114             else if (expr.Body is UnaryExpression)
115             {   //t=>t.Id
116                 UnaryExpression unaryExpression = expr.Body as UnaryExpression;
117                 MemberExpression memberExp = unaryExpression.Operand as MemberExpression;
118                 memberInfoList.Add(memberExp.Member);
119             }
120             #endregion
121
122             #region 处理扩展expr
123             if (expandExpr.Body is NewExpression)
124             {   // t=>new{t.Id,t.Name}
125                 NewExpression newExp = expandExpr.Body as NewExpression;
126                 for (int i = 0; i < newExp.Members.Count; i++)
127                 {
128                     MemberExpression memberExp = Expression.Property(parameter, newExp.Members[i].Name);
129                     if (!removeMemberInfoList.Any(member => member.Name == newExp.Members[i].Name))
130                     {
131                         removeMemberInfoList.Add(newExp.Members[i]);
132                     }
133                 }
134             }
135             else if (expr.Body is NewObjectExpression)
136             {
137                 NewObjectExpression newExp = expr.Body as NewObjectExpression;
138                 if (newExp.Members != null && newExp.Members.Count > 0)
139                 {
140                     for (int i = 0; i < newExp.Members.Count; i++)
141                     {
142                         MemberExpression memberExp = Expression.Property(parameter, newExp.Members[i].Name);
143                         if (!removeMemberInfoList.Any(member => member.Name == newExp.Members[i].Name))
144                         {
145                             removeMemberInfoList.Add(newExp.Members[i]);
146                         }
147                     }
148                 }
149             }
150             else if (expandExpr.Body is UnaryExpression)
151             {   //t=>t.Id
152                 UnaryExpression unaryExpression = expandExpr.Body as UnaryExpression;
153                 MemberExpression memberExp = unaryExpression.Operand as MemberExpression;
154                 if (!memberInfoList.Any(exp => exp.Name == memberExp.Member.Name))
155                 {
156                     removeMemberInfoList.Add(memberExp.Member);
157                 }
158             }
159             #endregion
160
161             for (int i = memberInfoList.Count - 1; i >= 0; i--)
162             {
163                 if (removeMemberInfoList.Any(member => member.Name == memberInfoList[i].Name))
164                 {
165                     memberInfoList.Remove(memberInfoList[i]);
166                 }
167             }
168             if (memberInfoList.Count <= 0)
169             {
170                 throw new System.Exception("Expression Remove Error.All Properties are removed.");
171             }
172             NewObjectExpression newObjExpression = new NewObjectExpression(typeof(object).GetConstructors()[0], null, memberInfoList);
173             result = Expression.Lambda<Func<T, object>>(newObjExpression, parameter);
174             return result;
175         }
176
177         /// <summary>
178         /// Expression And
179         /// </summary>
180         /// <param name="expr"></param>
181         /// <returns></returns>
182         public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> expandExpr)
183         {
184             Expression<Func<T, bool>> result = Expression.Lambda<Func<T, bool>>(Expression.And(expandExpr.Body, expr.Body), expr.Parameters);
185             return result;
186         }
187
188         /// <summary>
189         /// Expression And
190         /// </summary>
191         /// <param name="expr"></param>
192         /// <returns></returns>
193         public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr, Expression<Func<T, bool>> expandExpr)
194         {
195             Expression<Func<T, bool>> result = Expression.Lambda<Func<T, bool>>(Expression.Or(expandExpr.Body, expr.Body), expr.Parameters);
196             return result;
197         }
198     }

 1         /// <summary>
 2         /// 通过Lambed Expression获取属性名称
 3         /// </summary>
 4         /// <param name="expr">查询表达式</param>
 5         /// <returns></returns>
 6         public static List<string> GetPiList<T>(Expression<Func<T, object>> expr)
 7         {
 8             List<string> result = new List<string>();
 9             if (expr.Body is NewExpression)
10             {   // t=>new{t.Id,t.Name}
11                 NewExpression nexp = expr.Body as NewExpression;
12                 if (nexp.Members != null)
13                 {
14                     result = nexp.Members.Select(member => member.Name).ToList();
15                 }
16             }
17             else if (expr.Body is NewObjectExpression)
18             {   // t=>new{t.Id,t.Name}
19                 NewObjectExpression nexp = expr.Body as NewObjectExpression;
20                 if (nexp.Members != null)
21                 {
22                     result = nexp.Members.Select(member => member.Name).ToList();
23                 }
24             }
25             else if (expr.Body is UnaryExpression)
26             {   //t=>t.Id
27                 UnaryExpression uexp = expr.Body as UnaryExpression;
28                 MemberExpression mexp = uexp.Operand as MemberExpression;
29                 result.Add(mexp.Member.Name);
30             }
31             else
32             {
33                 throw new System.Exception("不支持的Select lambda写法");
34             }
35             return result;
36         }

正文

前言

    在 .Net Core 2.2中 Microsoft.AspNetCore.App 默认内置了EntityFramework Core 包，所以在使用过程中，我们无需再从 NuGet 仓库单独应用 EFCore 包；本文并不打算深入的介绍 EFCore 的各种使用方式、原理解析，本文重点在于解决让初学者在10分钟内快速使用上 EFCore 的问题。

1. Code First 方式

EFCore 支持 Code First 方式，这个特性允许开发人员基于业务实体模型创建数据库

1.1 首先创建一个 Asp.Net Core WebApi 项目 Ron.MSSQL，如下

1.2 创建业务实体模型文件夹 Models，添加两个业务实体 Topic,Post

    public class Topic
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public DateTime CreateTime { get; set; }
        public virtual ICollection<Post> Posts { get; set; }
    }

    public class Post
    {
        public int Id { get; set; }
        public int TopicId { get; set; }
        public string Content { get; set; }
        public DateTime CreateTime { get; set; }
        public virtual Topic Topic { get; set; }
    }

上面定义的两个实体对象之间通过 Topic.Posts 和 Post.Topic 属性建立了主外键关系，这两个表的主键为 Id，且类型为 int ，这表示在下面的创建数据库过程中，EFCore 会自动的为这两个实体对象建立关系和主键，并会自动设置 Id 字段为主键标识

1.3 编写数据库上下文对象，该对象必须继承自 DbContext

DbContext 内置了很多个构造函数，这里使用配置选项的方式，实现方式也非常简单，最终，在 ForumContext 类中定义上面的实体业务模型集合即可

    public class ForumContext : DbContext
    {
        public ForumContext(DbContextOptions<ForumContext> options) : base(options)
        {

        }

        public DbSet<Topic> Topics { get; set; }
        public DbSet<Post> Posts { get; set; }
    }

1.4 在 appsettings.json 文件中配置数据库连接字符串，这里使用的是本机安装的 SQLExpress，指定数据库名称为：Forum

  "ConnectionStrings": {
    "Forum": "server=.\\SQLEXPRESS;uid=sa;pwd=123456;database=Forum;"
  }

1.5 在 Startup.cs 中配置连接字符串，注入上下文对象

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<ForumContext>(options =>
            {
                var connectionString = this.Configuration["ConnectionStrings:Forum"];
                options.UseSqlServer(connectionString);
            });

            ...
        }

上面的代码使用 AddDbContext 方法，并配置了数据库连接字符串为配置文件中的 "ConnectionStrings:Forum" 节点的值

1.5 在项目的包管理器控制台中使用命令根据实体业务模型创建数据库

现在，打开项目中的包管理器控制台

• 在控制台中输入以下两组命令

Add-Migration Forum_v1
Update-Database

在输入命令 Add-Migration Forum_v1 后，回车，控制台输出 To undo this action, use Remove-Migration. 表示命令执行成功；同时可以看到，在项目中多了一个文件夹 Migrations；
注意：此时，数据库 Forum 并没有被创建

在 Migrations 文件夹中；当执行 Update-Database 命令后，EFCore 设计工具将根据 Migrations 中的定义去创建数据库，最终，控制台输出 Done 表示创建完成

查看数据库

从上图中可以看到，数据库创建成功，同时，Forum 数据库中还多了一个表 __EFMigrationsHistory ，该表存储的正是我们项目中的 Migrations 的内容，只有两个字段，对应 20190109031435_Forum_v1.cs 和 当前使用的 EFCore 版本号
如果后续有增加实体，只需要再次执行 Add-Migration 命令即可
如果希望获得帮助，还可在包管理器控制台执行命令 get-help Add-Migration

1.6 在项目中执行 CURD 操作

至此，数据库创建完成，为了在控制器中使用 ForumContext 对象，我们在 HomeController 中使用依赖注入的方式获得 FormContext 对象，以备后续使用

        private ForumContext context;
        public HomeController(ForumContext context)
        {
            this.context = context;
        }

现在，尝试着在项目中执行一些增删改查的工作，插入一条 Topic 记录，在 HomeController 中编写以下代码

    [Route("api/[controller]"), ApiController]
    public class HomeController : ControllerBase
    {
        private ForumContext context;
        public HomeController(ForumContext context)
        {
            this.context = context;
        }
        [HttpGet]
        public ActionResult<IEnumerable<Topic>> Get()
        {
            var topics = context.Topics.ToList();

            return topics;
        }

        [HttpPost]
        public void Post([FromBody] TopicViewModel model)
        {
            context.Topics.Add(new Topic()
            {
                Content = model.Content,
                CreateTime = DateTime.Now,
                Title = model.Title
            });
            context.SaveChanges();
        }

        [HttpPut]
        public void Put([FromBody] TopicViewModel model)
        {
            var topic = context.Topics.Where(f => f.Id == model.Id).FirstOrDefault();
            topic.Title = model.Title;
            topic.Content = model.Content;
            context.Topics.Update(topic);
            context.SaveChanges();
        }

        [HttpDelete("{id}")]
        public void Delete(int id)
        {
            var topic = context.Topics.Where(f => f.Id == id).FirstOrDefault();
            context.Topics.Remove(topic);
            context.SaveChanges();
        }
    }

上面的代码定义了 Get/Post/Put/Delete 接口，这是一个标准的 Resetful API ，通过依次调用模拟对数据库的 CURD 操作

2. DB First 的使用方式

在很多时候，我们的开发方式是先设计好数据库模型，然后再生成实体对象，这种方式对于从其它语言迁移到 .Net Core 上非常友好，从现有数据库中生成实体对象非常简单，只需要一个命令即可，还是以上面创建好的数据库 Forum 为例子

2.1 基于现有数据库生成实体对象，在项目中的包管理器控制台输入命令，指定使用的是 Microsoft.EntityFrameworkCore.SqlServer 驱动，生成的实体模型输出到目录 DbModels 中

`Scaffold-DbContext "server=.\SQLEXPRESS;uid=sa;pwd=123456;database=Forum" Microsoft.EntityFrameworkCore.SqlServer -OutPutDir DbModels

2.2 执行结果

如果仅需要生成部分数据表，还可以通过将 -Tables 参数添加到上述命令来指定要为哪些表生成实体。 例如 -Tables Blog,Post。多个数据表以逗号分隔

2.3 项目中生成的实体对象文件夹

通过查看生成的代码比较，和 Code First 方式基本相同，使用方式完全一致

3. 导航属性

不管是 Code First 还是 DB First ，在实体对象中，我们都可以看到有个一个导航属性，比如 Topic.Posts 和 Post.Topic ，该导航属性定义了前缀 virtual 表示延迟加载此关联对象，在 Code First 中，导航属性还起到主外键关系定义的作用

结束语

• 本文介绍两种使用 EF Core 的方式
• 通过一个简单的 Forum 示例来一步一步的了解了 EFCore 的使用过程

示例代码下载

https://github.com/lianggx/EasyAspNetCoreDemo/tree/master/Ron.MSSQL

WPF实战案例-打印