CentOS系统中常用查看系统信息和日志命令小结

进程 # ps -ef # 查看所有进程 # top # 实时显示进程状态(另一篇文章里面有详细的介绍) 用户： # w # 查看活动用户 # id <用户名> # 查看指定用户信息 # last # 查看用户登录日志 # cut -d: -f1 /etc/passwd # 查看系统所有用户 # cut -d: -f1 /etc/group # 查看系统所有组 # crontab -l # 查看当前用户的计划任务 系统 日志文件（ 可以通过cat 或tail 命令来查看） /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信息 /var/log/cron 与定时任务相关的日志信息 /var/log/spooler 与UUCP和news设备相关的日志信息 /var/log/boot.log 守护进程启动和停止相关的日志消息 系统信息 # uname -a # 查看内核/操作系统/CPU信息 # cat /etc/issue # cat /etc/redhat-release # 查看操作系统版本 # cat /proc/cpuinfo # 查看CPU信息 # hostname # 查看计算机名 # lspci -tv # 列出所有PCI设备 # lsusb […]

龙生   01 Apr 2018
View Details

查看Linux系统版本信息

一、查看Linux内核版本命令（两种方法）： 1、cat /proc/version [root@S-CentOS home]# cat /proc/version Linux version 2.6.32-431.el6.x86_64 (mockbuild@c6b8.bsys.dev.centos.org) (gcc version 4.4.7 20120313 (Red Hat 4.4.7-4) (GCC) ) #1 SMP Fri Nov 22 03:15:09 UTC 2013 2、uname -a [root@S-CentOS home]# uname -a Linux S-CentOS 2.6.32-431.el6.x86_64 #1 SMP Fri Nov 22 03:15:09 UTC 2013 x86_64 x86_64 x86_64 GNU/Linux 二、查看Linux系统版本的命令（3种方法）： 1、lsb_release -a，即可列出所有版本信息： [root@S-CentOS ~]# lsb_release -a LSB Version: :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noarch Distributor ID: CentOS Description: CentOS release 6.5 (Final) Release: 6.5 Codename: Final 这个命令适用于所有的Linux发行版，包括RedHat、SUSE、Debian…等发行版。 2、cat /etc/redhat-release，这种方法只适合Redhat系的Linux： [root@S-CentOS home]# cat /etc/redhat-release CentOS release 6.5 (Final) 3、cat /etc/issue，此命令也适用于所有的Linux发行版。 [root@S-CentOS home]# cat /etc/issue CentOS release […]

龙生   01 Apr 2018
View Details

Laravel 5.4: 特殊字段太长报错

laravel 5.4 改变了默认的数据库字符集，现在utf8mb4包括存储emojis支持。如果你运行MySQL v5.7.7或者更高版本，则不需要做任何事情。 当你试着在一些MariaDB或者一些老版本的的MySQL上运行 migrations 命令时，你可能会碰到下面这个错误：

1
2
3
4
5
[Illuminate\Database\QueryException]
SQLSTATE[42000]: Syntax error or access violation: 1071 Specified key was too long; max key length is 767 bytes (SQL: alter table users add unique users_email_unique(email))
 
[PDOException]
SQLSTATE[42000]: Syntax error or access violation: 1071 Specified key was too long; max key length is 767 bytes

我们可以在 AppServiceProvider.php 文件里的 boot 方法里设置一个默认值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?php
 
namespace App\Providers;
 
use Illuminate\Support\ServiceProvider;
use Illuminate\Support\Facades\Schema;
 
class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        Schema::defaultStringLength(191);
    }
 
    /**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}

  from:https://www.cnblogs.com/betx/p/6544090.html

龙生   30 Mar 2018
View Details

GIT创建与合并分支

在版本回退里，你已经知道，每次提交，Git都把它们串成一条时间线，这条时间线就是一个分支。截止到目前，只有一条时间线，在Git里，这个分支叫主分支，即master分支。HEAD严格来说不是指向提交，而是指向master，master才是指向提交的，所以，HEAD指向的就是当前分支。 一开始的时候，master分支是一条线，Git用master指向最新的提交，再用HEAD指向master，就能确定当前分支，以及当前分支的提交点： 每次提交，master分支都会向前移动一步，这样，随着你不断提交，master分支的线也越来越长。 当我们创建新的分支，例如dev时，Git新建了一个指针叫dev，指向master相同的提交，再把HEAD指向dev，就表示当前分支在dev上： 你看，Git创建一个分支很快，因为除了增加一个dev指针，改改HEAD的指向，工作区的文件都没有任何变化！ 不过，从现在开始，对工作区的修改和提交就是针对dev分支了，比如新提交一次后，dev指针往前移动一步，而master指针不变： 假如我们在dev上的工作完成了，就可以把dev合并到master上。Git怎么合并呢？最简单的方法，就是直接把master指向dev的当前提交，就完成了合并： 所以Git合并分支也很快！就改改指针，工作区内容也不变！ 合并完分支后，甚至可以删除dev分支。删除dev分支就是把dev指针给删掉，删掉后，我们就剩下了一条master分支： 真是太神奇了，你看得出来有些提交是通过分支完成的吗？ 下面开始实战。 首先，我们创建dev分支，然后切换到dev分支：

1
2
$ git checkout -b dev
Switched to a new branch 'dev'

  git checkout命令加上-b参数表示创建并切换，相当于以下两条命令：

1
2
3
$ git branch dev
$ git checkout dev
Switched to branch 'dev'

  然后，用git branch命令查看当前分支：

1
2
3
$ git branch
* dev
  master

  git branch命令会列出所有分支，当前分支前面会标一个*号。 然后，我们就可以在dev分支上正常提交，比如对readme.txt做个修改，加上一行：

1
Creating a new branch is quick.

  然后提交：

1
2
3
4
$ git add readme.txt
$ git commit -m "branch test"
[dev fec145a] branch test
1 file changed, 1 insertion(+)

  现在，dev分支的工作完成，我们就可以切换回master分支：

1
2
$ git checkout master
Switched to branch 'master'

  切换回master分支后，再查看一个readme.txt文件，刚才添加的内容不见了！因为那个提交是在dev分支上，而master分支此刻的提交点并没有变： 现在，我们把dev分支的工作成果合并到master分支上：

1
2
3
4
5
$ git merge dev
Updating d17efd8..fec145a
Fast-forward
readme.txt |    1 +
1 file changed, 1 insertion(+)

  git merge命令用于合并指定分支到当前分支。合并后，再查看readme.txt的内容，就可以看到，和dev分支的最新提交是完全一样的。 注意到上面的Fast-forward信息，Git告诉我们，这次合并是“快进模式”，也就是直接把master指向dev的当前提交，所以合并速度非常快。 当然，也不是每次合并都能Fast-forward，我们后面会讲其他方式的合并。 合并完成后，就可以放心地删除dev分支了：

1
2
$ git branch -d dev
Deleted branch dev (was fec145a).

  删除后，查看branch，就只剩下master分支了：

1
2
$ git branch
* master

  因为创建、合并和删除分支非常快，所以Git鼓励你使用分支完成某个任务，合并后再删掉分支，这和直接在master分支上工作效果是一样的，但过程更安全。 小结 Git鼓励大量使用分支： 查看分支：git branch 创建分支：git branch <name> 切换分支：git checkout <name> 创建+切换分支：git checkout -b <name> 合并某分支到当前分支：git merge <name> 删除分支：git branch -d <name>   from:https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/001375840038939c291467cc7c747b1810aab2fb8863508000

龙生   28 Mar 2018
View Details

git常用命令

$ git add . 添加所有文件 注意有个 . $ git commit -m '注释' 提交本地 $ git push origin master提交给默认分支 $ git -rm 删除 $ git pull origin master 从默认分支下载 $ git branch -v 查看所有分支 $ git log --pretty=oneline 查看版本日志 $ git reset --hard HEAD^/HEAD^^/HEAD~100/2287b773d655 恢复指定的版本 $ git reflog 显示所有执行过的命令行 ——————————————————————————————-- 查看分支：git branch 创建分支：git branch <name> 切换分支：git checkout <name> 创建+切换分支：git checkout -b <name> 合并某分支到当前分支：git merge <name> 删除分支：git branch -d <name>

龙生   28 Mar 2018
View Details

SVN建立分支和合并代码

1.SVN建立分支 正确SVN服务器上会有两个目录：trunk和branches。trunk目录下面代码就是所谓的主版本，而branches文件夹主要是用来放置分支版本。分支版本是依赖于主版本的，因此建立分支版本时候，必须要在trunk文件夹操作才可以的。下面是推荐的操作步骤： （1）从SVN上checkout Trunk版本下来。如果在本地机器上已有了trunk版本，需要更新一下到最新代码。 （2）在本地抓下来的trunk版本的文件上，点击右键，弹出菜单，选中如下菜单项。 弹出如下对话框，按在下面的要求，填写好配置。 点击OK按钮，SVN就会建立好对应的分支版本。 2.从SVN抓取分支代码 （1）在本地机，建立新目录，从SVN分支版本路径上，抓取分支版本上的代码 （2）在F:\branchesh_v20160726中可以对代码进行正常地更新和提交操作。 2.1删除不想要的分支版本 （1）在本地机的SVN目录，右键，选择TortoiseSVN/Repo-broswer，进入版本库浏览(Repo-browser)，在右侧树状窗口中的branches下，选择你要删除的分支版本，右键弹出菜单，点击“删除”即可。分支就能从代码库中删除。 3.从分支版本合并代码到trunk主版本中去 如果在分支版本新功能开发完成，需要将分支上的修改合并到主版本中，按下面步骤操作： （1）在合并代码之前，我们首先要更新分支代码,以防止别人提交了代码而你没有及时更新。造成别人的代码丢失。 （2）接下来我们要做的是将要有修改的代码提交。以保证其他人员的代码为最新状态。 （3）我们在分支代码合并到主干之前，先将主干代码更新一下。以保证别的人员合并之后的代码能及时更新到你本地。步骤同步骤（1）。 （4）主干代码更新完成之后，接下来我们打开分支代码的日志 （5）找到你要合并到主干的代码日志。然后右键打开菜单，选择Merge revision to  ，然后选择你的主干目录确定即可 from:https://blog.csdn.net/luofeixiongsix/article/details/52052631

龙生   28 Mar 2018
View Details

GIT版本回退

现在，你已经学会了修改文件，然后把修改提交到Git版本库，现在，再练习一次，修改readme.txt文件如下：

1
2
Git is a distributed version control system.
Git is free software distributed under the GPL.

  然后尝试提交：

1
2
3
4
$ git add readme.txt
$ git commit -m "append GPL"
[master 3628164] append GPL
1 file changed, 1 insertion(+), 1 deletion(-)

  像这样，你不断对文件进行修改，然后不断提交修改到版本库里，就好比玩RPG游戏时，每通过一关就会自动把游戏状态存盘，如果某一关没过去，你还可以选择读取前一关的状态。有些时候，在打Boss之前，你会手动存盘，以便万一打Boss失败了，可以从最近的地方重新开始。Git也是一样，每当你觉得文件修改到一定程度的时候，就可以“保存一个快照”，这个快照在Git中被称为commit。一旦你把文件改乱了，或者误删了文件，还可以从最近的一个commit恢复，然后继续工作，而不是把几个月的工作成果全部丢失。 现在，我们回顾一下readme.txt文件一共有几个版本被提交到Git仓库里了： 版本1：wrote a readme file

1
2
Git is a version control system.
Git is free software.

  版本2：add distributed

1
2
Git is a distributed version control system.
Git is free software.

  版本3：append GPL

1
2
Git is a distributed version control system.
Git is free software distributed under the GPL.

  当然了，在实际工作中，我们脑子里怎么可能记得一个几千行的文件每次都改了什么内容，不然要版本控制系统干什么。版本控制系统肯定有某个命令可以告诉我们历史记录，在Git中，我们用git log命令查看：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
$ git log
commit 3628164fb26d48395383f8f31179f24e0882e1e0
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Tue Aug 20 15:11:49 2013 +0800
 
    append GPL
 
commit ea34578d5496d7dd233c827ed32a8cd576c5ee85
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Tue Aug 20 14:53:12 2013 +0800
 
    add distributed
 
commit cb926e7ea50ad11b8f9e909c05226233bf755030
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Mon Aug 19 17:51:55 2013 +0800
 
    wrote a readme file

  git log命令显示从最近到最远的提交日志，我们可以看到3次提交，最近的一次是append GPL，上一次是add distributed，最早的一次是wrote a readme file。 如果嫌输出信息太多，看得眼花缭乱的，可以试试加上--pretty=oneline参数：

1
2
3
4
$ git log --pretty=oneline
3628164fb26d48395383f8f31179f24e0882e1e0 append GPL
ea34578d5496d7dd233c827ed32a8cd576c5ee85 add distributed
cb926e7ea50ad11b8f9e909c05226233bf755030 wrote a readme file

  需要友情提示的是，你看到的一大串类似3628164…882e1e0的是commit id（版本号），和SVN不一样，Git的commit id不是1，2，3……递增的数字，而是一个SHA1计算出来的一个非常大的数字，用十六进制表示，而且你看到的commit id和我的肯定不一样，以你自己的为准。为什么commit id需要用这么一大串数字表示呢？因为Git是分布式的版本控制系统，后面我们还要研究多人在同一个版本库里工作，如果大家都用1，2，3……作为版本号，那肯定就冲突了。 每提交一个新版本，实际上Git就会把它们自动串成一条时间线。如果使用可视化工具查看Git历史，就可以更清楚地看到提交历史的时间线： 好了，现在我们启动时光穿梭机，准备把readme.txt回退到上一个版本，也就是“add distributed”的那个版本，怎么做呢？ 首先，Git必须知道当前版本是哪个版本，在Git中，用HEAD表示当前版本，也就是最新的提交3628164…882e1e0（注意我的提交ID和你的肯定不一样），上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100。 现在，我们要把当前版本“append GPL”回退到上一个版本“add distributed”，就可以使用git reset命令：

1
2
$ git reset --hard HEAD^
HEAD is now at ea34578 add distributed

  --hard参数有啥意义？这个后面再讲，现在你先放心使用。 看看readme.txt的内容是不是版本add distributed：

1
2
3
$ cat readme.txt
Git is a distributed version control system.
Git is free software.

  果然。 还可以继续回退到上一个版本wrote a readme file，不过且慢，然我们用git log再看看现在版本库的状态：

1
2
3
4
5
6
7
8
9
10
11
12
$ git log
commit ea34578d5496d7dd233c827ed32a8cd576c5ee85
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Tue Aug 20 14:53:12 2013 +0800
 
    add distributed
 
commit cb926e7ea50ad11b8f9e909c05226233bf755030
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Mon Aug 19 17:51:55 2013 +0800
 
    wrote a readme file

  最新的那个版本append GPL已经看不到了！好比你从21世纪坐时光穿梭机来到了19世纪，想再回去已经回不去了，肿么办？ 办法其实还是有的，只要上面的命令行窗口还没有被关掉，你就可以顺着往上找啊找啊，找到那个append GPL的commit id是3628164…，于是就可以指定回到未来的某个版本：

1
2
$ git reset --hard 3628164
HEAD is now at 3628164 append GPL

  版本号没必要写全，前几位就可以了，Git会自动去找。当然也不能只写前一两位，因为Git可能会找到多个版本号，就无法确定是哪一个了。 再小心翼翼地看看readme.txt的内容：

1
2
3
$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.

  果然，我胡汉三又回来了。 Git的版本回退速度非常快，因为Git在内部有个指向当前版本的HEAD指针，当你回退版本的时候，Git仅仅是把HEAD从指向append GPL： 改为指向add distributed： 然后顺便把工作区的文件更新了。所以你让HEAD指向哪个版本号，你就把当前版本定位在哪。 现在，你回退到了某个版本，关掉了电脑，第二天早上就后悔了，想恢复到新版本怎么办？找不到新版本的commit id怎么办？ 在Git中，总是有后悔药可以吃的。当你用$ git reset --hard HEAD^回退到add […]

龙生   28 Mar 2018
View Details

Dapper功能讲解

简述 适用特性 使用Dapper流程 代码示例 简述 Dapper是一个轻量级的ORM工具:ORM框架的核心思想是对象关系映射，ORM是将表与表之间的操作，映射成对象和对象之间的操作，就是通过操作实体类来达到操作表的目的。从数据库提取的数据会自动按你设置的映射要求封装成特定的对象。之后你就可以通过对对象进行操作来修改数据库中的数据。这时候你面对的不是信息的碎片，而是一个形象鲜明的对象。 ORM 框架很多: Dapper、 Mybatis.Net、EntityFramework 和 NHibernate。如果你在小的项目中，使用Entity Framework、NHibernate 来处理大数据访问及关系映射，未免有点杀鸡用牛刀。而Mybatis.Net需要配置XML文件，综合考虑你会觉得觉得ORM省时省力。 适用特性 1、Dapper是一个轻型的ORM类。代码就一个SqlMapper.cs文件，编译后就70K。 2、Dapper很快。Dapper的速度接近与IDataReader，取列表的数据超过了DataTable。 3、Dapper支持多数据库。Dapper支持Mysql,SqlLite,SqlServer,Oracle等一系列的数据库。 4、Dapper支持多表并联的对象。支持一对多 多对多的关系。并且没侵入性，想用就用，不想用就不用。无XML无属性。代码以前怎么写现在还怎么写。 5、Dapper原理通过Emit反射IDataReader的序列队列，来快速的得到和产生对象。性能很高(性能和原生ado.net相近)。 6、Dapper支持net2.0,3.0,3.5,4.0。【如果想在Net2.0下使用，可以去网上找一下Net2.0下如何配置运行Net3.5即可。】 7、Dapper语法十分简单,快捷添加到项目，容易上手。并且无须迁就数据库的设计。 适用Dapper流程 流程一： 通过NuGet程序包进行Dapper安装引用： 这个引用的Dapper DLL文件是对前面说的SqlMapper.cs 源文件的封装。 流程二： 我们这里用Mysql数据库，那么用到的MySql.Data.dll在官网下载.net驱动包（已经附加在此教程demo中） mysql .net连接驱动下载地址：http://dev.mysql.com/downloads/connector/net/ 示例代码 1、定义一个Person类对应数据库的Person表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
CREATE TABLE person (
idint(11) NOT NULL AUTO_INCREMENT,
usernamevarchar(255) NOT NULL,
passwordvarchar(20) NOT NULL,
ageint(11) DEFAULT NULL,
registerDatedatetime DEFAULT NULL,
addressvarchar(255) DEFAULT NULL,
  PRIMARY KEY (id)
);
//Person类
publicclassPerson
{
publicint id { get; set; }
publicstring username { get; set; }
publicstring password { get; set; }
publicint age { get; set; }
publicDateTimeregisterDate { get; set; }
publicstring address { set; get; }
}

  2、定义连接数据库字符串

1
2
3
4
public static string ConnString = "server=localhost;port=3306;user id=root;password=123456;database=test";  
 
//SQL Server
public static string ConnString = "server=localhost;user id=sa;password=123456;database=Dormitory";

  3、 新增、修改、删除的 Execute 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static int Execute(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null);
 
//新增
var conn = MySqlDBHelper.CreateMySqlConnection();
           try
            {
                var result = conn.Execute("Insert into Person(username,password,age,registerDate,address) values (@username,@password,@age,@registerDate,@address)",
                                  new { username = txtUserName.Text, password = txtPassword.Text, age = numAge.Value, registerDate = dptRegisterDate.Value, address = txtAddress.Text });
                if (result > 0)
                {
                    MessageBox.Show("添加成功！");
                    LoadDBInfoToDgvFirst();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conn.State == System.Data.ConnectionState.Open)
                {
                    conn.Close();
                }
            }

批量新增 和新增一条语句是一样的，后面的param 是object 对象,单个模型数据和集合都可以支持。执行上面方法会插入多条记录，这样sql可以灵活的控制，参数不用像ADO.Net那样声明每个参数，最后还要把参数集合赋值给ADO的命令。可以看出这样简洁多了。 4、 查询的Query 方法

1
2
3
public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null, bool buffered = true, int? commandTimeout = null, CommandType? commandType = null);
实际运用：
  var result = conn.Query<Person>("select * from Person order by id desc limit @indx", new { indx = num });

  5、存储过程调用

1
2
3
4
5
6
7
8
var param = new DynamicParameters();
                param.Add("@idIn", numUpdateId.Value, DbType.Int32, ParameterDirection.Input);
                param.Add("@Inusername", txtUserName.Text, DbType.String, ParameterDirection.Input);
                param.Add("@res", 0, DbType.Int32, ParameterDirection.Output);
 
                var res2 = conn.Execute("prUpdatePersion", param, null, null, CommandType.StoredProcedure);
 
                int res = param.Get<Int32>("@res");

  6、多个数据库插入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
private void button4_Click(object sender, EventArgs e)
        {
            MySqlConnection mySqlConn = MySqlDBHelper.CreateMySqlConnection();
            MySqlTransaction tranMySql = mySqlConn.BeginTransaction();
 
            SqlConnection SqlServerConn = SqlServerDBHelper.CreateSqlServerConnection();
            SqlTransaction tranSqlServer = SqlServerConn.BeginTransaction();
 
            try
            {
                var persion = new Person { username = txtUserName.Text, password = txtPassword.Text, age = numAge.Value, registerDate = dptRegisterDate.Value, address = txtAddress.Text };
                int result = mySqlConn.Execute("Insert into Person(username,password,age,registerDate,address) values (@username,@password,@age,@registerDate,@address)",
                                  persion, tranMySql);
 
                persion.username += "Sqlserver";
                result = SqlServerConn.Execute("Insert into Person(username,password,age,registerDate,address) values (@username,@password,@age,@registerDate,@address)",
                                  persion, tranSqlServer);
 
                MessageBox.Show("添加成功！");
                tranMySql.Commit();
                tranSqlServer.Commit();
            }
            catch (Exception ex)
            {
                tranMySql.Rollback();
                tranSqlServer.Rollback();
                throw ex;
            }
            finally
            {
                if (mySqlConn.State == System.Data.ConnectionState.Open)
                {
                    mySqlConn.Close();
                }
                if (SqlServerConn.State == System.Data.ConnectionState.Open)
                {
                    SqlServerConn.Close();
                }
                tranSqlServer.Dispose();
                tranMySql.Dispose();
            }
            tabControl.SelectedTab = tabPage2;
            //加载信息
            LoadDBInfoToDoubleDgvFirst();
        }

通过上面的代码演示主要常用的是：封装后 Query 方法、Excute 方法。（其底层的封装的方法可以见源码：513 from:https://blog.csdn.net/laokang426/article/details/77885137

龙生   27 Mar 2018
View Details

Dapper 基本使用

项目右键 Manage NuGet Packages for Solution 搜索Dapper -> Install

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
 
namespace Dapper.Repository
{
    public class DapperDemo
    {
        public static string ConnectionString
        {
            get
            {
                string _connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString();
                return _connectionString;
            }
        }
 
        public SqlConnection OpenConnection()
        {
            SqlConnection connection = new SqlConnection(ConnectionString);
            connection.Open();
            return connection;
        }
 
        /// <summary>
        /// 添加
        /// </summary>
        /// <returns></returns>
        public bool Add()
        {
            int row = 0;
            ED_Data model = new ED_Data();
            model.TableName = "123";
            model.DataKey = "123";
            model.FieldName = "123";
            model.Value = "123";
            model.Reference = "123";
            model.Branch = 1;
            model.InActive = false;
            model.Updated = DateTime.Now;
 
            string query = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)";
            using (IDbConnection conn = OpenConnection())
            {
                row = conn.Execute(query, model);
            }
            if (row > 0)
                return true;
            else
                return false;
        }
 
        /// <summary>
        /// 修改
        /// </summary>
        /// <returns></returns>
        public int Update()
        {
            int row = 0;
            ED_Data model = new ED_Data();
            model.TableName = "123";
            model.DataKey = "123";
            model.Updated = DateTime.Now;
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "UPDATE ED_Data SET DataKey=@DataKey,Updated=@Updated WHERE TableName=@TableName";
                row = conn.Execute(query, model);
            }
            return row;
        }
 
        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public int Delete()
        {
            int row = 0;
            ED_Data model = new ED_Data();
            model.TableName = "123";
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "DELETE FROM ED_Data WHERE TableName=@TableName";
                row = conn.Execute(query, model);
            }
            return row;
        }
 
        /// <summary>
        /// 查询一条数据
        /// </summary>
        /// <param name="columnCatId"></param>
        /// <returns>ED_Data</returns>
        public ED_Data GetModel(string TableName)
        {
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "SELECT * FROM ED_Data WHERE TableName = @TableName";
                return conn.Query<ED_Data>(query, new { tableName = TableName }).SingleOrDefault<ED_Data>();
            }
        }
 
        /// <summary>
        /// 查询list集合
        /// </summary>
        /// <returns>List</returns>
        public List<ED_Data> GetED_DataList()
        {
            using (IDbConnection conn = OpenConnection())
            {
                const string query = "SELECT * FROM ED_Data";
                return conn.Query<ED_Data>(query, null).ToList();
            }
        }
 
        /// <summary>
        /// 事务处理
        /// 删除
        /// </summary>
        /// <param name="cat"></param>
        /// <returns></returns>
        public int DeleteColumnCatAndColumn(ED_Data cat)
        {
            try
            {
                using (IDbConnection conn = OpenConnection())
                {
                    string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName";
                    string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName";
 
                    IDbTransaction transaction = conn.BeginTransaction();
                    int row = conn.Execute(delete1, new { TableName = cat.TableName }, transaction, null, null);
                    row += conn.Execute(delete2, new { TableName = cat.TableName }, transaction, null, null);
                    transaction.Commit();
                    return row;
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
        
        /// <summary>
        /// 执行存储过程
        /// </summary>
        public void ExecuteStoredProcedure()
        {
            try
            {
                DynamicParameters para = new DynamicParameters();
                para.Add("@param1", 1);
                para.Add("@param2", 2);
 
                using (IDbConnection conn = OpenConnection())
                {
                    int row = conn.Execute("存储过程名称", para, null, null, CommandType.StoredProcedure);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
 
        /// <summary>
        /// 批量添加
        /// </summary>
        public void InsertBatch()
        {
            try
            {
                string sqlStr = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)";
                using (IDbConnection conn = OpenConnection())
                {
                    conn.Execute(sqlStr, new[]
                    {
                        new { TableName = "user1", DataKey = "a", FieldName = "name", Value = "000001", Reference = "", Branch = "", InActive = "", Updated = DateTime.Now },
                        new { TableName = "user2", DataKey = "b", FieldName = "age", Value = "000002", Reference = "", Branch= "", InActive = "", Updated = DateTime.Now },
                        new { TableName = "user3", DataKey = "c", FieldName = "phone", Value = "000003", Reference= "", Branch= "", InActive= "", Updated= DateTime.Now },
                    }, null, null, null);
                }
            }
            catch (Exception)
            {
                throw;
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
 
namespace Dapper.Repository
{
    public class ED_Data
    {
        public string TableName { get; set; }
 
        public string DataKey { get; set; }
 
        public string FieldName { get; set; }
 
        public string Value { get; set; }
 
        public string Reference { get; set; }
 
        public int Branch { get; set; }
 
        public bool InActive { get; set; }
 
        public DateTime Updated { get; set; }
    }
}

Base基类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
using Dapper.CoreLibrary;
using Dapper.Entity;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Transactions;
 
namespace Dapper.Repository
{
    public abstract class RepositoryBase<T> : DbConnectionFactory, IRepositoryBase<T> where T : IEntityBase<T>
    {
        public RepositoryBase(IDbConnection db)
            : base(db)
        { }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public virtual int Add(T model)
        {
            int result = 0;
            try
            {
                var ps = model.GetType().GetProperties();
                List<string> @colms = new List<string>();
                List<string> @params = new List<string>();
                foreach (var p in ps)
                {
                    if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                    {
                        @colms.Add(string.Format("[{0}]", p.Name));
                        @params.Add(string.Format("@{0}", p.Name));
                    }
                }
                var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                result = _conn.ExecuteScalar<int>(sql, model);
            }
            catch (Exception ex)
            {
                throw;
            }
            return result;
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="listModel"></param>
        public virtual void Add(List<T> listModel)
        {
            try
            {
                using (var scope = new TransactionScope())
                {
                    listModel.ForEach(model =>
                    {
                        var ps = model.GetType().GetProperties();
                        List<string> @colms = new List<string>();
                        List<string> @params = new List<string>();
                        foreach (var p in ps)
                        {
                            if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                            {
                                @colms.Add(string.Format("[{0}]", p.Name));
                                @params.Add(string.Format("@{0}", p.Name));
                            }
                        }
                        var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                        _conn.ExecuteScalar<int>(sql, model);
                    });
                    scope.Complete();
                }
            }
            catch (Exception ex)
            {
            }
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public virtual int AddWithGuid(T model)
        {
            int result = 0;
            try
            {
                var ps = model.GetType().GetProperties();
                List<string> @colms = new List<string>();
                List<string> @params = new List<string>();
                foreach (var p in ps)
                {
                    if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                    {
                        @colms.Add(string.Format("[{0}]", p.Name));
                        @params.Add(string.Format("@{0}", p.Name));
                    }
                }
                var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2});", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                result = _conn.Execute(sql, model);
            }
            catch (Exception ex)
            {
                throw;
            }
            return result;
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="model"></param>
        public virtual void Update(T model)
        {
            PropertyInfo pkInfo = null;
            var ps = model.GetType().GetProperties();
            List<string> @params = new List<string>();
            foreach (var p in ps)
            {
                if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                {
                    continue;
                }
                if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)))
                {
                    pkInfo = p;
                }
                else
                {
                    @params.Add(string.Format("[{0}]=@{0}", p.Name));
                }
            }
            var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name);
            _conn.Execute(sql, model);
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="listModel"></param>
        public virtual void Update(List<T> listModel)
        {
            using (var scope = new TransactionScope())
            {
                listModel.ForEach(model =>
                {
                    PropertyInfo pkInfo = null;
                    var ps = model.GetType().GetProperties();
                    List<string> @params = new List<string>();
                    foreach (var p in ps)
                    {
                        if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                        {
                            continue;
                        }
                        if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)))
                        {
                            pkInfo = p;
                        }
                        else
                        {
                            @params.Add(string.Format("[{0}] = @{0}", p.Name));
                        }
                    }
                    var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name);
                    _conn.Execute(sql, model);
                });
                scope.Complete();
            }
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="primaryValue">主键ID</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public virtual T GetModel(string primaryValue, string tableName = "")
        {
            try
            {
                string primaryWhere = string.Empty;
                var ps = typeof(T).GetProperties();
                if (string.IsNullOrEmpty(tableName))
                {
                    tableName = typeof(T).Name;
                }
                var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null);
 
                primaryWhere = (string.Format("[{0}] = @primarykey", primary.Name));
 
                var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, primaryWhere);
 
                return _conn.Query<T>(sql, new { primarykey = primaryValue }).FirstOrDefault();
            }
            catch (Exception)
            {
 
                throw;
            }
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="strWhere">where条件</param>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public virtual T GetModelQuery(string strWhere, string tableName = "")
        {
            try
            {
                var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, strWhere);
                return _conn.Query<T>(sql, new { where = strWhere }).FirstOrDefault();
            }
            catch (Exception)
            {
                throw;
            }
        }
 
        /// <summary>
        /// 根据主键删除
        /// </summary>
        /// <param name="primaryValue"></param>
        public virtual void Delete(string primaryValue)
        {
            try
            {
                string primaryWhere = string.Empty;
                var ps = typeof(T).GetProperties();
                var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null);
                var sql = string.Format("DELETE FROM [{0}] WHERE {1} = @primarykey", typeof(T).Name, primary.Name);
                _conn.Execute(sql, new { primarykey = primaryValue });
            }
            catch (Exception)
            {
                throw;
            }
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="strWhere"></param>
        public void DeleteStrWhere(string strWhere)
        {
            try
            {
                var sql = string.Format("DELETE FROM [{0}] WHERE {1}", typeof(T).Name, strWhere);
                _conn.Execute(sql);
            }
            catch (Exception)
            {
                throw;
            }
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="strWhere"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public virtual List<T> GetList(string strWhere, string tableName = "")
        {
            try
            {
                if (string.IsNullOrEmpty(tableName))
                    tableName = typeof(T).Name;
                var sql = string.Format("SELECT * FROM [{0}] " + (strWhere == "" ? "" : " WHERE " + " {1} "), tableName, strWhere);
                return _conn.Query<T>(sql).ToList();
            }
            catch (Exception)
            {
                throw;
            }
        }
 
        /// <summary>
        ///
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        public virtual PagerListResult<List<T>> GetPageList(PagerRequestParam param)
        {
            PagerListResult<List<T>> result = null;
            List<T> list = new List<T>();
            int pageTotal = 1;
            int recordTotal = 0;
            int startIndex = 1;
            int endIndex = param.PageSize;
            try
            {
                if (param.PageIndex - 1 > 0)
                {
                    startIndex = (param.PageIndex - 1 <= 0 ? 1 : param.PageIndex - 1) * param.PageSize + 1;
                    endIndex = param.PageIndex * param.PageSize;
                }
 
                if (string.IsNullOrEmpty(param.TableName))
                    param.TableName = typeof(T).Name;
                StringBuilder strSql = new StringBuilder();
                strSql.Append("SELECT * FROM ( ");
                strSql.Append(" SELECT ROW_NUMBER() OVER (");
                if (!string.IsNullOrEmpty(param.OrderBy))
                {
                    strSql.Append("ORDER BY T." + param.OrderBy);
                }
                else
                {
                    strSql.Append("ORDER BY T.ID DESC");
                }
                strSql.Append(")AS Row, T.*  FROM " + param.TableName + " T ");
                if (!string.IsNullOrEmpty(param.StrWhere))
                {
                    strSql.Append(" WHERE " + param.StrWhere);
                }
                strSql.Append(" ) TT");
                strSql.AppendFormat(" WHERE TT.Row BETWEEN {0} AND {1}", startIndex, endIndex);
 
                list = _conn.Query<T>(strSql.ToString(), param.StrWhere).ToList();
                if (list.Count > 0)
                {
                    recordTotal = this.GetRecordCount(param.StrWhere, param.TableName);
                    pageTotal = PagerRequestParam.Tool.PageTotal(param);
                }
                result = new PagerListResult<List<T>>(list, pageTotal, recordTotal);
            }
            catch (Exception ex)
            {
                result = new PagerListResult<List<T>>(ex);
            }
            return result;
        }
 
        /// <summary>
        /// 事务处理
        /// Demo
        /// </summary>
        /// <returns></returns>
        public int DeleteTransaction()
        {
            try
            {
                const string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName";
                const string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName";
 
                IDbTransaction transaction = _conn.BeginTransaction();
                int row = _conn.Execute(delete1, new { TableName = "user" }, transaction, null, null);
                row += _conn.Execute(delete2, new { TableName = "customer" }, transaction, null, null);
                transaction.Commit();
                return row;
            }
            catch (Exception)
            {
                throw;
            }
        }
 
        /// <summary>
        /// 获取记录数
        /// </summary>
        /// <param name="strWhere">Where条件</param>
        /// <returns></returns>
        public virtual int GetRecordCount(string strWhere, string tableName = "")
        {
            int count = 0;
            try
            {
                if (string.IsNullOrEmpty(tableName))
                    tableName = typeof(T).Name;
                StringBuilder strSql = new StringBuilder();
                strSql.Append("SELECT COUNT(1) FROM " + tableName);
                if (!string.IsNullOrEmpty(strWhere))
                {
                    strSql.Append(" WHERE " + strWhere);
                }
                count = _conn.ExecuteScalar<int>(strSql.ToString());
            }
            catch (Exception)
            {
 
                throw;
            }
            return count;
        }
    }
}

  from:https://blog.csdn.net/kingcruel/article/details/52848950

龙生   27 Mar 2018
View Details

总结一下当下流行的几个技术名词

DDD 领域驱动设计 …… 是一种设计思想 CQRS 命令查询职责分离 …… 一种架构，其实就是程序层面的读写分离 IoC 控制反转 …… 一种设计模式，主要用到了反射技术 DI 依赖注入 …… IoC实现的过程就是DI

龙生   27 Mar 2018
View Details
1 … 204 205 206 … 414

Copyright © 2025 Longsheng All rights reserved