Easy-DotNET
  • NET微服务
  • ORM
一个大西瓜
2023-04-18
目录

FreeSql

FreeSql 是一款基于 .NET Core 和 .NET Framework 的对象关系映射（ORM）框架，它支持多种数据库，包括但不限于 SQL Server、MySQL、PostgreSQL、Oracle 等。FreeSql 提供了简单易用的 API，支持 LINQ 查询，同时还支持事务处理、主从分离、读写分离等高级功能。

# 安装

在安装 FreeSql 之前，需要先确保你的项目是基于 .NET Core 或 .NET Framework 的。然后，你可以通过 NuGet 包管理器来安装 FreeSql。在 Visual Studio 中，你可以右键点击你的项目，然后选择“管理 NuGet 包”选项，然后搜索“FreeSql”并进行安装。

你也可以使用 dotnet 命令行工具来安装 FreeSql。在命令行中，输入以下命令：


dotnet add package FreeSql

# 配置

在使用 FreeSql 之前，你需要先配置数据库连接。FreeSql 支持多种数据库，因此需要配置不同的连接字符串。下面是一个示例，展示了如何配置连接字符串以使用 MySQL 数据库：


using FreeSql;
using Microsoft.Extensions.DependencyInjection;

// 注册服务
var services = new ServiceCollection()
    .AddFreeSql<MySqlProvider>(options => options
        .UseConnectionString(FreeSql.DataType.MySql, "server=localhost;port=3306;database=testdb;uid=root;pwd=123456;Charset=utf8;"))
    .BuildServiceProvider();

// 获取 FreeSql 对象
var fsql = services.GetService<IFreeSql>();

在这个示例中，我们使用了 Microsoft.Extensions.DependencyInjection 依赖注入框架来注册 FreeSql 服务，并配置了连接字符串。这个示例使用了 MySQL 数据库，你可以根据需要修改连接字符串中的参数。

# 使用

一旦你配置好了连接字符串，你就可以开始使用 FreeSql 了。下面是一些使用示例：

# 基本查询


using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "server=localhost;port=3306;database=testdb;uid=root;pwd=123456;Charset=utf8;")
    .Build();

// 查询所有用户
var users = fsql.Select<User>().ToList();

// 根据条件查询用户
var user = fsql.Select<User>().Where(u => u.Name == "张三").FirstOrDefault();

在这个示例中，我们创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 FreeSql 对象来执行基本查询。我们首先查询了所有的用户，然后查询了名为“张三”的用户。

# 查询where条件

var blogslist1 = fsql.Select<Blog>()
                    .Where( b => b.Rating > -3 )
                    .OrderBy( b => b.Url )
                    .ToList();

var blogslist2 = fsql.Select<Blog>()
                   .Where( "Rating>=@min and Rating<=@max",new
                   {
                       min=1,
                       max=10
                   } )
                   .OrderBy( b => b.Url )
                   .ToList();

Where可以写多个,实际是多个and条件

var blogslist1 = fsql.Select<Blog>()
                                .Where( b => b.Rating > -3 )
                                .Where ( b=>b.BlogId >50 )
                                .OrderBy( b => b.Url )
                                .ToList();

# 查询WhereIf条件

var blogslist3 = fsql.Select<Blog>()
               .Where( "BlogId>=@min and BlogId<=@max" , new
               {
                   min = 1 ,
                   max = 10
               } )
               //当条件成立时,才会过滤数据
               .WhereIf( 1 == 1, "Rating=@Rating", new
               {
                   Rating=0
               } )
               .OrderBy( b => b.BlogId )
               .ToList();

# 查询(IN查询)

# in查询
//数字类型
var list1 = DB.fsql.Select<Blog>()
                                .Where( a => new[] { 1 , 2 , 3 }.Contains( a.Rating ) )
                                .ToList();

/*
对应sql:
SELECT a.[BlogId], a.[Url], a.[Rating], a.[BlogTypeId], a.[Times]
FROM[Blog] a
WHERE( ( ( a.[Rating] ) in (1, 2, 3) ))
*/



//字符串类型
var list2 = DB.fsql.Select<Blog>()
                                .Where( it => it.BlogId >= 1 )
                                .Where( a => new[] { "piliang_rul" , "rul3" }.Contains( a.Url ) )
                                .ToList();
/*
对应sql:
SELECT a.[BlogId], a.[Url], a.[Rating], a.[BlogTypeId], a.[Times]
FROM[Blog] a
WHERE( a.[BlogId] >= 1 ) AND( ( ( a.[Url] ) in ( N'piliang_rul' , N'rul3' )))            
*/



//使用List 也可以
List<string> barcodelist = new List<string>() { "piliang_rul" , "rul3" };

var list = fsql.Select<SPIBOARDBINDS>()
                                 .Where( it => barcodelist.Contains( it.BARCODE ) )
                                .ToList();
# in子表查询
//in子表查询
var list3 = DB.fsql.Select<Blog>()
                           .Where( it => it.BlogId >= 1 )
                           .Where( a => DB.fsql.Select<BlogType>().As( "b" ).ToList( b => b.BlogTypeId ).Contains( a.BlogTypeId ) )
                           .ToList();

/*对应sql:
            SELECT a.[BlogId], a.[Url], a.[Rating], a.[BlogTypeId], a.[Times] 
            FROM [Blog] a 
            WHERE (a.[BlogId] >= 1) AND (((a.[BlogTypeId]) in (SELECT b.[BlogTypeId] 
                FROM [BlogType] b)))
*/

# 插入数据


using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "server=localhost;port=3306;database=testdb;uid=root;pwd=123456;Charset=utf8;")
    .Build();

// 创建新用户
var user = new User { Name = "李四" };

// 插入数据
fsql.Insert(user).ExecuteAffrows();

在这个示例中，我们首先创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 FreeSql 对象来插入一条新的用户数据。

# 插入数据

# 单个插入
var ids = fsql.Insert( bill ).ExecuteAffrows();

//执行SQL语句，返回影响的行数
int i0 = fsql.Insert( new Blog() { Rating = 1 , Url = "rul" } ).ExecuteAffrows();



//执行SQL语句，返回自增值
long autokey0 = fsql.Insert( new Blog() { Rating = 1 , Url = "rul" } ).ExecuteIdentity();



//返回插入后的数据,注意是返回集合,但是这种情况集合就一条数据
List<Blog> list1 = DBClass.fsql.Insert( new Blog()
{
    Rating = 0 ,
    Url = "rul3" ,
    BlogTypeId = "code1" ,
    Times = DateTime.Now
} ).ExecuteInserted();
# 批量插入
//执行SQL语句，返回影响的行数
int i1 = fsql.Insert( new List<Blog>() {
            new Blog() { Rating = 1 , Url = "rul" },
            new Blog() { Rating = 2 , Url = "rul" }} ).ExecuteAffrows();



//批量插入
//返回插入后的数据,这时这个集合里面有3条数据
List<Blog> list2 = DBClass.fsql.Insert( new List<Blog>() {
new Blog() {
    Rating = 0 ,
    Url = "piliang_rul",
    BlogTypeId = "code0",
    Times =DateTime.Now  },
new Blog() {
    Rating = 1 ,
    Url = "piliang_rul",
    BlogTypeId = "code1",
    Times =DateTime.Now  },
new Blog() {
    Rating = 2 ,
    Url = "piliang_rul",
    BlogTypeId = "code1",
    Times =DateTime.Now  }} ).ExecuteInserted();
# 获取自动增长ID
//ExecuteIdentity 返回标识列
long ids = DBClass.fsql.Insert( new Blog()
            {
                Rating = 0 ,
                Url = "rul" ,
                BlogTypeId = "code2" ,
                Times = DateTime.Now
            } ).ExecuteIdentity();
# 主从表插入
DateTime now = DateTime.Now;

//返回标识列
long ids = DBClass.fsql.Insert( new groupdata()
            {
                Names = "group_" + DateTime.Now.ToString( "yyyy-MM-dd HH:mm:ss" ) ,
            } ).ExecuteIdentity();


var list2 = DBClass.fsql.Insert( new List<users>() {
            new users()
            {
                //赋值主表id
                GroupId = (int)ids ,

                Names = "name:" + new Random().Next( 1 , 100 ).ToString (),
                age=new Random().Next( 1 , 18 ),

                Times =now
            },

            new users()
            {
                //赋值主表id
                GroupId = (int)ids ,

                Names = "name:" + new Random().Next( 1 , 8 ).ToString (),
                age=new Random().Next( 1 , 8 ),

                Times =now
            }} ).ExecuteInserted();
# 插入指定列和忽略列
//插入指定的列 InsertColumns
long ids2 = DBClass.fsql.Insert( new Blog()
{
    Rating = 0 ,
    Url = "rul" ,
    BlogTypeId = "code2" ,
    Times = DateTime.Now

} )
//只插入这2个列
.InsertColumns( a => new { a.Rating , a.Times } )
.ExecuteIdentity();



//忽略列 IgnoreColumns 
long ids3 = DBClass.fsql.Insert( new Blog()
{
    Rating = 0 ,
    Url = "rul" ,
    BlogTypeId = "code2" ,
    Times = DateTime.Now
} )
//忽略这2个列不插入 
.IgnoreColumns( a => new { a.BlogTypeId , a.Times } )
.ExecuteIdentity();
# 字典插入
var dic = new Dictionary<string , object>();
dic.Add( "Rating" , 1 );
dic.Add( "Times" , DateTime.Now );

//字典插入
long ids4 = DBClass.fsql.InsertDict( dic ).AsTable( "Blog" ).ExecuteIdentity();

# 更新数据

using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "server=localhost;port=3306;database=testdb;uid=root;pwd=123456;Charset=utf8;")
    .Build();

// 查询用户
var user = fsql.Select<User>().Where(u => u.Id == 1).FirstOrDefault();

// 更新用户
user.Name = "王五";
fsql.Update(user).ExecuteAffrows();

在这个示例中，我们首先创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 FreeSql 对象来查询 id 为 1 的用户，并将其名称更新为“王五”。

# 删除数据


using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "server=localhost;port=3306;database=testdb;uid=root;pwd=123456;Charset=utf8;")
    .Build();

// 查询用户
var user = fsql.Select<User>().Where(u => u.Id == 1).FirstOrDefault();

// 删除用户
fsql.Delete<User>().Where(u => u.Id == user.Id).ExecuteAffrows();

在这个示例中，我们首先创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 FreeSql 对象来查询 id 为 1 的用户，并将其删除。

# 高级查询

FreeSql 支持 LINQ 查询，这意味着你可以使用类似于 SQL 的语法来进行复杂的查询。下面是一些使用示例：


using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "server=localhost;port=3306;database=testdb;uid=root;pwd=123456;Charset=utf8;")
    .Build();

// 查询所有年龄大于 18 的用户，并按照年龄升序排序
var users = fsql.Select<User>().Where(u => u.Age > 18).OrderBy(u => u.Age).ToList();

// 分页查询用户
var users = fsql.Select<User>().Where(u => u.Age > 18).OrderBy(u => u.Age).Page(2, 10).ToList();

// 查询用户数
var count = fsql.Select<User>().Count();

在这个示例中，我们首先创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 Free Sql 对象来进行一些高级查询。我们首先查询了所有年龄大于 18 的用户，并按照年龄升序排序。然后，我们进行了分页查询，并查询了用户数。

# 事务处理

FreeSql 支持事务处理，这意味着你可以将多个操作封装在一个事务中，以确保这些操作要么全部成功，要么全部失败。下面是一个使用示例：


using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "server=localhost;port=3306;database=testdb;uid=root;pwd=123456;Charset=utf8;")
    .Build();

// 开始事务
using (var uow = fsql.CreateUnitOfWork()) {
    try {
        // 创建新用户
        var user = new User { Name = "张三" };
        fsql.Insert(user).ExecuteAffrows();

        // 删除用户
        fsql.Delete<User>().Where(u => u.Name == "李四").ExecuteAffrows();

        // 提交事务
        uow.Commit();
    } catch (Exception ex) {
        // 回滚事务
        uow.Rollback();
    }
}

在这个示例中，我们首先创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 FreeSql 对象来创建一个事务。在事务中，我们插入了一条新的用户数据，并删除了名为“李四”的用户。如果事务执行成功，则提交事务，否则回滚事务。

# 主从分离

FreeSql 支持主从分离，这意味着你可以在多个数据库实例之间分配读写操作。下面是一个使用示例：


using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "Data Source=192.168.1.1;Port=3306;Database=testdb;User ID=root;Password=123456;Charset=utf8;Allow User Variables=True")
    .UseSlave("Data Source=192.168.1.2;Port=3306;Database=testdb;User ID=root;Password=123456;Charset=utf8;Allow User Variables=True")
    .UseSlave("Data Source=192.168.1.3;Port=3306;Database=testdb;User ID=root;Password=123456;Charset=utf8;Allow User Variables=True")
    .Build();

// 查询用户
var user = fsql.Select<User>().Where(u => u.Id == 1).ToOne();

在这个示例中，我们首先创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 FreeSql 对象来配置主从分离，其中主数据库的连接字符串在 UseConnectionString 方法中指定，而从数据库的连接字符串则在 UseSlave 方法中指定。在查询用户时，FreeSql 会自动选择一个可用的从数据库进行查询。

# 读写分离

FreeSql 还支持读写分离，这意味着你可以将写操作分配给主数据库，而将读操作分配给从数据库。下面是一个使用示例：


using FreeSql;

public class User {
    public int Id { get; set; }
    public string Name { get; set; }
}

// 获取 FreeSql 对象
var fsql = new FreeSql.FreeSqlBuilder()
    .UseConnectionString(FreeSql.DataType.MySql, "Data Source=192.168.1.1;Port=3306;Database=testdb;User ID=root;Password=123456;Charset=utf8;Allow User Variables=True")
    .UseSlave("Data Source=192.168.1.2;Port=3306;Database=testdb;User ID=root;Password=123456;Charset=utf8;Allow User Variables=True")
    .UseSlave("Data Source=192.168.1.3;Port=3306;Database=testdb;User ID=root;Password=123456;Charset=utf8;Allow User Variables=True")
    .Build();

// 创建新用户
var user = new User { Name = "张三" };
fsql.Insert(user).ExecuteAffrows();

// 查询所有用户
var users = fsql.Select<User>().ToList();

在这个示例中，我们首先创建了一个名为 User 的类，表示一个用户对象。然后，我们使用 FreeSql 对象来配置读写分离，其中主数据库的连接字符串在 UseConnectionString 方法中指定，而从数据库的连接字符串则在 UseSlave 方法中指定。在创建新用户时，FreeSql 会自动将其写入主数据库中。在查询所有用户时，FreeSql 会自动选择一个可用的从数据库进行查询。

# 总结

FreeSql 是一款基于 .NET Core 和 .NET Framework 的 ORM 框架，它支持多种数据库，包括但不限于 SQL Server、MySQL、PostgreSQL、Oracle 等。FreeSql 提供了简单易用的 API，支持 LINQ 查询，同时还支持事务处理、主从分离、读写分离等高级功能。如果你正在寻找一款易于使用的 ORM 框架，并且需要支持多种数据库，那么 FreeSql 绝对是一个值得考虑的选择。

上次更新: 2023/09/21, 11:15:03
Dapper
SqlSugar

← SqlSugar→

Theme by Vdoing | Copyright © 2019-2024 一个大西瓜 | MIT License | 苏ICP备2023013501号