C#：30行数据插入到数据库中的效率测试-一行行执行、构造SQL一次执行、SqlBulkCopy...

最新推荐文章于 2021-12-02 07:00:12 发布
最新推荐文章于 2021-12-02 07:00:12 发布
阅读量90 收藏
点赞数
文章标签： c# 数据库
原文链接：http://www.cnblogs.com/Ferry/archive/2010/11/11/1874665.html
版权
 CSDN中看到有人问这一样一个问题： 

 

 

GridView中有30條記錄： 


產品編號         產品名稱                 產品價格 

001                   男士活力潔面乳     39 

002                   男士剃鬚刀             109 

...... 

030                   男士沐浴香波         120 


有兩种方法寫入數據庫： 

（1） 


打開數據庫連接 

逐條插入數據 

關閉連接 


（2） 

拼湊出更新數據的SQL語句 

打開數據庫連接 

執行這條拼湊的SQL語句 

關閉數據庫連接 


請問哪一種效率更高？大概能高出多少？ 


另外，在ASP.NET   2.0中，有SqlBulkCopy類，它能完全取代普通的ADO.NET操作嗎？ 


 

于是我做了个简单测试，代码如下：

 

数据库表很简单：

CREATE TABLE [dbo].[TestTable](
[ID] [int] NULL,
[CreateDateTime] [datetime] NULL,
[TestMethod] [nvarchar](50) NULL
) ON [PRIMARY]

 

 

 ExpandedBlockStart.gif代码

using  System;
 using  System.Text;
 using  System.Data;
 using  System.Data.SqlClient;

 namespace  InsertEfficiency
{
     class  Program
    {
         static   void  Main( string [] args)
        {
             // 构造数据源
            DataTable dt  =   new  DataTable();
            dt.Columns.Add( new  DataColumn( " ID " , typeof ( int )));
            dt.Columns.Add( new  DataColumn( " CreateDateTime " , typeof (DateTime)));
            dt.Columns.Add( new  DataColumn( " TestMethod " ,  typeof ( string )));

             for  ( int  i  =   1 ; i  <=   30 ; i ++ )
            {
                dt.Rows.Add( new   object [] { i, DateTime.Now,  " ExecuteSqlBulkCopy "  });
            }

            Test t  =   new  Test();

            DateTime begin1  =  DateTime.Now;
            t.ExecuteRowByRow(dt);
            DateTime end1  =  DateTime.Now;
            Console.WriteLine( " ExecuteRowByRow:{0}ms " , (end1  -  begin1).Milliseconds);

            DateTime begin2  =  DateTime.Now;
            t.ExecuteOnce(dt);
            DateTime end2  =  DateTime.Now;
            Console.WriteLine( " ExecuteOnce:{0}ms " , (end2  -  begin2).Milliseconds);

            DateTime begin3  =  DateTime.Now;
            t.ExecuteSqlBulkCopy(dt);
            DateTime end3  =  DateTime.Now;
            Console.WriteLine( " ExecuteSqlBulkCopy:{0}ms " , (end3  -  begin3).Milliseconds);

            Console.ReadLine();
        }
    }

     class  Test 
    {
         public  Test()
        {
        }

         public   void  ExecuteRowByRow(DataTable dt)
        {
             using (SqlConnection conn  =   new  SqlConnection(GetConnectionString))
            {
                conn.Open();
                 for  ( int  rowIndex  =   0 ; rowIndex  <  dt.Rows.Count; rowIndex ++ )
                {
                    DataRow dr  =  dt.Rows[rowIndex];

                    SqlCommand cmd  =   new  SqlCommand();
                    cmd.Connection  =  conn;
                    cmd.CommandText  =   string .Format( " insert into TestTable values ({0},'{1}','{2}') " ,
                        dr[ 0 ].ToString(), dr[ 1 ].ToString(),  " ExecuteRowByRow " );
                    cmd.ExecuteNonQuery();
                }
            }
        }
         public   void  ExecuteOnce(DataTable dt)
        {
            StringBuilder strSql  =   new  StringBuilder();
             for  ( int  rowIndex  =   0 ; rowIndex  <  dt.Rows.Count; rowIndex ++ )
            {
                DataRow dr  =  dt.Rows[rowIndex];
                 string  sql  =   string .Format( " insert into TestTable values ({0},'{1}','{2}') " ,
                        dr[ 0 ].ToString(), dr[ 1 ].ToString(),  " ExecuteOnce " );
                 if  (strSql.ToString().Length  ==   0 )
                {
                    strSql.Append(sql);
                }
                 else
                {
                    strSql.Append( " ; " ).Append(sql);
                }

            }
             using  (SqlConnection conn  =   new  SqlConnection(GetConnectionString))
            {
                conn.Open();
                SqlCommand cmd  =   new  SqlCommand();
                cmd.Connection  =  conn;
                cmd.CommandText  =  strSql.ToString();
                cmd.ExecuteNonQuery();
            }
        }

         public   void  ExecuteSqlBulkCopy(DataTable dt)
        {
             using  (SqlConnection conn  =   new  SqlConnection(GetConnectionString))
            {
                SqlBulkCopy bulk  =   new  SqlBulkCopy(conn);
                bulk.DestinationTableName  =   " TestTable " ;
                bulk.BatchSize  =  dt.Rows.Count;

                 if  (dt  !=   null   &&  dt.Rows.Count  !=   0 )
                {
                    conn.Open();
                    bulk.WriteToServer(dt);
                }
                bulk.Close();
            }
        }

         string  GetConnectionString
        {
             get
            {
                 return   @" server=.\mssqlserver2008;database=test;uid=sa;pwd=123456 " ;
            }
        }
    }
}

 

 

测试结果：

 

第一次执行ExecuteRowByRow:151msExecuteOnce:19msExecuteSqlBulkCopy:5ms 

 

 

第二次执行ExecuteRowByRow:140msExecuteOnce:15msExecuteSqlBulkCopy:6ms

 

 

 

第三次执行ExecuteRowByRow:179msExecuteOnce:18msExecuteSqlBulkCopy:5ms 

 

 虽然测试方法比较简单，但基本能说明问题了。

 -----------------------------------------------------------------------------------------------------------------------------------------------

 多线程测试一、

using  System;
 using  System.Text;
 using  System.Data;
 using  System.Data.SqlClient;
 using  System.Threading;

 namespace  InsertEfficiency
{
     class  Program
    {
         static   void  Main( string [] args)
        {
            Test t  =   new  Test();
            t.Testing();
            Console.ReadLine();
        }

    }

     class  Test 
    {
        DataTable dt  =   new  DataTable();

         public  Test()
        {
            CreateData();
        }

         private   void  CreateData()
        {
             // 构造数据源
            dt.Columns.Add( new  DataColumn( " ID " ,  typeof ( int )));
            dt.Columns.Add( new  DataColumn( " CreateDateTime " ,  typeof (DateTime)));
            dt.Columns.Add( new  DataColumn( " TestMethod " ,  typeof ( string )));

             for  ( int  i  =   1 ; i  <=   30 ; i ++ )
            {
                dt.Rows.Add( new   object [] { i, DateTime.Now,  " ExecuteSqlBulkCopy "  });
            }
        }

         public   void  Testing()
        {
             for  ( int  i  =   0 ; i  <   20 ; i ++ )
            {
                Thread t  =   new  Thread( new  ParameterizedThreadStart(ExcuteTesting));
                t.Start(i);
            }
        }

         private   void  ExcuteTesting( object  TreadNo)
        {
            DateTime begin1  =  DateTime.Now;
            ExecuteRowByRow();
            DateTime end1  =  DateTime.Now;
            Console.WriteLine( " Tread-{0}-ExecuteRowByRow:{1}ms " , TreadNo,(end1  -  begin1).Milliseconds);

            DateTime begin2  =  DateTime.Now;
            ExecuteOnce();
            DateTime end2  =  DateTime.Now;
            Console.WriteLine( " Tread-{0}-ExecuteOnce:{1}ms " , TreadNo, (end2  -  begin2).Milliseconds);

            DateTime begin3  =  DateTime.Now;
            ExecuteSqlBulkCopy();
            DateTime end3  =  DateTime.Now;
            Console.WriteLine( " Tread-{0}-ExecuteSqlBulkCopy:{1}ms " , TreadNo,(end3  -  begin3).Milliseconds);

            Console.WriteLine( " Tread-{0} execute successfully\r\n " , TreadNo);
            
        }

         private   void  ExecuteRowByRow()
        {
             using (SqlConnection conn  =   new  SqlConnection(GetConnectionString))
            {
                SqlCommand cmd  =   new  SqlCommand();
                cmd.Connection  =  conn;
                DataRow dr;
                conn.Open();
                SqlTransaction tran  =  conn.BeginTransaction();
                 try
                {
                     for  ( int  rowIndex  =   0 ; rowIndex  <  dt.Rows.Count; rowIndex ++ )
                    {
                        dr  =  dt.Rows[rowIndex];
                        cmd.CommandText  =   string .Format( " insert into TestTable values ({0},'{1}','{2}') " ,
                            dr[ 0 ].ToString(), dr[ 1 ].ToString(),  " ExecuteRowByRow " );
                        cmd.ExecuteNonQuery();
                    }
                    tran.Commit();
                }
                 catch
                {
                    tran.Rollback();
                }
            }
        }

         private   void  ExecuteOnce()
        {
            StringBuilder strSql  =   new  StringBuilder();
             for  ( int  rowIndex  =   0 ; rowIndex  <  dt.Rows.Count; rowIndex ++ )
            {
                DataRow dr  =  dt.Rows[rowIndex];
                 string  sql  =   string .Format( " insert into TestTable values ({0},'{1}','{2}') " ,
                        dr[ 0 ].ToString(), dr[ 1 ].ToString(),  " ExecuteOnce " );
                 if  (strSql.ToString().Length  ==   0 )
                {
                    strSql.Append(sql);
                }
                 else
                {
                    strSql.Append( " ; " ).Append(sql);
                }

            }
             using  (SqlConnection conn  =   new  SqlConnection(GetConnectionString))
            {
                SqlCommand cmd  =   new  SqlCommand();
                cmd.Connection  =  conn;
                cmd.CommandText  =  strSql.ToString();
                conn.Open();
                cmd.ExecuteNonQuery();
            }
        }

         public   void  ExecuteSqlBulkCopy()
        {
             using  (SqlConnection conn  =   new  SqlConnection(GetConnectionString))
            {
                SqlBulkCopy bulk  =   new  SqlBulkCopy(conn);
                bulk.DestinationTableName  =   " TestTable " ;
                bulk.BatchSize  =  dt.Rows.Count;

                 if  (dt  !=   null   &&  dt.Rows.Count  !=   0 )
                {
                    conn.Open();
                    bulk.WriteToServer(dt);
                }
                bulk.Close();
            }
        }

         private   string  GetConnectionString
        {
             get
            {
                 return   @" server=.\mssqlserver2008;database=test;uid=sa;pwd=123456 " ;
            }
        }
    }
}

 

结果：

Tread-2-ExecuteRowByRow:546ms

Tread-5-ExecuteRowByRow:521ms

Tread-0-ExecuteRowByRow:592ms

Tread-1-ExecuteRowByRow:623ms

Tread-10-ExecuteRowByRow:445ms

Tread-8-ExecuteRowByRow:471ms

Tread-4-ExecuteRowByRow:545ms

Tread-7-ExecuteRowByRow:494ms

Tread-9-ExecuteRowByRow:448ms

Tread-11-ExecuteRowByRow:396ms

Tread-6-ExecuteRowByRow:493ms

Tread-12-ExecuteRowByRow:441ms

Tread-13-ExecuteRowByRow:405ms

Tread-10-ExecuteOnce:74ms

Tread-18-ExecuteRowByRow:421ms

Tread-14-ExecuteRowByRow:457ms

Tread-15-ExecuteRowByRow:459ms

Tread-16-ExecuteRowByRow:457ms

Tread-19-ExecuteRowByRow:428ms

Tread-0-ExecuteOnce:99ms

Tread-3-ExecuteRowByRow:681ms

Tread-2-ExecuteOnce:144ms

Tread-9-ExecuteOnce:108ms

Tread-1-ExecuteOnce:117ms

Tread-17-ExecuteRowByRow:463ms

Tread-0-ExecuteSqlBulkCopy:28ms

Tread-0 execute successfully


Tread-5-ExecuteOnce:167ms

Tread-8-ExecuteOnce:145ms

Tread-15-ExecuteOnce:63ms

Tread-6-ExecuteOnce:118ms

Tread-10-ExecuteSqlBulkCopy:80ms

Tread-10 execute successfully


Tread-11-ExecuteOnce:154ms

Tread-2-ExecuteSqlBulkCopy:56ms

Tread-2 execute successfully


Tread-1-ExecuteSqlBulkCopy:59ms

Tread-1 execute successfully


Tread-8-ExecuteSqlBulkCopy:41ms

Tread-8 execute successfully


Tread-9-ExecuteSqlBulkCopy:83ms

Tread-9 execute successfully


Tread-5-ExecuteSqlBulkCopy:63ms

Tread-5 execute successfully


Tread-15-ExecuteSqlBulkCopy:50ms

Tread-15 execute successfully


Tread-3-ExecuteOnce:99ms

Tread-18-ExecuteOnce:136ms

Tread-6-ExecuteSqlBulkCopy:45ms

Tread-6 execute successfully


Tread-18-ExecuteSqlBulkCopy:8ms

Tread-18 execute successfully


Tread-7-ExecuteOnce:227ms

Tread-14-ExecuteOnce:156ms

Tread-19-ExecuteOnce:155ms

Tread-3-ExecuteSqlBulkCopy:26ms

Tread-3 execute successfully


Tread-11-ExecuteSqlBulkCopy:89ms

Tread-11 execute successfully


Tread-12-ExecuteOnce:218ms

Tread-19-ExecuteSqlBulkCopy:10ms

Tread-19 execute successfully


Tread-13-ExecuteOnce:221ms

Tread-4-ExecuteOnce:265ms

Tread-14-ExecuteSqlBulkCopy:36ms

Tread-14 execute successfully


Tread-4-ExecuteSqlBulkCopy:5ms

Tread-4 execute successfully


Tread-7-ExecuteSqlBulkCopy:50ms

Tread-7 execute successfully


Tread-12-ExecuteSqlBulkCopy:33ms

Tread-12 execute successfully


Tread-16-ExecuteOnce:201ms

Tread-13-ExecuteSqlBulkCopy:28ms

Tread-13 execute successfully


Tread-16-ExecuteSqlBulkCopy:10ms

Tread-16 execute successfully


Tread-17-ExecuteOnce:184ms

Tread-17-ExecuteSqlBulkCopy:3ms

Tread-17 execute successfully


多线程测试二、

         public   void  Testing()
        {
             for  ( int  i  =   0 ; i  <   20 ; i ++ )
            {
                Thread t  =   new  Thread( new  ParameterizedThreadStart(ExcuteTesting));
                t.Start(i);
                Thread.Sleep( 1000 );//多加了这行代码
            }
        }

 

 

结果：

Tread-0-ExecuteRowByRow:247ms

Tread-0-ExecuteOnce:18ms

Tread-0-ExecuteSqlBulkCopy:6ms

Tread-0 execute successfully


Tread-1-ExecuteRowByRow:11ms

Tread-1-ExecuteOnce:19ms

Tread-1-ExecuteSqlBulkCopy:4ms

Tread-1 execute successfully


Tread-2-ExecuteRowByRow:11ms

Tread-2-ExecuteOnce:22ms

Tread-2-ExecuteSqlBulkCopy:4ms

Tread-2 execute successfully


Tread-3-ExecuteRowByRow:11ms

Tread-3-ExecuteOnce:22ms

Tread-3-ExecuteSqlBulkCopy:4ms

Tread-3 execute successfully


Tread-4-ExecuteRowByRow:11ms

Tread-4-ExecuteOnce:20ms

Tread-4-ExecuteSqlBulkCopy:3ms

Tread-4 execute successfully


Tread-5-ExecuteRowByRow:6ms

Tread-5-ExecuteOnce:13ms

Tread-5-ExecuteSqlBulkCopy:4ms

Tread-5 execute successfully


Tread-6-ExecuteRowByRow:10ms

Tread-6-ExecuteOnce:21ms

Tread-6-ExecuteSqlBulkCopy:4ms

Tread-6 execute successfully


Tread-7-ExecuteRowByRow:10ms

Tread-7-ExecuteOnce:20ms

Tread-7-ExecuteSqlBulkCopy:5ms

Tread-7 execute successfully


Tread-8-ExecuteRowByRow:10ms

Tread-8-ExecuteOnce:326ms

Tread-8-ExecuteSqlBulkCopy:4ms

Tread-8 execute successfully


Tread-9-ExecuteRowByRow:10ms

Tread-9-ExecuteOnce:18ms

Tread-9-ExecuteSqlBulkCopy:4ms

Tread-9 execute successfully


Tread-10-ExecuteRowByRow:12ms

Tread-10-ExecuteOnce:17ms

Tread-10-ExecuteSqlBulkCopy:4ms

Tread-10 execute successfully


Tread-11-ExecuteRowByRow:10ms

Tread-11-ExecuteOnce:20ms

Tread-11-ExecuteSqlBulkCopy:5ms

Tread-11 execute successfully


Tread-12-ExecuteRowByRow:10ms

Tread-12-ExecuteOnce:20ms

Tread-12-ExecuteSqlBulkCopy:3ms

Tread-12 execute successfully


Tread-13-ExecuteRowByRow:10ms

Tread-13-ExecuteOnce:17ms

Tread-13-ExecuteSqlBulkCopy:3ms

Tread-13 execute successfully


Tread-14-ExecuteRowByRow:7ms

Tread-14-ExecuteOnce:14ms

Tread-14-ExecuteSqlBulkCopy:3ms

Tread-14 execute successfully


Tread-15-ExecuteRowByRow:9ms

Tread-15-ExecuteOnce:18ms

Tread-15-ExecuteSqlBulkCopy:3ms

Tread-15 execute successfully


Tread-16-ExecuteRowByRow:11ms

Tread-16-ExecuteOnce:21ms

Tread-16-ExecuteSqlBulkCopy:4ms

Tread-16 execute successfully


Tread-17-ExecuteRowByRow:9ms

Tread-17-ExecuteOnce:19ms

Tread-17-ExecuteSqlBulkCopy:3ms

Tread-17 execute successfully


Tread-18-ExecuteRowByRow:10ms

Tread-18-ExecuteOnce:20ms

Tread-18-ExecuteSqlBulkCopy:5ms

Tread-18 execute successfully


Tread-19-ExecuteRowByRow:10ms

Tread-19-ExecuteOnce:20ms

Tread-19-ExecuteSqlBulkCopy:5ms

Tread-19 execute successfully 

 

 

转载于:https://www.cnblogs.com/Ferry/archive/2010/11/11/1874665.html

powerx_yc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用SqlBulkCopy快速大批量导入数…
Dexter's Laboratory
05-27 664
实际的开发可能会遇到数据大批量插入数据的问题，若是一条条的循环倒数效率非常低下，这个较好的解决方案  1  2   protected void Button1_Click(object sender, EventArgs e)  3     {  4  5         DateTime beginTime = DateTime.Now;  6         Response.Write("
C#高级--多线程详解
s_156的博客
06-15 2696
C# 多线程详解
海量数据插入数据库效率对比测试 ---ADO.NET下SqlBulkCopy()对比LINQ 下InsertAllOnSubmit()
MemoryFraction
11-07 2115
摘要：使用.NET相关技术向数据库中插入海量数据是常用操作。本文对比ADO.NET和LINQ两种技术，分别使用SqlBulkCopy()和InsertAllOnSubmit()方法进行操作。得出结论：相同插入工作量（1w条数据）插入效率相差200倍之巨！本文给出测试方法、代码和测试结果截图。
ASP.NET(C#)SqlBulkCopy批量的快速插入数据
weixin_33860147的博客
01-28 147
· ASP.NET(C#)SqlBulkCopy批量的快速插入数据 SqlBulkCopy把DataTable，DataReader数据快速插入到数据库，数据迁移很快捷 privatestatic readonly string connStr = ConfigurationManager.ConnectionStrings["myConnStr"].ConnectionStrin...
批量插入数据到数据库请使用MysqlBulkCopy.dll.zip
07-30
源码包含有不同方法的添加，第一种逐条添加，第二种批量加入，其批量加实现原理其实就是把数据存入内存表（DataTable）中使用Backcopy一次性加入数据库。添加dll引用即可调用（无脑操作,何况源码里有）添加此对应dll...
C#.NET中如何批量插入大量数据到数据库中
09-03
在C#.NET中批量插入大量数据到数据库是一个常见的任务，特别是在处理诸如从Excel文件导入数据等场景时。这里，我们将探讨如何使用C#.NET高效地完成这个任务，并提供一个简单的示例来说明整个过程。 首先，我们需要...
C#批量插入数据到Sqlserver中的三种方式
09-01
综上所述，C#批量插入数据到Sqlserver的三种方式中，SqlBulkCopy通常是最佳选择，尤其在处理大规模数据时，其高效性和易用性使得它成为首选。不过，具体使用哪种方式，还需根据项目需求、数据量和性能要求进行权衡。
Z.SqlBulkCopy.Extension第三方批量复制插入sqlServer数据库的方法-C#源代码
11-05
Z.SqlBulkCopy.Extension第三方批量复制插入sqlServer数据库的方法-chm帮助文档 Z项目是MIT麻省理工大学的一个项目，其中有很多扩展库，其中一个关于批量导入数据到Sqlserver的方法和程序集，非常不错，很实用。 Z....
c#几种数据库的大数据批量插入（SqlServer、Oracle、SQLite和MySql）
01-20
在C#中处理大数据批量插入到数据库是提高性能的关键步骤，尤其当涉及到大量数据操作时。本文将介绍如何在SqlServer、Oracle、SQLite和MySql这四种常见数据库中进行批量插入。 1. **SqlServer数据批量插入** 使用`...
C# 海量数据瞬间插入到数据库的方法
air123456789的专栏
07-13 9004
C# 海量数据瞬间插入到数据库的方法当我们在数据库中进行大量的数据追加时，是不是经常因为数据量过大而苦恼呢？而所谓的海量数据，一般也是上万级的数据，比如我们要添加一百万条数据，应该如何提高它的效率呢？Oracle数据库：普通肉垫式     什么叫批量插入呢，就是一次性插入一批数据
C# 大规模数据分批与数据库交互
hellosmu的博客
11-22 2218
private static void ModifyInBatch(List&lt;int&gt; ids) { //Hashtable ht = new Hashtable(); List&lt;int&gt; subIdList = new List&lt;int&gt;(); if (ids != n...
C#大批量数据插入MySQL数据库的性能问题
东亮博客
04-01 5698
1.将表的引擎设为myisam   2.每1000条数据提交一次 这个是sqlite数据库批量插入的解决方案，可参考思路 最近处理一个将csv内容导入到sqlite数据库中，使用了事务(BEGIN TRANSACTION; sql语句; COMMIT;) 测试发现一次1000条导入，反而比10000条导入要快，总共6万多条数据，整下下来竟然快有6分钟，真是奇怪
ASP.NET WebApi 批量导入数据库
蓝鹰
11-15 3162
批量导入数据库 最近在WebApi项目开发中，用到批量导入人员信息功能。下面对知识进行简单的总结和大家分享一下（最重要的是批量导入数据库的思路）。 思路：在WebApi项目中，要想实现批量导入数据，并且通过客户端浏览器向服务器上传数据。由于服务器端和客户端基本上是分离（服务器本机除外）。因此，批量录入数据的逻辑： 一步骤：首先将Excel文件上传至服务器。 二步骤：然后在服务器端读取Exce
C# 执行 SQL 语句
zls365365的博客
11-30 4869
01 Command 对象概述Command 对象是一个数据命令对象，主要功能是向数据库发送查询、更新、删除、修改操作的 SQL 语句。Command 对象主要有以下几种方式。 SqlC...
C#批量高效率导入大数据到数据库[百万级以上]
zhangzhiping35的专栏
09-12 5312
将几百万条数据导入到数据库中，怎么样高效率的导入？ 下面我就介绍一个高效率的方法： 1、将数据库文件(DB.csv)导入到DataTable中： /// &lt;summary&gt;         /// 将CSV文件的数据读取到DataTable中         /// &lt;/summary&gt;         /// &lt;param name="fileName"...
C# 事务高效率插入数据
木头的专栏
01-11 4366
 public bool AddBalance(List list, ref string errMsg) { Curr_BalanceEntity model = new Curr_BalanceEntity(); Hashtable SQLStringList = new Hashtable(); S
c# 快速 将大量数据插入数据库
weixin_30263073的博客
04-12 834
快速插入数据 主要思想是通过在客户端把数据都缓存在Table中，然后利用SqlBulkCopy一次性把Table中的数据插入到数据库 public static void BulkToDB(DataTable dt) { SqlConnection sqlConn = new SqlConnection( ...
C# 执行 SQL 语句（完）
zls365365的博客
12-02 5236
Command 对象需要取得将要执行的 SQL 语句，通过调用该类提供的多种方法，向数据库提交 SQL语句。下面详细介绍 SqlCommand 对象中的几种执行 SQL 语句的方法。01 ...
SqlServer 插入Excel数据方法--SqlBulkCopy避免重复
最新发布
06-11
要将Excel数据插入SqlServer中并避免重复数据，可以使用以下步骤： ...在使用SqlBulkCopy插入数据时，应该先将Excel数据读取到DataTable中，然后在DataTable中检查是否存在重复数据，最后再将数据插入到SqlServer中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值