ASP.Net存储过程实现分页+三层架构

最新推荐文章于 2021-02-19 05:44:51 发布
最新推荐文章于 2021-02-19 05:44:51 发布
阅读量350 收藏 5
点赞数 1
分类专栏： ASP.NET Webform
原文链接：https://blog.csdn.net/WuLex
版权

在这里插入图片描述

CREATE PROCEDURE Sp_page @strTable      VARCHAR(50),--表名 
                         @strColumn     VARCHAR(50),--按该列来进行分页 
                         @intColType    INT, 
                         --@strColumn列的类型,0-数字类型,1-字符类型,2-日期时间类型 
                         @intOrder      BIT,--排序,0-顺序,1-倒序 
                         @strColumnlist VARCHAR(800), 
                         --要查询出的字段列表,*表示全部字段 
                         @intPageSize   INT,--每页记录数 
                         @intPageNum    INT,--指定页 
                         @strWhere      VARCHAR(800),--查询条件 
                         @intPageCount  INT output --总页数 
AS 
    DECLARE @sql NVARCHAR(4000) --用于构造SQL语句 
    DECLARE @where1 VARCHAR(800) --构造条件语句 
    DECLARE @where2 VARCHAR(800) --构造条件语句 

    IF @strWhere IS NULL 
        OR Rtrim(@strWhere) = '' 
      -- 为了避免SQL关键字与字段、表名等连在一起，首先为传入的变量添加空格 
      BEGIN --没有查询条件 
          SET @where1=' WHERE ' 
          SET @where2=' ' 
      END 
    ELSE 
      BEGIN --有查询条件 
          SET @where1=' WHERE (' + @strWhere + ') AND ' 
          SET @where2=' WHERE (' + @strWhere + ') ' 
      END 

    SET @strColumn = ' ' + @strColumn + ' ' 
    SET @strColumnlist = ' ' + @strColumnlist + ' ' 
    --构造SQL语句，计算总页数。计算公式为 总页数 = Ceiling ( 记录个数 / 页大小 ) 
    SET @sql='SELECT @intPageCount=CEILING((COUNT(*)+0.0)/' 
             + Cast(@intPageSize AS VARCHAR) + ') FROM ' 
             + @strTable + @where2 

    --执行SQL语句，计算总页数，并将其放入@intPageCount变量中 
    EXEC Sp_executesql 
      @sql, 
      N'@intPageCount int OUTPUT', 
      @intPageCount output 

    --将总页数放到查询返回记录集的第一个字段前，此语句可省略 
    SET @strColumnlist= Cast(@intPageCount AS VARCHAR(30)) 
                        + ' as PageCount,' + @strColumnlist 

    IF @intOrder = 0 --构造升序的SQL 
      SET @sql='SELECT TOP ' 
               + Cast(@intPageSize AS VARCHAR) + ' ' 
               + @strColumnlist + ' FROM ' + @strTable + @where1 
               + @strColumn + '>(SELECT MAX(' + @strColumn + ') ' 
               + ' FROM (SELECT TOP ' 
               + Cast(@intPageSize*(@intPageNum - 1) AS VARCHAR) 
               + @strColumn + ' FROM ' + @strTable + @where2 
               + 'ORDER BY ' + @strColumn + ') t) ORDER BY ' 
               + @strColumn 
    ELSE --构造降序的SQL 
      SET @sql='SELECT TOP ' 
               + Cast(@intPageSize AS VARCHAR) + ' ' 
               + @strColumnlist + ' FROM ' + @strTable + @where1 
               + @strColumn + '<(SELECT MIN(' + @strColumn + ') ' 
               + ' FROM (SELECT TOP ' 
               + Cast(@intPageSize*(@intPageNum - 1) AS VARCHAR) 
               + @strColumn + ' FROM ' + @strTable + @where2 
               + 'ORDER BY ' + @strColumn 
               + ' DESC) t) ORDER BY ' + @strColumn + ' DESC' 

    IF @intPageNum = 1--第一页 
      SET @sql='SELECT TOP ' 
               + Cast(@intPageSize AS VARCHAR(10)) + ' ' 
               + @strColumnlist + ' FROM ' + @strTable + @where2 
               + ' ORDER BY ' + @strColumn + CASE @intOrder WHEN 0 THEN '' ELSE 
               ' DESC' END 

    --PRINT @sql 
    EXEC(@sql) 

go

存储过程使用示例

DECLARE @intPageCount INT 

EXEC Sp_page 
  'stuInfo',--表名 
  'stuNO',--按该列来进行分页 
  0,-- 0-数字类型,1-字符类型,2-日期时间类型 
  0,-- 0-顺序,1-倒序 
  '*',--要查询出的字段列表,*表示全部字段 
  2,--每页记录数 
  1,--指定页 
  '',--查询条件 
  @intPageCount output 

PRINT @intPageCount

数据库表：

数据库表

项目的数据模块图：

项目结构图

BLL层：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using WebApplication3.DAL;
using WebApplication3.Model;
namespace WebApplication3.BLL
{
   
    public class UserInfoBLL
    {
        UserInfoDAL userDal = new UserInfoDAL();
        public object loadData(UserInfo user)
        {
           return userDal.loadData(user);
        }
        public int Count()
        {
            int count = UserInfoDAL.count;
            return count;
        }
    }
}

DAL层：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Web;
using WebApplication3.Model;
namespace WebApplication3.DAL
{
    public class UserInfoDAL
    {
        SQLHelper sqlHelp = new SQLHelper();
        public static int  count;
        public object loadData(UserInfo user)
        {
            SqlParameter[] paraValues = {
                                        new SqlParameter("@strTable",SqlDbType.VarChar),
                                        new SqlParameter("@strColumn",SqlDbType.VarChar),
                                        new SqlParameter("@intColType",SqlDbType.Int),
                                        new SqlParameter("@intOrder",SqlDbType.Int),
                                        new SqlParameter("@strColumnlist",SqlDbType.VarChar),
                                        new SqlParameter("@intPageSize",SqlDbType.Int),
                                        new SqlParameter("@intPageNum",SqlDbType.Int),
                                        new SqlParameter("@strWhere",SqlDbType.VarChar),
                                        new SqlParameter("@intPageCount",SqlDbType.Int)
                                        };
            paraValues[0].Value = user.tableName;
            paraValues[1].Value = user.Column;
            paraValues[2].Value = user.ColType;
            paraValues[3].Value = user.Order;
            paraValues[4].Value =user.Columnlist;
            paraValues[5].Value = user.PageSize;
            paraValues[6].Value = user.PageNum;
            paraValues[7].Value = user.Where;
            paraValues[8].Direction = ParameterDirection.Output;
            object obj = sqlHelp.ExecuteProcTable("sp_page", paraValues);
            count = Convert.ToInt32(paraValues[8].Value);
            return obj;
        }
    }
}

Model层（Entity类）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
namespace WebApplication3.Model
{
    public class UserInfo
    {
        public string tableName { get; set; }
        public string Column { get; set; }
        public int ColType { get; set; }
        public int Order { get; set; }
        public string Columnlist { get; set; }
        public int PageSize { get; set; }
        public int PageNum { get; set; }
        public string Where { get; set; }
        //public string PageCount { get; set; }
    }
}

UI层：前台代码（WebForm1.aspx）

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="WebApplication3.WebForm1" %>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
    <title></title>
    <script type="text/javascript">
　　function integer() {
　　　　var num = document.getElementById("TextBox1").value;
　　　　if (num=="") {
　　　　　　alert('请输入内容');
　　　　　　return false;
　　　　}
　　　　if (!(/(^[1-9]\d*$)/.test(num))) {
　　　　　　alert('输入的不是正整数');
　　　　　　return false;
    } else {
        return true;
　　　　}
　　}
</script>
</head>
<body>
    <form id="form1" runat="server">
        <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="False">
            <Columns>
                <asp:BoundField DataField="stuNO" HeaderText="学号" />
                <asp:BoundField DataField="stuName" HeaderText="姓名" />
            </Columns>
        </asp:GridView>
        <div>
            <asp:Button ID="btnFirst" runat="server" OnClick="btnFirst_Click" Text="首页" style="height: 21px" />
            <asp:Button ID="btnPre" runat="server" OnClick="btnPre_Click" Text="上一页" />
            <asp:Button ID="btnNext" runat="server" OnClick="btnNext_Click" Text="下一页" style="height: 21px" />
            <asp:Button ID="btnLast" runat="server" OnClick="btnLast_Click" Text="最后一页" />
            <asp:TextBox ID="TextBox1" runat="server" Width="83px"></asp:TextBox>
            <asp:Button ID="btnGO" runat="server" OnClientClick="integer()" OnClick="btnGO_Click" Text="跳转" />
        </div>
        <p>
            <asp:Label ID="Label1" runat="server"></asp:Label>
            <asp:Label ID="Label2" runat="server"></asp:Label>
            <asp:Label ID="Label3" runat="server" Text="每页显示条数"></asp:Label>
            <asp:DropDownList ID="DropDownList1" runat="server">
                <asp:ListItem>1</asp:ListItem>
                <asp:ListItem Selected="True">2</asp:ListItem>
                <asp:ListItem>5</asp:ListItem>
                <asp:ListItem>10</asp:ListItem>
            </asp:DropDownList>
            <asp:Button ID="btnOK" runat="server" OnClick="btnOK_Click" Text="确认" />
        </p>
    </form>
</body>
</html>

UI层：后台代码（WebForm1.aspx.cs）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using WebApplication3.BLL;
using WebApplication3.DAL;
using WebApplication3.Model;
namespace WebApplication3
{
    public partial class WebForm1 : System.Web.UI.Page
    {
        UserInfoBLL userBll = new UserInfoBLL();
        UserInfo user = new UserInfo();
        int count = 1;
        private void loadData()
        {
            count = Convert.ToInt32(ViewState["count"]);
            user.tableName = "stuInfo";
            user.Column = "stuNO";
            user.ColType = 0;
            user.Order = 0;
            user.Columnlist = "*";
            user.PageSize = Convert.ToInt32(DropDownList1.SelectedItem.Text);
            user.PageNum = count;
            user.Where = "";
            GridView1.DataSource = userBll.loadData(user);
            GridView1.DataBind();
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                ViewState["count"] = 1;
                loadData();
                Label1.Text  = "当前页：" + count;
                Label2.Text = "总页数：" + userBll.Count();
            }
        }
        protected void btnFirst_Click(object sender, EventArgs e)
        {
            ViewState["count"] = 1;
            loadData();
            Label1.Text  = "当前页：" + count;
            Label2.Text = "总页数：" + userBll.Count();
        }
        protected void btnPre_Click(object sender, EventArgs e)
        {
            if (Convert.ToInt32(ViewState["count"]) > 1)
            {
                ViewState["count"] = Convert.ToInt32(ViewState["count"]) - 1;
                loadData();
                Label1.Text = "当前页：" + count;
            }
        }
        protected void btnNext_Click(object sender, EventArgs e)
        {
            if (Convert.ToInt32(ViewState["count"]) < userBll.Count())
            {
                ViewState["count"] = Convert.ToInt32(ViewState["count"]) + 1;
                loadData();
                Label1.Text = "当前页：" + count;
            }
        }
        protected void btnLast_Click(object sender, EventArgs e)
        {
            ViewState["count"] = userBll.Count();
            loadData();
            Label1.Text = "当前页：" + count;
        }
        protected void btnGO_Click(object sender, EventArgs e)
        {
            try
            {
                ViewState["count"] = Convert.ToInt32(TextBox1.Text);
            }
            catch
            {
                return;
            }
            if (Convert.ToInt32(ViewState["count"]) <= userBll.Count())
            {
                loadData();
                Label1.Text = "当前页：" + count;
            }
            else
            {
                ClientScript.RegisterStartupScript(this.GetType(), "", "alert('超出范围');", true);
            }
        }
        protected void btnOK_Click(object sender, EventArgs e)
        {
            ViewState["count"] = 1;
            loadData();
            Label1.Text = "当前页：" + count;
            Label2.Text = "总页数：" + userBll.Count();
        }
    }
}

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;

namespace Webapp.DBHelper
{
    class SQLHelper
    {
        private string connStr = null;
        private SqlConnection conn = null;
        private SqlTransaction trans = null;
        public SQLHelper()
        {
            connStr = ConfigurationManager.ConnectionStrings["connStr"].ConnectionString;
            conn = new SqlConnection(connStr);
        }
        /// <summary>
        /// 打开数据库连接
        /// </summary>
        private void OpenDB()
        {
            try
            {
                if (conn != null && conn.State != ConnectionState.Open)
                {
                    conn.Open();
                }
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 关闭数据库连接
        /// </summary>
        private void CloseDB()
        {
            try
            {
                if (conn != null && conn.State != ConnectionState.Closed)
                {
                    conn.Close();
                }
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行带参非查询SQL命令
        /// </summary>
        /// <param name="cmdtxt">带参非查询SQL命令</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>影响的行数</returns>
        private SqlCommand CreateSqlCommand(string sql, SqlParameter[] parmas = null, CommandType cmdType = CommandType.Text)
        {
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = conn;
            cmd.CommandType = cmdType;
            cmd.CommandText = sql;
            if (trans != null)
            {
                cmd.Transaction = trans;
            }
            if (parmas != null)
            {
                cmd.Parameters.AddRange(parmas);
            }
            return cmd;
        }
        /// <summary>
        /// 执行一般非查询SQL命令
        /// </summary>
        /// <param name="cmdtxt">非查询SQL命令</param>
        /// <returns>影响的行数</returns>
        public int ExecuteSqlNonQuery(string sql)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(sql);
            try
            {
                return cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                if (trans == null)
                {
                    CloseDB();
                }
            }
        }
        /// <summary>
        /// 根据SQL指令返回第一行第一列结果
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <param name="parameters">cmd.Parameters.AddWithValue</param>
        /// <returns>返回第一行第一列结果</returns>
        public int ExecuteNonQuery(string sql, params SqlParameter[] parameters)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(sql, parameters);
            try
            {
                return cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                if (trans == null)
                {
                    CloseDB();
                }
            }
        }
        /// <summary>
        /// 执行不带参非查询存储过程
        /// </summary>
        /// <param name="proctxt">带参非查询存储过程名</param>        
        /// <returns>影响的行数</returns>
        public int ExecuteProcNonQuery(string proc)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(proc, null, CommandType.StoredProcedure);
            try
            {
                return cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                if (trans == null)
                {
                    CloseDB();
                }
            }
        }
        /// <summary>
        /// 执行带参非查询存储过程
        /// </summary>
        /// <param name="proctxt">带参非查询存储过程名</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>影响的行数</returns>
        public int ExecuteProcNonQuery(string proc, params SqlParameter[] parameters)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(proc, parameters, CommandType.StoredProcedure);
            try
            {
                return cmd.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                if (trans == null)
                {
                    CloseDB();
                }
            }
        }
        /// <summary>
        /// 执行一般查询SQL命令，返回DataReader对象
        /// </summary>
        /// <param name="cmdtxt">一般查询SQL命令</param>
        /// <returns>返回DataReader对象</returns>
        public SqlDataReader ExecuteSqlReader(string sql)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(sql);
            try
            {
                return cmd.ExecuteReader();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行带参查询SQL命令，返回DataReader对象
        /// </summary>
        /// <param name="cmdtxt">带参非查询SQL命令</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>返回DataReader对象</returns>
        public SqlDataReader ExecuteSqlReader(string sql, params SqlParameter[] parameters)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(sql, parameters);
            try
            {
                return cmd.ExecuteReader();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行不带参查询存储过程
        /// </summary>
        /// <param name="proctxt">不参查询存储过程名</param>        
        /// <returns>返回DataReader对象</returns>
        public SqlDataReader ExecuteProcReader(string proc)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(proc, null, CommandType.StoredProcedure);
            try
            {
                return cmd.ExecuteReader();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行带参查询存储过程，返回DataReader对象
        /// </summary>
        /// <param name="cmdtxt">带参查询存储过程</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>返回DataReader对象</returns>
        public SqlDataReader ExecuteProcReader(string proc, params SqlParameter[] parameters)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(proc, parameters, CommandType.StoredProcedure);
            try
            {
                return cmd.ExecuteReader();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行普通汇总查询SQL命令，返回object对象
        /// </summary>
        /// <param name="cmdtxt">普通汇总查询SQL命令</param>
        /// <returns>汇总结果，object对象</returns>
        public object ExecuteScalar(string sql)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(sql);
            try
            {
                return cmd.ExecuteScalar();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                CloseDB();
            }
        }
        /// <summary>
        /// 执行带参汇总查询SQL命令，返回object对象
        /// </summary>
        /// <param name="cmdtxt">带参汇总查询SQL命令</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>汇总结果，object对象</returns>  
        public object ExecuteScalar(string sql, params SqlParameter[] parameters)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(sql, parameters);
            try
            {
                return cmd.ExecuteScalar();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                CloseDB();
            }
        }
        /// <summary>
        /// 执行不带参汇总查询存储过程，返回object对象
        /// </summary>
        /// <param name="cmdtxt">存储过程名</param>       
        /// <returns>汇总结果，object对象</returns>        
        public object ExecuteProcScalar(string proc)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(proc, null, CommandType.StoredProcedure);
            try
            {
                return cmd.ExecuteScalar();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                CloseDB();
            }
        }
        /// <summary>
        /// 执行带参汇总查询存储过程，返回object对象
        /// </summary>
        /// <param name="cmdtxt">存储过程名</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>汇总结果，object对象</returns>   
        public object ExecuteProcScalar(string proc, params SqlParameter[] parameters)
        {
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(proc, parameters, CommandType.StoredProcedure);
            try
            {
                return cmd.ExecuteScalar();
            }
            catch (SqlException ex)
            {
                throw ex;
            }
            finally
            {
                CloseDB();
            }
        }
        /// <summary>
        /// 执行普通查询SQL命令，返回结果集DataTable
        /// </summary>
        /// <param name="cmdtxt">普通查询SQL命令</param>
        /// <returns>结果集DataTable</returns>
        public DataTable ExecuteTable(string sql)
        {
            SqlDataAdapter da = new SqlDataAdapter();
            da.SelectCommand = CreateSqlCommand(sql);
            DataTable dt = new DataTable();
            try
            {
                da.Fill(dt);
                return dt;
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行带参查询SQL命令，返回结果集DataTable
        /// </summary>
        /// <param name="cmdtxt">带参查询SQL命令</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>结果集DataTable</returns>
        public DataTable ExecuteSqlTable(string sql, params SqlParameter[] parameters)
        {
            SqlDataAdapter da = new SqlDataAdapter();
            da.SelectCommand = CreateSqlCommand(sql, parameters);
            DataTable dt = new DataTable();
            try
            {
                da.Fill(dt);
                return dt;
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行不带参查询存储过程，返回结果集DataTable
        /// </summary>
        /// <param name="cmdtxt">存储过程名</param>        
        /// <returns>结果集DataTable</returns>
        public DataTable ExecuteProcTable(string proc)
        {
            SqlDataAdapter da = new SqlDataAdapter();
            da.SelectCommand = CreateSqlCommand(proc, null, CommandType.StoredProcedure);
            DataTable dt = new DataTable();
            try
            {
                da.Fill(dt);
                return dt;
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 执行带参查询存储过程，返回结果集DataTable
        /// </summary>
        /// <param name="cmdtxt">存储过程名</param>
        /// <param name="parmas">参数对象数组</param>
        /// <returns>结果集DataTable</returns>
        public DataTable ExecuteProcTable(string proc, params SqlParameter[] parameters)
        {
            SqlDataAdapter da = new SqlDataAdapter();
            da.SelectCommand = CreateSqlCommand(proc, parameters, CommandType.StoredProcedure);
            DataTable dt = new DataTable();
            try
            {
                da.Fill(dt);
                return dt;
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        public DataTable ExecuteDataTable(string sql, params SqlParameter[] parameters)
        {
            //conn = new SqlConnection(connStr);
            OpenDB();
            SqlCommand cmd = CreateSqlCommand(sql, parameters);
            DataSet dataset = new DataSet();
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            try
            {
                adapter.Fill(dataset);
                return dataset.Tables[0];
            }
            catch (SqlException ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 开始一个事务
        /// </summary>
        public void BeginSqlTranscation()
        {
            OpenDB();
            trans = conn.BeginTransaction();
        }

        /// <summary>
        /// 提交一个事务
        /// </summary>
        public void CommitSqlTranscation()
        {
            trans.Commit();
            CloseDB();
            trans = null;
        }

        /// <summary>
        /// 事务回滚
        /// </summary>
        public void RollBackSqlTranscation()
        {
            trans.Rollback();
            CloseDB();
            trans = null;
        }
    }
}
.NET跨平台
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
ASP.NET存储过程实现分页效果(三层架构)
01-02
本文实例为大家分享了ASP.NET存储过程实现分页的具体代码，供大家参考，具体内容如下 实现效果： 文本框内输入跳转的页数，点击GO会跳转到该页 首先在项目下加入BLL,DAL,DataAccess,MODEL类库 1、前台界面 <%@ Page Language=C# AutoEventWireup=true CodeBehind=原始刷新分页.aspx.cs Inherits=分页.原始刷新分页 %> <!DOCTYPE html PUBLIC -//W3C//DTD XHTML 1.0 Transitional//EN http://www.w3.org/TR
asp调用存储过程！转贴
aedn的专栏
10-28 1063
1.调用存储过程的一般方法 先假设在sql server中有一存储过程dt_users： CREATE PROCEDURE [dbo].[dt_users] AS select * from users return GO 第一种方法是不利用command对象，直接用recordset对象 set rs=server.createobject("adodb.recordset") sql="exe
Asp.Net分页存储过程
huajinx的专栏
05-15 429
Asp.Net分页存储过程 SQL分页语句 一、比较万能的分页： sql代码： ? 1 2 3 select top 每页显示的记录数 * fromtopic where id not in  (selecttop （当前的页数-1）×每页显示的记录数 idfrom topic order by id desc)  ord
ASP与存储过程
Wind_Lam的专栏
11-03 932
ASP与存储过程    ASP与存储过程(Stored Procedures)的文章不少，但是我怀疑作者们是否真正实践过。我在初学时查阅过大量相关资料，发现其中提供的很多方法实际操作起来并不是那么回事。对于简单的应用，这些资料也许是有帮助的，但仅限于此，因为它们根本就是千篇一律，互相抄袭，稍微复杂点的应用，就全都语焉不详了。     现在，我基本上通过调用存储过程访问SQL Server，以下的文
asp调用存储过程
feiyou的专栏
10-28 611
1.调用存储过程的一般方法先假设在sql server中有一存储过程dt_users：CREATE PROCEDURE [dbo].[dt_users]ASselect * from usersreturnGO第一种方法是不利用command对象，直接用recordset对象set rs=server.createobject("adodb.recordset")sql="exec dt_user
ASP.Net + SQL Server 存储过程实现分页排序
极度魔界
01-28 846
问题提出:在应用程序中经常需要查询数据。当查询结果数据量比较大的时候，检索结果、界面显示都需要花费大量的时间。为了避免这个问题，应该每次只检索部分数据，也就是使用常见的分页方式来处理。分页的问题在asp.net中好像非常简单，只要在GridView中启用分页就可以了。启用分页后，GridView关联数据源控件，依旧会加载所有的数据。这个解决方法只是“掩耳盗铃” ，会导致在大数据量的情况下导致查
asp.net MVC+三层+分页+中英文切换+自定义显示列
10-21
在这个项目中，三层架构使得代码结构清晰，各层职责明确，提高了代码的可维护性和可扩展性。表示层（视图）负责展示数据，业务逻辑层处理业务规则，而数据访问层则负责与数据库的交互。 中英文切换功能是针对国际化...
三层架构+存储过程实现分页
05-21
三层架构和存储过程是数据库应用开发中的两种关键技术，它们在实现高效、可维护的数据处理方面起着关键作用。本文将详细探讨这两种技术及其在分页功能实现中的应用。 首先，三层架构是一种软件设计模式，主要由表现...
ASP.NET源码——三层无存储过程分页Demo.zip
10-10
这个压缩包中的"ASP.NET源码——三层无存储过程分页Demo"显然是一个示例项目，旨在展示如何在ASP.NET环境中实现分页功能，且不依赖于存储过程。 分页是Web应用中常见的功能，特别是在数据量大的情况下，为了提高...
asp.net 用存储过程实现分页(附代码)
08-08
asp.net 用存储过程实现分页(附代码)
三层架构crud和分页及无刷新分页
04-10
三层架构crud和分页,此外源码中还包涵前端应用Ajax进行crud和分页
ASP调用存储过程：有输入参数和输出参数的存储过程
kingwkb的专栏
08-04 5419
　　4. 有输入参数和输出参数的存储过程　　返回值其实是一种特殊的输出参数。在大多数情况下，我们用到的是同时有输入及输出参数的存储过程，比如我们想取得用户信息表中，某ID用户的用户名，这时候，有一个输入参数----用户ID，和一个输出参数----用户名。实现这一功能的存储过程如下： /*SP4*/CREATE PROCEDURE dbo
Asp.Net无刷新分页（ jquery.pagination.js）
weixin_33920401的博客
10-31 106
    采用Jquery无刷新分页插件jquery.pagination.js 实现无刷新分页效果   友情提示：本示例Handler中采用StringBuilder的append方法追加HTML，小数据量可以，但是大数据或是布局常变，建议返回JSON格式的数据，性能和灵活性更好！   1.插件参数列表   2.页面内容： &lt;%@ Page Language="C#...
ASP.NET存储过程分页
weixin_30640291的博客
05-26 84
存储过程： create PROCEDURE pagelist @tablename nvarchar(50),@fieldname nvarchar(50)='*',@pagesize int,--每页显示记录条数@currentpage int,--第几页@orderid nvarchar(50),--主键排序@sort int,--排序方式，1表示升序，0表示降序排列@rowcount i...
asp.net利用存储过程分页代码
Dream Li的专栏
08-23 5354
下面是存储过程（sqlserver2000下通过) --最通用的分页存储过程 -- 获取指定页的数据  CREATE PROCEDURE Pagination  @tblName   varchar(255),       -- 表名  @strGetFields varchar(1000) = *,  -- 需要返回的列  @fldName varchar(255)=, 
net调用MYSQL存储过程实现分页_ASP.NET存储过程实现分页效果(三层架构)
weixin_32050773的博客
02-19 120
本文实例为大家分享了ASP.NET存储过程实现分页的具体代码，供大家参考，具体内容如下实现效果：文本框内输入跳转的页数，点击GO会跳转到该页首先在项目下加入BLL,DAL,DataAccess,MODEL类库1、前台界面$(function () {$('#txtPageindex').focus(function () {$(this).val("");})})DataFormatString=...
使用存储过程在ASP.NET三层架构中实现GridView真分页
"asp.net三层架构下使用存储过程实现GridView控件的真分页技术" 在ASP.NET开发中，GridView是一个非常常见的数据展示控件，它提供了便捷的数据绑定和分页功能。然而，当处理大数据量时，GridView默认的分页方式（假...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值