dotnetcore中使用dapper

　　我们都知道，orm全称是，object relationship mapper，即，对象关系映射。也就是可以用object来map我们的db，而且市面上的orm框架有很多，其中有一个框架叫做dapper，而且被称为the king of orm。

　　市场上，也有一些其他的orm，比如ef core，nhibernate ，来处理大数据访问及关系映射。既然官方推出了ef core，说明其对框架的支持会很友好，为什么又会有那么多的orm框架供我们使用呢？其实，每一个框架都有其适用的场景。如果你在小的项目中，使用entity framework、entity framework core、nhibernate 来处理大数据访问及关系映射，未免有点杀鸡用牛刀。你又觉得orm省时省力，这时dapper 将是你不二的选择。其实，entity framework core的性能并不是很高，当对性能有要求的时候，一般公司都会自己封装一套orm。

为什么选择dapper？

1. 轻量。只有一个文件（sqlmapper.cs），编译完成之后只有120k(好象是变胖了)
2. 速度快。dapper的速度接近与idatareader，取列表的数据超过了datatable。
3. 支持多种数据库。dapper可以在所有ado.net providers下工作，包括sqlite, sqlce, firebird, oracle, mysql, postgresql and sql server
4. 可以映射一对一，一对多，多对多等多种关系。
5. 性能高。通过emit反射idatareader的序列队列，来快速的得到和产生对象，性能不错。
6. 支持framework2.0，3.0，3.5，4.0，4.5

在这里，我们在dotnet core下面使用dapper操作mysql。

首先，既然是演示，就先创建一个core mvc的项目，这里选择有模板的。因为公司使用的是dotnet core2.2的版本，我就基于core2.2版本创建一个项目。

dapper安装，使用nuget来安装dapper程序包

使用nuget安装mysql.data的程序包 

 

 安装这些程序包之后，在appsettings.json文件中添加链接数据库的字符串：

"connectionstrings": {
    "defaultconnection": "server=服务器;port=端口号;database=regatta{0};sslmode=none;uid=username;pwd=password;allow user variables=true"
  }

然后，封装一个工具类，来获得我们的连接字符串，和管理连接池

public class baserepository : idisposable
{
    public static iconfigurationroot configuration { get; set; }

    public static mysqlconnection conn;

    public static mysqlconnection getmysqlconnection(bool open = true,
        bool convertzerodatetime = false, bool allowzerodatetime = false)
    {
        var builder = new configurationbuilder()
        .setbasepath(directory.getcurrentdirectory())
        .addjsonfile("appsettings.json")
        .build();
        var cs = builder.getsection("connectionstrings:defaultconnection").value;
        var csb = new mysqlconnectionstringbuilder(cs)
        {
            allowzerodatetime = allowzerodatetime,
            convertzerodatetime = convertzerodatetime
        };
        conn = new mysqlconnection(csb.connectionstring);
        return conn;
    }

    public void dispose()
    {
        if (conn != null && conn.state != system.data.connectionstate.closed)
        {
            conn.close();
        }
    }
}

创建数据库中的一个需要映射的实体类：

public class area
{
    public int id { get; set; }

    public string name { get; set; }

    public int parentid { get; set; }
}

查询操作

/// <summary>
/// 查询所有数据
/// </summary>
/// <returns></returns>
public static list<area> querylist()
{
    var sql = "select * from area";
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        return connection.query<area>(sql).tolist();
    }
}

/// <summary>
/// in操作
/// </summary>
public static list<area> queryin()
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        var sql = "select * from area where id in @ids";
        //参数类型是array的时候，dappper会自动将其转化
        return connection.query<area>(sql, new { ids = new int[2] { 1, 2 }, }).tolist();
    }
}

public static list<area> queryin(int[] ids)
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        var sql = "select * from area where id in @ids";
        //参数类型是array的时候，dappper会自动将其转化
        return connection.query<area>(sql, new { ids }).tolist();
    }
}

插入操作

/// <summary>
/// 插入一条数据
/// </summary>
/// <param name="area"></param>
/// <returns></returns>
public static int insert(area area)
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        return connection.execute($"insert into area(name,parentid) values(@name,@parentid)", area);
    }
}

/// <summary>
/// 批量插入area数据，返回影响行数
/// </summary>
/// <param name="areas"></param>
/// <returns></returns>
public static int insert(list<area> areas)
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        return connection.execute("insert into area(id,name,parentid) values(@id,@name,@parentid)", areas);
    }
}

删除操作

/// <summary>
/// 删除一条
/// </summary>
/// <param name="area"></param>
/// <returns></returns>
public static int delete(area area)
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        return connection.execute("delete from area where id=@id", area);
    }
}

/// <summary>
/// 批量删除
/// </summary>
/// <param name="areas"></param>
/// <returns></returns>
public static int delete(list<area> areas)
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        return connection.execute("delete from area where id=@id", areas);
    }
}

修改操作

/// <summary>
/// 修改
/// </summary>
/// <param name="area"></param>
/// <returns></returns>
public static int update(area area)
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        return connection.execute("update area set name=@name where id=@id", area);
    }
}

/// <summary>
/// 批量修改
/// </summary>
/// <param name="areas"></param>
/// <returns></returns>
public static int update(list<area> areas)
{
    using (idbconnection connection = baserepository.getmysqlconnection())
    {
        return connection.execute("update area set name=@name where id=@id", areas);
    }
}

join操作

　　我们是面向对象编程，所以一个对象里面会有许多其他子对象，这个子对象里面又有其自己的子对象，这种关系在数据库里的表示就是外键。
比如我们有一本书book，它有主人area，book是一个对象，主人又是一个对象。

public class bookwithperson
{
    public int id { get; set; }
    public person pers { get; set; }
    public string bookname { get; set; }
}

　　我们自然想要一个方法把数据库里复杂的外键关系转成我们需要的对象bookwitharea，所有我们需要的信息都存在里面，取数据的时候只要找这个对象取数据就行了，比如我们需要一本书的主人的姓名，我们只需要bookwitharea.pers.name。如果是一对多的关系我们用数组，如果是多对多我们加一层mapping。
现在我们想根据书的id查询书的信息，包括主人信息。那么

public static bookwithperson queryjoin(book book)
{
    using (idbconnection connection = new sqlconnection(connectionstring))
    {
        var sql = @"select b.id,b.bookname,p.id,p.name,p.remark
                        from person as p
                        join book as b
                        on p.id = b.personid
                        where b.id = @id;";
        var result = connection.query<bookwithperson, person, bookwithperson>(sql,
        (bookwithperson, person) =>
        {
            bookwithperson.pers = person;
            return bookwithperson;
        },
        book);
    　　//spliton: "bookname");
    　　return (bookwithperson)result;
　　}
}

中，query的三个泛型参数分别是委托回调类型1，委托回调类型2，返回类型。形参的三个参数分别是sql语句，map委托，对象参数。所以整句的意思是先根据sql语句查询；同时把查询的area信息赋值给bookwitharea.pers，并且返回bookwitharea；book是对象参数，提供参数绑定的值。
最终整个方法返回bookwitharea，这样我们所需要的所有信息就有了。

参考地址：