C# ADO.NET帮助类，
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
namespace DBComm
{
static class DBCommand
{
public class DBParameters
{
private SqlCommand m_owner = null;
public DBParameters(SqlCommand owner)
{
m_owner = owner;
}
public SqlParameterCollection P()
{
return m_owner.Parameters;
}
};
public static bool BulkToDB(string tabname, DataTable dt, params string[] destColumnNames)
{
bool bRet = false;
do
{
if (dt == null)
break;
if (dt.Rows.Count == 0)
break;
using (SqlConnection conn = DBConn.GetConn())
{
if (conn == null)
break;
SqlBulkCopy bulkcopy = new SqlBulkCopy(conn);
if (bulkcopy == null)
break;
bulkcopy.DestinationTableName = tabname;
bulkcopy.BulkCopyTimeout = 30;
if (destColumnNames.Length == 0)
{
foreach (DataColumn col in dt.Columns)
bulkcopy.ColumnMappings.Add(col.ColumnName, col.ColumnName);
}
else
{
if (destColumnNames.Length == dt.Columns.Count)
{
for (int i = 0; i < destColumnNames.Length; ++i)
{
bulkcopy.ColumnMappings.Add(dt.Columns[i].ColumnName, destColumnNames[i]);
}
}
}
bulkcopy.BatchSize = dt.Rows.Count;
try
{
bulkcopy.WriteToServer(dt);
}
catch (System.Exception e)
{
string err = e.Message;
break;
}
finally
{
bulkcopy.Close();
}
}
bRet = true;
} while (false);
return bRet;
}
public static DBParameters ExecProcNonQuery(string proc_name, object[] paraValues)
{
using (SqlConnection conn = DBConn.GetConn())
{
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = proc_name;
AddInParaValues(cmd, paraValues);
cmd.ExecuteNonQuery();
return new DBParameters(cmd);
}
}
public delegate T[] FillValues<T>(SqlDataReader reader);
public static T[] QuerySomes<T>(string sql, FillValues<T> fill)
{
using (SqlConnection conn = DBConn.GetConn())
{
T[] result = null;
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
SqlDataReader reader = null;
lock (reader = cmd.ExecuteReader())
{
try
{
result = fill(reader);
}
catch (Exception e)
{
throw new Exception(e.StackTrace);
}
finally
{
reader.Close();
}
}
return result;
}
}
public delegate object FillValue(SqlDataReader reader);
public static object QuerySome(string sql, FillValue fill)
{
using (SqlConnection conn = DBConn.GetConn())
{
object result = null;
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
SqlDataReader reader = null;
lock (reader = cmd.ExecuteReader())
{
try
{
result = fill(reader);
}
catch (Exception e)
{
throw new Exception(e.StackTrace);
}
finally
{
reader.Close();
}
}
return result;
}
}
public static object FillResultValue(SqlDataReader reader)
{
object o = null;
if (reader.Read())
{
o = reader.GetValue(0);
}
return o;
}
public static bool QueryBoolean(string sql)
{
return Convert.ToBoolean(QuerySome(sql, new FillValue(FillResultValue)));
}
public static byte[] QueryBytes(string sql)
{
return (byte[])(QuerySome(sql, new FillValue(FillResultValue)));
}
public static int QueryInteger(string sql)
{
return Convert.ToInt32(QuerySome(sql, new FillValue(FillResultValue)));
}
public static string QueryStr(string sql)
{
return QuerySome(sql, new FillValue(FillResultValue)) as string;
}
private static string[] FillStrsValue(SqlDataReader reader)
{
List<string> lststr = new List<string>();
while (reader.Read())
{
lststr.Add(reader.GetString(0));
}
return lststr.ToArray();
}
public static string[] QueryStrs(string sql)
{
return QuerySomes(sql, new FillValues<string>(FillStrsValue));
}
private static bool[] FillBooleansValue(SqlDataReader reader)
{
List<bool> lstbool = new List<bool>();
while (reader.Read())
{
lstbool.Add(reader.GetBoolean(0));
}
return lstbool.ToArray();
}
public static bool[] QueryBooleans(string sql)
{
return QuerySomes(sql, new FillValues<bool>(FillBooleansValue));
}
public static void ExecCmd(string sql)
{
using (SqlConnection conn = DBConn.GetConn())
{
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
}
}
/// <summary>
/// 获取存储过程的参数列表
/// </summary>
/// <param name="proc_Name">存储过程名称</param>
/// <returns>DataTable</returns>
private static DataTable GetParameters(SqlConnection conn, string proc_Name)
{
SqlCommand comm = new SqlCommand("dbo.sp_sproc_columns", conn);
comm.CommandType = CommandType.StoredProcedure;
comm.Parameters.AddWithValue("@procedure_name", (object)proc_Name);
SqlDataAdapter sda = new SqlDataAdapter(comm);
DataTable dt = new DataTable();
sda.Fill(dt);
return dt;
}
/// <summary>
/// 为 SqlCommand 添加参数及赋值
/// </summary>
/// <param name="comm">SqlCommand</param>
/// <param name="paraValues">参数数组(必须遵循存储过程参数列表的顺序)</param>
private static void AddInParaValues(SqlCommand comm, params object[] paraValues)
{
using (SqlConnection conn = DBConn.GetConn())
{
comm.Parameters.Add(new SqlParameter("@RETURN_VALUE", SqlDbType.Int));
comm.Parameters["@RETURN_VALUE"].Direction = ParameterDirection.ReturnValue;
if (paraValues != null)
{
DataTable dt = GetParameters(conn, comm.CommandText);
int i = 0;
foreach (DataRow row in dt.Rows)
{
string key = row[3].ToString();
if (key != "@RETURN_VALUE")
{
int value = int.Parse(row[4].ToString());
if (value == 1)
{
comm.Parameters.AddWithValue(key, paraValues[i]);
}
else if (value == 2)//value为2则是输出参数
{
comm.Parameters.AddWithValue(key, paraValues[i]).Direction = ParameterDirection.Output;
//comm.Parameters[key].Direction = ParameterDirection.Output;
}
comm.Parameters[key].Size = Convert.ToInt32(row[7].ToString());
i++;
}
}
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
namespace DBComm
{
class DBConn
{
private static string m_connstr;
public static string ConnString
{
get { return m_connstr; }
private set { m_connstr = value; }
}
static DBConn()
{
SqlConnectionStringBuilder connStr = new SqlConnectionStringBuilder();
connStr.DataSource = ".";
connStr.InitialCatalog = "test";
connStr.IntegratedSecurity = true;
connStr.Pooling = true; //开启连接池
connStr.MinPoolSize = 0; //设置最小连接数为0
connStr.MaxPoolSize = 100; //设置最大连接数为100
connStr.ConnectTimeout = 10; //设置超时时间为10秒
ConnString = connStr.ConnectionString;
//ConnectDB(ConnString);
}
public static SqlConnection GetConn()
{
SqlConnection conn = new SqlConnection(ConnString);
conn.Open();
return conn;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
namespace DBComm
{
static class DBTableSource
{
public static DataTable GetSource(SqlConnection conn, string strsql)
{
DataTable dt = null;
SqlCommand cmd = null;
SqlDataAdapter ad = null;
try
{
lock (dt = new DataTable())
{
if (conn is SqlConnection)
{
cmd = new SqlCommand(strsql, conn);
ad = new SqlDataAdapter((SqlCommand)cmd);
}
dt.Clear();
ad.Fill(dt);
}
}
catch (Exception e)
{
throw e;
}
return dt;
}
public static DataTable Source(string strsql)
{
using (SqlConnection conn = DBConn.GetConn())
{
return GetSource(conn, strsql);
}
}
}
}
->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.
举个例子：
struct Data
{
int a,b,c;
}; /*定义结构体*/
struct Data * p;/*定义结构体指针*/
struct Data A = {1,2,3};/*声明变量A*/
int x;/*声明一个变量x*/
p = &A ; /*让p指向A*/
x = p->a;/*这句话的意思就是取出p所指向的结构体中包含的数据项a赋值给x*/
/*由于此时p指向A，因而 p->a == A.a,也就是1*/
对于一开始的问题 p = p->next;这应该出现在C语言的链表，这里的next应该是一个与p同类型的结构体指针，其定义格式应该是：
struct Data
{
int a;
struct Data * next;
};/*定义结构体*/
…………
main()
{
struct Data * p;/*声明指针变量p*/
……
p = p->next;/*将next中的值赋给p*/
}
链表指针是C语言的一个难点，但也是重点，学懂了非常有用。要仔细讲就必须先讲变量、指针。
什么是变量？所谓变量，不要浅显的认为会变得量就是变量。套用我们院长的问话：“教室变不变？”变，因为每天有不同的人在里面上课，但又不变，因为教室始终在那，没有变大或变小。这就是变量：有一个不变的地址和一块可变的存储空间。正常情况下，我们只看到变量这个房间里面的东西，也就是其内容，但不会关注变量的地址，但是C语言的指针，就是这个房间的地址。我们声明变量就相当于盖了间房子存放东西，我们可以直接观看房子里的东西，而声明指针，就是相当于获得了一个定位器，当用指针指向某个变量时，就是用指针给变量定位，以后我们就可以用指针找到他所“跟踪”的变量并可以获得里面的内容。
那结构体呢？结构体就相当于是有好几个房子组成的别墅，几个房子绑定在一起使用。假设现在有很多这种别墅分布在一个大迷宫里，每间别墅里都有一间房子。里面放了另一个别墅的位置信息，现在你手拿定位器找到了第一栋别墅，从里面得到了你想要的东西（链表的数据部分）,然后把下一栋别墅的位置计入你的定位器（p = p->next），再走向下一栋别墅……如此走下去，知道走到某地下一栋别墅信息没有了（p->next == NULL），你的旅行结束。这就是链表一次遍历的过程。现在你能明白 p=p->next的含义了吧！
写了这么多。希望你能明白。
如果想学好c和C++，链表和指针必须熟练掌握！
->是一个整体，它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法，如果我们在C语言中定义了一个结构体，然后申明一个指针指向这个结构体，那么我们要用指针取出结构体中的数据，就要用到“->”.
举个例子：
struct Data
{
int a,b,c;
}; /*定义结构体*/
struct Data * p;/*定义结构体指针*/
struct Data A = {1,2,3};/*声明变量A*/
int x;/*声明一个变量x*/
p = &A ; /*让p指向A*/
x = p->a;/*这句话的意思就是取出p所指向的结构体中包含的数据项a赋值给x*/
/*由于此时p指向A，因而 p->a == A.a,也就是1*/
对于一开始的问题 p = p->next;这应该出现在C语言的链表，这里的next应该是一个与p同类型的结构体指针，其定义格式应该是：
struct Data
{
int a;
struct Data * next;
};/*定义结构体*/
…………
main()
{
struct Data * p;/*声明指针变量p*/
……
p = p->next;/*将next中的值赋给p*/
}
链表指针是C语言的一个难点，但也是重点，学懂了非常有用。要仔细讲就必须先讲变量、指针。
什么是变量？所谓变量，不要浅显的认为会变得量就是变量。套用我们院长的问话：“教室变不变？”变，因为每天有不同的人在里面上课，但又不变，因为教室始终在那，没有变大或变小。这就是变量：有一个不变的地址和一块可变的存储空间。正常情况下，我们只看到变量这个房间里面的东西，也就是其内容，但不会关注变量的地址，但是C语言的指针，就是这个房间的地址。我们声明变量就相当于盖了间房子存放东西，我们可以直接观看房子里的东西，而声明指针，就是相当于获得了一个定位器，当用指针指向某个变量时，就是用指针给变量定位，以后我们就可以用指针找到他所“跟踪”的变量并可以获得里面的内容。
那结构体呢？结构体就相当于是有好几个房子组成的别墅，几个房子绑定在一起使用。假设现在有很多这种别墅分布在一个大迷宫里，每间别墅里都有一间房子。里面放了另一个别墅的位置信息，现在你手拿定位器找到了第一栋别墅，从里面得到了你想要的东西（链表的数据部分）,然后把下一栋别墅的位置计入你的定位器（p = p->next），再走向下一栋别墅……如此走下去，知道走到某地下一栋别墅信息没有了（p->next == NULL），你的旅行结束。这就是链表一次遍历的过程。现在你能明白 p=p->next的含义了吧！
写了这么多。希望你能明白。
如果想学好c和C++，链表和指针必须熟练掌握！