目前只写了与SqlServer的数据处理。
首先是静态工厂类。
using System;
using System.Configuration;
namespace XPSoft.BaseLibrary.DataAccess
{
/// <summary>
/// 数据访问对象的静态工厂类，用于创建不同类型的数据访问对象。
/// </summary>
public static class DataAccessFactory
{
/// <summary>
/// 通过数据访问类型去实例化一个数据访问对象。
/// </summary>
/// <param name="dataAccessType">数据访问类型枚举。</param>
/// <returns>数据访问对象。</returns>
public static IDataAccess InstanceDataAccess(DataAccessType dataAccessType)
{
// 声明一个数据访问对象，根据枚举参数选择实例化哪种类型。
IDataAccess dataAccess = null;
string provideName = ConfigurationManager.ConnectionStrings["SqlServer"].ProviderName;
string connectionString = ConfigurationManager.ConnectionStrings["SqlServer"].ConnectionString;
switch (dataAccessType)
{
// 创建SqlServer数据访问类。
case DataAccessType.SqlServer:
dataAccess = new SqlServerDataAccess(ConfigurationManager.ConnectionStrings["SqlServer"].ToString());
break;
}
if (dataAccess == null) { throw new ArgumentNullException("通过传入的枚举值，未能找到合适的数据访问类。"); }
return dataAccess;
}
}
}
接下来定义了一个数据类型枚举。
using System;
namespace XPSoft.BaseLibrary.DataAccess
{
/// <summary>
/// 数据访问类型枚举。
/// </summary>
public enum DataAccessType : byte
{
Oracle = 0, // Oracle数据库。
SqlServer = 1, // SqlServer数据库。
MySql = 2, // MySql数据库。
Oledb = 3 // 其他数据库。
}
}
接着是数据访问对象的接口。
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Xml;
namespace XPSoft.BaseLibrary.DataAccess
{
public interface IDataAccess
{
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <returns>受影响的行数。</returns>
int ExecuteNonQuery(string commandText);
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <returns>受影响的行数。</returns>
int ExecuteNonQuery(DbCommand command);
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="commandTexts">要执行的Sql语句集合。</param>
/// <returns>受影响的行数。</returns>
int ExecuteNonQuery(IList<string> commandTexts);
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="commands">要执行的DbCommand接口集合。</param>
/// <returns>受影响的行数。</returns>
int ExecuteNonQuery(IList<DbCommand> commands);
/// <summary>
/// 执行不返回数据集的存储过程。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <returns>受影响的行数。</returns>
int ExecuteNonQueryByStoredProcedure(string storedProcedureName);
/// <summary>
/// 执行不返回数据集的存储过程。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <returns>受影响的行数。</returns>
int ExecuteNonQueryByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);
/// <summary>
/// 执行Sql操作，返回数据集的第一行第一列。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <returns>数据集的第一行第一列。</returns>
object ExecuteScalar(string commandText);
/// <summary>
/// 执行Sql操作，返回数据集的第一行第一列。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <returns>数据集的第一行第一列。</returns>
object ExecuteScalar(DbCommand command);
/// <summary>
/// 执行存储过程，返回数据集的第一行第一列。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <returns>数据集的第一行第一列。</returns>
object ExecuteScalarByStoredProcedure(string storedProcedureName);
/// <summary>
/// 执行存储过程，返回数据集的第一行第一列。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <returns>数据集的第一行第一列。</returns>
object ExecuteScalarByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);
/// <summary>
/// 执行Sql操作，返回DataSet数据集。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <returns>DataSet数据集。</returns>
DataSet ExecuteDataSet(string commandText);
/// <summary>
/// 执行Sql语句，返回DataSet数据集。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <returns>DataSet数据集。</returns>
DataSet ExecuteDataSet(DbCommand command);
/// <summary>
/// 执行Sql语句，返回DataSet数据集。
/// </summary>
/// <param name="commandTexts">要执行的Sql语句集合。</param>
/// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
/// <returns>DataSet数据集。</returns>
DataSet ExecuteDataSet(IList<string> commandTexts, IList<string> tableNames);
/// <summary>
/// 执行Sql语句，返回DataSet数据集。
/// </summary>
/// <param name="commandTexts">要执行的DbCommand接口集合。</param>
/// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
/// <returns>DataSet数据集。</returns>
DataSet ExecuteDataSet(IList<DbCommand> commands, IList<string> tableNames);
/// <summary>
/// 执行存储过程，返回DataSet数据集。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <returns>DataSet数据集。</returns>
DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName);
/// <summary>
/// 执行存储过程，返回DataSet数据集。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <returns>DataSet数据集。</returns>
DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);
/// <summary>
/// 执行Sql语句，返回XmlDocument对象。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <returns>XmlDocument对象。</returns>
XmlDocument ExecuteDataXml(string commandText);
/// <summary>
/// 执行Sql操作，返回XmlDocument对象。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <returns>XmlDocument对象。</returns>
XmlDocument ExecuteDataXml(DbCommand command);
/// <summary>
/// 执行Sql操作，返回XmlDocument对象。
/// </summary>
/// <param name="commandTexts">要执行的Sql语句集合。</param>
/// <param name="tableNames">XmlDocument对象中Element属性的名称集合。</param>
/// <returns>XmlDocument对象。</returns>
XmlDocument ExecuteDataXml(IList<string> commandTexts, IList<string> tableNames);
/// <summary>
/// 执行存储过程，返回XmlDocument对象。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <returns>XmlDocument对象。</returns>
XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName);
/// <summary>
/// 执行存储过程，返回XmlDocument对象。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <returns>XmlDocument对象。</returns>
XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName, params DbParameter[] parameters);
}
}
最后就是实现类，目前只做了SqlServer的。
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Xml;
namespace XPSoft.BaseLibrary.DataAccess
{
public class SqlServerDataAccess : IDataAccess
{
// 数据库连接对象。
private static SqlConnection connection = null;
/// <summary>
/// 构造函数。
/// </summary>
public SqlServerDataAccess() { }
/// <summary>
/// 构造函数。
/// </summary>
/// <param name="connectionString">数据库连接字符串。</param>
public SqlServerDataAccess(string connectionString)
{
if (connection == null) {
// 通过字符串实例化SqlConnection对象。
connection = new SqlConnection(connectionString);
}
}
#region 私有方法
/// <summary>
/// 打开数据库连接对象。
/// </summary>
/// <exception cref="SqlException、InvalidOperationException"></exception>
private void OpenConnection()
{
// 如果数据连接为关闭状态，那么将打开连接。
// 否则将抛出异常。
if (connection.State == ConnectionState.Closed)
{
try { connection.Open(); }
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException iopEx) { throw iopEx; }
}
}
/// <summary>
/// 关闭数据库连接对象。
/// </summary>
/// <exception cref="SqlException"></exception>
private void CloseConnection()
{
// 如果数据连接不为关闭状态，那么将关闭连接。
// 否则将抛出异常。
if (connection.State != ConnectionState.Closed)
{
try { connection.Close(); }
catch (SqlException sqlEx) { throw sqlEx; }
}
}
/// <summary>
/// 将DataSet中的列映射成XML特性。
/// </summary>
/// <param name="ds">DataSet对象。</param>
private XmlDocument ConvertDataSetToXmlDocument(DataSet ds)
{
foreach (DataTable dt in ds.Tables)
{
foreach (DataColumn dc in dt.Columns)
{
dc.ColumnMapping = MappingType.Attribute;
}
}
XmlDocument xmlDom = new XmlDocument();
xmlDom.LoadXml(ds.GetXml());
return xmlDom;
}
#endregion
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>受影响的行数。</returns>
public int ExecuteNonQuery(string commandText)
{
// 如果要执行的Sql语句为空，将抛出ArgumentException异常。
if (string.IsNullOrWhiteSpace(commandText))
{ throw new ArgumentException("要执行的Sql语句不能为空。"); }
try
{
// 实例化一个SqlCommand对象，并指定要执行的Sql语句。
using (DbCommand command = new SqlCommand(commandText, connection))
{
// 打开数据库连接对象。
this.OpenConnection();
// 执行操作并返回受影响的行数。
int count = command.ExecuteNonQuery();
return count;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException iopEx) { throw iopEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <exception cref="SqlException、InvalidOperationException"></exception>
/// <returns>受影响的行数。</returns>
public int ExecuteNonQuery(DbCommand command)
{
try
{
// 打开数据库连接对象。
command.Connection = connection;
this.OpenConnection();
// 执行操作并返回受影响的行数。
int count = command.ExecuteNonQuery();
return count;
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException iopEx) { throw iopEx; }
finally
{
command.Dispose();
this.CloseConnection();
}
}
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="commandTexts">要执行的Sql语句集合。</param>
/// <exception cref="ArgumentNullException、SqlException、InvalidOperationException"></exception>
/// <returns>受影响的行数。</returns>
public int ExecuteNonQuery(IList<string> commandTexts)
{
if (commandTexts.Count <= 0)
{ throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
// Sql事务。
SqlTransaction transaction = null;
try
{
// 实例化一个SqlCommand对象，并指定要执行的Sql语句。
using (DbCommand command = new SqlCommand())
{
int count = 0;
// 打开数据库连接对象。
this.OpenConnection();
command.Connection = connection;
// 开始事务。
transaction = connection.BeginTransaction();
command.Transaction = transaction;
foreach (string commandText in commandTexts)
{
// 执行操作。
command.CommandText = commandText;
count += command.ExecuteNonQuery();
}
// 提交事务。
transaction.Commit();
// 返回受影响的行数。
return count;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException iopEx)
{
// 回滚事务。
transaction.Rollback();
throw iopEx;
}
finally
{
transaction.Dispose();
this.CloseConnection();
}
}
/// <summary>
/// 执行不返回数据集的Sql操作。
/// </summary>
/// <param name="commands">要执行的DbCommand接口集合。</param>
/// <exception cref="SqlException、InvalidOperationException"></exception>
/// <returns>受影响的行数。</returns>
public int ExecuteNonQuery(IList<DbCommand> commands)
{
// 受影响的行数。
int count = 0;
// 数据库事务对象。
SqlTransaction transaction = null;
try
{
// 打开数据库连接对象。
this.OpenConnection();
// 设置数据库事务对象。
transaction = connection.BeginTransaction();
foreach (DbCommand command in commands)
{
// 执行操作并返回受影响的行数。
command.Connection = connection;
command.Transaction = transaction;
count += command.ExecuteNonQuery();
command.Dispose();
}
// 提交事务。
transaction.Commit();
// 返回影响的行数。
return count;
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException iopEx)
{
// 回滚事务。
transaction.Rollback();
throw iopEx;
}
finally
{
transaction.Dispose();
this.CloseConnection();
}
}
/// <summary>
/// 执行不返回数据集的存储过程。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>受影响的行数。</returns>
public int ExecuteNonQueryByStoredProcedure(string storedProcedureName)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 打开数据库连接。
OpenConnection();
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = storedProcedureName;
command.CommandType = CommandType.StoredProcedure;
// 执行操作。
int count = command.ExecuteNonQuery();
// 返回受影响的行数。
return count;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行不返回数据集的存储过程。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>受影响的行数。</returns>
public int ExecuteNonQueryByStoredProcedure(string storedProcedureName, params DbParameter[] parameters)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 打开数据库连接。
OpenConnection();
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = storedProcedureName;
command.CommandType = CommandType.StoredProcedure;
// 添加存储过程参数。
foreach (DbParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
// 执行操作。
int count = command.ExecuteNonQuery();
// 返回受影响的行数。
return count;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行Sql操作，返回数据集的第一行第一列。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>数据集的第一行第一列。</returns>
public object ExecuteScalar(string commandText)
{
// 如果要执行的Sql语句为空，将抛出ArgumentException异常。
if (string.IsNullOrWhiteSpace(commandText))
{ throw new ArgumentException("要执行的Sql语句不能为空。"); }
try
{
// 实例化一个SqlCommand对象，并指定要执行的Sql语句。
using (DbCommand command = new SqlCommand(commandText, connection))
{
// 打开数据库连接对象。
this.OpenConnection();
// 返回数据集的第一行第一列。
object result = command.ExecuteScalar();
return result;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException iopEx) { throw iopEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行Sql操作，返回数据集的第一行第一列。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <exception cref="SqlException、InvalidOperationException"></exception>
/// <returns>数据集的第一行第一列。</returns>
public object ExecuteScalar(DbCommand command)
{
try
{
// 打开数据库连接对象。
command.Connection = connection;
this.OpenConnection();
// 返回数据集的第一行第一列。
object result = command.ExecuteScalar();
return result;
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException iopEx) { throw iopEx; }
finally
{
command.Dispose();
this.CloseConnection();
}
}
/// <summary>
/// 执行存储过程，返回数据集的第一行第一列。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>数据集的第一行第一列。</returns>
public object ExecuteScalarByStoredProcedure(string storedProcedureName)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 打开数据库连接对象。
OpenConnection();
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = storedProcedureName;
command.CommandType = CommandType.StoredProcedure;
// 返回数据集的第一行第一列。
object result = command.ExecuteScalar();
return result;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行存储过程，返回数据集的第一行第一列。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>数据集的第一行第一列。</returns>
public object ExecuteScalarByStoredProcedure(string storedProcedureName, params DbParameter[] parameters)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 打开数据库连接对象。
OpenConnection();
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = storedProcedureName;
command.CommandType = CommandType.StoredProcedure;
// 添加存储过程参数。
foreach (DbParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
// 返回数据集的第一行第一列。
object result = command.ExecuteScalar();
return result;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行Sql操作，返回DataSet数据集。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>DataSet数据集。</returns>
public DataSet ExecuteDataSet(string commandText)
{
if (string.IsNullOrWhiteSpace(commandText))
{ throw new ArgumentNullException("commandText", "要执行的Sql语句不能为空。"); }
try
{
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand(commandText))
{
// 创建数据库适配器。
using (DbDataAdapter adapter = new SqlDataAdapter())
{
adapter.SelectCommand = command;
// 打开数据库连接对象。
command.Connection = connection;
OpenConnection();
// 创建数据集。
DataSet dataSet = new DataSet();
// 填充数据集。
adapter.Fill(dataSet);
// 返回数据集。
return dataSet;
}
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行Sql语句，返回DataSet数据集。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <exception cref="SqlException、InvalidOperationException"></exception>
/// <returns>DataSet数据集。</returns>
public DataSet ExecuteDataSet(DbCommand command)
{
try
{
// 创建数据库适配器。
using (DbDataAdapter adapter = new SqlDataAdapter())
{
adapter.SelectCommand = command;
// 打开数据库连接对象。
command.Connection = connection;
OpenConnection();
// 创建数据集。
DataSet dataSet = new DataSet();
// 填充数据集。
adapter.Fill(dataSet);
// 返回数据集。
return dataSet;
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行Sql语句，返回DataSet数据集。
/// </summary>
/// <param name="commandTexts">要执行的Sql语句集合。</param>
/// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
/// <exception cref="ArgumentNullException、SqlException、InvalidOperationException"></exception>
/// <returns>DataSet数据集。</returns>
public DataSet ExecuteDataSet(IList<string> commandTexts, IList<string> tableNames)
{
try
{
if (commandTexts.Count <= 0)
{ throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
if (commandTexts.Count != tableNames.Count)
{ throw new ArgumentException("tableNames集合中的名称的数量不够。"); }
// 打开数据库连接。
OpenConnection();
// 创建数据集。
DataSet dataSet = new DataSet();
for (int i = 0; i < commandTexts.Count; i++)
{
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand(commandTexts[i]))
{
command.Connection = connection;
// 创建数据库适配器。
using (DbDataAdapter adapter = new SqlDataAdapter())
{
// 创建数据表。
DataTable dataTable = new DataTable();
// 设置数据表的名称。
dataTable.TableName = tableNames[i];
// 填充数据表。
adapter.SelectCommand = command;
adapter.Fill(dataTable);
// 将数据表添加到数据集。
dataSet.Tables.Add(dataTable);
// 释放数据适配器。
adapter.Dispose();
}
}
}
return dataSet;
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行Sql语句，返回DataSet数据集。
/// </summary>
/// <param name="commandTexts">要执行的DbCommand接口集合。</param>
/// <param name="tableNames">DataSet数据集中Table的名称集合。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>DataSet数据集。</returns>
public DataSet ExecuteDataSet(IList<DbCommand> commands, IList<string> tableNames)
{
try
{
if (commands.Count != tableNames.Count)
{ throw new ArgumentException("tableNames集合中的名称的数量不够。"); }
// 打开数据库连接。
OpenConnection();
// 创建数据集。
DataSet dataSet = new DataSet();
for (int i = 0; i < commands.Count; i++)
{
commands[i].Connection = connection;
// 创建数据库适配器。
using (DbDataAdapter adapter = new SqlDataAdapter())
{
// 创建数据表。
DataTable dataTable = new DataTable();
// 设置数据表的名称。
dataTable.TableName = tableNames[i];
// 填充数据表。
adapter.SelectCommand = commands[i];
adapter.Fill(dataTable);
// 将数据表添加到数据集。
dataSet.Tables.Add(dataTable);
// 释放数据适配器。
adapter.Dispose();
}
commands[i].Dispose();
}
return dataSet;
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行存储过程，返回DataSet数据集。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>DataSet数据集。</returns>
public DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 打开数据库连接对象。
OpenConnection();
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = storedProcedureName;
command.CommandType = CommandType.StoredProcedure;
using (DbDataAdapter adapter = new SqlDataAdapter())
{
// 创建数据集。
DataSet dataSet = new DataSet();
// 填充数据集。
adapter.SelectCommand = command;
adapter.Fill(dataSet);
// 释放数据适配器。
adapter.Dispose();
// 释放数据库命令对象。
command.Dispose();
// 返回数据集。
return dataSet;
}
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行存储过程，返回DataSet数据集。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>DataSet数据集。</returns>
public DataSet ExecuteDataSetByStoredProcedure(string storedProcedureName, params DbParameter[] parameters)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 打开数据库连接对象。
OpenConnection();
// 创建数据库命令对象。
using (DbCommand command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = storedProcedureName;
command.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
using (DbDataAdapter adapter = new SqlDataAdapter())
{
// 创建数据集。
DataSet dataSet = new DataSet();
// 填充数据集。
adapter.SelectCommand = command;
adapter.Fill(dataSet);
// 释放数据适配器。
adapter.Dispose();
// 释放数据库命令对象。
command.Dispose();
// 返回数据集。
return dataSet;
}
}
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
finally { this.CloseConnection(); }
}
/// <summary>
/// 执行Sql语句，返回XmlDocument对象。
/// </summary>
/// <param name="commandText">要执行的Sql语句。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>XmlDocument对象。</returns>
public XmlDocument ExecuteDataXml(string commandText)
{
if (string.IsNullOrWhiteSpace(commandText))
{ throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
try
{
// 格式化DataSet对象。
DataSet ds = this.ExecuteDataSet(commandText);
// 返回XmlDocument对象。
return ConvertDataSetToXmlDocument(ds);
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
}
/// <summary>
/// 执行Sql操作，返回XmlDocument对象。
/// </summary>
/// <param name="command">要执行的数据库命令对象。</param>
/// <exception cref="SqlException、InvalidOperationException"></exception>
/// <returns>XmlDocument对象。</returns>
public XmlDocument ExecuteDataXml(DbCommand command)
{
try
{
// 格式化DataSet对象。
DataSet ds = this.ExecuteDataSet(command);
// 返回XmlDocument对象。
return ConvertDataSetToXmlDocument(ds);
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
}
/// <summary>
/// 执行Sql操作，返回XmlDocument对象。
/// </summary>
/// <param name="commandTexts">要执行的Sql语句集合。</param>
/// <param name="tableNames">XmlDocument对象中Element属性的名称集合。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>XmlDocument对象。</returns>
public XmlDocument ExecuteDataXml(IList<string> commandTexts, IList<string> tableNames)
{
if (commandTexts.Count <= 0)
{ throw new ArgumentNullException("要执行的Sql语句不能为空。"); }
if (commandTexts.Count != tableNames.Count)
{ throw new ArgumentException("tableNames集合中的名称的数量不够。"); }
try
{
// 格式化DataSet对象。
DataSet ds = this.ExecuteDataSet(commandTexts, tableNames);
// 返回XmlDocument对象。
return ConvertDataSetToXmlDocument(ds);
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
}
/// <summary>
/// 执行存储过程，返回XmlDocument对象。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>XmlDocument对象。</returns>
public XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 格式化DataSet对象。
DataSet ds = this.ExecuteDataSetByStoredProcedure(storedProcedureName);
// 返回XmlDocument对象。
return ConvertDataSetToXmlDocument(ds);
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
}
/// <summary>
/// 执行存储过程，返回XmlDocument对象。
/// </summary>
/// <param name="storedProcedureName">要执行的存储过程名称。</param>
/// <param name="parameters">存储过程的参数。</param>
/// <exception cref="ArgumentException、SqlException、InvalidOperationException"></exception>
/// <returns>XmlDocument对象。</returns>
public XmlDocument ExecuteDataXmlByStoredProcedure(string storedProcedureName, params DbParameter[] parameters)
{
if (string.IsNullOrWhiteSpace(storedProcedureName))
{ throw new ArgumentNullException("要执行的存储过程名称不能为空。"); }
try
{
// 格式化DataSet对象。
DataSet ds = this.ExecuteDataSetByStoredProcedure(storedProcedureName, parameters);
// 返回XmlDocument对象。
return ConvertDataSetToXmlDocument(ds);
}
catch (SqlException sqlEx) { throw sqlEx; }
catch (InvalidOperationException ivoEx) { throw ivoEx; }
}
}
}
在经过一段时间学习，会把反射加入到工厂，数据访问类中加入DataSetToJson。
先做个记录。
时间： 2024-11-03 22:41:24