JCoder.Db4Net 3.9.3

JCoder.Db4Net

[TOC]

一.架构说明

1.1 引用类库

1.2 相关类库

获取方式

1. 版本要求：>=3.0.0
2. 以版本3.0.0为例

三.使用说明

3.1 主要类与接口

3.2特性说明

3.3 函数名称说明

4.1 创建实例-IDbOperator\IFactoryDbOperator

1. 创建实例

   
   // MySql, 需要先在项目里引用或加载MySql官方库MySql.Data.dll。
   IDbOperator _dber = new MySqlFactoryOperator()
   {
       ConnectionString = "server=127.0.0.1;database=test;uid=user;pwd=testpassword;Connect Timeout=18000"
   };
   
   // SQLite, 需要先在项目里引用或加载Sqlite官方库System.Data.SQLite.dll。
   IDbOperator _dber = new SQLiteFactoryOperator()
   {
       ConnectionString = "Data Source=.\data\test.db3;"
   };
   
   // Sql Server, 需要先在项目里引用或加载Sql Server官方库System.Data.SqlClient.dll。
   IDbOperator _dber = new MsSqlFactoryOperator()
   {
       ConnectionString = "Server=127.0.0.1;Database=test;Uid = user; Pwd=testpassword;"
   };
   
   

2. 使用创建全局实例

   
   // MySql
   IDbOperator _dber = Db.Hub.GetDberOrNew<MySqlFactoryOperator>();
   _dber.ConnectionString = "server=127.0.0.1;database=test;uid=user;pwd=testpassword;Connect Timeout=18000";
   
   

4.2 IDbOperator使用

1. CanConnect（是否能够连接数据库）

   // CanConnect（是否能够连接数据库）
   if (_dber.CanConnect()) { return; }
   

2. CreateParameter（创建相应的参数）

   // CreateParameter（创建相应的参数）
   return _dber.CreateParameter( "ID", 123);
   

3. Execute（执行SQL）

   // Execute（执行SQL）
   var _parameters = new List<DbParameter>()
   {
       _dber.CreateParameter("ID","ID123"),
       _dber.CreateParameter("Name","Name123"),
       _dber.CreateParameter("CreateTime",DateTime.Now),
   };
   var _sql = @"insert table1 (ID,Name,CreateTime) values (@ID,@Name,@CreateTime);";
   var _count = _dber.Execute(_sql, _parameters);//直接执行SQL
   //var _count = _dber.Execute(true,_sql, _parameters);// 使用事务执行SQL
   return _count >= 1;
   

4. Execute（执行多条SQL）

   // Execute（执行多条SQL）
   var _parameters = new List<DbParameter>()
   {
       _dber.CreateParameter("Value1","ID123"),
       _dber.CreateParameter("Value2","Name123"),
       _dber.CreateParameter("Value3","Name1456"),
   };
   var _sqls = new string[]
   {
       @"insert table3 (Values) values (@Value1);",
       @"insert table3 (Values) values (@Value2);",
       @"insert table3 (Values) values (@Value3);",
   } ;
   var _count = _dber.Execute(_sqls, _parameters);//直接执行SQL
   //var _count = _dber.Execute(true, _sqls, _parameters);// 使用事务执行SQL
   return _count >= 1;
   

5. ExecuteTransaction（使用事务执行指定的SQL）

   // ExecuteTransaction（使用事务执行指定的SQL）
   public void ExecuteTransaction()
   {
       _dber.StartTransaction();
   
        try
        {
           for (int i = 0; i < 3; i++)
           {
                var _parameters = new List<DbParameter>()
                {
                    _dber.CreateParameter("ID",i.ToString()),
                    _dber.CreateParameter("Name","Name123"),
                    _dber.CreateParameter("CreateTime",DateTime.Now),
                };
                var _sql = @"insert table1 (ID,Name,CreateTime) values (@ID,@Name,@CreateTime);";
                var _isSucceed = _dber.ExecuteTransaction(_sql, _parameters);
           }
        }
        catch (Exception ex)
        {
            _dber.RollbackTransaction();
            return;
        }
   
        _dber.FinishTransaction();
   }
   
   

6. ExecuteTransaction（使用指定的事务执行指定的SQL）

   // ExecuteTransaction（使用指定的事务执行指定的SQL）
   public void ExecuteTransaction()
   {
       for (int i = 0; i < 3; i++)
       {
           var _key = "Transaction" + i.ToString();
           _dber.StartTransaction(_key);
   
           var _id = i.ToString() + DateTime.Now.ToLongTimeString();
           try
           {
               var _parameters = new List<DbParameter>()
               {
                   _dber.CreateParameter("ID",_id),
                   _dber.CreateParameter("Name","Name123"),
                   _dber.CreateParameter("CreateTime",DateTime.Now),
               };
               var _sql = @"insert table1 (ID,Name,CreateTime) values (@ID,@Name,@CreateTime);";
               var _isSucceed = _dber.ExecuteTransaction(_key, _sql, _parameters);
           }
           catch (Exception ex)
           {
               _dber.RollbackTransaction(_key);
               return;
           }
   
           if (!_dber.FinishTransaction(_key))
           {
               return;
           }
       }
   }
   
   

7. RollbackTransaction（回滚指定的事务）

   // RollbackTransaction（回滚指定的事务）
   public void RollbackTransaction()
   {
       var _key = "Transaction";
       _dber.StartTransaction(_key);
   
       var _id = nameof(RollbackTransaction);
   
       try
       {
           var _parameters = new List<DbParameter>()
           {
               _dber.CreateParameter("ID",_id),
               _dber.CreateParameter("Name","Name123"),
               _dber.CreateParameter("CreateTime",DateTime.Now),
           };
           var _sql = @"insert table1 (ID,Name,CreateTime) values (@ID,@Name,@CreateTime);";
           var _isSucceed = _dber.ExecuteTransaction(_key, _sql, _parameters);
       }
       catch (Exception ex)
       {
           _dber.RollbackTransaction(_key);
           return;
       }
   
       _dber.RollbackTransaction(_key);
   }
   

8. QueryTable（查询数据，并返回DataTable）

   public DataTable QueryTable()
   {
       var _parameters = new List<DbParameter>()
       {
           _dber.CreateParameter("ID",123),
       };
       var _sql = "select * from table1 where ID=@ID;";
       return _dber.QueryTable(_sql, _parameters);
   }
   

9. QueryTables（查询数据，并返回DataSet）

   public DataSet QueryTables()
   {
       var _parameters = new List<DbParameter>()
       {
           _dber.CreateParameter("ID",123),
       };
       var _sql = "select * from table1 where ID=@ID;";
       _sql += "select * from table2 where ID=@ID;";
       return _dber.QueryTables(_sql, _parameters);
   }
   

10. QueryReader（查询数据，并返回DbDataReader）

public QueryReader QueryReader()
{
    var _parameters = new List<DbParameter>()
    {
        _dber.CreateParameter("ID",123),
    };
    var _sql = "select * from table1 where ID=@ID;";
    return _dber.QueryReader(_sql, _parameters);
}

11. QueryDictionary (将查询结果的首两列数据转换为Dictionary)

public Dictionary<string, string> QueryDictionary()
{
    var _sql = "select Key,Value from table1 ;";
    return _dber.QueryDictionary<string, string>(_sql);
}

12. QueryRowAsDictionary (将查询结果的首行数据转换为Dictionary)

    Dictionary<string, string> _dict =  _dber.QueryRowAsDictionary("select * from table1 ;");
    foreach (var kv in _dict)
    {
        Console.WriteLine($"[{kv.Key}]{kv.Value}");
    }

    // 输出 - 有数据时
    // [Key001]00327d8c-ddcc-46cc-92d1-9f82dca9374e
    // [Column001]阎臭潭
    // [Column002]Thithea Tisasheet
    // [Column003]2023-02-13 15:44:57.304646
    
    // 输出 - 没有数据时
    // [Key001]
    // [Column001]
    // [Column002]
    // [Column003]

13. QueryValues (将查询结果的首列数据转换为List)

public List<string> QueryNames()
{
    var _sql = "select Names from table1 ;";
    return _dber.QueryValues<string>(_sql);
}

14. QueryValue (将查询值转换为long)

public List<long> QueryValue()
{
    var _sql = "select count(1) from table1 ;";
    return _dber.QueryScalar<long>(_sql);
}

15. IsExistData (查询是否存在数据)

public bool IsExistData()
{
    var _sql = "select 1 from table1 where id=1;";
    return _dber.IsExistData(_sql);
}

4.3 IDbSqlTexter使用

1. 生成实例

   
   // 用于生成MySql语句，引用JCoder.Db4Net.MySql
   IDbSqlTexter _sqltexter = new MySqlTexter();
   
   // 用于生成Sqlite语句，引用JCoder.Db4Net.Sqlite
   IDbSqlTexter _sqltexter = new SqliteTexter();
   
   // 用于生成SqlServer语句，引用JCoder.Db4Net.SqlServer
   IDbSqlTexter _sqltexter = new MsSqlTexter();
   
   

2. 生成数据库相关的SQL语句

   
   // 生成获取当前数据库信息的SQL语句
   _sqltexter.GetDatabase();
   
    // 生成获取指定数据库信息的SQL语句
   _sqltexter.GetDatabase("database");
   
    // 生成获取数据库信息列表的SQL语句
   _sqltexter.GetDatabaseList();
   
    // 生成创建数据库的SQL语句
   _sqltexter.CreateDatabase("database");
   
    // 生成删除数据库的SQL语句
   _sqltexter.DeleteDatabase("database");
   
   

3. 生成数据表(Table)相关的SQL语句

   
   // 生成获取当前数据库的指定数据表的数据列信息的SQL语句
   _sqltexter.GetTableColumns("table01");
   // 生成获取指定数据库的指定数据表的数据列信息的SQL语句
   _sqltexter.GetTableColumns("database","table01");
   
    // 生成获取当前数据库的指定数据表信息的SQL语句SQL语句
   _sqltexter.GetTable("table01");
    // 生成获取当前数据库的指定数据表信息的SQL语句SQL语句
   _sqltexter.GetTable("database","table01");
   
    // 生成获取当前数据库的数据表列表的SQL语句
   _sqltexter.GetTableList();
    // 生成获取指定数据库的数据表列表的SQL语句
   _sqltexter.GetTableList("database");
   
    // 生成删除当前数据库的数据表的SQL语句
   _sqltexter.DeleteTable("table01");
    // 生成删除指定数据库的数据表的SQL语句
   _sqltexter.DeleteTable("database","table01");
   
    // 生成创建数据表的SQL语句
   _sqltexter.CreateTable("table01", new List<DbColumn>());
    // 生成创建数据表的SQL语句
   _sqltexter.CreateTable("database", "table01", new List<DbColumn>());
   
   

4. 生成视图(View)相关的SQL语句

   
   // 生成获取当前数据库的指定View的数据列信息的SQL语句
   _sqltexter.GetViewColumns("view01");
   // 生成获取指定数据库的指定View的数据列信息的SQL语句
   _sqltexter.GetViewColumns("database","view01");
   
    // 生成获取当前数据库的指定View信息的SQL语句SQL语句
   _sqltexter.GetView("view01");
    // 生成获取当前数据库的指定View信息的SQL语句SQL语句
   _sqltexter.GetView("database","view01");
   
    // 生成获取当前数据库的View列表的SQL语句
   _sqltexter.GetViewList();
    // 生成获取指定数据库的View列表的SQL语句
   _sqltexter.GetViewList("database");
   
    // 生成删除当前数据库的View的SQL语句
   _sqltexter.DeleteView("view01");
    // 生成删除指定数据库的View的SQL语句
   _sqltexter.DeleteView("database","view01");
   
   

5. 生成函数(Function)相关的SQL语句

   
   // 生成获取当前数据库的指定函数信息的SQL语句
   _sqltexter.GetFunction("func01");
   // 生成获取指定数据库的指定函数信息的SQL语句
   _sqltexter.GetFunction("database","func01");
   
    // 生成获取当前数据库的函数列表的SQL语句
   _sqltexter.GetFunctionList();
    // 生成获取指定数据库的函数列表的SQL语句
   _sqltexter.GetFunctionList("database");
   
    // 生成删除当前数据库的Function的SQL语句
   _sqltexter.DeleteFunction("func01");
    // 生成删除指定数据库指定函数的SQL语句
   _sqltexter.DeleteFunction("database","func01");
   
   

6. 生成存储过程(Procedure)相关的SQL语句

   
   // 生成获取当前数据库的指定存储过程信息的SQL语句
   _sqltexter.GetProcedure("proc01");
   // 生成获取指定数据库的指定存储过程信息的SQL语句
   _sqltexter.GetProcedure("database","proc01");
   
    // 生成获取当前数据库的存储过程列表的SQL语句
   _sqltexter.GetProcedureList();
    // 生成获取指定数据库的存储过程列表的SQL语句
   _sqltexter.GetProcedureList("database");
   
    // 生成删除当前数据库的Procedure的SQL语句
   _sqltexter.DeleteProcedure("proc01");
    // 生成删除指定数据库指定存储过程的SQL语句
   _sqltexter.DeleteProcedure("database","proc01");
   
   

4.4 扩展使用

1)ToEntity1st（查询数据，并将首条数据转换为数据实例）

// ToEntity1st（查询数据，并将首条数据转换为数据实例）
using JCoder.Db4Net;
using JCoder.Db4Net;

IDbOperator _operator = new MsSqlFactoryOperator()
{
    ConnectionString = "Server=127.0.0.1;Database=test;Uid = user; Pwd=testpassword;"
};
return this.Operator.ToEntity1st<T>("select top 1 * from table1;");

2)ToEntities（查询数据，并转换为数据实体列表）

// ToEntities（查询数据，并转换为数据实体列表）
using JCoder.Db4Net;

IDbOperator _operator = new MsSqlFactoryOperator()
{
    ConnectionString = "Server=127.0.0.1;Database=test;Uid = user; Pwd=testpassword;"
};
return this.Operator.ToEntities<T>("select top 10 * from table1;");

3)CRUD（增删查改）

using JCoder.Db4Net;

// Test Entity Class
[DbTable("t_table_test")]
 public class TestEntity
 {
     [DbPrimaryKey]
     [DbAutoIncrement]
     public int Key001 { get; set; }
     [DbPrimaryKey]
     [DbField(IsUnique=true)]
     public string Key002 { get; set; }

     [DbIndex("idx01")]
     public string C003 { get; set; }
 }

IDbOperator _operator = new MsSqlFactoryOperator()
{
    ConnectionString = "Server=127.0.0.1;Database=test;Uid = user; Pwd=testpassword;"
};

TestEntity x = new TestEntity()
{
    Key001 = 101,
    Key002 = "Test PK",
};

// Insert Data（新增数据）
this.Operator.Insert<TestEntity>(x);

// Update Data（更新数据）
x.C003 = "Update Test";
this.Operator.Update<TestEntity>(x);

// Delete Data（删除数据）
this.Operator.Delete<TestEntity>(x);

// Select Data（查询数据）
this.Operator.Select1st<TEntity>(" and Key001=101 and Key002-'Test PK'");

4)Create\Drop Table From Entity（由实体类创建\删除数据库的数据表）

using JCoder.Db4Net;

// Test Entity Class
 [DbTable("t_table_test")]
 public class TestEntity
 {
     [DbPrimaryKey]
     [DbAutoIncrement]
     public int Key001 { get; set; }
     [DbPrimaryKey]
     [DbField(IsUnique =true)]
     public string Key002 { get; set; }
     [DbIgnore]
     public string Key003 { get; set; }

     [DbIndex]
     [DbField(AllowNull = false, Default = "", Description = "Test Comment")]
     public string C001 { get; set; }
     [DbIndex("idx01")]
     public string C002 { get; set; }
     [DbIndex("idx01")]
     public string C003 { get; set; }

     [DbIgnore]
     public int C004 { get; set; }
     [DbField(AllowNull = false, Default = "0", Description = "Test Comment2")]
     public int C005 { get; set; }
     [DbNumberFieldExt(Precision = 11, Scale = 2)]
     public double C006 { get; set; }

     [DbField(AllowNull = false, Default = "", Description = "Test Comment2")]
     public string C007 { get; set; }
     public string C008 { get; set; }
     [DbTimeFieldExt(UpdateTimeOnCreate = true, UpdateTimeOnUpdate = true)]
     public DateTime C009 { get; set; }
 }

IDbOperator _operator = new MsSqlFactoryOperator()
{
    ConnectionString = "Server=127.0.0.1;Database=test;Uid = user; Pwd=testpassword;"
};

this.Operator.CreateTable<TestEntity>();
this.Operator.DropTable<TestEntity>();
   

3.5 Orm工具类使用

1)转换首条数据为实体对象(支持DbDataReader、DataTable)

using JCoder.Db4Net;

// data source
var _table = new DataTable();
// Property only.
var _result = JCoder.Db4Net.Orm.ToObject1st<T>(_table);
var _result = _table.ToObject1st<T>();
// Attributes first
var _result = JCoder.Db4Net.Orm.ToEntity1st<T>(_table);
var _result = _table.ToEntity1st<T>();

2)将数据转换为实体对象(支持DataRow、IDictionary<string, string>、IDictionary<string, object>))

using JCoder.Db4Net;

// data source
var _dict = new Dictionary<string, string>();   
// Attributes first
var _result = JCoder.Db4Net.Orm.ToEntity<T>(_dict);  
var _result = _dict.ToEntity<T>();     
// Property only.
var _result = JCoder.Db4Net.Orm.ToObject<T>(_dict);
var _result = _dict.ToObject<T>();

3)将数据源转换为实体对象列表(支持DbDataReader、DataTable)

using JCoder.Db4Net;

// data source
var _table = new DataTable();   
// Attributes first
var _result = JCoder.Db4Net.Orm.ToEntities<T>(_table);
var _result = _table.ToEntities<T>();   
// Property only.
var _result = JCoder.Db4Net.Orm.ToObjects<T>(_table);
var _result = _table.ToObjects<T>();

4)将数据源转换为实体对象字典(支持DbDataReader、DataTable)

using JCoder.Db4Net;

// data source
var _table = new DataTable();
_table.Columns.Add(new DataColumn("ID", typeof(string)));

// Property only.
var _result = JCoder.Db4Net.Orm.ToObjectDict<T>(_table, "ID");
var _result = _table.ToObjectDict<T>("ID");
// Attributes first
var _result = JCoder.Db4Net.Orm.ToEntityDict<T>(_table, "ID");
var _result = _table.ToEntityDict<T>("ID");

5)将数据填充到已有的实体对象里(支持DbDataReader、DataRow、IDictionary<string, string>、IDictionary<string, object>)

using JCoder.Db4Net;

var _target = new T();

// data source
var _source = new DbDataReader();   
// Property only.
var _result = JCoder.Db4Net.Orm.FillInObject<T>(_source, _target);
var _result = _source.FillInObject<T>(_target);
// Attributes first
var _result = JCoder.Db4Net.Orm.FillInEntity<T>(_source, _target);
var _result = _source.FillInEntity<T>(_target);

6)将实体对象转换为DataTable

using JCoder.Db4Net;

var _list = new List<T>();
var t = new T();

// Property only.
// 实体对象转换为DataTable
DataTable _table = JCoder.Db4Net.Orm.ObjectToDataTable(t);
DataTable _table = t.ObjectToDataTable();
// 实体对象列表转换为DataTable
DataTable _table = JCoder.Db4Net.Orm.ObjectsToDataTable(_list);
DataTable _table = _list.ObjectsToDataTable();

// Attributes first
// 实体对象转换为DataTable
DataTable _table = JCoder.Db4Net.Orm.EntityToDataTable(t);
DataTable _table = t.EntityToDataTable();
// 实体对象列表转换为DataTable
DataTable _table = JCoder.Db4Net.Orm.EntitiesToDataTable(_list);
DataTable _table = _list.EntitiesToDataTable();

7)将List转换为DataTable

using JCoder.Db4Net;

// 将List转换为DataTable（使用特性进行排序，自定义名称等）
public class BoTest
{
     [DbSubField("Width", "S001-Width", Sort = 2120)]//获取Size对象里的Width属性值，并显示为"S001-Width"
     [DbSubField("Height", "S001-Height", Sort = 2121)]//获取Size对象里的Height属性值，并显示为"S001-Height"
     public Size S001 { get; set; }
     public string Key { get; set; }
     [DbEnumName]//枚举显示为文本
     public AttributeTargets AT { get; set; }
     public AttributeTargets AT2 { get; set; }
     [DbSort(100)]
     public string P100 { get; set; }
     [DbSort(111)]//设置排序值（从小到大依次排序）
     public string P111 { get; set; }
     public DateTime CreateTime { get; set; }
     [DbIgnoreConvertion]//转换时忽略
     public int Z001 { get; set; }
}

 var _list = new List<BoTest>();
 for (int i = 0; i < 100; i++)
 {
     _list.Add(new()
     {
         S001 = new(i * 100, i * 1000),
         Key = $"Key_{i}",
         P100 = $"P100_{i}",
         P111 = $"P111_{i}",
         CreateTime = DateTime.Now,
         Z001 = i,
         AT = AttributeTargets.Interface,
         AT2 = AttributeTargets.Delegate,
     });
 }
 var _table = JCoder.Db4Net.Orm.EntitiesToDataTable(_list);

8)将实体对象转换为Dictionary<string,string>

using JCoder.Db4Net;

var t = new T();

// Property only.
// 实体对象转换为Dictionary<string,string>
Dictionary<string, string> _dict = JCoder.Db4Net.Orm.ObjectToDict(t);
Dictionary<string, string> _dict = t.ObjectToDict();

// Attributes first
// 实体对象转换为Dictionary<string,string>
Dictionary<string, string> _dict = JCoder.Db4Net.Orm.EntityToDict(t);
Dictionary<string, string> _dict = t.EntityToDict();

3.6 类Linq方式

1) Query查询数据

using JCoder.Db4Net;

IDbOperator _dber = Db.Hub.GetDberOrNew<MySqlFactoryOperator>();
var _exper = _dber.NewQuery<BoTest001>();
_exper.UseParameter = true; // 是否使用参数化执行Sql(Using sql parameters for sql execution).

_exper.Where(x => x.Key=="ABC"); // 设置筛选条件，Key="ABC"
_exper.Where(x => x.Key=="ABC" || x.Int001 > 5); // 设置筛选条件，Key="ABC" 或者 Int001>5
_exper.Where(x => x.Key=="ABC" && x.Int001 > 5); // 设置筛选条件，Key="ABC" 并且 Int001>5
_exper.Where(x => x.Key=="ABC")
      .Where(x => x.Int001 > 5); // 设置筛选条件，Key="ABC" 并且 Int001>5

_exper.OrderBy(x => x.Key); // 设置排序，以Key排序
_exper.OrderByDesc(x => x.Key); // 设置排序，以Key倒序
_exper.OrderBy(x => x.Bool001)
      .OrderByDesc(x => x.Key); // 设置排序，Bool001为第一排序，Key为第二排序（倒序）
      
_exper.Limited(5); // 设置只获取前5条数据
_exper.Limited(20,5); // 设置获取从第20条起的5条数据
_exper.Paging(5,10); // 设置获取第5页数据（10条数据为1页，起始页码为1）

_exper.SetColumn(x => x.AT); // 设置只查询AT数据列
_exper.SetColumn("Column001", x => x.CreateTime); // 设置只查询CreateTime数据列，并为之重命名为Column001

// 执行SQL并返回结果
DbResultTable _result = _exper.RunForTableR();
DataTable _result = _exper.RunForTable();
List<BoTest001> _result = _exper.RunForEntities();
BoTest001 _result = _exper.RunForEntity1st();
DbResult<bool> _result = _exper.RunForExistR();
bool _result = _exper.RunForExist();

2) Delete删除数据

using JCoder.Db4Net;

IDbOperator _dber = Db.Hub.GetDberOrNew<MySqlFactoryOperator>();
var _exper = _dber.NewDelete<BoTest001>();
_exper.UseParameter = true; // 是否使用参数化执行Sql(Using sql parameters for sql execution).

_exper.Where(x => x.Key=="ABC"); // 设置筛选条件，Key="ABC"
_exper.Where(x => x.Key=="ABC" || x.Int001 > 5); // 设置筛选条件，Key="ABC" 或者 Int001>5
_exper.Where(x => x.Key=="ABC" && x.Int001 > 5); // 设置筛选条件，Key="ABC" 并且 Int001>5
_exper.Where(x => x.Key=="ABC")
      .Where(x => x.Int001 > 5); // 设置筛选条件，Key="ABC" 并且 Int001>5

_exper.OrderBy(x => x.Key); // 设置排序，以Key排序
_exper.OrderByDesc(x => x.Key); // 设置排序，以Key倒序
_exper.OrderBy(x => x.Bool001)
      .OrderByDesc(x => x.Key); // 设置排序，Bool001为第一排序，Key为第二排序（倒序）
      
_exper.Limited(5); // 设置只删除前5条数据

// 执行SQL并返回结果
DbResultCount _result = _exper.RunR();
int _result = _exper.Run();

3) Update更新数据

using JCoder.Db4Net;

IDbOperator _dber = Db.Hub.GetDberOrNew<MySqlFactoryOperator>();
var _exper = _dber.NewUpdate<BoTest001>();
_exper.UseParameter = true; // 是否使用参数化执行Sql(Using sql parameters for sql execution).

_exper.Where(x => x.Key=="ABC"); // 设置筛选条件，Key="ABC"
_exper.Where(x => x.Key=="ABC" || x.Int001 > 5); // 设置筛选条件，Key="ABC" 或者 Int001>5
_exper.Where(x => x.Key=="ABC" && x.Int001 > 5); // 设置筛选条件，Key="ABC" 并且 Int001>5
_exper.Where(x => x.Key=="ABC")
      .Where(x => x.Int001 > 5); // 设置筛选条件，Key="ABC" 并且 Int001>5

_exper.OrderBy(x => x.Key); // 设置排序，以Key排序
_exper.OrderByDesc(x => x.Key); // 设置排序，以Key倒序
_exper.OrderBy(x => x.Bool001)
      .OrderByDesc(x => x.Key); // 设置排序，Bool001为第一排序，Key为第二排序（倒序）
      
_exper.Limited(5); // 设置只删除前5条数据

_exper.Update(x => x.Key=="ABC"); // 更新数据列Key的值为ABC
_exper.Update(x => x.Key=="ABC" && x.Int001 == 5); // 更新数据列Key的值为ABC，数据列Int001的值为5
_exper.Update(x => x.CreateTime， DateTime.Now); // 更新数据列CreateTime的值为当前时间

// 执行SQL并返回结果
DbResultCount _result = _exper.RunR();
int _result = _exper.Run();

实例使用

1. 参考JCoder.Db4Net