来一篇关于NET的合用于Asp.net的完全的DbHelperSQL类

一个很大的类库。应用程序之所以难以跨平台，在于直接调用了特定平台的接口，而一个巨大的类库，就能极大地减少应用程序对平台的依赖。<divclass="code">usingSystem;
usingSystem.Collections;
usingSystem.Collections.Generic;
usingSystem.Configuration;
usingSystem.Data;
usingSystem.Data.SqlClient;

namespaceDBUtility
{
publicabstractclassDbHelperSQL
{
publicDbHelperSQL()
{

}

//猎取解密后的字符串
protectedstaticstringconnectionString=newSymmetricMethod().Decrypto(ConfigurationSettings.AppSettings["connectionString"].ToString());

publicstaticintGetMaxID(stringFieldName,stringTableName)
{
stringstrsql="selectisnull(max("+FieldName+"),0)+1from"+TableName;
objectobj=DbHelperSQL.GetSingle(strsql);
if(obj==null)
{
return1;

}
else
{
returnint.Parse(obj.ToString());
}
}

publicstaticboolExists(stringstrSql)
{
objectobj=DbHelperSQL.GetSingle(strSql);
intcmdresult;
if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
{
cmdresult=0;
}
else
{
cmdresult=int.Parse(obj.ToString());
}
if(cmdresult==0)
{
returnfalse;
}
else
{
returntrue;
}
}

publicstaticboolExists(stringstrSql,paramsSqlParameter[]cmdParms)
{
objectobj=DbHelperSQL.GetSingle(strSql,cmdParms);
intcmdresult;
if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
{
cmdresult=0;
}
else
{
cmdresult=int.Parse(obj.ToString());
}
if(cmdresult==0)
{
returnfalse;
}
else
{
returntrue;
}
}

///<summary>
///前往毗连
///</summary>
///<returns></returns>
publicstaticSqlConnectionGetConnection()
{
stringcurrentConnectionString=connectionString;
if(!string.IsNullOrEmpty(System.Web.HttpContext.Current.User.Identity.Name))
{
currentConnectionString=currentConnectionString+";ApplicationName=ForegroundUserID="+System.Web.HttpContext.Current.User.Identity.Name;
}
returnnewSqlConnection(currentConnectionString);
}

///<summary>
///实行SQL语句，前往影响的纪录数
///</summary>
///<paramname="SQLString">SQL语句</param>
///<returns>影响的纪录数</returns>
publicstaticintExecuteSql(stringSQLString)
{
using(SqlConnectionconnection=GetConnection())
{
using(SqlCommandcmd=newSqlCommand(SQLString,connection))
{
try
{
connection.Open();
introws=cmd.ExecuteNonQuery();
returnrows;
}
catch(System.Data.SqlClient.SqlExceptionE)
{
thrownewException(E.Message);
}
finally
{
connection.Close();
}
}
}
}

///<summary>
///实行一条盘算查询了局语句，前往查询了局（object）。
///</summary>
///<paramname="SQLString">盘算查询了局语句</param>
///<returns>查询了局（object）</returns>
publicstaticobjectGetSingle(stringSQLString)
{
using(SqlConnectionconnection=GetConnection())
{
using(SqlCommandcmd=newSqlCommand(SQLString,connection))
{
try
{
connection.Open();
objectobj=cmd.ExecuteScalar();
if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
{
returnnull;
}
else
{
returnobj;
}
}
catch(System.Data.SqlClient.SqlExceptione)
{
thrownewException(e.Message);
}
finally
{
cmd.Dispose();
connection.Close();
}
}
}
}

publicstaticobjectExecuteScalar(stringstrSQL)
{
using(SqlConnectionconn=GetConnection())
{
if(conn.State==ConnectionState.Closed)
conn.Open();

SqlCommandcmd=newSqlCommand();
cmd.Connection=conn;
cmd.CommandType=CommandType.Text;
cmd.CommandText=strSQL;

objectresult=cmd.ExecuteScalar();

cmd.Parameters.Clear();
returnresult;
}
}

publicstaticobjectExecuteScalar(stringstrSQL,paramsSqlParameter[]paramter)
{
using(SqlConnectionconn=GetConnection())
{
if(conn.State==ConnectionState.Closed)
conn.Open();

SqlCommandcmd=newSqlCommand();
cmd.Connection=conn;
cmd.CommandType=CommandType.Text;
cmd.CommandText=strSQL;

if(paramter!=null)
{
foreach(SqlParameterparinparamter)
{
cmd.Parameters.Add(par);
}
}

objectresult=cmd.ExecuteScalar();

cmd.Parameters.Clear();
returnresult;
}
}

///<summary>
///实行查询语句，前往DataSet
///</summary>
///<paramname="SQLString">查询语句</param>
///<returns>DataSet</returns>
publicstaticDataSetQuery(stringSQLString)
{
using(SqlConnectionconnection=GetConnection())
{
DataSetds=newDataSet();
try
{
connection.Open();
SqlDataAdaptercommand=newSqlDataAdapter(SQLString,connection);
command.Fill(ds,"ds");
}
catch(System.Data.SqlClient.SqlExceptionex)
{
#ifDEBUG
thrownewException(ex.Message+SQLString);
#endif
thrownewException(ex.Message);
}
finally
{
connection.Close();
}
returnds;
}
}

///<summary>
///猎取数据集
///</summary>
///<paramname="SQLString"></param>
///<paramname="dtname"></param>
///<returns></returns>
publicstaticDataSetQuery(stringSQLString,stringdtname)
{
using(SqlConnectionconnection=GetConnection())
{
DataSetds=newDataSet();
try
{
connection.Open();
SqlDataAdaptercommand=newSqlDataAdapter(SQLString,connection);
command.Fill(ds,dtname);
}
catch(System.Data.SqlClient.SqlExceptionex)
{
thrownewException(ex.Message);
}
finally
{
connection.Close();
}
returnds;
}
}

///<summary>
///
///</summary>
///<paramname="SQLString"></param>
///<paramname="dtname"></param>
///<paramname="ds"></param>
///<returns></returns>
publicstaticDataSetQuery(stringSQLString,stringdtname,refDataSetds)
{
using(SqlConnectionconnection=GetConnection())
{
try
{
connection.Open();
SqlDataAdaptercommand=newSqlDataAdapter(SQLString,connection);
command.Fill(ds,dtname);
}
catch(System.Data.SqlClient.SqlExceptionex)
{
thrownewException(ex.Message);
}
finally
{
connection.Close();
}
returnds;
}
}

///<summary>
///实行SQL语句，前往影响的纪录数
///</summary>
///<paramname="SQLString">SQL语句</param>
///<returns>影响的纪录数</returns>
publicstaticintExecuteSql(stringSQLString,paramsSqlParameter[]cmdParms)
{
using(SqlConnectionconnection=GetConnection())
{
using(SqlCommandcmd=newSqlCommand())
{
try
{
PrepareCommand(cmd,connection,null,SQLString,cmdParms);
introws=cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
returnrows;
}
catch(System.Data.SqlClient.SqlExceptionE)
{
thrownewException(E.Message);
}
finally
{
}
}
}
}

///<summary>
///实行多条SQL语句，完成数据库事件。
///</summary>
///<paramname="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
publicstaticvoidExecuteSqlTran(HashtableSQLStringList)
{
using(SqlConnectionconn=GetConnection())
{
conn.Open();
using(SqlTransactiontrans=conn.BeginTransaction())
{
objectmyDeValue=null;
SqlCommandcmd=newSqlCommand();
try
{
foreach(DictionaryEntrymyDEinSQLStringList)
{
SqlParameter[]cmdParms=(SqlParameter[])myDE.Value;
myDeValue=myDE.Value;

PrepareCommand(cmd,conn,trans,myDE.Key.ToString(),cmdParms);
intval=cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
}
catch(Exceptionex)
{
throwex;
}
trans.Commit();
}
}
}

publicstaticList<int>ExecuteSqlTranRunID(IList<DictionaryEntry>SQLStringList,SqlConnectionconn,SqlTransactiontrans)
{
List<int>list=newList<int>();
if(conn.State==ConnectionState.Closed)conn.Open();
SqlCommandcmd=newSqlCommand();
try
{
foreach(DictionaryEntrymyDEinSQLStringList)
{
SqlParameter[]cmdParms=(SqlParameter[])myDE.Value;
PrepareCommand(cmd,conn,trans,myDE.Key.ToString(),cmdParms);
list.Add(int.Parse(cmd.ExecuteScalar().ToString()));
cmd.Parameters.Clear();
}
}
catch(Exceptionex)
{
trans.Rollback();
throwex;
}
finally
{

}
returnlist;
}

///<summary>
///实行事件，且事件中第一条Sql的前往值作为前面一切Sql最初一个参数的值
///</summary>
///<paramname="SqlStringList"></param>
publicstaticvoidExecuteSqlTrans(List<DictionaryEntry>SqlStringList)
{
using(SqlConnectionconn=GetConnection())
{
conn.Open();
using(SqlTransactiontrans=conn.BeginTransaction())
{
SqlCommandcmd=newSqlCommand();
intidentity=0;
stringcmdText;
SqlParameter[]parameter;
try
{
for(inti=0;i<SqlStringList.Count;i++)
{
cmdText=SqlStringList[i].Key.ToString();
parameter=(SqlParameter[])SqlStringList[i].Value;
if(i==0)
{
PrepareCommand(cmd,conn,trans,cmdText,parameter);
identity=int.Parse(cmd.ExecuteScalar().ToString());
cmd.Parameters.Clear();
}
else
{
if(parameter[parameter.Length-1].Value==DBNull.Value||decimal.Parse(parameter[parameter.Length-1].Value.ToString())==0)
{
parameter[parameter.Length-1].Value=identity;
}
PrepareCommand(cmd,conn,trans,cmdText,parameter);
cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
}
trans.Commit();
}
catch(Exceptione)
{
trans.Rollback();
throwe;
}
}
}
}

///<summary>
///实行多条SQL语句，完成数据库事件。
///</summary>
///<paramname="SQLStringList">SQL语句的有序表（key为sql语句，value是该语句的SqlParameter[]）</param>
publicstaticvoidExecuteSqlTran(IList<DictionaryEntry>SQLStringList)
{
using(SqlConnectionconn=GetConnection())
{
conn.Open();
using(SqlTransactiontrans=conn.BeginTransaction())
{
objectmyDeValue=null;
SqlCommandcmd=newSqlCommand();
try
{
//轮回
foreach(DictionaryEntrymyDEinSQLStringList)
{
if(myDE.Key==null||string.IsNullOrEmpty(myDE.Key.ToString()))
{
continue;
}
else
{
stringcmdText=myDE.Key.ToString();
SqlParameter[]cmdParms=(SqlParameter[])myDE.Value;
myDeValue=myDE.Value;
PrepareCommand(cmd,conn,trans,cmdText,cmdParms);
intval=cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
}
trans.Commit();

}
catch(SqlExceptionex)
{
trans.Rollback();
throwex;
}

}

}
}

///<summary>
///实行一条盘算查询了局语句，前往查询了局（object）。
///</summary>
///<paramname="SQLString">盘算查询了局语句</param>
///<returns>查询了局（object）</returns>
publicstaticobjectGetSingle(stringSQLString,paramsSqlParameter[]cmdParms)
{
using(SqlConnectionconnection=GetConnection())
{
using(SqlCommandcmd=newSqlCommand())
{
try
{
PrepareCommand(cmd,connection,null,SQLString,cmdParms);
objectobj=cmd.ExecuteScalar();
cmd.Parameters.Clear();
if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
{
returnnull;
}
else
{
returnobj;
}
}
catch(System.Data.SqlClient.SqlExceptione)
{
thrownewException(e.Message);
}
finally
{

}
}
}
}

///<summary>
///实行查询语句，前往DataSet
///</summary>
///<paramname="SQLString">查询语句</param>
///<returns>DataSet</returns>
publicstaticDataSetQuery(stringSQLString,paramsSqlParameter[]cmdParms)
{
using(SqlConnectionconnection=GetConnection())
{
SqlCommandcmd=newSqlCommand();
PrepareCommand(cmd,connection,null,SQLString,cmdParms);
using(SqlDataAdapterda=newSqlDataAdapter(cmd))
{
DataSetds=newDataSet();
try
{
da.Fill(ds,"ds");
cmd.Parameters.Clear();
}
catch(System.Data.SqlClient.SqlExceptionex)
{
#ifDEBUG
thrownewException(ex.Message+SQLString);
#endif
thrownewException(ex.Message);
}
finally
&nbspJava欺骗了我们那么多年，如今的多核时代，我认为它气数已尽！

碰到复杂点的问题都不知道能不能解决，现在有点实力的公司都选择自已在开源的基础上做开发。但没听说过有人在IIS上做改进的,windows、sqlserver集群方面的应用也很少见。

业务逻辑代码都不必做任何改动；继承性和多态性使得代码的可重用性大大提高，你可以通过继承已有的对象最大限度保护你以前的投资。并且C#和C++、Java一样提供了完善的调试/纠错体系。

对于中小项目来说.net技术是完全可以胜任，但为什么现在大型公司或网站都选择php或java呢？就是因为微软不够开放，没有提供从硬件到应用服务器再到业务应用的整套解决方案。

PHP的源代码完全公开，在OpenSource意识抬头的今天，它更是这方面的中流砥柱。不断地有新的函数库加入，以及不停地更新，使得PHP无论在UNIX或是Win32的平台上都可以有更多新的功能。它提供丰富的函数，使得在程式设计方面有着更好的资源。目前PHP的最新版本为4.1.1，它可以在Win32以及UNIX/Linux等几乎所有的平台上良好工作。PHP在4.0版后使用了全新的Zend引擎，其在最佳化之后的效率，比较传统CGI或者ASP等技术有了更好的表现。

能产生和执行动态、交互式、高效率的站占服务器的应用程序。运用ASP可将VBscript、javascript等脚本语言嵌入到HTML中，便可快速完成网站的应用程序，无需编译，可在服务器端直接执行。容易编写。

有一丝可惜的是，这个系列太强了，Java阵营的朋友根本就是哑口无言...争论之火瞬间被浇灭，这不是我想这么早就看到的，但是值了。

主流网站开发语言之PHPHP的全名非常有趣，它是一个巢状的缩写名称——“PHP:HypertextPreprocessor”，打开缩写还是缩写。PHP是一种HTML内嵌式的语言(就像上面讲的ASP那样)。而PHP独特的语法混合了C，Java，Perl以及PHP式的新语法。它可以比CGI或者Perl更快速地执行动态网页。