일반 페이징 클래스

저장 프로시저를 결합하면 페이징이 가장 간단해집니다. 다음 소스 코드를 참조하세요.

이 페이징 클래스에서 작동하는 저장 프로시저 #region 이 페이징 클래스에서 작동하는 저장 프로시저입니다.
/**//******************************************** ***************
*
* 다음 저장 프로시저와 결합된 강력한 기능
*
************************************************* * *****/
/**//*
-- 호출기 1,10,0,0, 'EmployeeID>2 및 EmployeeID<5 ' , 'Employees','*','LastName',0
절차 호출기 생성
@PageIndex int,--색인 페이지 1
@PageSize int,--페이지당 페이지 수 2
@RecordCount int out,--총 행 수 3
@PageCount int out,--총 페이지 수 4
@WhereCondition Nvarchar(1000),--쿼리 조건 5
@TableName nvarchar(500),--쿼리 테이블 이름 6
@SelectStr nvarchar(500) = '*',--쿼리 열 7
@Order nvarchar(500),--정렬된 열 8
@OrderType bit = 0, -- 정렬 유형을 설정합니다. 0이 아닌 값은 내림차순입니다. 9
@Groupby NVarChar(100) = ''
AS

선언 @strSQL nvarchar(2000) -- 기본 명령문
@strTmp nvarchar(1000) 선언 - 임시 변수
@strOrder nvarchar(1000) --

@OrderType != 0인 경우

시작하다
set @strTmp = '<(분 선택'
set @strOrder = ' order by ' + @Order +' desc'
끝
또 다른
시작하다
set @strTmp = '>(최대 선택'
set @strOrder = ' 순서 기준 ' + @Order +' asc'
end

set @strSQL = 'select top' + str(@PageSize) + ' ' + @SelectStr + ' from '
+ @TableName + ' 여기서 ' + @Order + '' + @strTmp + '(['
+ @Order + ']) from (상단 ' + str((@PageIndex-1)*@PageSize) + ' [' 선택
+ @Order + '] from ' + @TableName + '' + @strOrder + ') as tblTmp)'
+ @Groupby + @strOrder

if @WhereCondition != ''
set @strSQL = 'select top' + str(@PageSize) + ' ' + @SelectStr + ' from '
+ @TableName + ' 여기서 ' + @Order + '' + @strTmp + '(['
+ @Order + ']) from (상단 ' + str((@PageIndex-1)*@PageSize) + ' [' 선택
+ @Order + '] from ' + @TableName + ' where (' + @WhereCondition + ') '
+ @strOrder + ') as tblTmp) 및 (' + @WhereCondition + ') ' + @Groupby + @strOrder

@PageIndex = 1인 경우
시작하다
@strTmp = '' 설정
@WhereCondition != ''인 경우
set @strTmp = ' where (' + @WhereCondition + ')'

set @strSQL = 'select top ' + str(@PageSize) + ' ' + @SelectStr + ' from '
+ @TableName + '' + @strTmp + ' ' + @Groupby + @strOrder
끝
exec(@strSQL)
--print @strSQL

IF @WhereCondition <>''
시작하다
SET @strTmp = 'SELECT -1 FROM' + @TableName + ' Where ' + (@WhereCondition)
끝
또 다른
시작하다
SET @strTmp = 'SELECT -1 FROM' + @TableName
끝
EXEC SP_EXECUTESQL @strTmp
SET @RecordCount = @@RowCount
-- 총 페이지 수를 가져옵니다.
-- "CEILING" 함수: 특정 숫자보다 작지 않은 가장 작은 정수를 가져옵니다.
SET @PageCount = CEILING(@RecordCount * 1.0 / @PageSize)
가다
************************************************** * ***************************/
/**//******************************************** *** *******************************
*
* 용법
*
************************************************* * *****************************/
/**//*
Dim ts As String = Request.Form.Item("txtDate")

If (ts = "" Or ts Is Nothing) Then
ts = Request.QueryString("txtDate")
종료 조건

Dim ts2 As String = Request.Form.Item("txtDate2")

If (ts2 = "" Or ts2 Is Nothing) Then
ts2 = Request.QueryString("txtDate2")
End If

Dim ps As String = Request.Form.Item("pageIndex")

If (ps = "" Or ps Is Nothing) Then
ps = Request.QueryString("페이지인덱스")

Dim t As Integer = 2

인 경우 종료

Dim p를 정수로 사용 = 1
만약 ts가 아무것도 아니라면
TS = ""
종료 조건
ps가 아무것도 아닌 경우
추신 = ""
If Not 종료

(ps = "") 그러면
p = 정수.Parse(ps)

희미하면

종료 호출기 = 새 호출기로
pager.PageIndex = p
호출기.PageSize = 20
pager.PageMode = PageMode.Str
pager.WhereCondition = "convert(datetime,'" + ts + "')와 변환(datetime,'" + ts2 + "') 사이의 날짜"
'pager.WhereCondition = " 변환(char(10),TheDate,120)= '" + ts + "'"
pager.TableName = "LoadCountlog"
pager.SelectStr = "*"
호출기.주문 = "ID"
pager.OrderType = 거짓
Dim dt As System.Data.DataTable = pager.GetDatas(p)
myDataGrid.DataSource = dt
myDataGrid.DataBind()
Dim goUrl As String = "WebForm1.aspx?txtDate=" + ts + "&txtDate2=" + ts2
Me.Label3.Text = "전체:" + pager.PageCount.ToString + "페이지," + pager.RecordCount.ToString() + "Bar<strong>" + pager.OutPager(pager, goUrl, False) + "< /강한>"
*/
#endregion
시스템 사용;
System.Data 사용;
System.Data.SqlClient 사용;
System.Configuration 사용;
System.Collections 사용;
System.Text 사용;
네임스페이스 솔럭키
{
/**//// <요약>
/// 페이징 모드
/// </summary>
공개 열거형 PageMode
{
/**//// <요약>
///번호 페이징
/// </summary>
번호 =0,
/**//// <요약>
/// 문자 페이징
/// </summary>
Str =1
}
/**//// <요약>
/// 페이징 클래스는 저장 프로시저를 통해 페이징을 수행할 수 있으며 매우 강력합니다.
/// </summary>

공개 클래스 호출기
{
개인 int pageIndex = 0;
개인 int RecordCount = 0;
개인 int pageSize = 20;
개인 int pageCount = 0;
개인 int rowCount = 0;
개인 문자열 tableName = "";
개인 문자열 whereCondition = "1=1";
개인 문자열 selectStr = "*";
개인 문자열 순서 = "";
개인 문자열 프로시저="호출기";
개인 bool orderType = true;
개인 PageMode pageMode =PageMode.Num;
개인 문자열 sqlConnectionString = ConfigurationSettings.AppSettings["database"];
개인 문자열 데이터베이스 소유자 = "dbo"

데이터 연결#지역 데이터 연결
/**//// <요약>
/// 데이터 연결 문자열
/// </summary>
개인 문자열 SqlConnectionString
{
얻다
{
this.sqlConnectionString을 반환합니다.
}
세트
{
this.sqlConnectionString=값;
}
}

/**//// <요약>
///연결 인스턴스를 가져옵니다.
/// </summary>
/// <반환></반환>
개인 SqlConnection GetSqlConnectionString()
{
노력하다
{
새로운 SqlConnection(SqlConnectionString)을 반환합니다.
}
잡다
{
throw new Exception("SQL 연결 문자열이 잘못되었습니다.");
}
}

/**//// <요약>
/// 데이터 객체 소유자
/// </summary>
개인 문자열 DatabaseOwner
{
얻다
{
this.databaseOwner를 반환합니다.
}
세트{
this.databaseOwner=값;
}
}

#endregion

공개 호출기()
{
//
// TODO: 여기에 생성자 논리를 추가합니다.
//
//Enum.Parse(tyo
}
공개 호출기(문자열 연결)
{
if (connstr!=null)
this.SqlConnectionString=connstr;
}
#지역
/**//// <요약>
/// 동작할 저장 프로시저 이름에는 기본 페이징 저장 프로시저가 있습니다.
/// </summary>
공개 문자열 절차
{
얻다{
this.procedure를 반환하십시오.
}
세트 {
if (값==null || value.Length <=0)
{
this.procedure="호출기";
}
또 다른
{
this.프로시저=값;
}
}
}

/**//// <요약>
/// 현재 표시할 페이지 수
/// </summary>
공개 int PageIndex

{
얻다
{
this.pageIndex를 반환합니다.
}
세트
{
this.pageIndex = 값;
}
}

/**//// <요약>
///총 페이지 수
/// </summary>
공개 정수 페이지 수
{
얻다
{
this.pageCount를 반환합니다.
}
세트
{
this.pageCount = 값;
}
}

/**//// <요약>
///총 행 수
/// </summary>
공개 int RecordCount
{
얻다
{
this.recordCount를 반환합니다.
}
세트
{
this.recordCount = 값;
}
}

/**//// <요약>
///페이지당 항목 수
/// </summary>
공개 정수 페이지 크기
{
얻다
{
this.pageSize를 반환합니다.
}
세트
{
this.pageSize = 값;
}
}

/**//// <요약>
///테이블 이름
/// </summary>
공개 문자열 TableName
{
얻다
{
테이블 이름을 반환합니다.
}
세트
{
this.tableName = 값;
}
}

/**//// <요약>
/// 조건부 쿼리
/// </summary>
공개 문자열 WhereCondition
{
얻다
{
whereCondition을 반환합니다.
}
세트
{
whereCondition = 값;
}
}

/**//// <요약>
/// 쿼리 대상(검색 대상), 예: AddTime AS 시간, ID AS 번호
/// </summary>
공개 문자열 SelectStr
{
얻다
{
selectStr을 반환합니다.
}
세트
{
selectStr = 값;
}
}

/**//// <요약>
/// 정렬된 열
/// </summary>
공개 문자열 주문
{
얻다
{
반품 주문;
}
세트
{
주문 = 가치;
}
}

/**//// <요약>
/// 정렬 유형 true:asc false:desc
/// </summary>
공개 boolean 주문 유형
{
얻다
{
주문 유형 반환;
}
세트
{
주문 유형 = 값;
}
}

/**//// <요약>
/// 페이징 모드
/// </summary>
공개 PageMode PageMode
{
얻다
{
this.pageMode를 반환합니다.
}
세트
{
this.pageMode = 값;
}
}

/**//// <요약>
/// 현재 반환된 수량을 가져옵니다.
/// </summary>
공개 int RowCount
{
얻다
{
this.rowCount를 반환합니다.
}
}

비공개 문자열 groupby;
공개 문자열 Groupby
{
얻다
{
this.groupby를 반환합니다.
}
세트
{
this.groupby = 값;
}
}

#끝지역
/**//// <요약>
/// 페이지 매김 검색 결과
/// </summary>
공개 DataTable GetDatas(int pageIndex)
{
this.pageIndex = 페이지인덱스;
호출기 호출기 = this;
//pager.pageIndex = 페이지인덱스;
DataTable returnTb = 페이지 매김(ref pager).Tables[0];
this.rowCount = returnTb.Rows.Count;
return returnTb;
}

/**//// <요약>
/// 페이징 작업 저장 프로시저 함수
/// </summary>
/// <param name="pager"></param>
/// <반환></반환>
개인 데이터 세트 페이지 매김(참조 호출기 호출기)
{
(SqlConnection myConnection = GetSqlConnectionString() ) 사용
{
SqlDataAdapter myCommand = new SqlDataAdapter(pager.databaseOwner + "."+pager.Procedure, myConnection);
myCommand.SelectCommand.CommandType = CommandType.StoredProcedure;

SqlParameter 매개변수PageIndex = new SqlParameter("@PageIndex", SqlDbType.Int);
매개변수페이지인덱스.값 = 페이저.페이지인덱스;
myCommand.SelectCommand.Parameters.Add(parameterPageIndex);

SqlParameter 매개변수PageSize = new SqlParameter("@PageSize", SqlDbType.Int);
매개변수PageSize.Value = 호출기.PageSize;
myCommand.SelectCommand.Parameters.Add(parameterPageSize);

SqlParameter 매개변수RecordCount = new SqlParameter("@RecordCount", SqlDbType.Int);
매개변수RecordCount.Value = 0;
ParameterRecordCount.Direction = ParameterDirection.InputOutput;
myCommand.SelectCommand.Parameters.Add(parameterRecordCount);

SqlParameter 매개변수PageCount = new SqlParameter("@PageCount", SqlDbType.Int);
매개변수페이지카운트.값 = 0;
ParameterPageCount.Direction = ParameterDirection.InputOutput;
myCommand.SelectCommand.Parameters.Add(parameterPageCount);

SqlParameter 매개변수WhereCondition = new SqlParameter("@WhereCondition", SqlDbType.NVarChar,500);
매개변수WhereCondition.Value = 호출기.WhereCondition;
myCommand.SelectCommand.Parameters.Add(parameterWhereCondition);

SqlParameter 매개변수TableName = new SqlParameter("@TableName", SqlDbType.NVarChar,500);
매개변수TableName.Value = 호출기.TableName;
myCommand.SelectCommand.Parameters.Add(parameterTableName);

SqlParameter 매개변수Order = new SqlParameter("@Order", SqlDbType.NVarChar,500);
매개변수Order.Value = 호출기.Order;
myCommand.SelectCommand.Parameters.Add(parameterOrder);

SqlParameter 매개변수SelectStr = new SqlParameter("@SelectStr", SqlDbType.NVarChar,500);
매개변수SelectStr.Value = 호출기.SelectStr;
myCommand.SelectCommand.Parameters.Add(parameterSelectStr);

SqlParameter 매개변수Groupby = new SqlParameter("@Groupby", SqlDbType.NVarChar, 100);
매개변수Groupby.Value = 호출기.Groupby;
myCommand.SelectCommand.Parameters.Add(parameterGroupby);

SqlParameter 매개변수OrderType = new SqlParameter("@OrderType", SqlDbType.Bit);
매개변수OrderType.Value = pager.OrderType==false?0:1;
myCommand.SelectCommand.Parameters.Add(parameterOrderType);

DataSet returnDS = new DataSet();

//SqlDataAdapter sqlDA = myCommand.crnew SqlDataAdapter(myCommand);
myCommand.Fill(returnDS);

pager.PageCount = (int)parameterPageCount.Value;
pager.RecordCount = (int)parameterRecordCount.Value

return returnDS;
}

}

페이지 매김 생성 #region 페이지 매김 생성
/**//// <요약>
/// 페이징 형식 생성
/// </summary>
/// <param name="pager"></param>
/// <param name="url"></param>
/// <param name="isBr"></param>
/// <반환></반환>
공개 문자열 OutPager(호출기 호출기,문자열 URL,bool isBr)
{
StringBuilder returnOurWml;
if(isBr)
{
returnOurWml= new StringBuilder("["+ pager.PageCount.ToString() + "page," + pager.RecordCount.ToString() +"bar]<br/>");
}
또 다른
{
returnOurWml = 새로운 StringBuilder();
}
if (pager.PageMode == PageMode.Num)
{
//페이징의 각 행에 표시되는 숫자
int 페이지수 = 10;
정수 페이지 = 0;
int startInt = 1;
int endInt = pager.PageCount;
int i = 1;

문자열 endStr = "";

if (pager.PageCount>pagersCount)
{

//이중 k = ;
페이저 = pager.PageIndex / pagersCount;

if (페이저 == 0)
{
호출기 = 1;
}
else if((pager.PageIndex % pagersCount)!=0)
{
호출기 +=1;
}

endInt = 호출기 * pagersCount;
if (pager.PageIndex <= endInt)
{
startInt = endInt +1 - pagersCount;
if (startInt <1)
{
startInt = 1;
}
}

//표시 수량이 부족한 경우 pagersCount
if (endInt>=pager.PageCount)
{
endInt = 호출기.PageCount;
}
또 다른
{
//if (pager.PageIndex)
endStr = " <a href="";
endStr += url + "&amp;pageIndex=" + (endInt + 1).ToString() + "" title='page" + (endInt + 1).ToString()+"page'>";
endStr += "&gt;&gt;";
endStr += "</a> ";
}

if (페이저 > 1)
{
returnOurWml.Append(" <a href="");
returnOurWml.Append(url + "&amp;pageIndex=" + (startInt - 1).ToString() + "" title='page" + (startInt - 1).ToString()+"page'>");
returnOurWml.Append("&lt;&lt;");
returnOurWml.Append("</a> ");
}
}

for (i = startInt; i<=endInt;i++)
{

if (i!=pager.PageIndex)
{
returnOurWml.Append(" <a href="");
returnOurWml.Append(url + "&amp;pageIndex=" + i.ToString() + "" title='page"+ i.ToString()+"page'>");
returnOurWml.Append("["+i.ToString() + "]");
returnOurWml.Append("</a> ");
}
또 다른
{
returnOurWml.Append("<u>"+ i.ToString() + "</u>");
}
}

returnOurWml.Append(endStr);

return returnOurWml.Append("<br/>").ToString();
}
또 다른
{
if (pager.PageIndex > 1)
{
returnOurWml.Append(" <a href="");
returnOurWml.Append(url + "&amp;pageIndex=" + (pager.PageIndex -1).ToString() + "">");
returnOurWml.Append("이전 페이지");
returnOurWml.Append("</a> ");
}
if (pager.PageIndex < pager.PageCount)
{
returnOurWml.Append(pager.PageIndex.ToString());
returnOurWml.Append(" <a href="");
returnOurWml.Append(url + "&amp;pageIndex=" + (pager.PageIndex +1).ToString() + "">");
returnOurWml.Append("다음 페이지");
returnOurWml.Append("</a> ");
}
return returnOurWml.Append("<br/>").ToString();
}
}

#끝지역
}
}

http://www.cnblogs.com/solucky/archive/2006/09/20/509741.html