【ASP.NET】如何连接SQLServer

时间：2017-11-10 01:49:38 阅读：221 评论：0 收藏：0 [点我收藏+]

标签：extend 重复定义排序 dap param config文件字符串 UI asm

在Models下建立这两个文件，

SqlHelper文件

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Collections;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Reflection;
namespace ClientCheckWeb.Models
{
    public class SqlHelper
    {
        //数据库连接字符串
        private static string s_ConnectionString = "";
        public static string ConnectionString
        {
            get
            {
                if (string.IsNullOrEmpty(s_ConnectionString))
                {
                    string conStr = ConfigurationManager.ConnectionStrings["DbConnectionStr"].ConnectionString;
                    int pos = conStr.IndexOf(";pwd=");
                    string txt1 = conStr.Substring(0, pos);
                    string txt2 = conStr.Substring(pos + 5);
                    conStr = txt1 + ";pwd=" + Sam.Common.Security.Decrypt(txt2);
                    string conStr_lower = conStr.ToLower();
                    string wUser = "Trusted_Connection";
                    if (conStr_lower.IndexOf(wUser.ToLower()) >= 0)
                    {
                        s_ConnectionString = "error";
                    }
                    else
                    {
                        s_ConnectionString = conStr;
                    }
                }
                return s_ConnectionString;
            }
        }
        // Hashtable to store cached parameters
        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());

        private static object ReadValue(SqlDataReader reader, string fName, TypeCode typeCode)
        {
            object value = null;
            int fOrder = -1;
            try
            {
                fOrder = reader.GetOrdinal(fName);
            }
            catch (Exception ex)
            {
            }
            value = ReadValue(reader, fOrder, typeCode);
            return value;
        }
        private static object ReadValue(SqlDataReader reader, int fOrder, TypeCode typeCode)
        {
            object value = null;
            if (fOrder < 0)
            {
            }
            else if (reader.IsDBNull(fOrder))
            {
            }
            else if (typeCode == TypeCode.String)
            {
                value = reader.GetString(fOrder);
            }
            else if (typeCode == TypeCode.Int16)
            {
                value = reader.GetInt16(fOrder);
            }
            else if (typeCode == TypeCode.Int32)
            {
                value = reader.GetInt32(fOrder);
            }
            else if (typeCode == TypeCode.Int64)
            {
                value = reader.GetInt64(fOrder);
            }
            else if (typeCode == TypeCode.DateTime)
            {
                value = reader.GetDateTime(fOrder);
            }
            else if (typeCode == TypeCode.Boolean)
            {
                value = reader.GetBoolean(fOrder);
            }
            else if (typeCode == TypeCode.Decimal)
            {
                value = reader.GetDecimal(fOrder);
            }
            else if (typeCode == TypeCode.Double)
            {
                value = reader.GetDouble(fOrder);
            }
            else if (typeCode == TypeCode.Byte)
            {
                value = reader.GetByte(fOrder);
            }
            else
            {
                string str = typeCode.ToString();
                int i = 0;
            }
            return value;
        }
        public static T DoQueryFirstField<T>(string sql, T defValue, params SqlParameter[] commandParameters)
        {
            T result = defValue;
            using (SqlConnection connection = new SqlConnection(ConnectionString))
            {
                SqlDataReader reader = ExecuteReader(connection, CommandType.Text, sql, commandParameters);

                if (reader.Read())
                {
                    Type type = result.GetType();

                    TypeCode typeCode = Type.GetTypeCode(type);
                    object value = ReadValue(reader, 0, typeCode);
                    if (value != null)
                    {
                        result = (T)value;
                    }
                }
                reader.Dispose();
            }
            return result;
        }
        public static List<T> DoQuery<T>(string sql, params SqlParameter[] commandParameters)
        {
            List<T> list = new List<T>();
            using (SqlConnection connection = new SqlConnection(ConnectionString))
            {
                SqlDataReader reader = ExecuteReader(connection, CommandType.Text, sql, commandParameters);

                while (reader.Read())
                {
                    T obj = Activator.CreateInstance<T>();
                    Type type = obj.GetType();
                    foreach (FieldInfo fi in type.GetFields(BindingFlags.Instance | BindingFlags.Public))
                    {
                        string fName = fi.Name;
                        TypeCode typeCode = Type.GetTypeCode(fi.FieldType);
                        object value = ReadValue(reader, fName, typeCode);
                        if (value != null)
                        {
                            fi.SetValue(obj, value);
                        }
                    }
                    foreach (PropertyInfo pi in type.GetProperties(BindingFlags.Instance | BindingFlags.Public))
                    {
                        string fName = pi.Name;
                        TypeCode typeCode = Type.GetTypeCode(pi.PropertyType);
                        object value = ReadValue(reader, fName, typeCode);
                        if (value != null)
                        {
                            pi.SetValue(obj, value, null);
                        }
                    }

                    list.Add(obj);
                }
                reader.Dispose();
            }
            return list;
        }
        /// <summary>
        ///执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="cmdType">命令类型：文本语句、存储过程</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteNonQuery(ConnectionString, cmdType, cmdText, commandParameters);
        }
        /// <summary>
        /// 执行SQL语句,返回受影响的行数（默认按文本查询类型执行)
        /// </summary>
        /// <param name="cmdText">语句内容</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns></returns>
        public static int ExecuteNonQuery(string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteNonQuery(ConnectionString, CommandType.Text, cmdText, commandParameters);
        }
        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
        }
        /// <summary>
        /// 执行SQL语句,返回受影响的行数
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// 执行SQL语句,返回受影响的行数。需要事务控制
        /// </summary>
        /// <param name="trans">事务管理对象</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>受影响的行数</returns>
        public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// 执行SQL语句返回数据结果集
        /// </summary>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>数据结果集</returns>
        public static SqlDataReader ExecuteReader(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteReader(ConnectionString, cmdType, cmdText, commandParameters);
        }

        public static SqlDataReader ExecuteReader(string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteReader(ConnectionString, CommandType.Text, cmdText, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句返回数据结果集
        /// </summary>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>数据结果集</returns>
        public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return rdr;
            }

        }

        /// <summary>
        /// 执行SQL语句返回数据结果集
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>数据结果集</returns>
        public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            SqlDataReader rdr = cmd.ExecuteReader();
            cmd.Parameters.Clear();
            return rdr;
        }

        /// <summary>
        /// 执行SQL语句返回第一行第一列内容
        /// </summary>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>第一行一列的值通过Convert.To{Type}转化成相应类型</returns>
        public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteScalar(ConnectionString, cmdType, cmdText, commandParameters);
        }

        public static object ExecuteScalar(string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteScalar(ConnectionString, CommandType.Text, cmdText, commandParameters);
        }

        /// <summary>
        /// 执行SQL语句返回第一行第一列内容
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>第一行一列的值通过Convert.To{Type}转化成相应类型</returns>
        public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
        }

        /// <summary>
        /// 执行SQL语句返回第一行第一列内容
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>第一行一列的值通过Convert.To{Type}转化成相应类型</returns>
        public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// 执行SQL语句返回第一行第一列内容
        /// </summary>
        /// <param name="trans">事务管理对象</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <param name="commandParameters"></param>
        /// <returns>第一行一列的值通过Convert.To{Type}转化成相应类型</returns>
        public static object ExecuteScalar(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
            object val = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return val;
        }

        /// <summary>
        /// 执行SQL语句返回内存数据表
        /// </summary>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>内存数据表</returns>
        public static DataTable ExecuteTable(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteTable(ConnectionString, cmdType, cmdText, commandParameters);
        }
        public static DataTable ExecuteTable(string cmdText, params SqlParameter[] commandParameters)
        {
            return ExecuteTable(ConnectionString, CommandType.Text, cmdText, commandParameters);
        }
        /// <summary>
        ///  执行查询的SQL语句返回内存数据表
        /// </summary>
        /// <param name="connectionString">数据库连接串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>内存数据表</returns>
        public static DataTable ExecuteTable(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                SqlDataAdapter ap = new SqlDataAdapter();
                ap.SelectCommand = cmd;
                DataSet st = new DataSet();
                ap.Fill(st, "Result");
                cmd.Parameters.Clear();
                return st.Tables["Result"];
            }
        }

        /// <summary>
        ///  执行SQL语句返回内存数据表
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">执行文本串</param>
        /// <param name="commandParameters">查询参数</param>
        /// <returns>内存数据表</returns>
        public static DataTable ExecuteTable(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
            SqlDataAdapter ap = new SqlDataAdapter();
            ap.SelectCommand = cmd;
            DataSet st = new DataSet();
            ap.Fill(st, "Result");
            cmd.Parameters.Clear();
            return st.Tables["Result"];
        }
        #region 添加参数数组到缓存Hashtable中
        /// <summary>
        ///添加参数数组到缓存Hashtable中
        /// </summary>
        /// <param name="cacheKey">Hashtable中的KEY值</param>
        /// <param name="commandParameters">参数数组</param>
        public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
        {
            parmCache[cacheKey] = commandParameters;

        }
        #endregion

        #region 复制方式获取缓存Hashtable中的参数数组
        /// <summary>
        /// 复制方式获取缓存Hashtable中的参数数组
        /// </summary>
        /// <param name="cacheKey">Hashtable中的KEY值</param>
        /// <returns>参数数组</returns>
        public static SqlParameter[] GetCachedParameters(string cacheKey)
        {
            SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];
            if (cachedParms == null)
                return null;

            SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }
        #endregion

        #region 组织Sql查询对象的关系
        /// <summary>
        /// 组织Sql查询对象的关系（包括参数设置）
        /// </summary>
        /// <param name="cmd">Sql查询对象</param>
        /// <param name="conn">数据库连接对象</param>
        /// <param name="trans">事务对象</param>
        /// <param name="cmdType">查询类型</param>
        /// <param name="cmdText">查询语句</param>
        /// <param name="cmdParms">参数数组</param>
        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = cmdType;
            if (cmdParms != null)
            {
                foreach (SqlParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }
        #endregion

        /// <summary>
        /// 执行对默认数据库有自定义排序的分页的查询
        /// </summary>
        /// <param name="SqlAllFields">查询字段，如果是多表查询，请将必要的表名或别名加上，如:a.id,a.name,b.score</param>
        /// <param name="SqlTablesAndWhere">查询的表如果包含查询条件，也将条件带上，但不要包含order by子句，也不要包含"from"关键字，如:students a inner join achievement b on a.... where ....</param>
        /// <param name="IndexField">用以分页的不能重复的索引字段名，最好是主表的自增长字段，如果是多表查询，请带上表名或别名，如:a.id</param>
        /// <param name="OrderASC">排序方式,如果为true则按升序排序,false则按降序排</param>
        /// <param name="OrderFields">排序字段以及方式如：a.OrderID desc,CnName desc</OrderFields>
        /// <param name="PageIndex">当前页的页码</param>
        /// <param name="PageSize">每页记录数</param>
        /// <param name="RecordCount">输出参数，返回查询的总记录条数</param>
        /// <param name="PageCount">输出参数，返回查询的总页数</param>
        /// <returns>返回查询结果</returns>
        public static DataTable ExecutePage(string SqlAllFields, string SqlTablesAndWhere, string IndexField, string OrderFields, int PageIndex, int PageSize, out int RecordCount, out int PageCount, params SqlParameter[] commandParameters)
        {
            using (SqlConnection connection = new SqlConnection(ConnectionString))
            {
                connection.Open();
                return ExecutePage(connection, SqlAllFields, SqlTablesAndWhere, IndexField, OrderFields, PageIndex, PageSize, out RecordCount, out PageCount, commandParameters);
            }
        }

        /// <summary>
        /// 执行有自定义排序的分页的查询
        /// </summary>
        /// <param name="connection">SQL数据库连接对象</param>
        /// <param name="SqlAllFields">查询字段，如果是多表查询，请将必要的表名或别名加上，如:a.id,a.name,b.score</param>
        /// <param name="SqlTablesAndWhere">查询的表如果包含查询条件，也将条件带上，但不要包含order by子句，也不要包含"from"关键字，如:students a inner join achievement b on a.... where ....</param>
        /// <param name="IndexField">用以分页的不能重复的索引字段名，最好是主表的自增长字段，如果是多表查询，请带上表名或别名，如:a.id</param>
        /// <param name="OrderASC">排序方式,如果为true则按升序排序,false则按降序排</param>
        /// <param name="OrderFields">排序字段以及方式如：a.OrderID desc,CnName desc</OrderFields>
        /// <param name="PageIndex">当前页的页码</param>
        /// <param name="PageSize">每页记录数</param>
        /// <param name="RecordCount">输出参数，返回查询的总记录条数</param>
        /// <param name="PageCount">输出参数，返回查询的总页数</param>
        /// <returns>返回查询结果</returns>
        public static DataTable ExecutePage(SqlConnection connection, string SqlAllFields, string SqlTablesAndWhere, string IndexField, string OrderFields, int PageIndex, int PageSize, out int RecordCount, out int PageCount, params SqlParameter[] commandParameters)
        {
            RecordCount = 0;
            PageCount = 0;
            if (PageSize <= 0)
            {
                PageSize = 10;
            }
            if (connection.State != ConnectionState.Open)
                connection.Open();
            string SqlCount = "select count(*) from " + SqlTablesAndWhere;
            SqlCommand cmd = new SqlCommand(SqlCount, connection);
            if (commandParameters != null)
            {
                foreach (SqlParameter parm in commandParameters)
                    cmd.Parameters.Add(parm);
            }
            RecordCount = (int)cmd.ExecuteScalar();
            if (RecordCount % PageSize == 0)
            {
                PageCount = RecordCount / PageSize;
            }
            else
            {
                PageCount = RecordCount / PageSize + 1;
            }
            if (PageIndex > PageCount)
                PageIndex = PageCount;
            if (PageIndex < 1)
                PageIndex = 1;
            string Sql = null;
            if (PageIndex == 1)
            {
                Sql = "select top " + PageSize + " " + SqlAllFields + " from " + SqlTablesAndWhere + " " + OrderFields;
            }
            else
            {
                Sql = "select top " + PageSize + " " + SqlAllFields + " from ";
                if (SqlTablesAndWhere.ToLower().IndexOf(" where ") > 0)
                {
                    string _where = Regex.Replace(SqlTablesAndWhere, @"\ where\ ", " where (", RegexOptions.IgnoreCase | RegexOptions.Compiled);
                    Sql += _where + ") and (";
                }
                else
                {
                    Sql += SqlTablesAndWhere + " where (";
                }
                Sql += IndexField + " not in (select top " + (PageIndex - 1) * PageSize + " " + IndexField + " from " + SqlTablesAndWhere + " " + OrderFields;
                Sql += ")) " + OrderFields;
            }
            cmd.CommandText = Sql;
            SqlDataAdapter ap = new SqlDataAdapter();
            ap.SelectCommand = cmd;
            DataSet st = new DataSet();
            ap.Fill(st, "PageResult");
            cmd.Parameters.Clear();
            return st.Tables["PageResult"];
        }
    }
}

SqlHelper.cs

Extends.cs文件

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.SqlClient;
using System.Data;

namespace ClientCheckWeb.Models
{
    static public class Extend
    {
        public static decimal ToDecimal(this string str)
        {
            decimal dValue = 0;
            if (!decimal.TryParse(str, out dValue))
            {
                dValue = 0;
            }
            return dValue;
        }
        /// <summary>
        /// <para>　将参数中的空类型转化为数据库中对应的默认类型。</para>
        /// <para>　</para>
        /// <para>　AnsiString、Binary、Byte、String类型转化为""。</para>
        /// <para>　Currency（货币类型）、Decimal、Double、Int16、Int32、Int64、UInt16、UInt32、UInt64、VarNumeric(变长数字)转化为0。</para>
        /// <para>　Boolean类型转化为false</para>
        /// </summary>
        /// <param name="paraList">需要转化的List集合</param>
        /// <returns>一个SqlParameter类型的数组</returns>
        public static SqlParameter[] ToNotNullArray(this List<SqlParameter> paraList)
        {
            foreach (SqlParameter para in paraList)
            {
                //拿到参数的数据类型
                DbType dbType = para.DbType;
                if (para.Value != null)
                {
                    //非空，不需要处理
                }
                else if (dbType == DbType.AnsiString || dbType == DbType.Binary || dbType == DbType.Byte
                     || dbType == DbType.String)
                {
                    para.Value = "";
                }
                else if (dbType == DbType.Currency || dbType == DbType.Decimal || dbType == DbType.Double
                     || dbType == DbType.Int16 || dbType == DbType.Int32 || dbType == DbType.Int64
                     || dbType == DbType.UInt16 || dbType == DbType.UInt32 || dbType == DbType.UInt64
                     || dbType == DbType.VarNumeric)
                {
                    para.Value = 0;
                }
                else if (dbType == DbType.Boolean)
                {
                    para.Value = false;
                }
            }
            return paraList.ToArray();
        }
    }
}

Extends.cs

需要在web.config下面配置：

  <connectionStrings>
    <add name="DbConnectionStr" connectionString="server=.\sql2008;database=MoveCheckDB;uid=sa;pwd=+gLUb/wnwuO1h5AFQYiZMg==" />
  </connectionStrings>

其中DbConnectionStr是在SqlHelper.cs需要加载配置的关键字，connectionString里面的database表示数据库名称

完整的web.config文件：

<?xml version="1.0" encoding="utf-8"?>
<!--
  有关如何配置 ASP.NET 应用程序的详细信息，请访问
  http://go.microsoft.com/fwlink/?LinkId=169433
  -->
<configuration>
  <configSections>
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
  </configSections>
  <connectionStrings>
    <add name="DbConnectionStr" connectionString="server=.\sql2008;database=MoveCheckDB;uid=sa;pwd=+gLUb/wnwuO1h5AFQYiZMg==" />
  </connectionStrings>
  <appSettings>
    <add key="webpages:Version" value="2.0.0.0" />
    <add key="webpages:Enabled" value="false" />
    <add key="PreserveLoginUrl" value="true" />
    <add key="ClientValidationEnabled" value="true" />
    <add key="UnobtrusiveJavaScriptEnabled" value="true" />
  </appSettings>
  <system.web>
    <compilation debug="true" targetFramework="4.5" />
    <httpRuntime targetFramework="4.5" />
    <authentication mode="Forms">
      <forms loginUrl="~/Account/Login" timeout="2880" />
    </authentication>
    <pages>
      <namespaces>
        <add namespace="System.Web.Helpers" />
        <add namespace="System.Web.Mvc" />
        <add namespace="System.Web.Mvc.Ajax" />
        <add namespace="System.Web.Mvc.Html" />
        <add namespace="System.Web.Optimization" />
        <add namespace="System.Web.Routing" />
        <add namespace="System.Web.WebPages" />
      </namespaces>
    </pages>
  </system.web>
  <system.webServer>
    <validation validateIntegratedModeConfiguration="false" />
  <handlers><remove name="ExtensionlessUrlHandler-ISAPI-4.0_32bit" /><remove name="ExtensionlessUrlHandler-ISAPI-4.0_64bit" /><remove name="ExtensionlessUrlHandler-Integrated-4.0" /><add name="ExtensionlessUrlHandler-ISAPI-4.0_32bit" path="*." verb="GET,HEAD,POST,DEBUG,PUT,DELETE,PATCH,OPTIONS" modules="IsapiModule" scriptProcessor="%windir%\Microsoft.NET\Framework\v4.0.30319\aspnet_isapi.dll" preCondition="classicMode,runtimeVersionv4.0,bitness32" responseBufferLimit="0" /><add name="ExtensionlessUrlHandler-ISAPI-4.0_64bit" path="*." verb="GET,HEAD,POST,DEBUG,PUT,DELETE,PATCH,OPTIONS" modules="IsapiModule" scriptProcessor="%windir%\Microsoft.NET\Framework64\v4.0.30319\aspnet_isapi.dll" preCondition="classicMode,runtimeVersionv4.0,bitness64" responseBufferLimit="0" /><add name="ExtensionlessUrlHandler-Integrated-4.0" path="*." verb="GET,HEAD,POST,DEBUG,PUT,DELETE,PATCH,OPTIONS" type="System.Web.Handlers.TransferRequestHandler" preCondition="integratedMode,runtimeVersionv4.0" /></handlers></system.webServer>
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="DotNetOpenAuth.Core" publicKeyToken="2780ccd10d57b246" />
        <bindingRedirect oldVersion="1.0.0.0-4.0.0.0" newVersion="4.1.0.0" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="DotNetOpenAuth.AspNet" publicKeyToken="2780ccd10d57b246" />
        <bindingRedirect oldVersion="1.0.0.0-4.0.0.0" newVersion="4.1.0.0" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="System.Web.Helpers" publicKeyToken="31bf3856ad364e35" />
        <bindingRedirect oldVersion="1.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" />
        <bindingRedirect oldVersion="1.0.0.0-4.0.0.0" newVersion="4.0.0.0" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="System.Web.WebPages" publicKeyToken="31bf3856ad364e35" />
        <bindingRedirect oldVersion="1.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="WebGrease" publicKeyToken="31bf3856ad364e35" />
        <bindingRedirect oldVersion="1.0.0.0-1.3.0.0" newVersion="1.3.0.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
  <entityFramework>
    <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
      <parameters>
        <parameter value="v11.0" />
      </parameters>
    </defaultConnectionFactory>
  </entityFramework>
</configuration>

web.config

按照如下方式使用：

           List<SqlParameter> parameterlist = new List<SqlParameter>();
            parameterlist.Add(new SqlParameter("@imsi","abc"));
            parameterlist.Add(new SqlParameter("@imei","abcd"));
            parameterlist.Add(new SqlParameter("@sendTime",DateTime.Now));
            parameterlist.Add(new SqlParameter("@msgId",1));
            parameterlist.Add(new SqlParameter("@addrId", 2));
            parameterlist.Add(new SqlParameter("@desc","asfa"));

            string sql = @"INSERT INTO Client(imsi,imei,sendTime,msgId,addrId,[desc]) VALUES (@imsi,@imei,@sendTime,@msgId,@addrId,@desc)";
            SqlHelper.ExecuteNonQuery(sql, parameterlist.ToNotNullArray());

【ASP.NET】如何连接SQLServer

标签：extend 重复定义排序 dap param config文件字符串 UI asm

原文地址：http://www.cnblogs.com/HDK2016/p/7811954.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行