SqlHelper,JSonHelper类

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

public class SqlHelper
{
    public static readonly string conString = ConfigurationManager.ConnectionStrings["sqlCon"].ConnectionString;
    //增删改
    public static bool ExeNonQuery(string sql, CommandType type, params SqlParameter[] lists)
    {
        bool bFlag = false;
        using (SqlConnection con = new SqlConnection(conString))
        {
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = con;
            cmd.CommandText = sql;
            cmd.CommandType = type;
            if (lists != null)
            {
                foreach (SqlParameter p in lists)
                {
                    cmd.Parameters.Add(p);
                }
            }
            try
            {
                if (con.State == ConnectionState.Closed)
                {
                    con.Open();
                }
                int result = cmd.ExecuteNonQuery();
                if (result > 0)
                {
                    bFlag = true;
                }

            }
            catch { ;}
        }
        return bFlag;
    }

    //查．读
    public static SqlDataReader ExeDataReader(string sql, CommandType type, params SqlParameter[] lists)
    {
        SqlConnection con = new SqlConnection(conString);
        SqlCommand cmd = new SqlCommand();
        cmd.Connection = con;
        cmd.CommandText = sql;
        cmd.CommandType = type;

        if (con.State == ConnectionState.Closed)
        {
            con.Open();
        }

        if (lists != null)
        {
            foreach (SqlParameter p in lists)
            {
                cmd.Parameters.Add(p);
            }
        }

        SqlDataReader reader = cmd.ExecuteReader();

        return reader;
    }

    //返回单个值
    public static object GetScalar(string sql, CommandType type, params SqlParameter[] lists)
    {
        object returnValue = null;
        using (SqlConnection con = new SqlConnection(conString))
        {
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = con;
            cmd.CommandText = sql;
            cmd.CommandType = type;
            if (lists != null)
            {
                foreach (SqlParameter p in lists)
                {
                    cmd.Parameters.Add(p);
                }
            }
            try
            {
                if (con.State == ConnectionState.Closed)
                {
                    con.Open();
                }
                returnValue = cmd.ExecuteScalar();

            }
            catch { ; }
        }
        return returnValue;
    }

    //事务
    public static bool ExeNonQueryTran(List<SqlCommand> list)
    {
        bool flag = true;
        SqlTransaction tran = null;
        using (SqlConnection con = new SqlConnection(conString))
        {
            try
            {
                if (con.State == ConnectionState.Closed)
                {
                    con.Open();
                    tran = con.BeginTransaction();
                    foreach (SqlCommand com in list)
                    {
                        com.Connection = con;
                        com.Transaction = tran;
                        com.ExecuteNonQuery();
                    }
                    tran.Commit();
                }
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
                tran.Rollback();
                flag = false;
            }
        }
        return flag;
    }
    //返回DataTable
    public static DataTable GetTable(string sql)
    {
        SqlConnection conn = new SqlConnection(conString);
        SqlDataAdapter da = new SqlDataAdapter(sql, conn);
        DataTable table = new DataTable();
        da.Fill(table);
        return table;
    }
   //调用带参数的存储过程返回datatable
    public static DataTable GetTablebyproc(string proc, int pageRow, int pagSize, string tabName)
    {
        SqlConnection conn = new SqlConnection(conString);
        SqlCommand cmd = new SqlCommand(proc,conn);
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.Add("@rows", pageRow);
        cmd.Parameters.Add("@pagesize", pagSize);
        cmd.Parameters.Add("@tablename", tabName);
        SqlDataAdapter apt = new SqlDataAdapter(cmd);
        DataTable table = new DataTable();
        apt.Fill(table);
        return table;

    }
    public static DataTable GetDataByPager(string tbname, string fieldkey, int pagecurrent, int pagesize, string fieldshow, string fieldorder, string wherestring, ref int pagecount)
    {
        SqlParameter[] parameters = {
                new SqlParameter("@tbname",   SqlDbType.VarChar, 100),
                new SqlParameter("@FieldKey", SqlDbType.VarChar, 100),
                new SqlParameter("@PageCurrent", SqlDbType.Int),
                new SqlParameter("@PageSize", SqlDbType.Int),
                new SqlParameter("@FieldShow", SqlDbType.VarChar, 200),
                new SqlParameter("@FieldOrder", SqlDbType.VarChar, 200),
                new SqlParameter("@WhereString", SqlDbType.VarChar, 500),
                new SqlParameter("@RecordCount", SqlDbType.Int),
            };
        parameters[0].Value = tbname;
        parameters[1].Value = fieldkey;
        parameters[2].Value = pagecurrent;
        parameters[3].Value = pagesize;
        parameters[4].Value = fieldshow;
        parameters[5].Value = fieldorder;
        parameters[6].Value = wherestring;
        parameters[7].Direction = ParameterDirection.Output;
        DataTable dt = ExecuteQuery("sp_get_data", parameters).Tables[0];
        pagecount = Convert.ToInt32(parameters[7].Value);
        return dt;
    }
    /// <summary>
    /// 执行有参数的查询类存储过程
    /// </summary>
    /// <param name="pstrStoreProcedure">存储过程名</param>
    /// <param name="pParms">存储过程的参数数组</param>
    /// <returns>查询得到的结果集</returns>
    public static DataSet ExecuteQuery(string pstrStoreProcedure, SqlParameter[] pParms)
    {


        DataSet dsResult = new DataSet();
        SqlDataAdapter sda = new SqlDataAdapter();
        SqlConnection con = new SqlConnection(conString);
        SqlCommand cmd;
        int intCounter;
        try
        {
            if (con.State != ConnectionState.Open)
                con.Open();
            cmd = new SqlCommand();
            cmd.Connection = con;
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.CommandText = pstrStoreProcedure;
            if (pParms != null)
            {
                for (intCounter = 0; intCounter < pParms.GetLength(0); intCounter++)
                {
                    cmd.Parameters.Add(pParms[intCounter]);
                }
            }
            sda.SelectCommand = cmd;
            sda.Fill(dsResult);


        }
        catch (SqlException ex)
        {
            throw new Exception(ex.Message);
        }
        finally
        {
            //清空关闭操作
            sda.Dispose();
            con.Close();
            con.Dispose();

        }
        return dsResult;
    }
    /// <summary>
    /// 此分页存储过程直没修改 大家可以用自己的
    /// </summary>
    /// <param name="tableName">表名</param>
    /// <param name="getFields">需要返回的列</param>
    /// <param name="orderName">排序的字段名</param>
    /// <param name="pageSize">页尺寸</param>
    /// <param name="pageIndex">页码</param>
    /// <param name="isGetCount">返回记录总数,非 0 值则返回</param>
    /// <param name="orderType">设置排序类型,0表示升序非0降序</param>
    /// <param name="strWhere"></param>
    /// <returns></returns>
    //public static DataSet GetList(string tableName, string getFields, string orderName, int pageSize, int pageIndex, bool isGetCount, bool orderType, string strWhere)
    //{
    //    SqlParameter[] parameters = {
    //            new SqlParameter("@tblName", SqlDbType.VarChar, 255),
    //            new SqlParameter("@strGetFields", SqlDbType.VarChar, 1000),
    //            new SqlParameter("@fldName", SqlDbType.VarChar, 255),
    //          new SqlParameter("@PageSize", SqlDbType.Int),
    //       new SqlParameter("@PageIndex", SqlDbType.Int),
    //        new SqlParameter("@doCount", SqlDbType.Bit),
    //            new SqlParameter("@OrderType", SqlDbType.Bit),
    //            new SqlParameter("@strWhere", SqlDbType.VarChar, 1500)            
    //                             };
    //    parameters[0].Value = tableName;
    //    parameters[1].Value = getFields;
    //    parameters[2].Value = orderName;
    //    parameters[3].Value = pageSize;
    //    parameters[4].Value = pageIndex;
    //    parameters[5].Value = isGetCount ? 1 : 0;
    //    parameters[6].Value = orderType ? 1 : 0;
    //    parameters[7].Value = strWhere;
    //    return SqlHelper.RunProcedure("pro_pageList", parameters, "ds");
    //}
    //public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
    //{
    //    using (SqlConnection connection = new SqlConnection(conString))
    //    {
    //        DataSet dataSet = new DataSet();
    //        connection.Open();
    //        new SqlDataAdapter { SelectCommand = BuildQueryCommand(connection, storedProcName, parameters) }.Fill(dataSet, tableName);
    //        connection.Close();
    //        return dataSet;
    //    }
    //}
    /// <summary>
    /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
    /// </summary>
    /// <param name="connection">数据库连接</param>
    /// <param name="storedProcName">存储过程名</param>
    /// <param name="parameters">存储过程参数</param>
    /// <returns>SqlCommand</returns>
    private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
    {
        SqlCommand command = new SqlCommand(storedProcName, connection)
        {
            CommandType = CommandType.StoredProcedure
        };
        foreach (SqlParameter parameter in parameters)
        {
            if (parameter != null)
            {
                if (((parameter.Direction == ParameterDirection.InputOutput) || (parameter.Direction == ParameterDirection.Input)) && (parameter.Value == null))
                {
                    parameter.Value = DBNull.Value;
                }
                command.Parameters.Add(parameter);
            }
        }
        return command;
    }
    //根据表名和主键id来进行删除
    public static int DelData(string tabName, string ID)
    {
        if (ID != string.Empty && ID != "0")
        {
            string sql = string.Format("delete from {0}  WHERE (ID IN ({1}))", tabName, ID);
            int delNum = ExecuteSql(sql);
            return delNum;
        }
        return 0;
    }
    //增删改返回执行条数
    public static int ExecuteSql(string SQLString)
    {
        int num2;
        using (SqlConnection connection = new SqlConnection(conString))
        {
            SqlCommand command = new SqlCommand(SQLString, connection);
            try
            {
                connection.Open();
                num2 = command.ExecuteNonQuery();
            }
            catch (SqlException exception)
            {
                connection.Close();
                throw exception;
            }
            finally
            {
                if (command != null)
                {
                    command.Dispose();
                }
            }
        }
        return num2;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.Web.Script.Serialization;
using System.Data;

    public class JSonHelper
    {

        public static string CreateJson(DataTable table)
        {
            string jsname = "total";
            StringBuilder json = new StringBuilder("{""+jsname+"":[");
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    json.Append("{");
                    foreach (DataColumn column in table.Columns)
                    {
                        json.Append("""+column.ColumnName+"":""+row[column.ColumnName].ToString()+"",");
                    }
                    json.Remove(json.Length - 1, 1);
                    json.Append("},");
                }
                json.Remove(json.Length - 1, 1);
            }
            json.Append("]}");
            return json.ToString();
        }
        public static string CreateJsons(DataTable dt, bool flag, int count)
        {
            StringBuilder json = new StringBuilder();
            if (dt.Rows.Count > 0)
            {
                json.Append("{");
                if (flag)
                {
                    json.Append(""total":");
                    json.Append(count);
                    json.Append(",");
                }
                json.Append(""rows":[");
                foreach (DataRow row in dt.Rows)
                {
                    json.Append("{");
                    foreach (DataColumn column in dt.Columns)
                    {
                        json.Append(""JSON_"+column.ColumnName.ToLower()+"":""+row[column.ColumnName].ToString()+"",");
                    }
                    json.Remove(json.Length - 1, 1);
                    json.Append("},");
                }
                json.Remove(json.Length - 1, 1);
            }
            json.Append("]}");
            return json.ToString();
        }


        public static string CreateJsonParameters(DataTable dt, bool displayCount, int totalcount)
        {
            StringBuilder JsonString = new StringBuilder();
            //Exception Handling        
            if (dt != null)
            {
                JsonString.Append("{ ");
                if (displayCount)
                {
                    JsonString.Append(""total":");
                    JsonString.Append(totalcount);
                    JsonString.Append(",");
                }
                JsonString.Append(""rows":[ ");
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    JsonString.Append("{ ");
                    for (int j = 0; j < dt.Columns.Count; j++)
                    {
                        if (j < dt.Columns.Count - 1)
                        {
                            //if (dt.Rows[i][j] == DBNull.Value) continue;
                            if (dt.Columns[j].DataType == typeof(bool))
                            {
                                JsonString.Append(""JSON_" + dt.Columns[j].ColumnName.ToLower() + "":" +
                                                  dt.Rows[i][j].ToString().ToLower() + ",");
                            }
                            else if (dt.Columns[j].DataType == typeof(string))
                            {
                                JsonString.Append(""JSON_" + dt.Columns[j].ColumnName.ToLower() + "":" + """ +
                                                  dt.Rows[i][j].ToString().Replace(""", "\"") + "",");
                            }
                            else
                            {
                                JsonString.Append(""JSON_" + dt.Columns[j].ColumnName.ToLower() + "":" + """ + dt.Rows[i][j] + "",");
                            }
                        }
                        else if (j == dt.Columns.Count - 1)
                        {
                            //if (dt.Rows[i][j] == DBNull.Value) continue;
                            if (dt.Columns[j].DataType == typeof(bool))
                            {
                                JsonString.Append(""JSON_" + dt.Columns[j].ColumnName.ToLower() + "":" +
                                                  dt.Rows[i][j].ToString().ToLower());
                            }
                            else if (dt.Columns[j].DataType == typeof(string))
                            {
                                JsonString.Append(""JSON_" + dt.Columns[j].ColumnName.ToLower() + "":" + """ +
                                                  dt.Rows[i][j].ToString().Replace(""", "\"") + """);
                            }
                            else
                            {
                                JsonString.Append(""JSON_" + dt.Columns[j].ColumnName.ToLower() + "":" + """ + dt.Rows[i][j] + """);
                            }
                        }
                    }
                    /*end Of String*/
                    if (i == dt.Rows.Count - 1)
                    {
                        JsonString.Append("} ");
                    }
                    else
                    {
                        JsonString.Append("}, ");
                    }
                }
                JsonString.Append("]");
                JsonString.Append("}");
                return JsonString.ToString().Replace("
", "");
            }
            else
            {
                return null;
            }
        }
        public static string DataTableToJson(DataTable table, string name)
        {
            StringBuilder Json = new StringBuilder("{""+name+"":[");
            if (table.Rows.Count > 0)
            {
                foreach (DataRow row in table.Rows)
                {
                    Json.Append("{");
                    foreach (DataColumn cloumn in table.Columns)
                    {
                        Json.Append("""+cloumn.ColumnName+"":""+row[cloumn.ColumnName].ToString()+"",");
                    }
                    Json.Remove(Json.Length - 1, 1);
                    Json.Append("},");
                }
                Json.Remove(Json.Length - 1, 1);
            }
            Json.Append("]}");
            return Json.ToString();
        }
    }