首页 > 其他分享 >dapper实现CURD

dapper实现CURD

时间：2023-12-03 21:37:04浏览次数：43  
标签：commandTimeout transaction IDbTransaction 实现 int CURD dapper null public

dapper的使用

 1、引用包

 2、student类

[Table("dbo.Student")]
public partial class Student
{
    [Required]
    public int Id { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }

}

2、DapperRepository中以下两个都需要

①DapperRepository类

public partial class DapperRepository : IDapperRepository
{
    /// <summary>
    /// 数据库连接对象
    /// </summary>
    private readonly IDbConnection _db;

    /// <summary>
    /// 服务提供器
    /// </summary>
    private readonly IServiceProvider _serviceProvider;

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="serviceProvider"></param>
    /// <param name="db"></param>
    public DapperRepository(
      IDbConnection db
      , IServiceProvider serviceProvider = null
    )
    {
        _serviceProvider = serviceProvider;
        _db = db;
    }

    /// <summary>
    /// 连接上下文
    /// </summary>
    public virtual IDbConnection Context
    {
        get
        {
            if (_db.State != ConnectionState.Open) _db.Open();
            return _db;
        }
    }

    /// <summary>
    /// 动态连接上下文
    /// </summary>
    public virtual dynamic DynamicContext { get; }

    /// <summary>
    /// 查询返回动态类型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="buffered"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    public virtual IEnumerable<dynamic> Query(string sql, object param = null, IDbTransaction transaction = null, bool buffered = true, int? commandTimeout = null, CommandType? commandType = null)
    {
        return Context.Query(sql, param, transaction, buffered, commandTimeout, commandType);
    }

    /// <summary>
    /// 查询返回特定类型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="buffered"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    public virtual IEnumerable<T> Query<T>(string sql, object param = null, IDbTransaction transaction = null, bool buffered = true, int? commandTimeout = null, CommandType? commandType = null)
    {
        return Context.Query<T>(sql, param, transaction, buffered, commandTimeout, commandType);
    }

    /// <summary>
    /// 查询返回动态类型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    public virtual Task<IEnumerable<dynamic>> QueryAsync(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
    {
        return Context.QueryAsync(sql, param, transaction, commandTimeout, commandType);
    }

    /// <summary>
    /// 查询返回特定类型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    public virtual Task<IEnumerable<T>> QueryAsync<T>(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
    {
        return Context.QueryAsync<T>(sql: sql, param, transaction, commandTimeout, commandType);
    }

    /// <summary>
    /// 执行命令
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    public virtual int Execute(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
    {
        return Context.Execute(sql, param, transaction, commandTimeout, commandType);
    }

    /// <summary>
    /// 执行命令
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    public virtual Task<int> ExecuteAsync(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null)
    {
        return Context.ExecuteAsync(sql, param, transaction, commandTimeout, commandType);
    }

    /// <summary>
    /// 切换仓储
    /// </summary>
    /// <typeparam name="TEntity">实体类型</typeparam>
    /// <returns>仓储</returns>
    public virtual IDapperRepository<TEntity> Change<TEntity>()
        where TEntity : class, new()
    {
        throw new NotImplementedException();
        // return _serviceProvider.GetService<IDapperRepository<TEntity>>();
    }
}

②DapperRepository

  /// <summary>
  /// Dapper 仓储实现类
  /// </summary>
  /// <typeparam name="TEntity"></typeparam>
  public partial class DapperRepository<TEntity> : DapperRepository, IDapperRepository<TEntity>
      where TEntity : class, new()
  {
      /// <summary>
      /// 构造函数
      /// </summary>
      /// <param name="serviceProvider"></param>
      /// <param name="db"></param>
      public DapperRepository(IDbConnection db
        , IServiceProvider serviceProvider = null) : base(db, serviceProvider)
      {
      }

      /// <summary>
      /// 获取一条
      /// </summary>
      /// <param name="id"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual TEntity Get(object id, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.Get<TEntity>(id, transaction, commandTimeout);
      }

      /// <summary>
      /// 获取一条
      /// </summary>
      /// <param name="id"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual Task<TEntity> GetAsync(object id, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.GetAsync<TEntity>(id, transaction, commandTimeout);
      }

      /// <summary>
      /// 获取所有实体
      /// </summary>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual IEnumerable<TEntity> GetAll(IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.GetAll<TEntity>(transaction, commandTimeout);
      }

      /// <summary>
      /// 获取所有实体
      /// </summary>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual Task<IEnumerable<TEntity>> GetAllAsync(IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.GetAllAsync<TEntity>(transaction, commandTimeout);
      }

      /// <summary>
      /// 新增一条
      /// </summary>
      /// <param name="entity"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual long Insert(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.Insert(entity, transaction, commandTimeout);
      }

      /// <summary>
      /// 新增一条
      /// </summary>
      /// <param name="entity"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <param name="sqlAdapter"></param>
      /// <returns></returns>
      public virtual Task<int> InsertAsync(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null, ISqlAdapter sqlAdapter = null)
      {
          return Context.InsertAsync(entity, transaction, commandTimeout, sqlAdapter);
      }

      /// <summary>
      /// 新增多条
      /// </summary>
      /// <param name="entities"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual long Insert(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.Insert(entities, transaction, commandTimeout);
      }

      /// <summary>
      /// 新增多条
      /// </summary>
      /// <param name="entities"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <param name="sqlAdapter"></param>
      /// <returns></returns>
      public virtual Task<int> InsertAsync(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null, ISqlAdapter sqlAdapter = null)
      {
          return Context.InsertAsync(entities, transaction, commandTimeout, sqlAdapter);
      }

      /// <summary>
      /// 更新一条
      /// </summary>
      /// <param name="entity"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual bool Update(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.Update(entity, transaction, commandTimeout);
      }

      /// <summary>
      /// 更新一条
      /// </summary>
      /// <param name="entity"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual Task<bool> UpdateAsync(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.UpdateAsync(entity, transaction, commandTimeout);
      }

      /// <summary>
      /// 更新多条
      /// </summary>
      /// <param name="entities"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual bool Update(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.Update(entities, transaction, commandTimeout);
      }

      /// <summary>
      /// 更新多条
      /// </summary>
      /// <param name="entities"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual Task<bool> UpdateAsync(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.UpdateAsync(entities, transaction, commandTimeout);
      }

      /// <summary>
      /// 删除一条
      /// </summary>
      /// <param name="entity"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual bool Delete(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.Delete(entity, transaction, commandTimeout);
      }

      /// <summary>
      /// 删除一条
      /// </summary>
      /// <param name="entity"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual Task<bool> DeleteAsync(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.DeleteAsync(entity, transaction, commandTimeout);
      }

      /// <summary>
      /// 删除多条
      /// </summary>
      /// <param name="entities"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual bool Delete(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.Delete(entities, transaction, commandTimeout);
      }

      /// <summary>
      /// 删除多条
      /// </summary>
      /// <param name="entities"></param>
      /// <param name="transaction"></param>
      /// <param name="commandTimeout"></param>
      /// <returns></returns>
      public virtual Task<bool> DeleteAsync(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null)
      {
          return Context.DeleteAsync(entities, transaction, commandTimeout);
      }
  }

3、以下两个都需要

 ①IDapperRepository

/// <summary>
/// 非泛型 Dapper 仓储
/// </summary>
public partial interface IDapperRepository
{
    /// <summary>
    /// 连接上下文
    /// </summary>
    IDbConnection Context { get; }

    /// <summary>
    /// 动态连接上下文
    /// </summary>
    dynamic DynamicContext { get; }

    /// <summary>
    /// 查询返回动态类型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="buffered"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    IEnumerable<dynamic> Query(string sql, object param = null, IDbTransaction transaction = null, bool buffered = true, int? commandTimeout = null, CommandType? commandType = null);

    /// <summary>
    /// 查询返回特定类型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="buffered"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    IEnumerable<T> Query<T>(string sql, object param = null, IDbTransaction transaction = null, bool buffered = true, int? commandTimeout = null, CommandType? commandType = null);

    /// <summary>
    /// 查询返回动态类型
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    Task<IEnumerable<dynamic>> QueryAsync(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null);

    /// <summary>
    /// 查询返回特定类型
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    Task<IEnumerable<T>> QueryAsync<T>(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null);

    /// <summary>
    /// 执行命令
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    int Execute(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null);

    /// <summary>
    /// 执行命令
    /// </summary>
    /// <param name="sql"></param>
    /// <param name="param"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="commandType"></param>
    /// <returns></returns>
    Task<int> ExecuteAsync(string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null);

    /// <summary>
    /// 切换仓储
    /// </summary>
    /// <typeparam name="TEntity">实体类型</typeparam>
    /// <returns>仓储</returns>
    IDapperRepository<TEntity> Change<TEntity>()
        where TEntity : class, new();
}

②IDapperRepository

/// <summary>
/// Dapper 仓储接口定义
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public partial interface IDapperRepository<TEntity> : IDapperRepository
    where TEntity : class, new()
{
    /// <summary>
    /// 获取一条
    /// </summary>
    /// <param name="id"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    TEntity Get(object id, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 获取一条
    /// </summary>
    /// <param name="id"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    Task<TEntity> GetAsync(object id, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 获取所有实体
    /// </summary>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    IEnumerable<TEntity> GetAll(IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 获取所有实体
    /// </summary>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    Task<IEnumerable<TEntity>> GetAllAsync(IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 新增一条
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    long Insert(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 新增一条
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="sqlAdapter"></param>
    /// <returns></returns>
    Task<int> InsertAsync(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null, ISqlAdapter sqlAdapter = null);

    /// <summary>
    /// 新增多条
    /// </summary>
    /// <param name="entities"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    long Insert(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 新增多条
    /// </summary>
    /// <param name="entities"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <param name="sqlAdapter"></param>
    /// <returns></returns>
    Task<int> InsertAsync(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null, ISqlAdapter sqlAdapter = null);

    /// <summary>
    /// 更新一条
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    bool Update(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 更新一条
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    Task<bool> UpdateAsync(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 更新多条
    /// </summary>
    /// <param name="entities"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    bool Update(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 更新多条
    /// </summary>
    /// <param name="entities"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    Task<bool> UpdateAsync(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 删除一条
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    bool Delete(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 删除一条
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    Task<bool> DeleteAsync(TEntity entity, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 删除多条
    /// </summary>
    /// <param name="entities"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    bool Delete(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null);

    /// <summary>
    /// 删除多条
    /// </summary>
    /// <param name="entities"></param>
    /// <param name="transaction"></param>
    /// <param name="commandTimeout"></param>
    /// <returns></returns>
    Task<bool> DeleteAsync(IEnumerable<TEntity> entities, IDbTransaction transaction = null, int? commandTimeout = null);
}

4、MSReposity类

public class MSReposity : DapperRepository
{
    public MSReposity(object sqlConnection) : base(MSReposity.MssConnection, null) { }

    /// <summary>
    /// 必须设置数据库连接地址
    /// </summary>
    public static SqlConnection MssConnection
    {
        get;
        set;
    }
}

public class MSReposity<T> : DapperRepository<T> where T : class, new()
{
    MSReposity(IDbConnection db, IServiceProvider serviceProvider = null) : base(MSReposity.MssConnection, serviceProvider)
    {
    }

    public MSReposity() : base(MSReposity.MssConnection, null) { }
}

5、Service类

internal class Service
{
    private readonly MSReposity<Student> repo;

    string QuerySql = $"Select * from student";
    string UpdateSql = "UPDATE student SET name= @name, address= @address WHERE id = @id;";
    string InsertSql = "INSERT INTO student (name, address) VALUES (@name, @address);";
    string DeleteSql = "DELETE FROM student WHERE id = @id;";
    
    public Service() 
    {
        MSReposity.MssConnection = new System.Data.SqlClient.SqlConnection(ConnectionConfiguration.Connection);
        repo = new MSReposity<Student>();
    }

    /// <summary>
    /// 查询
    /// </summary>
    /// <returns></returns>
    public IEnumerable<Student> Query()
    {
        List<Student> res = new List<Student>();
        
        try
        {
            var tmps = repo.Query<Student>(QuerySql);
            foreach (var item in tmps)
            {
                Student student = new Student() {Id = item.Id, Name = item.Name,  Address = item.Address };
                res.Add(student);
            }
        }
        catch (Exception exp)
        { }
        return res;
    }

    /// <summary>
    /// 更新
    /// </summary>
    /// <param name="input"></param>
    public void Update(Student input)
    {
        try
        {
            if (null != input)
            {
                repo.Execute(UpdateSql, input);
            }
        }
        catch (Exception exp)
        {
            throw exp;
        }
    }

    /// <summary>
    /// 插入
    /// </summary>
    /// <param name="student"></param>
    public void Insert(Student input)
    {
        try
        {
            if (null != input)
            {
                repo.Execute(InsertSql, input);
            }
        }
        catch (Exception exp)
        {
            throw exp;
        }
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="student"></param>
    public void Delete(Student input)
    {
        try
        {
            if (null != input)
            {
                repo.Execute(DeleteSql, new { id=input.Id});
            }
        }
        catch (Exception exp)
        {
            throw exp;
        }
    }

}

6、ConnectionConfiguration类

public class ConnectionConfiguration
{
    public static string Connection { get; set; } = @"Data Source=DESKTOP-NJ2V6IC;Initial Catalog=Study;Integrated Security=True";
}

7、页面

public partial class Form1 : Form
{
    Service service;
    public Form1()
    {
        InitializeComponent();
        service = new Service();
    }

    /// <summary>
    /// 加载数据
    /// </summary>
    void Load()
    {
        dataGridView1.Rows.Clear();
        List<Student> students = service.Query().ToList();
        foreach (var student in students)
        {
            int index = dataGridView1.Rows.Add();
            dataGridView1.Rows[index].Cells[0].Value = student.Id;
            dataGridView1.Rows[index].Cells[1].Value = student.Name;
            dataGridView1.Rows[index].Cells[2].Value = student.Address;
        }
    }

    /// <summary>
    /// 查询
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void button1_Click(object sender, EventArgs e)
    {
        Load();
    }

    /// <summary>
    /// 修改
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void button2_Click(object sender, EventArgs e)
    {
        try
        {
            int index = dataGridView1.CurrentRow.Index;
            if (index != -1)
            {
                Student student = new Student();
                student.Id = int.Parse(dataGridView1.Rows[index].Cells[0].Value.ToString());
                student.Name = dataGridView1.Rows[index].Cells[1].Value.ToString();
                student.Address = dataGridView1.Rows[index].Cells[2].Value.ToString();

                service.Update(student);
                MessageBox.Show("更新成功");
            }
        }
        catch (Exception ex)
        {

        }
    }

    /// <summary>
    /// 插入
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void button3_Click(object sender, EventArgs e)
    {
        try
        {
            int index = dataGridView1.CurrentRow.Index;
            if (index != -1)
            {
                Student student = new Student();
                student.Name = dataGridView1.Rows[index].Cells[1].Value.ToString();
                student.Address = dataGridView1.Rows[index].Cells[2].Value.ToString();

                service.Insert(student);
                MessageBox.Show("插入成功");
            }
        }
        catch (Exception ex)
        {

        }
    }

    /// <summary>
    /// 删除
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void button4_Click(object sender, EventArgs e)
    {
        try
        {
            int index = dataGridView1.CurrentRow.Index;
            if (index != -1)
            {
                Student student = new Student();
                student.Id = int.Parse(dataGridView1.Rows[index].Cells[0].Value.ToString());

                service.Delete(student);
                MessageBox.Show("删除成功");
            }
        }
        catch (Exception ex)
        {

        }
    }

}

 

标签：commandTimeout,transaction,IDbTransaction,实现,int,CURD,dapper,null,public
From： https://www.cnblogs.com/wokkkkkk/p/17873810.html

相关文章

  • 2023-2024-1 20211211 《信息安全系统设计与实现（上）》第14章
    MYSQL简介MySQL是一个关系数据库系统在关系数据库中，数据存储在表中。每个表由多个行和列组成。表中的数据相互关联。表也可能与其他表有关联。关系结构使得可在表上运行查询来检索信息并修改数据库中的数据。MySQL是一个开源数据库管理系统，由服务器和客户机组成。在将客户机连接......
  • 如何实现 token 加密
    以最常见的token格式jwt为例,token分为三段，分别是header、payload、signature。其中，header标识签名算法和令牌类型；payload标识主体信息，包含令牌过期时间、发布时间、发行者、主体内容等；signature是使用特定的算法对前面两部分进行加密，得到的加密结果。token有防篡改的......
  • 信息安全系统设计与实现——学习笔记12
    任务详情：自学教材，提交学习笔记Part1知识点归纳&GPT提问知识点归纳1.什么是MySQLMySQL是一个关系数据库系统。在关系数据库中，数据存储在表中。关系数据库系统的标准查询语言是SQL(结构化查询语言)2.UbuntuLinux下MySQL的安装与使用（1）安装MySQL命令sudoapt-getinstallmys......
  • 信息安全系统设计与实现学习笔记12
    信息安全系统设计与实现学习笔记12一、知识点归纳以及自己最有收获的内容1.知识点归纳第14章MySQL数据库系统MySQLMySQL是一个关系型数据库管理系统，由瑞典MySQLAB公司开发，目前属于Oracle公司。特点开源性，隶属于Oracle旗下产品。支持大型数据库，处理上千万条记录的大......
  • yocto-queue 库如何实现替代数组【玩转源码】
    前言前面提到了可以使用yocto-queue库代替Array操作数组，本篇则深入源码了解一下yocto-queue是如何实现替代数组的。yocto-queue源码分析源码中的代码量相对较少，读起来会比较轻松，看似可以琢磨的点少，其实不然。代码中包含知识点主要包括类的属性、链表与数组的对比、队列、自定义迭代......
  • 仿京东淘宝商品列表筛选组件：实现一个高效的侧边栏弹框筛选功能
    仿京东淘宝商品列表筛选组件：实现一个高效的侧边栏弹框筛选功能一、引言随着电子商务的快速发展，用户体验成为了竞争的关键因素。在众多的电商网站中，如京东和淘宝，商品列表筛选功能为用户提供了便捷的途径来找到心仪的商品。本文将详细介绍如何使用cc-widget、uni-icons和xg-list......
  • asyncio协程库实现原理剖析
    目录迭代器可迭代对象&迭代器自定义迭代器生成器生成器就是迭代器生成器的4个状态用yield重构迭代器生成器三种应用场景生成器进阶函数运行机制函数对象和代码对象函数运行帧同步和异步协程yield表达式yield表达式的优先级send()用法yield表达式作为函数入参使用close()结束生成......
  • 《信息安全系统设计与实现》第十三周学习笔记
    第十四章MYSQL实践mysql简介MySQL是一个开源数据库管理系统，由服务器和客户机组成。在将客户机连接到服务器后，用户可向服务器输入SQL命令，以便创建数据库，删除数据库，存储、组织和检索数据库中的数据。MySQL有广泛的应用。mysql安装利用sudoaptinstallmysql-server命令进行......
  • 《信息安全系统设计与实现》第13周学习笔记
    MySQL简介MySQL是一种开源的关系型数据库管理系统，由瑞典MySQLAB公司开发并维护，后被SunMicrosystems收购，再后被Oracle收购。MySQL以其高性能、稳定可靠、易于使用和广泛支持的特点而闻名。它支持多种操作系统，包括Windows、Linux和MacOS等。MySQL使用标准的SQL语言进行数据的存......
  • 《信息安全系统设计与实现》第十三周学习笔记
      第十四章MYSQL实践mysql简介MySQL是一个开源数据库管理系统，由服务器和客户机组成。在将客户机连接到服务器后，用户可向服务器输入SQL命令，以便创建数据库，删除数据库，存储、组织和检索数据库中的数据。MySQL有广泛的应用。mysql安装在ubuntu中使用sudoaptinstallmysql-......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99