SqlHelper
<1>SqlHelper
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Data.SqlClient;
using System.Data;
using System.Reflection;
namespace LLSql.DAL
{
public class SqlHelper
{
/// <summary>
/// 获取连接数据库字符串
/// </summary>
private static string connStr = ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString;
/// <summary>
/// 对连接执行 Transact-SQL 语句并返回受影响的行数
/// </summary>
/// <param name="sql">对数据库表进行Insert，Update和Delete语句</param>
/// <param name="parameters">sql语句参数</param>
/// <returns>返回值为该命令所影响的行数</returns>
public static int ExecuteNonQuery(string sql, params SqlParameter[] parameters)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = sql;
cmd.Parameters.AddRange(parameters);
int i = cmd.ExecuteNonQuery();
return i;
}
}
}
/// <summary>
/// 执行查询，并返回查询所返回的结果集中第一行的第一列。一般用于SQL聚合函数，如：count,Max，min，avg。。
/// </summary>
/// <param name="sql">要执行的sql语句</param>
/// <param name="parameters">sql语句的参数</param>
/// <returns>返回查询所返回的结果集中第一行的第一列。忽略其他列或行。返回的最大字符数为 2033 个字符。</returns>
public static object ExecuteScalar(string sql, params SqlParameter[] parameters)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = sql;
cmd.Parameters.AddRange(parameters);
//ExcuteScalar()的返回值是object类型的（如果想返回int类型的数据，可先将cmd.ExecuteSalar()转化成int类型再进行返回）
return cmd.ExecuteScalar();
}
}
}
/// <summary>
/// DataSet是将查询结果填充到本地内存中，这样即使与连接断开，服务器的连接断开，都不会影响数据的读取。但是它也有一个坏处，就是只有小数据量才能往里面存放，数据量大了就给你的本地内存冲爆了。电脑会卡死去。大数据量的话还得用SqlDataReader
/// </summary>
/// <param name="sql">要执行的sql语句</param>
/// <param name="parameters">sql语句的参数</param>
/// <returns>返回值是一个DataSet</returns>
public static DataSet ExecuteDataSet(string sql, params SqlParameter[] parameters)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = sql;
cmd.Parameters.AddRange(parameters);
DataSet ds = new DataSet();
using (SqlDataAdapter adapter = new SqlDataAdapter(cmd))
{
//将cmd的执行结果填充到ds里面
adapter.Fill(ds);
return ds;
}
}
}
}
/// <summary>
/// 执行查询，并将查询的结果以DataTable的形式返回
/// </summary>
/// <param name="sql">要执行的sql语句</param>
/// <param name="parameters">sql语句的参数</param>
/// <returns>返回值是一个DataTable</returns>
public static DataTable ExecuteDataTable(string sql, params SqlParameter[] parameters)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
//换一种写法，与上面的几种写法稍稍有点不同
using (SqlCommand cmd = new SqlCommand(sql, conn))
{
cmd.Parameters.AddRange(parameters);
DataTable dt = new DataTable();
using (SqlDataAdapter adapter = new SqlDataAdapter(cmd))
{
adapter.Fill(dt);
return dt;
}
}
}
}
/// <summary>
/// 将查询的结果转换成一个T类型的对象
/// </summary>
/// <typeparam name="T">泛型类T</typeparam>
/// <param name="sql">要执行的sql语句</param>
/// <param name="parameters">sql语句的参数</param>
/// <returns>T类型的对象集合</returns>
public static List<T> ExecuteClass<T>(string sql, params SqlParameter[] parameters)
{
List<T> list = new List<T>();
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = sql;
cmd.Parameters.AddRange(parameters);
DataSet ds = new DataSet();
using (SqlDataAdapter adapter = new SqlDataAdapter(cmd))
{
adapter.Fill(ds);
}
//获取ds里面的第0个表（索引从0开始）
DataTable dt = ds.Tables[0];
//获取T类型的所有公有属性
PropertyInfo[] tMembers = typeof(T).GetProperties();
//遍历dt表的所有行
for (int i = 0; i < dt.Rows.Count; i++)
{
//创建一个泛型T类型的对象t。
T t = Activator.CreateInstance<T>();
//遍历dt表的所有列
for (int j = 0; j < dt.Columns.Count; j++)
{
//遍历T类型的所有公有属性
foreach (PropertyInfo tMember in tMembers)
{
//如果发现dt表中的列名与遍历出来的T类型属性名相同
if (dt.Columns[j].ColumnName.ToUpper().Equals(tMember.Name.ToUpper()))
{
//将dt.Rows[i][j]赋值给t对象的tMember成员
if (dt.Rows[i][j] != DBNull.Value)
{
tMember.SetValue(t, dt.Rows[i][j], null);
}
else
{
tMember.SetValue(t, null, null);
}
break;//;//注意这里的break是写在if语句里面的，意思就是说如果列名和属性名称相同并且已经赋值了，那么我就跳出foreach循环，进行j+1的下次循环
}
}
}
list.Add(t);
}
return list;
}
}
}
/// <summary>
/// 直接将查询到的数据（表）转换成一个泛型类
/// </summary>
/// <typeparam name="T">泛型类T</typeparam>
/// <param name="cmdText">要执行的sql语句</param>
/// <param name="parameters">sql语句的参数</param>
/// <returns>T类型的对象的集合</returns>
public static List<T> SelectDataToList<T>(string cmdText, params SqlParameter[] parameters)
{
DataTable dt = new DataTable();
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
using (SqlCommand cmd = conn.CreateCommand())
{
cmd.CommandText = cmdText;
cmd.Parameters.AddRange(parameters);
using (SqlDataAdapter adapter = new SqlDataAdapter(cmd))
{
adapter.Fill(dt);
}
}
}
IList<T> list = new List<T>(); //实例化一个泛型类
var tMembers = typeof(T).GetProperties(); //获取T类的所有公共属性
for (int i = 0; i < dt.Rows.Count; i++) //遍历dt表的行
{
T t = Activator.CreateInstance<T>();//创建T类型的实例
for (int j = 0; j < dt.Columns.Count; j++) //遍历dt表的列
{
foreach (var tMember in tMembers) //遍历T类的公共方法
{
if (tMember.Name.ToUpper() == dt.Columns[j].ColumnName.ToUpper()) //如果属性的名字与列的名字一致，则赋值
{
if (dt.Rows[i][j] != null)
{
tMember.SetValue(t, dt.Rows[i][j], null);
}
else
{
tMember.SetValue(t, null, null);
}
break;
}
}
}
list.Add(t);
}
return list.ToList();
}
/*
public static object ExecuteDataReader(string sql, params SqlParameter[] paramters)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
using(SqlCommand cmd=new SqlCommand(sql,conn))
{
cmd.Parameters.AddRange(paramters);
using (SqlDataReader dr = cmd.ExecuteReader())
{
if (dr.Read()==true)
{
}
}
}
}
}
*/
/// <summary>
/// 从数据库取值赋给.net类的对象属性，如果值为DBNull.Value,则将值转换成.Net认的null
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static object FromDbValue(object value)
{
if (value == DBNull.Value)
{
return null;
}
else
{
return value;
}
}
/// <summary>
/// 将.net类对象的属性值插入到数据库，如果类的属性值为null，则将值转换成数据库认的DBNull.value
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static object ToDbValue(object value)
{
if (value == null)
{
return DBNull.Value;
}
else
{
return value;
}
}
}
}
<2>LLSql.DAL
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using LLSql.Model;
using System.Data.SqlClient;
using System.Data;
namespace LLSql.DAL
{
/// <summary>
/// 根据ID获取GetById,Updata(更新数据),DeleteById(id为某一条的数据),GetDataAll(所有数据),Insert(插入数据),GetPageData(分页数据)
/// </summary>
public class CustomerDAL
{
/// <summary>
/// 【查】根据用户提供的表id查询某条数据
/// </summary>
/// <param name="id">用户给定的表id</param>
/// <returns>XS类的对象</returns>
public static XS GetById(string id)
{
DataTable dt= SqlHelper.ExecuteDataTable("select * from xs where 学号=@xh", new SqlParameter("@xh", id));
if (dt.Rows.Count <= 0)
{
return null;
}
else if (dt.Rows.Count > 1)
{
throw new Exception("不好啦，查出多条数据，数据重复啦");
}
else
{
DataRow row = dt.Rows[0];
XS xs = new XS();
xs.备注 =(string)SqlHelper.FromDbValue( row["备注"]);
xs.出生时间 = (DateTime)row["出生时间"];
xs.姓别 = (int)row["姓别"];
xs.姓名 = (string)row["姓名"];
xs.学号 = (string)row["学号"];
xs.专业名 = (string)SqlHelper.FromDbValue( row["专业名"]);
xs.总学分 = (int)SqlHelper.FromDbValue( row["总学分"]);
return xs;
}
}
/// <summary>
/// 获取所有的数据
/// </summary>
public static List<XS> GetDataAll()
{
return SqlHelper.ExecuteClass<XS>("select * from xs");
}
/// <summary>
/// 【增】 插入一条数据到数据库
/// </summary>
/// <param name="xs">插入的数据为XS类的对象属性</param>
public static bool Insert(XS xs)
{
int i = SqlHelper.ExecuteNonQuery("insert into xs(学号,姓名,姓别,专业名,出生时间,总学分,备注) values(@xh,@xm,@xb,@zym,@cssj,@zxf,@bz)",
new SqlParameter("@xh", xs.学号),
new SqlParameter("@xm", xs.姓名),
new SqlParameter("@xb", xs.姓别),
new SqlParameter("@zym",SqlHelper.ToDbValue( xs.专业名)),
new SqlParameter("@cssj",xs.出生时间),
new SqlParameter("@zxf", SqlHelper.ToDbValue( xs.总学分)),
new SqlParameter("@bz",SqlHelper.ToDbValue( xs.备注)));
if (i > 0)
{
return true;
}
else
{
return false;
}
}
/// <summary>
///【删】 根据用户提供的表id删除某条数据
/// </summary>
/// <param name="id"></param>
public static bool DeleteById(string id)
{
int i = SqlHelper.ExecuteNonQuery("delete from xs where 学号=@xh", new SqlParameter("@xh", id));
if (i > 0)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// 【改】编辑用户资料
/// </summary>
/// <param name="xs">编辑的数据为XS类的对象属性</param>
/// <param name="id">需要编辑行的Id</param>
public static bool UpDate(XS xs)
{
int i = SqlHelper.ExecuteNonQuery("update xs set 姓名=@xm,姓别=@xb,专业名=@zym,出生时间=@cssj,总学分=@zxf,备注=@bz where 学号=@xh",
new SqlParameter("@xm", xs.姓名),
new SqlParameter("@xb", xs.姓别),
new SqlParameter("@zym",SqlHelper.ToDbValue( xs.专业名)),
new SqlParameter("@cssj", xs.出生时间),
new SqlParameter("@zxf", SqlHelper.ToDbValue(xs.总学分)),
new SqlParameter("@bz", SqlHelper.ToDbValue(xs.备注)),
new SqlParameter("@xh",xs.学号)
);
if (i > 0)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// 随便写了一下，登陆检查用户名是否存在
/// </summary>
/// <param name="userName">用户名</param>
/// <returns>是否有该用户名存在的bool值</returns>
public static bool GetUserName(string userName)
{
DataTable dt = SqlHelper.ExecuteDataTable("select * from xs where 姓名=@name", new SqlParameter("@name", userName));
if (dt.Rows.Count <= 0)
{
return false;
}
else if (dt.Rows.Count > 1)
{
throw new Exception("存在重名用户");
}
else
{
return true;
}
}
}
}