佛系糖果的博客

vb.net的异步读写数据流（使用线程、委托）

发表于 2016-10-18 分类于未分类阅读次数： Valine：
本文字数： 5.7k 阅读时长 ≈ 5 分钟

在理解异步读写前，了解一下线程和委托是必要的。

一、线程与委托

1、为什么要用异步？
无论是MemoryStream，BufferedStream，FileStream数据流，一旦的读写开始，应用程序就会处于停滞状况。直到数据读写完成，并返回。文件数据的读写基本上是一种非常消耗资源的过程，处理的数据量越大，I/O对系统性能的影响就越明显。为了避免长时间等待I/O操作使程序处理“瘫痪”状态，异步I/O就显得非常重要。异步的实现就是使用一个新的线程来完成，主线程的任务并不影响，这样大大提高了程序的效能。
2、线程
每个程序有一个主线程，如果一个循环处于主线程中，程序在较长的循环，将出现“不响应”的情况。
线程在System.Threading中。线程创建可专用于一个功能块（方法、函数），
线程的开始用Start方法
线程的结束用Abort方法
下面感受一下线程作用：
窗体上添加两Button，两个TextBox，代码如下，点击Button1启动循环，接着点击Button2.

Public Class Form1

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim i As Int32
For i = 0 To 123451
TextBox1.Text = i
Next
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
TextBox2.Text = "终于出现奇迹"
End Sub
End Class

可以明显看到虽然点击了Button1，但TextBox1的内容并没有什么变化，同时，在点击Button2时，TextBox并没有内容显示。
这是因为线程正被循环一直占用，暂时无法响应Button2,直到循环完成后，它才终于忙过来处理Button2. 这会给用户造成“程序已经无响应、死了”的误会。
下面改善上面的做法，新建一个线程来专门处理循环，这样就不影响主线程响应Button2:

Imports System.Threading
Public Class Form1
Dim mythread As Thread

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
mythread = New Thread(AddressOf ShowNumber) '构造线程
mythread.Name = "myShowNumber"
mythread.Start() '启动线程
End Sub

Private Sub ShowNumber()
Dim i As Int32
For i = 0 To 123451
TextBox1.Text = i
Next

mythread.Abort() '终止线程
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
TextBox2.Text = "终于出现奇迹"
End Sub
End Class

然而一点击，发现出错，提示：线程间操作无效: 从不是创建控件“TextBox1”的线程访问它。

这是因为Textbox1是主线程中的，却在另一个新的线程中访问，这种是不安全的，相当于去别人房间使用电视机。怎么办？这里可以用委托，委托能够进别人房间的人去使用电视机。
3、委托委托的思想，就是自己不能干或不想干的事，委托另一个有能力或有权限的人去干那件事。实际上，我们一直要用委托思想，比如基本类型的变量名。Dim i As Integer i变量名就是相当于委托，实际上，一个变量代表的是指定内存地址中的值，如果不用变量名，就得实际上引用这个内存的地址。
而我们就用“变量名”来干操作这个地址里的东西。
除了变量名可以用委托一样，方法也可以用委托，这就是我们普通所说的委托。
定义和使用大致与变量名的方式一样：
（1）定义委托类型： Private Delegate Sub MyDelegate(byval k as int32) ‘参数多种，多个）这里类似定义变量的类型一样。
（2）定义要赋的具体“值”：这里的具体值，不是值，而是一个具体的方法，方法的形式必须与上面定义保持一致。就象变量名是整形时，赋值也应该是整形，而不是String.
例如：Private Sub YourSelfMethod(byval m as int32) ‘方法名自定，但形式与（1）保持一致。
（3）调用这个值：也就是委托去办事。用Invoke方法：Control.Invoke(New MyDelegate(AddressOf YourSelfMethod), intValue)
这一步就把（1），（2）使用上了。
下面接着上面的例子，使用委托来调用Form1中的TextBox1.

Imports System.Threading
Public Class Form1
Dim mythread As Thread
Private Delegate Sub VoidShow(ByRef i As Int32) '定义要委托的类型

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
mythread = New Thread(AddressOf ShowNumber)
mythread.Name = "myShowNumber"
mythread.Start()
End Sub

Private Sub ShowNumber()
Dim i As Int32
For i = 0 To 123451
'TextBox1.Text = i
Me.Invoke(New VoidShow(AddressOf TureShowNumber), i) '用New构造委托，再用Invoke执行
Next

mythread.Abort()
End Sub

'新加入的被委托要做的事
Private Sub TureShowNumber(ByRef i As Int32)
TextBox1.Text = i
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
TextBox2.Text = "终于出现奇迹"
End Sub
End Class

点击Buttton1，可以看到因为新线程的使用，TextBox1中的数字一直在变量。
而且，同时点击Button2程序不会“死机”，很快地响应。
注意的是：因为线程的中止使用的是强制中断Abort，所以即时窗体会显示：
System.Threading.ThreadAbortException 类型的第一次机会异常在 mscorlib.dll中发生这个不影响使用。

二、异步读写

异步I/O与同步I/O最大的不同在于：同步I/O只有完成整个I/O操作后，程序才会进行下一步（所以这之前象死机一样）。
异步I/O在操作读写操作的同时，程序可以继续下一步工作，不影响程序其它执行。简单地说，主线程和新线程各自执行，不相互影响。
即流程如下：

程序（主线程）在左边开始时，就建立了新线程进行异步读写。
在异步开始时，就传入了一个回调参数，这个用于异步完成时，自动调用这个参数所指的过程。
其中的IAsyncResult表示异步操作的状态。结束异步操作时需要这个参数。
一般我们在I/O操作时都是同步，异步在FileStream构造时就必须指明文件采用的异步方法：

Public Sub New(
path As String,
mode As FileMode,
access As FileAccess,
share As FileShare,
bufferSize As Integer, _ '缓冲大小
useAsync As Boolean _ 'True为异步
)

下面看一下异步操作的例子：
1、委托：只是为了在线程中调用窗体中的控件TextBox1来显示状态。
2、线程：是异步I/O的必要过程
3、回调函数：这是异步完成后，自动来通知或告之，异步I/O已经完成了（否则，怎么知道异步的结束呢？）

Imports System.IO
Imports System.Threading
Public Class Form1
    Dim btArray(15) As Byte
    Dim fs As FileStream
    Dim myThread As Thread
    Dim blnProcess As Boolean '进程是否使用标志

    Private Delegate Sub ShowMyMessage(ByVal str As String) '线程中无法调用窗体控件，用委托解决

    '启动写或读进程
    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        TextBox1.Text = ""
        Try
            If RadioButton2.Checked = True Then '写选中
                myThread = New Thread(AddressOf WriteData)
                myThread.Name = "WriteBulkData"
                myThread.Start()
            Else
                myThread = New Thread(AddressOf ReadData)
                myThread.Name = "ReadBulkData"
                myThread.Start()
            End If
        Catch ex As Exception
            MessageBox.Show(ex.Message)
        End Try
    End Sub

    Private Sub WriteData()
        Try
            fs = New FileStream("D:\\11.txt", FileMode.Open, FileAccess.Write, FileShare.Write, 16, True)
            Dim myWCB As New AsyncCallback(AddressOf MyAsyncWriteCallBack)
            blnProcess = True
            fs.BeginWrite(btArray, 0, 12, myWCB, Nothing)
            ProcessMessage("Write")
            fs.Close()
        Catch ex As Exception
            MessageBox.Show(ex.Message)
        End Try
    End Sub

    Private Sub ReadData()
        Try
            fs = New FileStream("d:\\11.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 16, True)
            Dim myRCB As New AsyncCallback(AddressOf MyAsyncReadCallBack)
            blnProcess = True
            fs.BeginRead(btArray, 0, 16, myRCB, Nothing)
            ProcessMessage("Read")
            fs.Close()
        Catch ex As Exception
            MessageBox.Show(ex.Message)
        End Try
    End Sub

    Private Sub MyAsyncWriteCallBack(ByVal myIar As IAsyncResult)
        Thread.Sleep(50)
        blnProcess = False
        fs.EndWrite(myIar)

        '委托显示信息
        Dim str As String = " 异步线程数据写入完成。"
        Me.Invoke(New ShowMyMessage(AddressOf ShowMessage), str)
    End Sub

    Private Sub MyAsyncReadCallBack(ByVal myIar As IAsyncResult)
        Thread.Sleep(50)
        blnProcess = False
        fs.EndRead(myIar)

        '委托显示信息
        Dim str As String = " 异步线程数据读取完成。"
        Me.Invoke(New ShowMyMessage(AddressOf ShowMessage), str)
    End Sub

    Private Sub ShowMessage(ByVal str As String)
        TextBox1.Text &= Now.ToString & str & vbCrLf
    End Sub

    Private Sub ProcessMessage(ByVal strRW As String)
        Dim strMessage As String = ""
        If strRW = "Read" Then
            strMessage = " 判断异步正在读取..."
        Else
            strMessage = " 判断异步正在写入..."
        End If

        Do While blnProcess = True
            Me.Invoke(New ShowMyMessage(AddressOf ShowMessage), strMessage)
        Loop
        Thread.Sleep(50)

        strMessage = " 判断读写已经完成。"
        Me.Invoke(New ShowMyMessage(AddressOf ShowMessage), strMessage)
    End Sub
End Class

上面通过一个循环不断判断异步进行得怎么样（实际上是用的全局blnProcess来判断）
因为是例子，数据量不大，所以在过程加加入Sleep来延迟异步还在进行中。
为了减少显示的信息，把时间延时量减小到50毫秒。

An error occurred during local report processing

发表于 2016-10-18 分类于未分类阅读次数： Valine：
本文字数： 485 阅读时长 ≈ 1 分钟

在.net平台使用 RDLC 进行报表开发，本机测试正常，到别的机器不是没反应就是报 An error occurred during local report processing 等错误
最后发现要确保报表所需的控件存在以及版本正确。

Microsoft.ReportViewer.Common.dll 
Microsoft.ReportViewer.DataVisualization.dll 
Microsoft.ReportViewer.ProcessingObjectModel.dll 
Microsoft.ReportViewer.WinForms.dll

这四个搞定后终于正常了！最后别忘了语言资源的使用
─zh-Hans

Microsoft.ReportViewer.Common.resources.dll
Microsoft.ReportViewer.DataVisualization.resources.dll 
Microsoft.ReportViewer.Design.resources.dll 
Microsoft.ReportViewer.WinForms.resources.dll

C# MySql “Parameter '@??' must be defined”

发表于 2016-10-18 分类于未分类阅读次数： Valine：
本文字数： 824 阅读时长 ≈ 1 分钟

C# 一段程序如下，执行出错，错误信息是

'@rowNum' must be defined”~~~

但是直接在 mySql workbatch 中运行是正确的！！ 原因何在？
搜索一下， 看到老外的网站说 连接串要加上 ： ~~~“Allow User Variables=True”,
再试验一次，发现可以了！！
string mySqlConnString = @"Database=testDB ; User Id = root; Password =password;Data source=10.10.10.107;";
MySql.Data.MySqlClient.MySqlConnection mySqlConn = new MySql.Data.MySqlClient.MySqlConnection();
mySqlConn.ConnectionString = mySqlConnString;
mySqlConn.Open();
MySql.Data.MySqlClient.MySqlCommand mySqlCmd = new MySql.Data.MySqlClient.MySqlCommand(); //declare @rowNumber as integer; mySqlCmd.Connection = mySqlConn;
mySqlCmd.CommandText = "set @rowNum:=0;
create temporary table T_729540255 as ( Select @rowNum:=ifnull(@rowNum,0)+1 as Temp_id, A.employee_id,A.employee_no From employee A)";
mySqlCmd.ExecuteNonQuery();

C#通用数据库操作类

发表于 2016-10-18 分类于未分类阅读次数： Valine：
本文字数： 76 阅读时长 ≈ 1 分钟

各种搜集数据库操作完整类，在一篇博文留言中发现了一个开源的 Dbhelper 试了下，用起来很爽。。。
博文地址波多尔斯基 DbHelper
开源地址 DevLib

C# MySqlHelper 类

发表于 2016-10-18 分类于未分类阅读次数：
本文字数： 41k 阅读时长 ≈ 37 分钟

来源:懒惰的肥兔

using System;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using MySql.Data.MySqlClient;

namespace Helpers
{
    /// <summary>
    /// MySqlHelper操作类
    /// </summary>
    public sealed partial class MySqlHelper
    {
        /// <summary>
        /// 批量操作每批次记录数
        /// </summary>
        public static int BatchSize = 2000;

        /// <summary>
        /// 超时时间
        /// </summary>
        public static int CommandTimeOut = 600;

        /// <summary>
        ///初始化MySqlHelper实例
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        public MySqlHelper(string connectionString)
        {
            this.ConnectionString = connectionString;
        }

        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        public string ConnectionString { get; set; }

        #region 实例方法

        #region ExecuteNonQuery

        /// <summary>
        /// 执行SQL语句,返回影响的行数
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回影响的行数</returns>
        public int ExecuteNonQuery(string commandText, params MySqlParameter[] parms)
        {
            return ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回影响的行数
        /// </summary>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回影响的行数</returns>
        public int ExecuteNonQuery(CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteNonQuery(ConnectionString, commandType, commandText, parms);
        }

        #endregion ExecuteNonQuery

        #region ExecuteScalar

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <typeparam name="T">返回对象类型</typeparam>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public T ExecuteScalar<T>(string commandText, params MySqlParameter[] parms)
        {
            return ExecuteScalar<T>(ConnectionString, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public object ExecuteScalar(string commandText, params MySqlParameter[] parms)
        {
            return ExecuteScalar(ConnectionString, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public object ExecuteScalar(CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteScalar(ConnectionString, commandType, commandText, parms);
        }

        #endregion ExecuteScalar

        #region ExecuteDataReader

        /// <summary>
        /// 执行SQL语句,返回只读数据集
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回只读数据集</returns>
        private MySqlDataReader ExecuteDataReader(string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataReader(ConnectionString, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回只读数据集
        /// </summary>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回只读数据集</returns>
        private MySqlDataReader ExecuteDataReader(CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataReader(ConnectionString, commandType, commandText, parms);
        }
        #endregion

        #region ExecuteDataRow

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行</returns>
        public DataRow ExecuteDataRow(string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataRow(ConnectionString, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行
        /// </summary>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行</returns>
        public DataRow ExecuteDataRow(CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataRow(ConnectionString, commandType, commandText, parms);
        }

        #endregion ExecuteDataRow

        #region ExecuteDataTable

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一个数据表
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一个数据表</returns>
        public DataTable ExecuteDataTable(string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataTable(ConnectionString, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一个数据表
        /// </summary>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一个数据表</returns>
        public DataTable ExecuteDataTable(CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(ConnectionString, commandType, commandText, parms).Tables[0];
        }

        #endregion ExecuteDataTable

        #region ExecuteDataSet

        /// <summary>
        /// 执行SQL语句,返回结果集
        /// </summary>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集</returns>
        public DataSet ExecuteDataSet(string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(ConnectionString, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集
        /// </summary>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集</returns>
        public DataSet ExecuteDataSet(CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(ConnectionString, commandType, commandText, parms);
        }

        #endregion ExecuteDataSet

        #region 批量操作

        /// <summary>
        /// 使用MySqlDataAdapter批量更新数据
        /// </summary>
        /// <param name="table">数据表</param>
        public void BatchUpdate(DataTable table)
        {
            BatchUpdate(ConnectionString, table);
        }

        /// <summary>
        ///大批量数据插入,返回成功插入行数
        /// </summary>
        /// <param name="table">数据表</param>
        /// <returns>返回成功插入行数</returns>
        public int BulkInsert(DataTable table)
        {
            return BulkInsert(ConnectionString, table);
        }

        #endregion 批量操作

        #endregion 实例方法

        #region 静态方法

        private static void PrepareCommand(MySqlCommand command, MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, MySqlParameter[] parms)
        {
            if (connection.State != ConnectionState.Open) connection.Open();

            command.Connection = connection;
            command.CommandTimeout = CommandTimeOut;
            // 设置命令文本(存储过程名或SQL语句)
            command.CommandText = commandText;
            // 分配事务
            if (transaction != null)
            {
                command.Transaction = transaction;
            }
            // 设置命令类型.
            command.CommandType = commandType;
            if (parms != null && parms.Length > 0)
            {
   //预处理MySqlParameter参数数组，将为NULL的参数赋值为DBNull.Value;
                foreach (MySqlParameter parameter in parms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                }
                command.Parameters.AddRange(parms);
            }
        }

        #region ExecuteNonQuery

        /// <summary>
        /// 执行SQL语句,返回影响的行数
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, string commandText, params MySqlParameter[] parms)
        {
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                return ExecuteNonQuery(connection, CommandType.Text, commandText, parms);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回影响的行数
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                return ExecuteNonQuery(connection, commandType, commandText, parms);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回影响的行数
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回影响的行数</returns>
        public static int ExecuteNonQuery(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteNonQuery(connection, null, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回影响的行数
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回影响的行数</returns>
        public static int ExecuteNonQuery(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteNonQuery(transaction.Connection, transaction, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回影响的行数
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回影响的行数</returns>
        private static int ExecuteNonQuery(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            MySqlCommand command = new MySqlCommand();
            PrepareCommand(command, connection, transaction, commandType, commandText, parms);
            int retval = command.ExecuteNonQuery();
            command.Parameters.Clear();
            return retval;
        }

        #endregion ExecuteNonQuery

        #region ExecuteScalar

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <typeparam name="T">返回对象类型</typeparam>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public static T ExecuteScalar<T>(string connectionString, string commandText, params MySqlParameter[] parms)
        {
            object result = ExecuteScalar(connectionString, commandText, parms);
            if (result != null)
            {
                return (T)Convert.ChangeType(result, typeof(T)); ;
            }
            return default(T);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public static object ExecuteScalar(string connectionString, string commandText, params MySqlParameter[] parms)
        {
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                return ExecuteScalar(connection, CommandType.Text, commandText, parms);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                return ExecuteScalar(connection, commandType, commandText, parms);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public static object ExecuteScalar(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteScalar(connection, null, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        public static object ExecuteScalar(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteScalar(transaction.Connection, transaction, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行第一列
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一行第一列</returns>
        private static object ExecuteScalar(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            MySqlCommand command = new MySqlCommand();
            PrepareCommand(command, connection, transaction, commandType, commandText, parms);
            object retval = command.ExecuteScalar();
            command.Parameters.Clear();
            return retval;
        }

        #endregion ExecuteScalar

        #region ExecuteDataReader

        /// <summary>
        /// 执行SQL语句,返回只读数据集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回只读数据集</returns>
        private static MySqlDataReader ExecuteDataReader(string connectionString, string commandText, params MySqlParameter[] parms)
        {
            MySqlConnection connection = new MySqlConnection(connectionString);
            return ExecuteDataReader(connection, null, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回只读数据集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回只读数据集</returns>
        private static MySqlDataReader ExecuteDataReader(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            MySqlConnection connection = new MySqlConnection(connectionString);
            return ExecuteDataReader(connection, null, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回只读数据集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回只读数据集</returns>
        private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataReader(connection, null, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回只读数据集
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回只读数据集</returns>
        private static MySqlDataReader ExecuteDataReader(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataReader(transaction.Connection, transaction, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回只读数据集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回只读数据集</returns>
        private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            MySqlCommand command = new MySqlCommand();
            PrepareCommand(command, connection, transaction, commandType, commandText, parms);
            return command.ExecuteReader(CommandBehavior.CloseConnection);
        }

        #endregion

        #region ExecuteDataRow

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>,返回结果集中的第一行</returns>
        public static DataRow ExecuteDataRow(string connectionString, string commandText, params MySqlParameter[] parms)
        {
            DataTable dt = ExecuteDataTable(connectionString, CommandType.Text, commandText, parms);
            return dt.Rows.Count > 0 ? dt.Rows[0] : null;
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>,返回结果集中的第一行</returns>
        public static DataRow ExecuteDataRow(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            DataTable dt = ExecuteDataTable(connectionString, commandType, commandText, parms);
            return dt.Rows.Count > 0 ? dt.Rows[0] : null;
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>,返回结果集中的第一行</returns>
        public static DataRow ExecuteDataRow(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            DataTable dt = ExecuteDataTable(connection, commandType, commandText, parms);
            return dt.Rows.Count > 0 ? dt.Rows[0] : null;
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一行
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>,返回结果集中的第一行</returns>
        public static DataRow ExecuteDataRow(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            DataTable dt = ExecuteDataTable(transaction, commandType, commandText, parms);
            return dt.Rows.Count > 0 ? dt.Rows[0] : null;
        }

        #endregion ExecuteDataRow

        #region ExecuteDataTable

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一个数据表</returns>
        public static DataTable ExecuteDataTable(string connectionString, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms).Tables[0];
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一个数据表</returns>
        public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(connectionString, commandType, commandText, parms).Tables[0];
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一个数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一个数据表</returns>
        public static DataTable ExecuteDataTable(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(connection, commandType, commandText, parms).Tables[0];
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一个数据表
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集中的第一个数据表</returns>
        public static DataTable ExecuteDataTable(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(transaction, commandType, commandText, parms).Tables[0];
        }

        /// <summary>
        /// 执行SQL语句,返回结果集中的第一个数据表
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="tableName">数据表名称</param>
        /// <returns>返回结果集中的第一个数据表</returns>
        public static DataTable ExecuteEmptyDataTable(string connectionString, string tableName)
        {
            return ExecuteDataSet(connectionString, CommandType.Text, string.Format("select * from {0} where 1=-1", tableName)).Tables[0];
        }

        #endregion ExecuteDataTable

        #region ExecuteDataSet

        /// <summary>
        /// 执行SQL语句,返回结果集
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandText">SQL语句</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集</returns>
        public static DataSet ExecuteDataSet(string connectionString, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集</returns>
        public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                return ExecuteDataSet(connection, commandType, commandText, parms);
            }
        }

        /// <summary>
        /// 执行SQL语句,返回结果集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集</returns>
        public static DataSet ExecuteDataSet(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(connection, null, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集
        /// </summary>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集</returns>
        public static DataSet ExecuteDataSet(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            return ExecuteDataSet(transaction.Connection, transaction, commandType, commandText, parms);
        }

        /// <summary>
        /// 执行SQL语句,返回结果集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="transaction">事务</param>
        /// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
        /// <param name="commandText">SQL语句或存储过程名称</param>
        /// <param name="parms">查询参数</param>
        /// <returns>返回结果集</returns>
        private static DataSet ExecuteDataSet(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
        {
            MySqlCommand command = new MySqlCommand();

            PrepareCommand(command, connection, transaction, commandType, commandText, parms);
            MySqlDataAdapter adapter = new MySqlDataAdapter(command);

            DataSet ds = new DataSet();
            adapter.Fill(ds);
            if (commandText.IndexOf("@") > 0)
            {
                commandText = commandText.ToLower();
                int index = commandText.IndexOf("where ");
                if (index < 0)
                {
                    index = commandText.IndexOf("\\nwhere");
                }
                if (index > 0)
                {
                    ds.ExtendedProperties.Add("SQL", commandText.Substring(0, index - 1));  //将获取的语句保存在表的一个附属数组里，方便更新时生成CommandBuilder
                }
                else
                {
                    ds.ExtendedProperties.Add("SQL", commandText);  //将获取的语句保存在表的一个附属数组里，方便更新时生成CommandBuilder
                }
            }
            else
            {
                ds.ExtendedProperties.Add("SQL", commandText);  //将获取的语句保存在表的一个附属数组里，方便更新时生成CommandBuilder
            }

            foreach (DataTable dt in ds.Tables)
            {
                dt.ExtendedProperties.Add("SQL", ds.ExtendedProperties["SQL"]);
            }

            command.Parameters.Clear();
            return ds;
        }

        #endregion ExecuteDataSet

        #region 批量操作

        /// <summary>
        ///使用MySqlDataAdapter批量更新数据
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="table">数据表</param>
        public static void BatchUpdate(string connectionString, DataTable table)
        {
            MySqlConnection connection = new MySqlConnection(connectionString);

            MySqlCommand command = connection.CreateCommand();
            command.CommandTimeout = CommandTimeOut;
            command.CommandType = CommandType.Text;
            MySqlDataAdapter adapter = new MySqlDataAdapter(command);
            MySqlCommandBuilder commandBulider = new MySqlCommandBuilder(adapter);
            commandBulider.ConflictOption = ConflictOption.OverwriteChanges;

            MySqlTransaction transaction = null;
            try
            {
                connection.Open();
                transaction = connection.BeginTransaction();
   //设置批量更新的每次处理条数
                adapter.UpdateBatchSize = BatchSize;
   //设置事物
                adapter.SelectCommand.Transaction = transaction;

                if (table.ExtendedProperties["SQL"] != null)
                {
                    adapter.SelectCommand.CommandText = table.ExtendedProperties["SQL"].ToString();
                }
                adapter.Update(table);
                transaction.Commit();/////提交事务
            }
            catch (MySqlException ex)
            {
                if (transaction != null) transaction.Rollback();
                throw ex;
            }
            finally
            {
                connection.Close();
                connection.Dispose();
            }
        }

        /// <summary>
        ///大批量数据插入,返回成功插入行数
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="table">数据表</param>
        /// <returns>返回成功插入行数</returns>
        public static int BulkInsert(string connectionString, DataTable table)
        {
            if (string.IsNullOrEmpty(table.TableName)) throw new Exception("请给DataTable的TableName属性附上表名称");
            if (table.Rows.Count == 0) return 0;
            int insertCount = 0;
            string tmpPath = Path.GetTempFileName();
            string csv = DataTableToCsv(table);
            File.WriteAllText(tmpPath, csv);
            using (MySqlConnection conn = new MySqlConnection(connectionString))
            {
                MySqlTransaction tran = null;
                try
                {
                    conn.Open();
                    tran = conn.BeginTransaction();
                    MySqlBulkLoader bulk = new MySqlBulkLoader(conn)
                    {
                        FieldTerminator = ",",
                        FieldQuotationCharacter = '"',
                        EscapeCharacter = '"',
                        LineTerminator = "\\r\\n",
                        FileName = tmpPath,
                        NumberOfLinesToSkip = 0,
                        TableName = table.TableName,
                    };
                    bulk.Columns.AddRange(table.Columns.Cast<DataColumn>().Select(colum => colum.ColumnName).ToList());
                    insertCount = bulk.Load();
                    tran.Commit();
                }
                catch (MySqlException ex)
                {
                    if (tran != null) tran.Rollback();
                    throw ex;
                }
            }
            File.Delete(tmpPath);
            return insertCount;
        }

        /// <summary>
        ///将DataTable转换为标准的CSV
        /// </summary>
        /// <param name="table">数据表</param>
        /// <returns>返回标准的CSV</returns>
        private static string DataTableToCsv(DataTable table)
        {
            //以半角逗号（即,）作分隔符，列为空也要表达其存在。
            //列内容如存在半角逗号（即,）则用半角引号（即""）将该字段值包含起来。
            //列内容如存在半角引号（即"）则应替换成半角双引号（""）转义，并用半角引号（即""）将该字段值包含起来。
            StringBuilder sb = new StringBuilder();
            DataColumn colum;
            foreach (DataRow row in table.Rows)
            {
                for (int i = 0; i < table.Columns.Count; i++)
                {
                    colum = table.Columns[i];
                    if (i != 0) sb.Append(",");
                    if (colum.DataType == typeof(string) && row[colum].ToString().Contains(","))
                    {
                        sb.Append("\\"" + row[colum].ToString().Replace("\\"", "\\"\\"") + "\\"");
                    }
                    else sb.Append(row[colum].ToString());
                }
                sb.AppendLine();
            }

            return sb.ToString();
        }

        #endregion 批量操作

        #endregion 静态方法
    }
}

MySqlHelper.cs

windows 中哈希校验工具

发表于 2016-10-13 分类于未分类阅读次数： Valine：
本文字数： 113 阅读时长 ≈ 1 分钟

推荐两款好用的 md5 、 hash 文件校验工具

WinMD5
链接: http://pan.baidu.com/s/1kUOTY8f
密码: dsj7
Hash 链接: http://pan.baidu.com/s/1c1VnQWK
密码: cbq6

windows 下端口扫描工具

发表于 2016-10-13 分类于未分类阅读次数： Valine：
本文字数： 66 阅读时长 ≈ 1 分钟

推荐一款多线程端口扫描实用工具，可设置ip段范围。

链接: http://pan.baidu.com/s/1i4MqmqD
密码: as72

18位身份证号码合法性计算

发表于 2016-10-13 分类于书籍文档阅读次数： Valine：
本文字数： 1.8k 阅读时长 ≈ 2 分钟

来看下合法性计算方法

1、将前面的身份证号码17位数分别乘以不同的系数。从第一位到第十七位的系数分别为：7－9－10－5－8－4－2－1－6－3－7－9－10－5－8－4－2。

2、将这17位数字和系数相乘的结果相加。

3、用加出来和除以11，看余数是多少？

4、余数只可能有0－1－2－3－4－5－6－7－8－9－10这11个数字。其分别对应的最后一位身份证的号码为1－0－X －9－8－7－6－5－4－3－2。(即馀数0对应1，馀数1对应0，馀数2对应X…)

5、通过上面得知如果余数是3，就会在身份证的第18位数字上出现的是9。如果对应的数字是2，身份证的最后一位号码就是罗马数字x。

例如：某男性的身份证号码为【53010219200508011x】，我们看看这个身份证是不是合法的身份证。

首先我们得出前17位的乘积和【(57)+(39)+(010)+(15)+(08)+(24)+(12)+(91)+(26)+(03)+(07)+(59)+(010)+(85)+(08)+(14)+(1*2)】是189，然后用189除以11得出的结果是189/11=17—-2，也就是说其余数是2。最后通过对应规则就可以知道余数2对应的检验码是X。所以，可以判定这是一个正确的身份证号码。

阅读全文 »

ajax jsonp跨域请求数据出错 Uncaught SyntaxError: Unexpected token :

发表于 2016-10-12 分类于书籍文档阅读次数： Valine：
本文字数： 374 阅读时长 ≈ 1 分钟

解决使用 ajax 的 jsonp 出现 Uncaught SyntaxError: Unexpected token : 偶然使用 ajax 处理 jsonp 时居然提示“Uncaught SyntaxError: Unexpected token :“ 检查了json数据没有问题，搜集了一番发现使用回掉的方式可以解决

$.ajax({
    type: "get",
    url: "xxxxxx",
    dataType: "jsonp",
    jsonp: "callback",
    jsonpCallback: "success",
    success: function(json) {
        $("msg").html(json.data);
    }
});

需要注意服务端这样写 php

1	$_GET['callback']."(".json_encode($json).")";

VB.NET 操作 access 数据库

发表于 2016-10-10 分类于学习记录阅读次数： Valine：
本文字数： 3.2k 阅读时长 ≈ 3 分钟

VB.NET 操作 access 数据库

'添加引用 Imports System.Data.OleDb

''' <summary>
''' 操作 mdb 数据库进行查询/添加/修改/删除
''' </summary>
''' <param name="DataSource">指定连接到的数据源的名称。</param>
''' <param name="Provider">指定连接字符串关联的数据提供程序的名称。</param>
''' <param name="Password">指定连接到的数据源的密码。</param>
''' <param name="OleDbCmd">指定 SQL 命令。</param>
''' <param name="Options">指定执行的状态 1:检测是否注册 2:验证登陆 
''' 3:查询数据 4:添加/修改/删除 数据 5:获取地址ID 。</param>
''' <param name="Getstring">指定返回的数据。</param>
''' <returns></returns>
''' <remarks></remarks>
Public Function Access_db(
                    ByVal DataSource As String,
                    ByVal Provider As String,
                    ByVal Password As String,
                    ByVal OleDbCmd As String,
                    ByVal Options As Integer,
                    ByRef Getstring As String)

    ' 声明为创建和管理由 OleDbConnection 类使用的连接字符串的内容提供了一种简单方法。
    Dim builder As New OleDbConnectionStringBuilder()
    ' 获取或设置要连接到的数据源的名称。
    builder.DataSource = DataSource
    ' 获取或设置一个字符串，该字符串包含与内部连接字符串关联的数据提供程序的名称。
    builder.Provider = Provider
    ' 将带有指定键和值的项添加到 DbConnectionStringBuilder 中。
    builder.Add("Jet OLEDB:Database Password", Password)
    ' builder("User Id") = "Admin;NewValue=Bad"
    ' 控制台输出显示连接字符串
    Console.WriteLine(builder.ConnectionString)

    ' If the connection string is null, use a default.
    If builder.ConnectionString = "" Then
        builder.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\test.mdb;User Id=username;Password=pass;"
    End If

    ' This sample assumes that you have a database named
    ' C:\\Sample.mdb available.
    Using connection As New OleDbConnection(builder.ConnectionString)

        ' The insertSQL string contains a SQL statement that
        ' inserts a new row in the source table.
        Dim command As New OleDbCommand(OleDbCmd)
        ' 获取或设置在终止对执行命令的尝试并生成错误之前的等待时间。
        command.CommandTimeout = 20

        ' Set the Connection to the new OleDbConnection.
        command.Connection = connection

        ' Open the connection and execute the insert command.
        Try
            connection.Open()
            ' Do something with the database here.

            Console.WriteLine("query:" & command.ExecuteNonQuery())

            Select Case Options

                Case 2 ' 验证登录
                    Dim reader As OleDbDataReader = command.ExecuteReader()

                    ' Call Read before accessing data.
                    While reader.Read()
                        ' ReadSingleRow(CType(reader, IDataRecord))
                        Getstring = reader("Info_username".ToString) & reader("Info_password".ToString)
                        Console.WriteLine(Getstring)
                        'Console.WriteLine(reader("字段名"))
                        'Console.WriteLine(reader(0).ToString)
                    End While

                    ' Call Close when done reading.
                    reader.Close()

                Case 3 ' 查询数据
                    Dim reader As OleDbDataReader = command.ExecuteReader()

                    ' Call Read before accessing data.
                    While reader.Read()

                        Getstring = reader("compellation").ToString
                    End While

                    ' Call Close when done reading.
                    reader.Close()
                Case 4 ' 添加数据/更新数据/删除数据
                    Return True.ToString
                Case 5 ' 获取地址ID
                    Dim reader As OleDbDataReader = command.ExecuteReader()

                    ' Call Read before accessing data.
                    While reader.Read()
                        ' ReadSingleRow(CType(reader, IDataRecord))
                        Getstring = reader("ID").ToString
                        'Console.WriteLine(reader("字段名"))
                        'Console.WriteLine(reader(0).ToString)
                    End While

                    ' Call Close when done reading.
                    reader.Close()

                Case Else

            End Select
        Catch ex As System.InvalidOperationException
            Return "InvalidOperationException" ' 未注册 oledb4.0
        Catch ex As System.Data.OleDb.OleDbException
            Return "OleDbException" ' 数据库连接错误
        Catch ex As Exception
            Console.WriteLine(ex.Message)
        End Try

    End Using
End Function

fesugar

个人博客，分享自己的实践脚印的互联网技术以及实际应用的日志
|非专业人士；
|三线小城市普通打工仔一名；
|养家糊口不易~
~~~~~