ASP.NET Core MVC+Layui使用EF

ASP.NET Core MVC+Layui使用EF Core连接MySQL执行简单的CRUD操作

录导航：

前言：
示例实现功能预览：
博客实例源码下载地址：
一、创建ASP.NET Core Web应用程序：
二、添加EF Core NuGet包：
安装方式：
三、创建对应数据库表的实体模型：创建用户模型（UserInfo）:
四、将数据库连接字符串添加到 appsettings.json：
五、创建数据库上下文：概述：创建：
六、将上下文添加到 Startup.cs 中的依赖项注入：
七：引入Layui样式和js：将相关文件存放到wwwroot文件下：将相关文件引入默认布局页面中：
八、 ASP.NET Core MVC 和 EF Core实现MySQL CRUD功能:Create：Retrieve：Update：Delete：

文章正文：

回到顶部

前言：

　　本章主要通过一个完整的示例讲解ASP.NET Core MVC+EF Core对MySQL数据库进行简单的CRUD操作，希望能够为刚入门.NET Core的小伙伴们提供一个完整的参考实例。关于ASP.NET Core MVC+EF操作MsSQL Server详情请参考官方文档(https://docs.microsoft.com/zh-cn/aspnet/core/data/ef-mvc/?view=aspnetcore-3.1)。

回到顶部

示例实现功能预览：

回到顶部

博客实例源码下载地址：

https://github.com/YSGStudyHards/ASP.NET-Core-MVC-Layui-EF-Core-CRUD_Sample

回到顶部

一、创建ASP.NET Core Web应用程序：

注意，本章节主要以APS.NET Core 3.1版本作为博客的样式实例！

回到顶部

二、添加EF Core NuGet包：

　　若要在项目中使用EF Core操作MySQL数据库，需要安装相应的数据库驱动包。本章教程主要使用 MySQL数据库，所以我们需要安装相关驱动包MySql.Data.EntityFrameworkCore。

回到顶部

安装方式：

点击工具=>NuGet包管理器=>程序包管理器控制台输入以下命令：

Install-Package MySql.Data.EntityFrameworkCore -Version 8.0.20

点击工具=>NuGet包管理器=>管理解决方案的NuGet程序包：

搜索：MySql.Data.EntityFrameworkCore 点击安装。

回到顶部

三、创建对应数据库表的实体模型：

　　注意该篇博客使用的是手动模型优先的方式进行数据库表字段与模型属性映射，当然如果大家觉得这样子比较麻烦的话可以真正意义上的模型优先，直接创建模型在program.cs中配置创建对应模型的数据库逻辑代码即可无需手动创建数据库，可参考官网文档教程（https://docs.microsoft.com/zh-cn/aspnet/core/data/ef-rp/intro?view=aspnetcore-3.1&tabs=visual-studio#create-the-database）。

创建用户模型（UserInfo）:

注意：属性大小写和数据库中的表字段保持一致，Id 属性成为此类对应的数据库表的主键列。默认情况下，EF Core 将名为 Id 或 xxxID 的属性视为主键。有关详细信息，请参阅 F Core - 密钥。

    /// <summary>
    /// 学生信息模型
    /// </summary>
    public class UserInfo
    {
        /// <summary>
        /// 学生编号
        /// </summary>
        [Description("学生编号")]
        public int? Id { get; set; }

        /// <summary>
        /// 学生姓名
        /// </summary>
        [Description("学生姓名")]
        public string UserName { get; set; }

        /// <summary>
        /// 学生性别
        /// </summary>
        [Description("学生性别")]
        public string Sex { get; set; }

        /// <summary>
        /// 学生联系电话
        /// </summary>
        [Description("学生联系电话")]
        public string Phone { get; set; }

        /// <summary>
        /// 学生描述
        /// </summary>
        [Description("学生描述")]
        public string Description { get; set; }

        /// <summary>
        /// 学生爱好
        /// </summary>
        [Description("学生爱好")]
        public string Hobby { get; set; }
    }

回到顶部

四、将数据库连接字符串添加到 appsettings.json：

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
        "MySqlConnection":"Data Source=127.0.0.1;User ID=root;Password=root;DataBase=SchoolUserInfo_db"
  }
}

回到顶部

五、创建数据库上下文：

概述：

数据库上下文类是为给定数据模型协调 EF Core 功能的主类。上下文派生自 Microsoft.EntityFrameworkCore.DbContext。上下文指定数据模型中包含哪些实体。在此项目中将数据库上下文类命名为 SchoolUserInfoContext。

创建：

using Microsoft.EntityFrameworkCore;
using Model;

namespace Dal
{
    public class SchoolUserInfoContext : DbContext
    {
        public SchoolUserInfoContext(DbContextOptions<SchoolUserInfoContext> options)
            : base(options)
        {
        }

        /// <summary>
        /// DbSet实体集属性对应数据库中的表(注意实体集名必须与表明一致)
        /// </summary>
        public DbSet<UserInfo> UserInfos { get; set; }

        /// <summary>
        /// TODO:当数据库创建完成后， EF 创建一系列数据表，表名默认和 DbSet 属性名相同。 集合属性的名称一般使用复数形式，但不同的开发人员的命名习惯可能不一样，
        /// 开发人员根据自己的情况确定是否使用复数形式。 在定义 DbSet 属性的代码之后，添加下面代码，对DbContext指定单数的表名来覆盖默认的表名。
        /// </summary>
        /// <param name="modelBuilder"></param>
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<UserInfo>().ToTable("UserInfo");
        }
    }
}

回到顶部

六、将上下文添加到 Startup.cs 中的依赖项注入：

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            //注入EF Core数据库上下文服务
            services.AddDbContext<SchoolUserInfoContext>(options=>
                options.UseMySQL(Configuration.GetConnectionString("MySqlConnection")));

            services.AddControllersWithViews();
        }

回到顶部

七：引入Layui样式和js：

前往官网下载Layui相关样式和js包，下载地址：https://www.layui.com/

Layui弹出层插件layer.js（有很多地方需要用到弹窗），下载地址：https://layer.layui.com/

将相关文件存放到wwwroot文件下：

将相关文件引入默认布局页面中：

回到顶部

八、 ASP.NET Core MVC 和 EF Core实现MySQL CRUD功能:

注意在这里主要展示的EF Core与数据库操作的部分代码，详细代码可下载实例源码查看。

Create：

        /// <summary>
        /// 学生信息添加
        /// </summary>
        /// <param name="addUserInfo"></param>
        /// <returns></returns>
        public async Task<bool> Create(AddUserInfoViewModel addUserInfo)
        {
            try
            {
                var userInfo=new UserInfo()
                {
                    UserName=addUserInfo.UserName,
                    Sex=addUserInfo.Sex,
                    Hobby=addUserInfo.Hobby,
                    Phone=addUserInfo.Phone,
                    Description=addUserInfo.Description
                };

                _shoSchoolUserInfoContext.UserInfos.Add(userInfo);

                await _shoSchoolUserInfoContext.SaveChangesAsync();

                return true;
            }
            catch
            {
                return false;
            }
        }

Retrieve：

        /// <summary>
        /// 获取用户信息
        /// </summary>
        /// <param name="page">当前页码</param>
        /// <param name="limit">显示条数</param>
        /// <param name="userName">用户姓名</param>
        /// <returns></returns>
        public async Task<PageSearchModel> GetPageListData(int page=1, int limit=15, string userName="")
        {
            try
            {
                List<UserInfo> listData;
                var totalCount=0;
                if (!string.IsNullOrWhiteSpace(userName))
                {
                    listData=await _shoSchoolUserInfoContext.UserInfos.Where(x=> x.UserName.Contains(userName)).OrderByDescending(x=> x.Id).Skip((page - 1) * limit).Take(limit).ToListAsync();

                    totalCount=_shoSchoolUserInfoContext.UserInfos
                        .Count(x=> x.UserName.Contains(userName));
                }
                else
                {
                    listData=await _shoSchoolUserInfoContext.UserInfos.OrderByDescending(x=> x.Id).Skip((page - 1) * limit).Take(limit).ToListAsync();

                    totalCount=_shoSchoolUserInfoContext.UserInfos.Count();
                }

                return new PageSearchModel()
                {
                    ResultMsg="success",
                    Code=200,
                    TotalCount=totalCount,
                    DataList=listData
                };
            }
            catch (Exception e)
            {
                return new PageSearchModel() { Code=400, ResultMsg=e.Message };
            }
        }

Update：

        /// <summary>
        /// 学生信息修改
        /// </summary>
        /// <param name="userInfo"></param>
        /// <returns></returns>
        public async Task<bool> Update(UserInfo userInfo)
        {

            try
            {
                _shoSchoolUserInfoContext.UserInfos.Update(userInfo);

                await _shoSchoolUserInfoContext.SaveChangesAsync();

                return true;
            }
            catch
            {
                return false;
            }
        }

Delete：

        /// <summary>
        /// 学生信息删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<bool> Delete(int? id)
        {
            try
            {
                var searchUserInfo=await _shoSchoolUserInfoContext.UserInfos.FindAsync(id);

                if (searchUserInfo==null)
                {
                    return false;
                }

                _shoSchoolUserInfoContext.UserInfos.Remove(searchUserInfo);
                await _shoSchoolUserInfoContext.SaveChangesAsync();

                return true;
            }
            catch
            {
                return false;
            }
        }

作者：追逐时光

原文：https://www.cnblogs.com/Can-daydayup/p/12593599.html

日客户要求表内的数据依据某种分组生成HTML页面进行展示，一般处理这种需求直接上编程工具就好了，从数据库里读取数据，根据规则生成字符串，最后将字符串写出到文件。由于需求比较急，作为数据库编程系列文章，如果能用SQL实现首选还是SQL，这样处理既直接又快速，不过针对SQL要真的有耐心和信心写完，调试更是崩溃。由于要写出文件到硬盘，最后还是选择MySQL作为数据库工具，Navicat作为开发工具。

有两张表计划表、市县表，二者依靠市县编码（sxbm）进行等值连接，计划表内含有各个学校投放在各个市县的专业代号（zydh），专业名称（zymc）、招生备注(bz)、学制(xz)、要求的学历(xl)、计划数(jh)等字段组成的计划信息，院校编码(yxbm)为学校的两位数编码，院校代号(yxdh)为院校编码(yxbm)+市县编码(sxbm)组成的四位数编码，院校代号其实可以区分出学校在哪个市县的投档的专业计划。要求以学校为单位创建HTML页面，页面首先要以市县作为表格分割，然后根据专业代号排序。具体实现过程如下：

创建计划表：

CREATE TABLE `zzjh2019v` (
`YXDH` varchar(9) COMMENT '学校代号',
`YXMC` varchar(54) COMMENT '学校名称',
`ZYDH` varchar(2) COMMENT '专业代号',
`ZYMC` varchar(28) COMMENT '专业名称',
`XZ` varchar(3) COMMENT '学制',
`XL` varchar(4) COMMENT '学历',
`JH` varchar(6) COMMENT '招生计划数',
`BZ` varchar(200) COMMENT '备注',
`yxbm` char(2) COMMENT '学校编码',
`sxbm` char(2) COMMENT '市县编码'
) ENGINE=InnoDB CHARACTER SET=utf8mb4 COLLATE=utf8mb4_bin ROW_FORMAT=Compact;

创建市县编码表：

CREATE TABLE `sx` (
`sxbm` char(2) COMMENT '市县编码',
`sxmc` varchar(20) COMMENT '市县名称'
) ENGINE=InnoDB CHARACTER SET=utf8mb4 COLLATE=utf8mb4_bin ROW_FORMAT=Compact;

纠结了很久这个东西怎么写，最后采取游标、拼接字符串、字符串聚合，动态SQL，写文件等一些列操作完成需求，创建的存储过程如下：

CREATE DEFINER=`root`@`localhost` PROCEDURE `splitjh`()
BEGIN
declare done INT DEFAULT 0;
declare pyxbm char(2);
declare psxmc varchar(10);
declare pyxmc varchar(50);
declare pjhall int;
declare pjhrows TEXT;
declare yxjh cursor
for
select yxbm,yxmc,sum(jh) jhall from zzjh2019v a,sx b where a.sxbm=b.sxbm group by yxbm,yxmc order by yxbm;
declare CONTINUE HANDLER FOR SQLSTATE '02000' SET done=1;
open yxjh;
fetch yxjh into pyxbm,pyxmc,pjhall;
while done !=1 do
select group_concat(jhrow separator '') into pjhrows from
(select concat('<tr class="subtitle"><td>',yxdh,'</td><td>',yxmc,'在 <span><font color="red">',b.sxmc,'</font></span> 招生计划如下</td><td>',sum(jh),'</td><td></td><td></td></tr>',group_concat('<tr class="jhrow"><td>',zydh,'</td><td>',zymc,'(',bz,')</td><td>',jh,'</td><td>',xz,'</td><td>',xl,'</td></tr>' order by zydh separator '')) jhrow
from zzjh2019v a,sx b where yxbm=pyxbm and a.sxbm=b.sxbm group by yxdh order by yxdh,zydh) jhs;
set @pfilename=concat('''d:/32/1/1/jh11',pyxbm,'.html''');
set @sql=concat('select concat(''<html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><link rel="stylesheet" type="text/css" href="zsjh.css" ><title>3+2计划</title></head><body><h3></h3><table><tr class="subtitle"><th>代号</th><th>专业及名称备注</th><th>人数</th><th>学制</th><th>学历</th></tr>'',''',pjhrows,''',''</body></html>'') from dual into outfile ',@pfilename);
prepare execsql from @sql;
execute execsql;
DEALLOCATE PREPARE execsql;
fetch yxjh into pyxbm,pyxmc,pjhall;
end while;
close yxjh;
END;

首先看效果，执行过程

call splitjh();

在磁盘形成的HTML文件效果如下图（数据有一定的敏感性，进行了遮挡处理）：

文件展示页面

生成的文件列表如下图：

生成的文件列表

这里一共有87所学校，所以生成了87的文件，添加CSS样式文件，让表格呈现如前图所示。

技术点

1）MySQL的游标，以及循环读取游标的方法，涉及的语句如下：

declare yxjh cursor
for
select yxbm,yxmc,sum(jh) jhall from zzjh2019v a,sx b where a.sxbm=b.sxbm group by yxbm,yxmc order by yxbm;#游标定义
declare CONTINUE HANDLER FOR SQLSTATE '02000' SET done=1;#游标循环条件，注意此句一定要定义在游标之后，才起作用
open yxjh;#打开游标
fetch yxjh into pyxbm,pyxmc,pjhall;#将游标行内容赋值给变量。

2）执行动态SQL，由于MySQL into outfile 后接的文件名不能为变量，所以必须使用动态SQL的方法，涉及的语句如下：

prepare execsql from @sql;#从一个变量准备一个动态sql，注意execsql不用提前定义
execute execsql;#执行准备好的语句
DEALLOCATE PREPARE execsql;#销毁语句

综上就是使用MySQL数据库，并借用MySQL写文件的方式将数据从数据库内按照需求导出文件，为何不用navicat导出呢？因为无法达到要求，又是聚合、又是格式，所以只能自己编写过程通过SQL语句拼接字符串的方式来实现。没有太多的技术难度，主要是想法和调试难度。后续在此基础上又开发了以市县为单位创建HTML文件，各招生学校作为分割的过程。本案例是实际需求催生出来的做法，在遇到这样的需求前你是先想到SQL还是先想到开发工具呢？从实际效果看使用SQL这种方式更加灵活。这样的SQL实现的字符串拼接是不是有点极限呢？

言

唠嗑一下。都在说去O或者开源，但是对于数据库选型来说，很多人却存在着误区。例如，去O，狭义上讲，是去Oracle数据库。但是从广义上来说，是去Oracle公司产品或者具有漂亮国垄断地位和需要商业授权的数据库产品。

去O，目前国内有一个现象，就是很多公司或个人听到去O，第一反应是改用Mysql，实际上Mysql也是Oracle公司的。而且Mysql虽然是开源的，但是需要遵循GPL开源协议，这个协议里面(大概意思)含有这么两点就可以窥见一斑：

1、如果用Mysql源码进行二次修改，修改后的产品也必须开源，例如目前国产分布式数据库TiDB就遵循该协议进行开源；

2、如果要对Mysql二次封装或者修改后进行实现商业版本，就必须取得甲骨文公司授权。以上这两条，就足以让Mysql这款开源数据库并不具备“开源优势”，将来该被制裁还是会被制裁。

目前去O，还有一款备选开源数据库是PostgreSQL,它是基于BSD开源协议的，该开源协议是四大开源协议里面最“开放”和自由的，不会受到商业版权化影响，并且组织或个人也可以通过它的源码进行二次封装或者进行发行商业版，例如华为的OpenGuass是基于该开源版本进行二次开发的，并且基于PostgreSQL或者基于OpenGuass进行二次封装成商业版本的数据库(国产、非国产等)也比比皆是。

以上只是吐个槽，本篇文章主要是想通过.NET6+EF CORE + 三大数据库，进行一个在同等环境下的简单的读写性能测试。

【备注】由于各种原因，接下来的测试结果可能会不准确，以下仅供学习或参考使用。

数据库运行环境：Cent OS 7.5

PostgreSQL版本：14

MySQL数据库版本：8.0

Oracle数据库：12C 64位

客户端环境：WIN 10 专业版

运行时环境：.NET 6

ORM：EF CORE

开发语言：C#

CentOS环境安装PostgreSQL

远程服务器上已有授权的Oracle环境和Mysql环境，所以具体安装细节不再进行描述，如果感兴趣的小伙伴也可以自行百度一下Oracle和Mysql的安装教程，应该非常多。由于服务器上暂时还没有PostgreSQL环境，我暂且也把安装PostgreSQL的安装步骤也顺手记录下。

PostgreSQL安装：

下载地址：

https://www.postgresql.org/download/linux/redhat/

选择版本以后，会有对应提示的安装方式命令，就不发出来了，可自行参考。

以下是安装以后的一些配置。

安装完毕，并且启动pgsql服务以后，此处我先创建一个测试用的数据库：testdb

使用命令：su - postgres 可以进行默认的登录，默认无密码。

登陆以后使用命令：psql 可以进入到可执行SQL的命令的页面，以postgres=# 开头。其他命令和有关创建用户的SQL语句如图所示。

修改配置文件： /var/lib/pgsql/14/data/postgresql.conf

将注释的listen_addresses打开，设置值为 ‘*’

路径上的14代表版本，如果是13版本就是13，以此类推，下同。

修改/var/lib/pgsql/14/data/pg_hba.conf配置文件，对IPV4访问新增一行配置如下：

然后要重启pgsql服务，以用于生效。

由于pgsql默认的端口是5432，为了可以跨远程访问，此处把远程服务器上的端口开放出来。命令：firewall-cmd --zone=public --add-port=5432/tcp --permanent

然后重载防火墙，命令：firewall-cmd --reload

测试数据库有关表结构。以下表均没有设置索引，仅单表测试，结果仅供参考。

Mysql表结构:

PostgreSQL表结构：

Oracle表结构:

.NET 6开发测试代码

先创建一个minimal api项目，以及一个服务类库项目。类库引用需要操作Oracle数据库、MySQL数据库以及Postgresql数据库有关的组件。

对服务类设置为启动项，然后新增三个文件夹(MyModel,OraModel和PgModel)，用于分别存放三个数据库的实体类。然后在程序包管理控制台上，通过命令：

Scaffold-DbContext “mysql连接字符串" Pomelo.EntityFrameworkCore.MySql -OutputDir MyModel -Force

自动生成指定的mysql数据库实体类。其中，MyModel是需要生成的目标目录文件夹。

通过命令：

Scaffold-DbContext "Oracle连接字符串" Oracle.EntityFrameworkCore -OutputDir OraModel -Force

自动生成Oracle数据库实体类。

通过命令：

Scaffold-DbContext "pgsql连接字符串" Npgsql.EntityFrameworkCore.PostgreSQL -OutputDir PgModel -Force

自动生成PostgreSQL数据库实体类。

新建一个测试服务类DatabaseTestService，提供简单插入和更新功能：

在minimai api项目里，新增两个简单的测试API用于测试。为了简单，就直接实例化一下进行访问，然后返回执行结果。

以上方法可能执行适合会导致耗时而失败，为了直观一点，改成控制台里面输出。

实现里面也做点调整。

测试插入和更新

运行程序以后，对三个数据库分别插入数据并计时。

先看Oracle物理表情况。

插入总共数据条数：

部分数据结果集：

然后是mysql物理表数据。

插入数据总数：

部分数据结果集：

最后是PostgreSQL。插入总条数：

部分数据结果集：

以下是通过EF CORE进行插入的结果：

接下来进行一轮更新操作，为了防止数据量太大，所以只进行批量更新10000条数据。结果如下：

看下数据更新结果是不是正常。

Oracle数据：

MySQL数据:

PGSQL数据：

数据库数据清空，屏蔽掉C#代码一些实体赋值时间，重新执行两次仅统计批量插入数据库部分的执行的时间进行重新测试，仅测试批量插入耗时结果。

第一回测试结果：

接下来不删除数据，重新执行一轮。

Oracle估计哪儿有问题，数据让人很尴尬啊。接下来只比较MySQL和PgSQL

来一波批量插入：

再来一波三次的批量更新：

有关代码(最后测试使用)：

 public class DatabaseTestService
    {
        public String TestInsert()
        {
            StringBuilder sb=new StringBuilder();
           Console.WriteLine("*************************开始插入测试************************");
            for(int i=1; i < 5; i++)
            {
          //      Console.WriteLine(TestOracleInsert(i));
                Console.WriteLine(TestMysqlInsert(i));
                Console.WriteLine(TestPostgreSQLInsert(i));
            }
            return sb.ToString();
        }
        public String TestUpdate()
        {
            StringBuilder sb=new StringBuilder();
            Console.WriteLine("*************************开始更新测试************************");
            //       Console.WriteLine(TestOracleUpdate());
            for (int i=0;i<3;i++) {
                Console.WriteLine(TestMysqlUpdate(i));
                Console.WriteLine(TestPostgreSQLUpdate(i));
            }
            return sb.ToString();
        }
        private String TestOracleInsert(int loop)
        {
            StringBuilder sb=new();
            Stopwatch stopwatch=new();
            List<OraModel.TestTable> tables=new();

            for (int i=1; i <=50000; i++)
            {
                OraModel.TestTable table=new();
                table.Id=Guid.NewGuid().ToString("N");
                table.Message=$"第{loop}轮测试数据{i}";
                table.CurrentTime=DateTime.Now;
                table.Code=(loop * 5000) + i;
                tables.Add(table);
            }
            using (var context=new OraModel.ModelContext())
            {
                try {

                    stopwatch.Start();
                    context.Database.BeginTransaction();
                    context.TestTables.AddRange(tables);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入50000条到【Oracle】数据库【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch(Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入50000条到【Oracle】数据库【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestMysqlInsert(int loop)
        {
            StringBuilder sb=new();
            Stopwatch stopwatch=new();
            List<MyModel.TestTable> tables=new();
            for (int i=1; i <=100000; i++)
            {
                MyModel.TestTable table=new();
                table.Id=Guid.NewGuid().ToString("N");
                table.Message=$"第{loop}轮测试数据{i}";
                table.CurrentTime=DateTime.Now;
                table.Code=i;
                tables.Add(table);
            }
            using (var context=new MyModel.testdbContext())
            {
                try
                {
                    stopwatch.Start();
                    context.Database.BeginTransaction();
                    context.TestTables.AddRange(tables);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【MySQL】数据库【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【MySQL】数据库【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestPostgreSQLInsert(int loop)
        {
            StringBuilder sb=new();
            Stopwatch stopwatch=new();
            List<PgModel.TestTable> tables=new();

            for (int i=1; i <=100000; i++)
            {
                PgModel.TestTable table=new();
                table.Id=Guid.NewGuid().ToString("N");
                table.Message=$"第{loop}轮测试数据{i}";
                table.CurrentTime=DateTime.Now;
                table.Code=i;
                tables.Add(table);
            }
            using (var context=new PgModel.testdbContext())
            {
                try
                {

                    stopwatch.Start();
                    context.Database.BeginTransaction();
                    context.TestTables.AddRange(tables);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【PostgreSQL】数据库【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮插入100000条到【PostgreSQL】数据库【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestOracleUpdate()
        {
            StringBuilder sb=new();
            Stopwatch stopwatch=new();
           
            using (var context=new OraModel.ModelContext())
            {
                
                var datas=context.TestTables.OrderBy(x=>x.Code).Take(10000);
                context.Database.BeginTransaction();
                foreach (var value in datas)
                {
                    value.Message=$"数据变更,code={value.Code}";
                }
                try
                {
                    stopwatch.Start();
                    context.TestTables.UpdateRange(datas);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【Oracle】数据库10000条【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                    
                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【Oracle】数据库10000条【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestMysqlUpdate(int loop)
        {
            StringBuilder sb=new();
            Stopwatch stopwatch=new();
            using (var context=new MyModel.testdbContext())
            {

                var datas=context.TestTables.OrderBy(x=> x.Code).Skip(loop*50000).Take(50000);
                context.Database.BeginTransaction();
                foreach (var value in datas)
                {
                    value.Message=$"数据变更,code={value.Code}";
                }
                try
                {
                    stopwatch.Start();
                    context.TestTables.UpdateRange(datas);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【MySQL】数据库50000条【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"批量更新【MySQL】数据库50000条【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }
        private String TestPostgreSQLUpdate(int loop)
        {
            StringBuilder sb=new();
            Stopwatch stopwatch=new();
            using (var context=new PgModel.testdbContext())
            {

                var datas=context.TestTables.OrderBy(x=> x.Code).Skip(loop * 50000).Take(50000);
                context.Database.BeginTransaction();
                foreach (var value in datas)
                {
                    value.Message=$"数据变更,code={value.Code}";
                }
                try
                {
                    stopwatch.Start();
                    context.TestTables.UpdateRange(datas);
                    context.SaveChanges();
                    context.Database.CommitTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮 批量更新【PostgreSQL】数据库50000条【成功】:耗时{stopwatch.ElapsedMilliseconds} ms...");

                }
                catch (Exception ex)
                {
                    context.Database.RollbackTransaction();
                    stopwatch.Stop();
                    sb.Append($"第{loop}轮 批量更新【PostgreSQL】数据库50000条【失败】:耗时{stopwatch.ElapsedMilliseconds} ms...");
                }
                finally
                {
                }
            }

            return sb.ToString();
        }



    }

以上测试至此就结束了。结论可能有点尴尬，也许跟环境配置有关，也可能跟ef core操作数据库的支持与实现有关。并且当前仅在单表环境下测试，并没有通过多表测试、存过测试、压力测试等，结果仅供娱乐和参考。同时欢迎各位大佬们提供更多测试内容，也欢迎各位大佬转发或评论或点赞等一键三连。

本文原链接：https://www.cnblogs.com/weskynet/p/16097151.html

在线咨询

上一篇：Event 对象之事件句柄　(Event Handl
下一篇：CSS的样式冲突，一个细节的知识点，回答了程序员们多

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

ASP.NET Core MVC+Layui使用EF

前言：

示例实现功能预览：

博客实例源码下载地址：

一、创建ASP.NET Core Web应用程序：

二、添加EF Core NuGet包：

安装方式：

点击工具=>NuGet包管理器=>程序包管理器控制台输入以下命令：

点击工具=>NuGet包管理器=>管理解决方案的NuGet程序包：

三、创建对应数据库表的实体模型：

创建用户模型（UserInfo）:

四、将数据库连接字符串添加到 appsettings.json：

五、创建数据库上下文：

概述：

创建：

六、将上下文添加到 Startup.cs 中的依赖项注入：

七：引入Layui样式和js：

将相关文件存放到wwwroot文件下：

将相关文件引入默认布局页面中：

八、 ASP.NET Core MVC 和 EF Core实现MySQL CRUD功能:

Create：

Retrieve：

Update：

Delete：

创建计划表：

创建市县编码表：

您的项目需求