Web开发：SQLsugar的安装和使用

目录

一、安装

二、使用：增删改查（基础写法）

1.连接字符串写法

2.基础增删改查

三、增删查改-封装写法（推荐）

四、更多好玩的写法

1.设置新表名

2.左外连接的三种写法

3.映射处理

五、事务

六、通过数据库生成C#实体类

七、特性

八、过滤器  & SQL打印  &  SQL超时 

九、小结

---

一、安装

第一步，在你的项目中找到解决方案，右键-管理解决方案的Nuget

第二步，下载对应的包，注意你的框架是哪个就下载哪个的包，一个项目安装一次包即可

我的是.NET6，因此安装sqlSugarCore 

点击应用和确定

安装好后会显示sqlsugar的包

二、使用：增删改查（基础写法）
1.连接字符串 & SqlSugarClient 
【SQLserver】
连接本地，以下两种写法都可以，可以用“.”代替主机名称
部分版本要加上 Encrypt=True;TrustServerCertificate=True
ConnectionString = "server = .; Database = TestDb; Trusted_Connection = SSPI;", // 数据库连接字符串 
ConnectionString = "server = DESKTOP-FTH2P3S; Database = TestDb; Trusted_Connection = SSPI;", // 数据库连接字符串

 private static SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
    {
        ConnectionString = conn, // 数据库连接字符串
        DbType = DbType.SqlServer, // 数据库类型
        IsAutoCloseConnection = true, // 是否自动关闭数据库连接
    },
      db => {
       //(A)全局生效配置点，一般AOP和程序启动的配置扔这里面 ，所有上下文生效
      //调试SQL事件，可以删掉
      db.Aop.OnLogExecuting = (sql, pars) =>
      {  
          //获取原生SQL推荐 5.1.4.63  性能OK
          Console.WriteLine(UtilMethods.GetNativeSql(sql,pars)); 
          //获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
          //Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer,sql,pars)) 
      };
 
      //多个配置就写下面
      //db.Ado.IsDisableMasterSlaveSeparation=true; 
      //注意多租户 有几个设置几个
      //db.GetConnection(i).Aop
});
【SQLlite】
public static string path = "Data Source=C:\\path\\to\\your\\database\\School.db;"
public static string conn = $"Data Source={path};";

//【开发环境】根目录获取方式参考
string root = Directory.GetCurrentDirectory().Split("\\bin")[0];   
//【生产环境】根目录
string root ="xxx.db" ;  //将db放在和exe并列的文件路径中
AI写代码
bash
2.基础增删改查
using SqlSugar;
using SqlSugar;
using System.Diagnostics.CodeAnalysis;
using System.Reflection; 
[SugarTable("TestTable")] // 指定实体类对应的数据库表名
class TestTable
{
    [SugarColumn(IsPrimaryKey = true)] // 指定主键列
    public string Id { get; set; }    
    public string Name { get; set; } 
    public int Age { get; set; } 
    public string Content { get; set; } 
    public int IsEnable { get; set; } 
    public int IsDeleted { get; set; } 
    public string Stage { get; set; } 
    public string Remarks { get; set; }
} 
class Test
{   
    static void Main(string[] args)
    {
        // 创建 SqlSugar 实例
        SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = "server = DESKTOP-FTH2P3S; Database = TestDb; Trusted_Connection = SSPI;", // 数据库连接字符串
            DbType = DbType.SqlServer, // 数据库类型
            IsAutoCloseConnection = true, // 是否自动关闭数据库连接
        });
 
        // 1.插入数据
        var model = new TestTable()
        {
            Id = Guid.NewGuid().ToString(),
            Name = "Tom",
            Age = 18,
            Content = "Hello World",
            IsEnable = 1,
            IsDeleted = 0,
            Stage = "Stage 1",
            Remarks = "Test"
        };
        int insert_code = db.Insertable(model).ExecuteCommand();//返回影响行数
 
        // 2.查询数据
        var list = db.Queryable<TestTable>().ToList();
 
        // 3.自定义查询SQL
        var result = db.SqlQueryable<TestTable>("SELECT * FROM TestTable WHERE Age > 30").ToList();
 
        // 4.更新数据（先查询实体，然后对需修改的值赋值，再更新）
        var updateModel = db.Queryable<TestTable>().Where(it => it.Id == "8ffd64fc-8aea-4641-a57b-d957ad0dd229").First();
        if (updateModel != null)
        {
            updateModel.Name = "Jerry";
            var update_code = db.Updateable(updateModel).ExecuteCommand();//返回影响行数
        } 
        // 5.删除数据
        var delete_code = db.Deleteable<TestTable>().Where(it => it.Id == "8ffd64fc-8aea-4641-a57b-d957ad0dd229").ExecuteCommand();//返回影响行数 
    }
}

三、增删查改-封装写法（推荐）
【拓展方法编写】
public static class SqlSugarExtensions
{
    public static string conn = "server = DESKTOP-FTH2P3S; Database = EnterpriseHRM; Trusted_Connection = SSPI;";
    private static SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
    {
        ConnectionString = conn, // 数据库连接字符串
        DbType = DbType.SqlServer, // 数据库类型
        IsAutoCloseConnection = true, // 是否自动关闭数据库连接
    },
      db => {
          db.Aop.OnLogExecuting = (sql, pars) =>
          {
              //控制台打印sql
              Console.WriteLine(UtilMethods.GetNativeSql(sql, pars));
              //调试窗口打印sql
              Trace.WriteLine($"【时间】{DateTime.Now}\n【SQL】{sql}\n------------------------");
          };
      }); 
    //重设连接字符串
    public static void SetConnecttionString(string conn)
    {
        db.CurrentConnectionConfig.ConnectionString = conn;
    } 
    // 扩展方法：获取整表数据列表（可自由选择是否带表达式树）
    public static List<T> GetList<T>(this T entity, Expression<Func<T, bool>> exp=null) where T : class, new()
    {
        return db.Queryable<T>().WhereIF(exp!=null,exp).ToList();
    } 
    // 扩展方法：获取第一条数据(携带表达式树)
    public static T First<T>(this T entity, Expression<Func<T, bool>> exp=null) where T : class, new()
    {
        if (exp == null)
        {
            return db.Queryable<T>().First();
        }
        return db.Queryable<T>().First(exp);
    } 
    // 扩展方法：判断是否存在数据(命名避免Any和原LINQ表达式冲突)
    public static bool AnyData<T>(this T entity, Expression<Func<T, bool>> exp = null) where T : class, new()
    {
        if (exp == null)
        {
            return db.Queryable<T>().Any();
        }
        return db.Queryable<T>().Any(exp);
    }     
    
    // 扩展方法：判断是否存在数据(命名避免Count和原LINQ表达式冲突)
    public static int CountData<T>(this T entity, Expression<Func<T, bool>> exp = null) where T : class, new()
    {
        if (exp == null)
        {
            return db.Queryable<T>().Count();
        }
        return db.Queryable<T>().Count(exp);
    } 
    // 扩展方法：根据主键查询单条记录
    public static T GetEntityById<T>(this T entity, object id) where T : class, new()
    {
        return db.Queryable<T>().InSingle(id);
    } 
    // 扩展方法：更新记录
    public static bool Update<T>(this T entity) where T : class, new()
    {
        return db.Updateable(entity).ExecuteCommand() > 0;
    } 
    // 扩展方法：批量更新记录
    public static bool BatchUpdate<T>(this List<T> list) where T : class, new()
    {
        if (list.Count < 10000)
        {
            return db.Updateable(list).ExecuteCommand() > 0;
        }
        return db.Fastest<T>().BulkUpdate(list) > 0;
    } 
    // 扩展方法：插入新记录
    public static bool Insert<T>(this T entity) where T : class, new()
    {
        return db.Insertable(entity).ExecuteCommand() > 0;
    } 
    // 扩展方法：批量插入新记录
    public static bool BatchInsert<T>(this List<T> list) where T : class, new()
    {
        if (list.Count < 10000)
        {
            return db.Insertable(list).ExecuteCommand() > 0;
        }
        return db.Fastest<T>().BulkCopy(list) > 0;
    } 
    //扩展方法：保存数据（无则插入有则更新）
    public static bool Save<T>(this T entity) where T : class, new()
    {
        var x = db.Storageable(entity).ToStorage();
        int a = x.AsInsertable.ExecuteCommand();//不存在插入
        int b = x.AsUpdateable.ExecuteCommand();//存在更新
        return a == 1 || b == 1;
    } 
    //扩展方法：保存数据（无则插入有则更新）
    public static bool BatchSave<T>(this List<T> list) where T : class, new()
    {
        if (list.Count < 10000)
        {
            return db.Storageable(list).ExecuteCommand() > 0;
        }
        return db.Fastest<T>().BulkMerge(list) > 0;
    }  
    // 扩展方法：根据实体删除记录
    public static bool Delete<T>(this T entity) where T : class, new()
    {
        return db.Deleteable(entity).ExecuteCommand() > 0;
    } 
    // 扩展方法：根据实体批量删除记录
    public static bool BatchDelete<T>(this List<T> list) where T : class, new()
    {
        return db.Deleteable(list).ExecuteCommand() > 0;
    }
 
    // 扩展方法：根据表达式删除
    public static bool DeleteByExp<T>(this T entity, Expression<Func<T, bool>> exp) where T : class, new()
    {
        return db.Deleteable<T>().Where(exp).ExecuteCommand()!=0;
    }
 
    // 扩展方法：自定义 SQL 查询
    public static List<T> QueryBySQL<T>(this T entity, string sql) where T : class, new()
    {
        return db.SqlQueryable<T>(sql).ToList();
    }
 
    //静态方法：执行ADO.NET的SQL操作
    public static bool ExecuteSQL(string sql)
    {
        return db.Ado.ExecuteCommand(sql) > 0;
    }
 
    //静态方法：自定义SQL查询，返回一列
    public static List<string> QueryStrListBySQL(string sql)
    {
        return db.Ado.SqlQuery<string>(sql);
    }
 
    //静态方法：生成实体类
    public static void DbFristToCode(string path)
    {
        // 生成实体类
        db.DbFirst // 使用 DbFirst 工具
            .IsCreateAttribute() // 使用属性生成实体类
            .CreateClassFile(path); // 输出路径
    }
 
    // 扩展方法：对实体进行分页，输入第几页，一页多少数据，输出总条数，总页数
    public static (List<T> DataList, int TotalCount, int TotalPage) GetPagedList<T>(this T list, int pageIndex, int pageSize)
    {
        int totalCount = 0;
        int totalPage = 0;
        var resultlist = db.Queryable<T>().ToPageList(pageIndex, pageSize, ref totalCount, ref totalPage);
        var tuplelist = (DataList: resultlist, TotalCount: totalCount, TotalPage: totalPage);
        return tuplelist;
    }
}

【调用示例】
  UserInfo userInfo   = new UserInfo();
  var list = userInfo.GetList();
  var entity = userInfo.GetListById("01A3A618-4496-4820-A164-E3455E7A1E84");
  entity.UserName = "刘晓彤";
  var b = entity.Update();
  var listfilter = userInfo.QueryBySQL("SELECT * FROM UserInfo where SEX='女'");

四、更多好玩的写法
1.设置新表名
db.Queryable<School>().AS("Student").ToList();
//生成的SQL  SELECT [ID],[NAME] FROM  Student

2.左外连接的三种写法
【三种写法】

//返回模糊类型
var result = db.Queryable<UserInfo>()
    .LeftJoin<Post>((o, d) => o.PostID == d.PostID)
    .Select((o, d) => new
    {
        UserId = o.UserID,
        UserName = o.UserName,
        PostName = d.PostName
    })
    .ToList();
 
//返回实体类
List<UserPostInfo> result2 = db.Queryable<UserInfo>()
    .LeftJoin<Post>((o, d) => o.PostID == d.PostID)
    .Select<UserPostInfo>() // 直接指定返回的实体类
    .ToList();
 
//表达式联表
var exp=Expressionable.Create<Order, Custom>();
exp.And((o,cus)=>o.CustomId == cus.Id);
exp.AndIF(Name!=null,(o, cus) => o.Name==Name);
var list= db.Queryable<Order>()
    .LeftJoin<Custom>(exp.ToExpression())//动态拼出来的条件
    .LeftJoin<OrderDetail>((o, cus, oritem) => o.Id == oritem.OrderId)
    .Where(o => o.Id == 1) 
    .ToList();

 【多表左外连接】
//多表左外连接
db.Queryable<Order, OrderItem, Custom>((o, i, c) => new JoinQueryInfos(
    JoinType.Left, o.Id == i.OrderId, //左连接 左链接 左联 
    JoinType.Left, o.CustomId == c.Id 
))
.Select((o,i,c)=>new ViewModel{ name=o.Name ..})
.ToList()

3.映射处理
//映射处理
var list=db.Queryable<SchoolA>()
        .LeftJoin<StudentA>((x, y) => (x.SchoolId == y.SchoolId))
        .Select((x,y) => new UnitView01()
        {
            Name=x.SchoolName,
            Count=100
        },
        true)//true表示 其余字段根据字段名字自动映射
        .ToList();

五、事务
try
{
    db.Ado.BeginTran();
    db.Insertable(new Order() { .....}).ExecuteCommand();
    db.Insertable(new Order() { .....}).ExecuteCommand();
    db.Ado.CommitTran();
}
catch (Exception ex)
{
    db.Ado.RollbackTran();
    throw ex;
}
六、通过数据库生成C#实体类

运行以下代码即可，其中CreateClassFile里面的路径可以写一个文件夹的路径

using ConsoleApp1;
using SqlSugar; 
class Program
{ 
    static void Main()
    {
        // 配置数据库连接字符串
        string connectionString = "server = DESKTOP-FTH2P3S; Database = EnterpriseHRM; Trusted_Connection = SSPI;";
        var db = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = connectionString,
            DbType = DbType.SqlServer, // 根据你的数据库类型设置 DbType
            IsAutoCloseConnection = true, // 自动释放连接
            InitKeyType = InitKeyType.Attribute // 使用 Attribute 方式获取 Key
        }); 
        // 生成实体类
        db.DbFirst // 使用 DbFirst 工具
            .IsCreateAttribute() // 使用属性生成实体类
            .CreateClassFile("F:\\C_program\\sqlsugar_demo\\repos\\ConsoleApp1\\ConsoleApp1\\GenerateModel"); // 输出路径
    }
}

 生成效果如下所示

本地路径 

七、特性
[SugarTable("dbstudent")]//当和数据库名称不一样可以设置表别名 指定表明
public class Student
{
    [SugarColumn(IsPrimaryKey = true, IsIdentity = true)]//数据库是自增才配自增 
    public int Id { get; set; }
 
    [SugarColumn(ColumnName ="StudentName")]//数据库与实体不一样设置列名 
    public string Name { get; set; }
 
    [SugarColumn(InsertSql  = "getdate()")] //插入的默认值是当前日期，还支持字符串/数字：'momo'   0   num+1（字段是num）
    public DateTime CreateTime2 { get; set; }
 
    //UpdateServerTime =true 更新的时候取服务器时间
    //IsOnlyIgnoreInsert =true 插入的时候不插入该列（可用可不用根据需求来）
    [SugarColumn(UpdateServerTime =true,IsOnlyIgnoreInsert =true)]// getdate() now() sysdate
    public DateTime UpdateTime { get; set; }
}

八、过滤器  & SQL打印  &  SQL超时 
public static SqlSugarClient db = new SqlSugarClient(
    new ConnectionConfig()
    {
        ConnectionString = conn, // 数据库连接字符串
        DbType = DbType.SqlServer, // 数据库类型
        IsAutoCloseConnection = true, // 是否自动关闭数据库连接
         LanguageType = SqlSugar.LanguageType.Chinese //尽可能使用中文报错
    },
    db => 
    { 
 
        //Sql超时
        db.Ado.CommandTimeOut = 30;//单位秒
 
        db.QueryFilter.AddTableFilter<UserInfo>(x => x.LeaveTime == null); //查UserInfo表，查的都是x.LeaveTime == null的值
 
        db.Aop.OnLogExecuting = (sql, pars) =>
        {
            //以下方式三选一即可
 
            //输出sql,查看执行sql 性能无影响
            Console.WriteLine(sql);
 
            //获取原生SQL推荐 5.1.4.63  性能OK
            Console.WriteLine(UtilMethods.GetNativeSql(sql,pars))
 
            //获取无参数化SQL 对性能有影响，特别大的SQL参数多的，调试使用
            Console.WriteLine(UtilMethods.GetSqlString(DbType.SqlServer,sql,pars))
        };
 
    }
);
九、小结
1.连接字符串（db）

SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
        {
            ConnectionString = "server = DESKTOP-FTH2P3S; Database = TestDb; Trusted_Connection = SSPI;", // 数据库连接字符串
            DbType = DbType.SqlServer, // 数据库类型
            IsAutoCloseConnection = true, // 是否自动关闭数据库连接
        });

2.五大方法（增删改查+自定义SQL查询） 

db.Insertable(model).ExecuteCommand();
db.Updateable(updateModel).ExecuteCommand();
db.Queryable<TestTable>().ToList();
db.Deleteable<TestTable>().ExecuteCommand();
db.SqlQueryable<TestTable>("sql语句").ToList();

原文链接：https://blog.csdn.net/m0_67412019/article/details/135462581