Assim como nas versões anteriores, o ASP.NET 2.0 fornece ao desenvolvedor alguns estilos para definirmos no controle GridView. Utilizando esses estilos evitam-se escrever códigos CSS para tal finalidade mas, claro, desde que os estilos pré-definidos pelo Visual Studio .NET sejam compatíveis com o layout da aplicação.

Para acessar esses estilos no controle GridView basta simplesmente clicar em sua Smart Tag e, posteriormente no link Auto Fomart. Uma janela semelhante a mostrada abaixo é exibida para você escolher o estilo que desejar.

Como vemos, existem vários estilos/formatações que podemos escolher para se aplicar no controle GridView. Apesar do controle GridView dar suporte à uma nova funcionalidade chamada “Temas e Skins” (através da propriedade SkinID), que são arquivos que definem a aparência visual de um determinado controle, o Auto Format não tem a ver com isso.

De qualquer forma, não será abordado nesta série de artigos Temas e Skins por ser um assunto extenso, que requer um artigo específico, mas fica registro aqui um artigo diretamente do portal MSDN que explica detalhadamente tal funcionalidade.

Além disso, podemos definir para cada coluna um estilo diferente, podendo inclusive informar através da propriedade CssClass uma classe em nosso arquivo de estilos (*.css) que corresponderá a formatação de uma coluna ou uma seção dela. A figura abaixo exibe como ter acesso à essas propriedades de formatação.

Como já vimos anteriormente, clica-se na Smart Tag do controle GridView e em seguida no link Edit Columns. A janela acima é exibada e, assim, podemos clicar em cima da coluna que desejamos alterar, e suas respectivas propriedades são apresentadas no painel da direita. Em vermelho vemos as propriedades de estilos para a coluna e percebemos a flexibilidade, onde podemos definir um estilo completamente diferente para cada seção (Control, Footer, Header e Item) do controle GridView.

Formatando Valores

Freqüentemente quando utilizamos um controle do tipo GridView e inserimos valores do tipo Data, Dinheiro, Inteiros ou Decimais, precisamos formatar esse valor de acordo com a finalidade desse Campo. Para tal necessidade as colunas nos fornecem uma propriedade chamada DataFormatString, que veremos a sua utilidade abaixo.

Existem dois tipos de formatação: Standard Formats e Custom Formats. O objetivo é mostrar as formatações mais utilizadas em aplicativos para serem executados nos padrões brasileiros, então deixemos claro o seguinte: o padrão para valores numéricos será o Stardand Format. Já a formatação para datas, será utilizado o Custom Format.

A propriedade DataFormatString fornece uma formatação customizada para o valor inserido na BoundColumn. Esta propriedade consiste em duas partes separadas por dois pontos estando dentro de um par de chaves da seguinte forma: {:}. Isso é válido apenas quando estiver inserindo na BoundColumn valores numéricos ou do tipo data.

A sintaxe é a seguinte: {0:[Formato][Qtde. Casas Decimais]}. O caracter que vem após os dois pontos é o formato em que o valor será exibido. Você também poderá optar por definir a quantidade de casas decimais da seguinte forma: {0:C2}. A seguir uma lista com os valores possíveis:

Observação: Os caracteres acima que especificam o formato a ser exibido não são case-sensitive, exceto para o X, pois se ele for minúsculo os valores serão apresentados em minúsculo, do contrário, serão exibidos em maiúsculo.

Observação 1: Devemos nos atentar para o MM e para o mm, pois o maiúsculo significa Mês, já o minúsculo significa Minutos.

Observação 2: Você poderia também ao invés de barras “/” utilizar o hífen “-” como separador para as Datas, ficando a String de formatação da seguinte forma: {0:dd-MM-yyyy hh:mm:ss}.

Para configurar os valores no controle GridView clique na Smart Tag do mesmo e selecione Edit Columns. Em seguida, clique em cima da coluna que deseja formatar e a propriedade DataFormatString será exibida no painel do lado direito, como é exibido na figura abaixo:

Há ainda vários outros padrões para a formatação de datas os quais optei por não colocar aqui pois utilizamos na maioria das vezes o formato brasileiro. Mas para quem se interessar pode encontrar maiores informações no link direto da fonte da Microsoft: Standard DateTime Format Strings.

Customização em runtime

Há casos em que necessitamos customizar alguns desses estilos em runtime, como por exemplo: se um valor exceder um X, a cor da linha em questão do controle GridView deve ser vermelha. No controle DataGrid utilizávamos o evento ItemDataBound para fazer essa consistência. Já no controle GridView temos ainda este evento, mas com um outro nome: RowDataBound. O exemplo abaixo ilustra esse processo:

protected void GridView1_RowDataBound(object sender, GridViewRowEventArgs e)
{
    if (e.Row.RowType == DataControlRowType.DataRow) {
        DbDataRecord data = (DbDataRecord)e.Row.DataItem;
        if (data.GetDecimal(0) > 2)
            e.Row.BackColor = Color.Red;
        }
}

Através do enumerador DataControlRowType verificamos qual o tipo da linha, pois esse evento é disparado a cada linha criada no controle GridView. Se a linha for do tipo DataRow, aí iremos verificar se o valor da coluna “Valor” é ou não maior que 2 (essa será a consistência para o exemplo).

Devemos agora nos atentar para qual o tipo de fonte de dados está sendo passado para a propriedade DataSource do controle. Isso varia quando utilizamos DataSets e DataReaders, pois devemos fazer o Cast para o tipo de objeto correto. Finalmente, se a condição for atendida, mudamos a cor da linha em questão para vermelho.

O código abaixo mostra os tipos de casts para as diferentes fonte de dados:

//Datasets
((DataRowView)e.Row.DataItem)["NomeColuna"]
((DataRowView)e.Row.DataItem)[0]

//DataReaders
((DbDataRecord)e.Row.DataItem)["NomeColuna"]
((DbDataRecord)e.Row.DataItem)[0]

//Objetos
((TipoObjeto)e.Row.DataItem).Propriedade

Lembrando que no caso do uso dos DataReaders, devemos importar o Namespace System.Data.Common para poder utilizar a Classe DbDataRecord.

Observação: O objeto GridViewRowEventArgs que vem como parâmetro no evento RowDataBound contém as informações completas da linha em questão, ou seja, como este evento é disparado a cada linha que é criada dentro do controle GridView, ele nos fornece informações como o tipo da linha, os valores provenientes da fonte de dados que serão exibidos, os controles filhos de cada linha, entre diversas outras propriedades.

GridView.zip (674.49 kb)

Há momentos em que o result-set da base de dados é muito grande, ou seja, é retornado ao cliente uma grande quantidade de registros, o que pode custar muito caro para o mesmo pois recebe todos os registros e exibe apenas os registros que se enquadram na página atual, e limitando ao número de registros por páginas.

A paginação de dados vem justamente para suprir esta necessidade, podendo dar ao usuário uma forma mais simples de navegar pelo result-set e consequentemente, a aplicação ganha muito em performance. O controle GridView já fornece uma arquitetura que permite a paginação automática de registros.

A forma de como habilitar esta opção é idêntica à ordenação de colunas que fizemos anteriormente, ou seja, deve-se clicar na Smart Tag do controle GridView e marcar o CheckBox chamado Enable Paging, como é ilustrado na figura abaixo:

Habilitando esta opção, o controle GridView já fará a paginação dos registros automaticamente. Através do código HTML abaixo da página ASPX, vemos como o mesmo ficou configurado:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    AllowPaging="True"             
    AutoGenerateColumns="False" 
    DataSourceID="SqlDataSource1"
    PageSize="2">
    <Columns>
        <asp:BoundField 
            DataField="Nome" 
            HeaderText="Nome" />
        <asp:BoundField 
            DataField="Email" 
            HeaderText="Email" />
    </Columns>
</asp:GridView>

Uma nova propriedade é apresentada: PageSize. Ela é responsável por definir a quantidade de registros que serão apresentados por página.

Utilizando o objeto SqlDataSouce

Como neste objeto temos a propriedade DataSourceMode, onde definimos qual será a forma de recuperar os dados da fonte de dados (Dataset ou DataReader), infelizmente ele não pode ser definido como DataReader, pois para efetuar a paginação o objeto deverá obrigatoriamente implementar a interface ICollection, que é somente o caso do objeto Dataset. Vale lembrar que isso já é um problema conhecido nas versões 1.x do ASP.NET.

Para conseguir a paginação de forma automática temos que definir a propriedade DataSourceMode como Dataset ou omití-la. Mas é importante dizer que nada impedirá você de criar uma paginação e controle customizados para esta situação.

Utilizando o objeto ObjectDataSouce

Ao utilizar este tipo de objeto temos que fazer alguns ajustes para habilitar a paginação no controle GridView. Apesar de existir algumas formas diferentes de se fazer, no exemplo mostrado abaixo a paginação retornará apenas os registros pertinentes a página solicitada pelo usuário. Logo a Stored Procedure responsável por retornar estes registros deve receber dois parâmetros:

• PageNumber – O número da página requisitada pelo usuário.
• PageSize – Quantidade de registros por página.

Abaixo é exibida a Stored Procedure que utiliza subqueries para retornar a quantidade de registros de uma determinada página:

ALTER PROCEDURE dbo.CustomPaging 
    @PageSize As Int,    
    @PageNumber As Int AS
	
    DECLARE @COUNTER As Int
    SET @COUNTER = (SELECT COUNT(*) FROM Usuario)
	
    IF @PageNumber = 0
        SET @PageNumber = 1
	
    SELECT Nome FROM Usuario
        WHERE UsuarioID IN 
            (SELECT TOP(@PageSize) UsuarioID FROM Usuario
                WHERE UsuarioID NOT IN 
                    (SELECT TOP(@PageSize * (@PageNumber - 1)) UsuarioID FROM Usuario
                        ORDER BY Nome)
            ORDER BY Nome)
        ORDER BY Nome
			
    RETURN @COUNTER

Agora com o SQL Server 2005 e o SQL Server Express 2005, a cláusula TOP do T-SQL pode ser parametrizada, o que nas versões anteriores só conseguíamos através de uma query dinâmica. A quantidade total de registros (que utilizamos a função COUNT para recuperar) é necessária, pois o objeto ObjectDataSource precisa desse valor para calcular as páginas à serem exibidas ao usuário.

Depois da Stored Procedure pronta vamos analisar a classe de negócios que receberá os parâmetros e executará a Stored Procedure acima. Abaixo o código da classe de negócios:

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

public class Paging
{
    private int _count = 0;

    public int TotalUsuarios(){
        return this._count;
    }

    public List ResgataUsuarios(int pageSize, int pageNumber)
    {
        List coll = new List();
        SqlConnection conn = new SqlConnection(
            WebConfigurationManager.ConnectionStrings["ConnString"].ConnectionString);
        SqlCommand cmd = new SqlCommand("CustomPaging", conn);

        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.AddWithValue("@PageSize", pageSize);
        cmd.Parameters.AddWithValue("@PageNumber", pageNumber);
        cmd.Parameters.AddWithValue("@RETURN_VALUE", 0).Direction = 
            ParameterDirection.ReturnValue;

        SqlDataReader dr = null;
        try
        {
            conn.Open();
            dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            while (dr.Read())
            {
                Usuario u = new Usuario();
                u.Nome = dr.GetString(0);
                coll.Add(u);
            }
        }
        finally
        {
            if (dr != null)
                dr.Close();

            this._count = 
                Convert.ToInt32(cmd.Parameters["@RETURN_VALUE"].Value);
        }
        return coll;
    }
}

Imports Microsoft.VisualBasic
Imports System.Data
Imports System.Data.SqlClient
Imports System.Collections.Generic
Imports System.Web.Configuration

Public Class Paging

    Private _count As Integer = 0

    Public Function TotalUsuarios() As Integer
        Return Me._count
    End Function

    Public Function ResgataUsuarios(ByVal pageSize As Integer, _
        ByVal pageNumber As Integer) As Generic.List(Of Usuario)

        Dim coll As New Generic.List(Of Usuario)
        Dim conn As SqlConnection = _
            New SqlConnection( _
                WebConfigurationManager.ConnectionStrings("ConnString").ConnectionString)
        Dim cmd As New SqlCommand("CustomPaging", conn)

        cmd.CommandType = CommandType.StoredProcedure
        cmd.Parameters.AddWithValue("@PageSize", pageSize)
        cmd.Parameters.AddWithValue("@PageNumber", pageNumber)
        cmd.Parameters.AddWithValue("@RETURN_VALUE", 0).Direction = _
            ParameterDirection.ReturnValue

        Dim dr As SqlDataReader = Nothing
        Try
            conn.Open()
            dr = cmd.ExecuteReader(Data.CommandBehavior.CloseConnection)
            While dr.Read()
                Dim u As New Usuario
                With u
                    .Nome = dr.GetString(0)
                End With
                coll.Add(u)
            End While
        Finally
            If Not IsNothing(dr) Then
                dr.Close()
            End If

            Me._count = _
                Convert.ToInt32(cmd.Parameters("@RETURN_VALUE").Value)
        End Try
        Return coll
    End Function

End Class

Analisando o código acima, temos um membro privado na classe Paging, que é responsável por armazenar a quantidade total de registros da base de dados (ou da condição da cláusula SQL). O método ResgataUsuarios que recebe os parâmetros pageSize e o pageNumber, os quais já descrevemos acima suas utilidades, e através dele os mesmos são anexados à coleção de parâmetros do objeto SqlCommand que executa a Stored Procedure.

Através de um objeto SqlDataReader percorremos os registros da base de dados e populamos o objeto Usuario que posteriormente é adicionado à uma coleção genérica deste mesmo tipo.

Já o método TotalUsuarios retorna o valor contido dentro do membro privado denominado _count, o qual representa a quantidade total de registros da base de dados (ou da condição da cláusula SQL). Como já foi falado, o objeto ObjectDataSource ou qualquer outro tipo de paginação requer este valor para calcular e exibir a quantidade de páginas disponíveis ao usuário. Recuperamos este valor total através de um parâmetro do tipo RETURN_VALUE, que a Stored Procedure retorna para a aplicação.

Através do código HTML abaixo da página ASPX, vemos como configurar o objeto ObjectDataSource e o controle GridView corretamente:

<asp:ObjectDataSource 
    ID="ObjectDataSource1" 
    runat="server" 
    EnablePaging="True"
    SelectCountMethod="TotalUsuarios"                     
    StartRowIndexParameterName="pageNumber"
    MaximumRowsParameterName="pageSize"
    SelectMethod="ResgataUsuarios"
    TypeName="Paging">
</asp:ObjectDataSource>    

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    AllowPaging="True" 
    AutoGenerateColumns="False"
    DataSourceID="ObjectDataSource1"
    PageSize="2">
    <Columns>
        <asp:BoundField 
            DataField="Nome" 
            HeaderText="Nome" />
    </Columns>
</asp:GridView>

Analisando o código HTML da página ASPX acima, vemos duas propriedades que já são de nosso conhecimento: a SelectMethod e TypeName, que foram descritas na seção sobre Tipos de DataSource. Abaixo são listadas as propriedades do objeto ObjectDataSource que ainda não analisamos:

• EnablePaging – É necessário definir para True quando queremos habilitar a paginação de registros no objeto ObjectDataSource.

• SelectCountMethod – Definimos nesta propriedade o nome do método da classe de negócios que é responsável por retornar a quantidade total de registros.

• StartRowIndexParameterName – Baseando-se na classe de negócios que criamos acima, esta propriedade é definida com o nome do parâmetro (pageNumber) responsável pela página que o usuário requisitou.

• MaximumRowsParameterName – Baseando-se na classe de negócios que criamos acima, esta propriedade é definida com o nome do parâmetro (pageSize) responsável pela quantidade de registros exibidos por página.

Já na configuração do controle GridView não se tem muito à fazer: temos que definir a fonte de dados a ser utilizada; habilitar a paginação através da propriedade AllowPaging e, finalmente, através da propriedade PageSize definir a quantidade de registros que serão exibidos por página. Realizados esses ajustes, o GridView já está pronto para realizar a paginação de registros sem a necessidade de definirmos os valores aos parâmetros, pois o controle GridView em conjunto com o objeto ObjectDataSource fará isso de forma transparente.

A imagem abaixo exibe o controle GridView já em funcionamento utilizando o objeto ObjectDataSource como fonte de dados:

GridView.zip (674.49 kb)

Quando exibimos ao cliente uma grande quantidade de dados, algumas funcionalidades se fazem essenciais para que ele possa visualizar e analisar estes dados de forma mais eficiente. Uma dessas funcionalidades é chamada de ordenação de colunas, ou Sorting.

Quando utilizamos o DataGrid da versão 1.x do ASP.NET, para poder ter esta funcionalidade, tínhamos que, através do evento SortCommand do DataGrid, recuperar a coluna que foi clicada pelo usuário e invocar novamente o procedimento que resgata os dados e popula o Datagrid, informando a coluna que será utilizada para efetuar a ordenação. Agora, com o controle GridView, conseguimos obter esta funcionalidade sem a escrita de nenhuma linha de código, salvo quando utilizamos o objeto ObjectDataSource.

Utilizando o objeto SqlDataSouce

Para habilitarmos esta funcionalidade no controle GridView utilizando o objeto SqlDataSource devemos clicar na Smart Tag e marcar o CheckBox chamado Enable Sorting, como é mostrado na imagem abaixo:

Habilitando esta opção, o controle GridView já fará a ordenação dos registros automaticamente. Através do código HTML abaixo da página ASPX, vemos como o mesmo ficou configurado:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    AllowSorting="True"	
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:BoundField 
            DataField="Nome" 
            HeaderText="Nome" 
            SortExpression="Nome" />
        <asp:BoundField 
            DataField="Email" 
            HeaderText="Email" />
    </Columns>
</asp:GridView>

Analisando o código acima podemos notar a propriedade SortExpression da coluna do tipo BoundField. É através desta propriedade que o ASP.NET se encarrega de ordenar a coluna automaticamente clicada pelo usuário e, no caso acima, somente a ordenação para a coluna Nome está habilitada. Algo importante à dizer é que a propriedade SortExpression deve conter exatamente o nome da coluna da fonte de dados para que a ordernação seja possível.

O objeto SqlDataSource possui um propriedade chamada DataSourceMode. Através desta propriedade você define ao objeto SqlDataSource qual será a forma, Dataset ou DataReader, que ele utilizará para resgatar os dados da base de dados. Por padrão, ou seja, quando não definimos esta propriedade, o SqlDataSource faz isso utilizando um objeto do tipo Dataset.

como já vimos acima, essa ordenação é feita automaticamente somente quando definimos a propriedade DataSourceMode como Dataset (ou quando omitimos). Quando definimos esta propriedade como DataReader, sem mais nenhuma outra configuração no objeto SqlDataSource, receberemos a seguinte exceção:

Quando definimos o objeto DataReader para recuperar os dados e quisermos também ter a ordenação dos registros, devemos fazer alguns outros ajustes no objeto SqlDataSource para alcançar este objetivo. Vamos analisá-los passo à passo abaixo:

• A propriedade DataSourceMode: Definimos para DataReader quando queremos utilizar este para recuperar os dados da fonte de dados.

• A propriedade SelectCommand: Por design, somente conseguimos isso utilizando uma Stored Procedure. É nesta propriedade que devemos definir o nome da Stored Procedure que será responsável por recuperar os dados.

• A propriedade SelectCommandType: Como a propriedade SelectCommand estará armazenando uma Stored Procedure, através da SelectCommandType informaremos exatamente isso, ou seja, informar ao ASP.NET que é uma Stored Procedure ao invés de um Sql Statement.

• A propriedade SortParameterName: É justamente o parâmetro que estará dentro da Stored Procedure e que será responsável pela ordenação. Automaticamente o ASP.NET associa o nome da coluna clicada pelo usuário (a propriedade SortExpression) como o value deste parâmetro. Nota: Não há necessidade de colocar o “@” no nome deste parâmetro.

Para exemplificar o uso do objeto DataReader para recuperar os dados através do SqlDataSource e utilizar a ordenação dos dados, abaixo é exibido o código HTML da página ASPX e a respectiva Stored Procedure (que está definida na propriedade SelectCommand):

<asp:SqlDataSource 
    ID="SqlDataSource1" 
    runat="server" 
    ConnectionString="<%$ ConnectionStrings:ConnString %>"
    DataSourceMode="DataReader"
    SortParameterName="Coluna"            
    SelectCommand="Sorting" 
    SelectCommandType="StoredProcedure">
</asp:SqlDataSource>

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    AllowSorting="True"	
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:BoundField 
            DataField="Nome" 
            HeaderText="Nome" 
            SortExpression="Nome" />
    </Columns>
</asp:GridView>

ALTER PROCEDURE dbo.Sorting 
	@Coluna As Varchar(30)
AS
	DECLARE @Query As NVarchar(4000)
	SET @Query = 'SELECT Nome, Email, UsuarioID FROM Usuario'
	
	IF @Coluna != ''
		SET @Query = @Query + ' ORDER BY ' + @Coluna
		
	EXECUTE sp_executesql @Query

Como vemos, a Stored Procedure recebe um parâmetro que será utilizado para efetuar a ordenação. Reparem que o nome do parâmetro da Stored Procedure é o mesmo que está definido na propriedade SortParameterName do objeto SqlDataSource. A verificação do valor deste parâmetro, se é ou não vazio, é necessária pois a primeira vez que a página for carregada não é passado nenhum valor à ele.

Utilizando o objeto ObjectDataSouce

Ao contrário do objeto SqlDataSouce, o objeto ObjectDataSouce necessita de algum código adicional justamente porque o mesmo está ligado à uma classe de regras negócios, a qual deve contemplar a ordenação de um result-set qualquer. O processo de ordenação para o objeto ObjectDataSource é basicamente idêntico ao mostrado acima com o objeto SqlDataSource, apenas contemplando nos parâmetros do método que retorna a coleção de objetos uma string que representará a coluna à ser ordenada.

Como a parte de vinculação do objeto ObjectDataSouce ao controle GridView é semelhante à forma acima, vamos diretamente analisar o código que será responsável pela ordenação de registros:

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

public class Usuarios
{
    public List<Usuario> ResgataUsuarios() {
        return ResgataUsuarios(string.Empty);
    }

    public List<Usuario> ResgataUsuarios(string coluna) {
        List<Usuario> coll = new List<Usuario>();
        string connString = 
          WebConfigurationManager.ConnectionStrings["ConnString"].ConnectionString
        SqlConnection conn = new SqlConnection(connString);
        string query = "SELECT UsuarioID, Nome, Email FROM Usuario";

        if(coluna != string.Empty)
            query += " ORDER BY " + coluna;

        SqlCommand cmd = new SqlCommand(query, conn);
        SqlDataReader dr = null;
        try
        {
            conn.Open();
            dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            while(dr.Read()){
                Usuario u = new Usuario();
                u.ID = dr.GetInt32(0);
                u.Nome = dr.GetString(1);
                u.Email = dr.GetString(2);
                coll.Add(u);
            }
        }
        finally {
            if (dr != null)
                dr.Close();
        }
        return coll;
    }
}

Analisando o código acima temos sobrecarga para o método ResgataUsuarios, onde em um deles recebemos uma string que corresponde à coluna a ser ordenada. Como fizemos com a Stored Procedure, neste método também analisamos se o parâmetro é ou não vazio pois, a partir disto, acrescentamos a cláusula ORDER BY, se necessário. Há ainda pequenas configurações a serem feitas no objeto ObjectDataSource, ou seja, no caso deste objeto, em sua Smart Tag, não temos o CheckBox para habilitar a Ordenação, tendo assim que recorrer à janela de propriedade e marcar a propriedade AllowSorting como True.

Além disso precisamos também definir a propriedade SortParameterName onde, neste caso, irá o nome do parâmetro responsável pela ordenação do nosso método ResgataUsuarios, que é coluna. Vejamos abaixo o código HTML resultante na página ASPX depois dessas configurações:

<asp:ObjectDataSource 
    ID="ObjectDataSource1" 
    runat="server" 
    SelectMethod="ResgataUsuarios"
    SortParameterName="coluna"
    TypeName="Usuarios">
</asp:ObjectDataSource>

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    AutoGenerateColumns="False" 
    DataSourceID="ObjectDataSource1" 
    AllowSorting="True">
    <Columns>
        <asp:BoundField 
            DataField="Nome" 
            HeaderText="Nome" 
            SortExpression="Nome" />
    </Columns>
</asp:GridView>

Automaticamente em runtime, o ASP.NET define o valor da propriedade SortExpression clicada pelo usuário como value do parâmetro do método ResgataUsuarios. Essa atribuição é possível pois já temos mapeado na propriedade SortParameterName o nome do parâmetro responsável pela ordenação do método referido.

Observação Importante: A propriedade SortParameterName é extremamente importante, independentemente de qual objeto de Data Source utilizamos no controle GridView: isso porque podemos ter vários parâmetros na Stored Procedure ou mesmo no método da classe de negócios.

GridView.zip (674.49 kb)

Ao contrário das versões anteriores, o controle GridView nos fornece uma grande quantidade de tipos de colunas, que antes só conseguíamos através da criação manual de uma Template Column. Para que o desenvolvedor perca não tempo na criação destes tipos de colunas a Microsoft já implementou no GridView alguns novos tipos de colunas que usamos com bastante frequencia nas aplicações atuais. As mesmas estão listadas abaixo:

• BoundField
• CheckBoxField
• HyperLinkField
• ImageField
• ButtonField
• CommandField
• TemplateField

Voltando ao DataGrid da versão 1.x do ASP.NET, tínhamos que ir até o Property Builder para definirmos as colunas que queríamos que fossem apresentadas neste controle. Atualmente temos o que chamamos de Smart Tags que nos auxiliam, disponibilizando um acesso rápido e intuitivo às principais propriedades dos controles. É através destas Smart Tags que abrimos a janela para criarmos e editarmos as colunas que queremos em nosso controle GridView. A figura abaixo ilustra isso:

Ao clicar em Edit Columns… na Smart Tag uma nova janela é aberta, e então definiremos as colunas do nosso GridView. Na figura abaixo conseguimos visualizar, envolvidas em um quadrado vermelho, os tipos das colunas mencionadas acima:

Dentro desta janela principal temos três importantes seções que configurarão as colunas do GridView. A figura abaixo exibe essas seções e veremos qual a finalidade de cada uma delas:

• 1 – Exibe as colunas disponíveis para adicionarmos no GridView.

• 2 – Exibe as colunas que já fazem parte do GridView.

• 3 – As propriedades correspondentes a cada coluna selecionada na seção 2.

Quando já temos um controle do tipo Data Source definido, como é ilustrado na figura 3, já são listados como BoundFields os campos provenientes desta fonte, nos quais podemos também definir como uma coluna do GridView.

Para adicionarmos uma nova coluna ao GridView basta selecionar o tipo da mesma na seção 1 e clicar no botão Add. Assim a mesma aparecerá na seção 2, onde podemos ajustar e definir as propriedades na seção 3 desta janela. Também nesta seção (a número 2), temos a opção de exclusão de uma coluna, clicando no botão X. Finalmente, ainda nesta seção, temos mais dois botões onde definimos a ordem de cada coluna.

Outra opção que chama a atenção é a propriedade Auto-generate fields, que é responsável por gerar automaticamente as colunas do GridView refletindo exatamente os campos do controle Data Source informado. Há também um link chamado Convert this field into a TemplateField, que tem a finalidade de converter qualquer coluna definida no controle GridView em uma Template, que permite ao desenvolvedor manipular manualmente.

Tipos de Colunas

BoundField

Esta coluna simplesmente representa um campo da fonte de dados em uma coluna como um texto (Label) dentro do GridView. É esta a coluna padrão para todos os campos do tipo texto da fonte de dados, em caso de não defirnirmos manualmente.

O código HTML gerado na página ASPX por este tipo de coluna é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:BoundField 
            DataField="UsuarioID" 
            HeaderText="UsuarioID" 
            InsertVisible="False"
            ReadOnly="True" 
            SortExpression="UsuarioID" />
        <asp:BoundField 
            DataField="Nome" 
            HeaderText="Nome" 
            SortExpression="Nome" />
        <asp:BoundField 
            DataField="Email" 
            HeaderText="Email" 
            SortExpression="Email" />
    </Columns>
</asp:GridView>

Abaixo é mostrado uma listagem com as principais propriedades da coluna BoundField:

CheckBoxField

Esta coluna é um caso típico onde nas versões 1.x do ASP.NET precisávamos criar uma coluna do tipo TemplateColumn se quiséssemos exibir um valor booleano em formato de um controle CheckBox. Isso foi resolvido com a criação da coluna CheckBoxField, que representa através de um controle CheckBox um valor booleano da fonte de dados.

O código HTML gerado na página ASPX por este tipo de coluna é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server"
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:CheckBoxField 
            DataField="Ativo" 
            HeaderText="Ativo" 
            SortExpression="Ativo" />
    </Columns>
</asp:GridView>

Abaixo é mostrado uma listagem com as principais propriedades da coluna CheckBoxField:

HyperLinkField

Apesar desta coluna já existir na versão 1.x do ASP.NET, ela tem uma limitação: só podemos definir um único parâmetro através do Property Builder do controle DataGrid. Se por alguma situação especial precisássemos ter mais de um parâmetro definido na QueryString, tínhamos que recorrer ao código para fazer isso. Essa deficiência foi sanada nesta nova versão, onde agora podemos definir não apenas um campo da fonte de dados, mas sim um Array contendo os nomes dos campos que desejamos anexar à URL.

O código HTML gerado na página ASPX por este tipo de coluna é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:HyperLinkField 
            DataNavigateUrlFields="UsuarioID,Ativo" 
            DataNavigateUrlFormatString="?ID={0}&Ativo={1}"
            DataTextField="Nome" 
            NavigateUrl="Pagina.aspx" />
    </Columns>
</asp:GridView>

Abaixo é mostrado uma listagem com as principais propriedades da coluna HyperLinkField:

ImageField

Como já vimos um pouco acima, este tipo de coluna também exigia a criação de uma coluna do tipo TemplateColumn nas versões anteriores do ASP.NET. A coluna ImageField veio para suprir esta necessidade, possibilitando exibir uma imagem proveniente de uma fonte de dados (seja o caminho/path ou a imagem em si).

Caso você tenha na sua fonte de dados a imagem em si ao invés de um path/caminho para um arquivo físico, você terá que criar um Handler (implementando a Interface IHttpHandler) para exibir a referida Imagem. Como isso foge do escopo deste artigo, fica registrado aqui um artigo do Dino Esposito, onde ele explica como criar e implementar este Handler.

O código HTML gerado na página ASPX por este tipo de coluna é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:ImageField 
            DataImageUrlField="Foto" 
            DataImageUrlFormatString="~/Images/{0}">
        </asp:ImageField>
    </Columns>
</asp:GridView>

Abaixo é mostrado uma listagem com as principais propriedades da coluna ImageField:

ButtonField

Este tipo de coluna representa uma coluna da fonte de dados em formato de um Button. É utilizada quando queremos executar uma ação customizada em nosso GridView ou fora dele, no qual podemos identificá-la através da propriedade CommandName que definimos para esta coluna.

O código HTML gerado na página ASPX por este tipo de coluna é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:ButtonField 
            DataTextField="Nome" 
            Text="Button" 
            CommandName="Exibir" />
    </Columns>
</asp:GridView>

Abaixo é mostrado uma listagem com as principais propriedades da coluna ButtonField:

CommandField

Representa um conjunto especial de controles que, acrescentado ao GridView, habilita-o para operações de Select, Cancel, Update, Insert e Delete para manipular os dados que foram carregados através da fonte de dados.

O código HTML gerado na página ASPX por este tipo de coluna é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:CommandField 
            ShowDeleteButton="True" 
            ShowEditButton="True" 
            ShowSelectButton="True" />
    </Columns>
</asp:GridView>

Abaixo é mostrado uma listagem com as principais propriedades da coluna CommandField:

TemplateField

Caso nenhuma das colunas apresentadas anteriormente satisfaça a necessidade, podemos optar pela criação de uma TemplateField ou TemplateColumn, como também é conhecida. Este tipo de coluna permite customizá-la, incluindo qualquer tipo de formatação ou controle.

O código HTML gerado na página ASPX por este tipo de coluna é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID">
    <Columns>
        <asp:TemplateField>
            <ItemTemplate>
                <asp:RadioButton 
                    ID="RadioButton1" 
                    runat="server" />
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>

GridView.zip (674.49 kb)

É muito comum trabalharmos com acesso a dados em qualquer tipo de aplicação, seja Windows, Web, Web Service, etc., e com isso, escrevemos diversos tipos de códigos para diversas operações, como por exemplo:

• paginação
• habilitar a ordenação
• exibição de registro detalhado
• edição
• exclusão

Para que conseguíssemos desenvolver estas funcionalidades na versão anterior do ASP.NET 1.x, tínhamos que escrever bastante linhas de códigos. Nada muito exagerado, porém de certa forma por muitas vezes o código era redundante.

Como estas tarefas são bastante utilizadas em nosso dia-a-dia, a Microsoft criou controles do tipo Data Bound para não precisarmos ir diretamente ao código para criar tais funcionalidades. Esses controles são: SqlDataSource, ObjectDataSource e o XmlDataSource.

Esses controles são totalmente compatíveis com o controle que é tema deste artigo, o GridView, permitindo com esta integração, uma grande facilidade em criar aplicações que acessam e manipulam os dados de forma bem fácil e intuitiva (através das Smart Tags), permitindo assim atingir também desenvolvedores iniciantes que ainda não estão à vontade trabalhando diretamente com código.

Os controls Data Bound encapsulam a maioria das operações, que antes precisavam ser desenvolvidas para diferentes repositórios de dados. Isso tira a preocupação de definir e/ou gerir a conexão com a base de dados, a query e seus respectivos parâmetros que serão utilizados. Através de propriedades podemos especificar seus devidos valores em design-time.

Abaixo vemos a finalidade de cada um desses controles:

• SqlDataSource: Fornece acesso à uma base de dados SQL Server.

• ObjectDataSource: Fornece acesso à um determinado método de uma alguma classe. Estas classes geralmente encapsulam o acesso à base de dados, ou qualquer repositório, retornando uma coleção de objetos que deve ser apresentada ao usuário.

• XmlDataSource: Fornece acesso e manipulação à um arquivo XML.

Abaixo abordaremos cada um desses controles detalhadamente.

SqlDataSource

Como já vimos, este controle é responsável por encapsular a manipulação dos dados de uma base de dados SQL Server. Temos nele propriedades essencias, como por exemplo, os comandos SelectCommand, InsertCommand, DeleteCommand e UpdateCommand, que é onde definimos os comandos (queries ou Stored Procedures) que serão executadas para cada ação.

Podemos definir estas propriedades via design (IDE), através da janelas de propriedades do Visual Studio .NET 2005 ou declarativamente no código HTML da página ASPX. Utilizando a IDE do Visual Studio .NET 2005 existem as chamadas Smart Tags, que são uma espécie de “Wizard”, onde podemos configurar passo a passo cada uma dessas propriedades, habilitando inclusive uma opção para manipular as colunas que queremos exibir ao usuário.

Depois de arrastar um SqlDataSource para o nosso WebForm, haverá um botão no canto superior direito deste que, ao clicar, um wizard é exibido para fazermos as configurações. Abaixo a Figura 1 ilustra este processo:

Ao clicar em Configure Data Source…, uma nova janela será aberta informando as configurações à serem efetuadas para o funcionamento do objeto SqlDataSource. Isso inclui desde a escolha do banco de dados, passando pela query (ou Stored Procedure) que será executada. Há uma opção chamada Advanced que, geramos automaticamente os comandos de Insert, Delete e Update (semelhante ao que já fazemos atualmente com o Dataset e DataAdapter). As imagens abaixo ilustram este processo passo à passo:

É importante informar que os comandos gerados automaticamente são baseados no comando de seleção. Logo, os campos que são informados na seleção refletem nos comandos de inserção e atualização. Veremos abaixo o código HTML correspondente ao nosso objeto SqlDataSource e o controle GridView, gerado em nosso arquivo ASPX:

<asp:SqlDataSource 
    ID="SqlDataSource1" 
    runat="server" 
    ConnectionString="<%$ ConnectionStrings:ConnString %>"
    SelectCommand="SELECT [UsuarioID], [Nome], [Email] FROM [Usuario]" 
    DeleteCommand="DELETE FROM [Usuario] WHERE [UsuarioID] = @original_UsuarioID" 
    InsertCommand="INSERT INTO [Usuario] ([Nome], [Email]) VALUES (@Nome, @Email)" 
    UpdateCommand="UPDATE [Usuario] SET [Nome] = @Nome, [Email] = @Email 
	WHERE [UsuarioID] = @original_UsuarioID">
    <DeleteParameters>
        <asp:Parameter Name="original_UsuarioID" Type="Int32" />
    </DeleteParameters>
    <UpdateParameters>
        <asp:Parameter Name="Nome" Type="String" />
        <asp:Parameter Name="Email" Type="String" />
        <asp:Parameter Name="original_UsuarioID" Type="Int32" />
    </UpdateParameters>
    <InsertParameters>
        <asp:Parameter Name="Nome" Type="String" />
        <asp:Parameter Name="Email" Type="String" />
    </InsertParameters>
</asp:SqlDataSource>

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="SqlDataSource1">
</asp:GridView>

Como podemos ver no código HTML correspondente ao objeto SqlDataSource, os comandos são gerados com códigos T-SQL e estão devidamente em suas respectivas propriedades. Para cada comando, há uma seção no código HTML do objeto SqlDataSource que são definidos os parâmetros que serão utilizados pela query (ou Stored Procedure), incluindo o seu nome e tipo de dado.

Depois de completamente configurado o objeto SqlDataSource, o definimos como a fonte de dados para o controle GridView, através da propriedade DataSourceID como vimos no código HTML acima. A imagem abaixo ilustra como definir o DataSource do GridView através da Smart Tag:

ObjectDataSource

Este objeto destina-se também a vincular os dados ao controle GridView, mas utilizando uma função de uma classe qualquer que nos retorne uma coleção de objetos. Porém sem a necessidade de fazer diretamente via código. O processo de vinculação é também parecido com o objeto SqlDataSource em relação à forma de vínculo ao GridView; o que difere logicamente é o “Wizard” que é exibido para a configuração do mesmo.

Antes de exibir o wizard vamos montar o código que será responsável por resgatar os dados da base de dados, popular os objetos e, consequentemente, retornar uma coleção do mesmo. Abaixo é exibido a classe “Usuario”:

using System;

public class Usuario
{
    private int _id;
    private string _nome;
    private string _email;
    private string _endereco;
    private string _cidade;
    private string _estado;
    private string _foto;

    public int ID
    {
        get { return this._id; }
        set { this._id = value; }
    }

    public string Nome
    {
        get { return this._nome; }
        set { this._nome = value; }
    }

    public string Email
    {
        get { return this._email; }
        set { this._email = value; }
    }

    public string Endereco
    {
        get { return this._endereco; }
        set { this._endereco = value; }
    }

    public string Cidade
    {
        get { return this._cidade; }
        set { this._cidade = value; }
    }

    public string Estado
    {
        get { return this._estado; }
        set { this._estado = value; }
    }

    public string Foto
    {
        get { return this._foto; }
        set { this._foto = value; }
    }
}

Depois da classe que armazena os valores provenientes do banco de dados ou de qualquer outra repositório, vamos criar a classe que tem a finalidade de ir até o banco de dados, resgatar os dados através de objetos que já são de nosso conhecimento (SqlConnection, SqlCommand, SqlDataReader) e popular objetos do tipo Usuario, que criamos logo acima. O código abaixo é responsável por esse processo:

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

public class Usuarios
{
    public List<Usuario> ResgataUsuarios() {
        List<Usuario> coll = new List<Usuario>();
        string connString = 
          WebConfigurationManager.ConnectionStrings["ConnString"].ConnectionString
        SqlConnection conn = new SqlConnection(connString);
        SqlCommand cmd = 
          new SqlCommand("SELECT UsuarioID, Nome, Email FROM Usuario", conn);
        SqlDataReader dr = null;
        try
        {
            conn.Open();
            dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            while(dr.Read()){
                Usuario u = new Usuario();
                u.ID = dr.GetInt32(0);
                u.Nome = dr.GetString(1);
                u.Email = dr.GetString(2);
                coll.Add(u);
            }
        }
        finally {
            if (dr != null)
                dr.Close();
        }
        return coll;
    }
}

Como vemos, a classe Usuarios possui um método público que retorna uma lista tipificada de objetos do tipo Usuario. É este método que vamos definir no objeto ObjectDataSource, que fará todo o trabalho, desde criar a instância da classe até a chamada do método e a carga do controle GridView.

Veremos abaixo o passo à passo de como configurar o objeto ObjectDataSource com esta classe e método. Ao clicar na Smart Tag e escolhendo a Configure Data Source…, temos:

Como podemos ver na Figura 7, temos as abas para definir os métodos para Select, Update, Insert e Delete. Podemos ver que é mesmo muito semelhante a forma que trabalhamos com o objeto SqlDataSource mas, neste caso, devemos informar as funções que estão na classe de negócios responsáveis por cada ação. O código HTML resultante da criação deste objeto ObjectDataSource no arquivo ASPX é:

<asp:ObjectDataSource 
    ID="ObjectDataSource1" 
    runat="server" 
    SelectMethod="ResgataUsuarios"
    TypeName="Usuarios">
</asp:ObjectDataSource>

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="ObjectDataSource1">
</asp:GridView>

Uma propriedade que ainda não analisamos é a TypeName, que recebe uma String que corresponde ao nome da classe que o objeto ObjectDataSource representará, utilizando Reflection para carregar e executar o(s) método(s) deste tipo. Esta String contém o nome de um determinado tipo particalmente qualificado, que está localizado nos diretórios Bin ou App_Code. Se o componente estiver registrado no Global Assembly Cache – GAC a String conterá o tipo complemento, incluindo o Namespace. Vale lembrar que, se o componente estiver no Global Assembly Cache, você deverá fazer as devidas referências no Machine.Config ou Web.Config, dependendo da sua necessidade.

Nota Importante: Se por algum motivo a classe de regras de negócios tiver um construtor parametrizado, você deverá utilizar o evento ObjectCreating do objeto ObjectDataSource. Este evento é invocado antes da criação do objeto, permitindo customizar esta instanciação. Um dos parâmetros do evento, é um objeto do tipo ObjectDataSourceEventArgs, que possui uma propriedade (escrita/leitura) chamada ObjectInstance, que tem a responsabilidade de executar os métodos que foram definidos nas propriedades [XXX]Method. Quando esta propriedade é definida neste evento, o objeto ObjectDataSource irá respeitar, executando os métodos baseando-se nesta instância. O código abaixo exibe a forma de como customizar:

protected void ObjectDataSource1_ObjectCreating(object sender, 
    ObjectDataSourceEventArgs e){

    string conn =
        WebConfigurationManager.ConnectionStrings["ConnString"].ConnectionString;    
    Usuarios usuarios = 
        new Usuarios(conn);
    e.ObjectInstance = usuarios;
}

XmlDataSource

Além dos objetos que vimos anteriormente, o ASP.NET 2.0 ainda disponibiliza um objeto nas mesmas características, mas este é utilizado para acessar arquivos XML. Este objeto é chamado de XmlDataSouce. Criei abaixo um arquivo XML chamado de Usuarios.xml, que contém uma relação de usuários para demonstrar a configuração e utilização deste objeto.

<?xml version="1.0" encoding="utf-8" ?>
<Usuarios>
    <Usuario
        Nome="Israel Aece"
        Email="israel@projetando.net"
        Cidade="Valinhos">    
    </Usuario>
    <Usuario
        Nome="Claudia Fernanda"
        Email="claudia@projetando.net"
        Cidade="Valinhos">
    </Usuario>
    <Usuario
        Nome="Juliano Aece"
        Email="juliano@projetando.net"
        Cidade="Valinhos">
    </Usuario>
    <Usuario
        Nome="Carlos Bonna"
        Email="bonna@projetando.net"
        Cidade="Campinas">
    </Usuario>
</Usuarios>

Depois do arquivo XML criado, vamos definí-lo como a fonte de dados de controle GridView utilizando o objeto XmlDataSource. A figura abaixo exibe como configurá-lo:

No campo Data File (campo obrigatório) definimos o caminho do arquivo que queremos que o objeto XmlDataSource carregue. Já no campo Tranform File você pode definir opcionalmente um arquivo com os estilos (*.xsl) para que, se necessário, você altere a estrutura do arquivo XML. O código HTML gerado por este objeto é apresentado abaixo:

<asp:XmlDataSource 
    ID="XmlDataSource1" 
    runat="server" 
    DataFile="~/Usuarios.xml">
</asp:XmlDataSource>

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    DataSourceID="XmlDataSource1">
</asp:GridView>

Tipos de Parâmetros

Quando utilizamos algum objeto de DataSource, temos ainda uma seção dentro deles que não exploramos. Esta seção é definida através dos elementos FilterParameters, SelectParameters, InsertParameters, DeleteParameters e UpdateParameters. É através deles que passamos para a query, Stored Procedure ou método quando for uma classe de negócios os valores para os parâmetros que são necessários para efetuar a operação corretamente.

Dentro desta seção podemos definir os parâmetros que serão utilizados, porém customizando-os de acordo com a sua origem, ou seja, podemos ter parâmetros provenientes de QueryStrings, variáveis de sessão, Cookies, controles do formulário, entre outros.

Para cada um destes tipos de parâmetros existe uma classe específica que é herdada diretamente da classe Parameter que está contida no namespace System.Web.UI.WebControls. A classe Parameter fornece um mecanismo para preencher os parâmetros necessários na query, Stored Procedure ou classe de negócios. É esta a classe base para todos os tipos de parâmetros do ASP.NET.

Vejamos abaixo os tipos de parâmetros suportados pelo ASP.NET, que são classes derivadas da classe Parameter:

Como todos esses parâmetros herdam da classe Parameter, os mesmos contém uma propriedade chamada DefaultValue que utilizamos para definir um valor padrão para quando o valor, controle ou propriedade dos respectivos parâmetros não estiverem disponíveis ou forem inválidos.

Abaixo veremos a utilização de dois desses parâmetros: o ControlParameter e o QueryStringParameter. O cenário do exemplo é resgatar os usuários baseando-se em um Estado (UF) informado pelo usuário, através de um TextBox (Figura 9) e QueryString (Figura 10):

<asp:SqlDataSource 
    ID="SqlDataSource1" 
    runat="server" 
    ConnectionString="<%$ ConnectionStrings:ConnString %>"
    SelectCommand="SELECT [Nome], [Email] FROM [Usuario] WHERE Estado = @UF">
    <SelectParameters>
        <asp:ControlParameter 
            ControlID="txtUF" 
            PropertyName="Text"
            Name="UF" />
    </SelectParameters>
</asp:SqlDataSource>

<asp:SqlDataSource 
    ID="SqlDataSource1" 
    runat="server" 
    ConnectionString="<%$ ConnectionStrings:ConnString %>"
    SelectCommand="SELECT [Nome], [Email] FROM [Usuario] WHERE Estado = @UF">
    <SelectParameters>
        <asp:QueryStringParameter 
            QueryStringField="UF" 
            Name="UF" />
    </SelectParameters>
</asp:SqlDataSource>

Como podemos certificar, o valor do parâmetro (independente de onde está vindo) é passado, neste caso, para a query definida na propriedade SelectCommand utilizando o objeto SqlDataSource.

Eventos

Como estes objetos derivam de uma classe em comum (DataSourceControl) o mesmos tem alguns eventos semelhantes. Veremos cada sum desses eventos e suas respectivas descrições listadas na tabela abaixo:

* Eventos pertencentes apenas ao objeto ObjectDataSource.

GridView.zip (674.49 kb)

O grande problema, é que retornamos ao cliente registros indispensáveis para página corrente, o que de certa forma, causa um grande tráfego na rede para no final ser desconsiderado. Sendo assim, retornar todos os registros, e armazenar em uma variável de sessão, também é muito custoso, talvez quando o acesso é mínimo, não se perceba, mas quando a quantidade de usuários requisitando a mesma informação, isso poderá ocasionar sérios problemas de performance.

Tendo este cenário e/ou problema, a solução seria retornarmos da base de dados somente os registros correspondentes a página qual o usuário requerer. Além de diminuir o tráfego de dados na rede, isso nos proporcionará um grande ganho de performance. O artigo mostrará como retornar somente os registros da base de dados qual se enquadram com a página que o usuário requerer. Isso será feito através de uma Stored Procedure, utilizando a tabela Customers da base de dados Northwind como exemplo. Através de um SqlDataReader, recuperamos o result set retornado pela Stored Procedure e populamos o controle DataList.

O primeiro passo e construirmos a Stored Procedure para nos retornar os registros que necessitamos. Com isso, precisamos informar a ela a pagina requerida pelo Usuário, a quantidade de registros à ser exibido por página e também criarmos um parâmetro de OUTPUT para sabermos a quantidade total de registros, que é necessário para efetuar os cálculos no cliente, para que seja possível manipular corretamente a navegação entre as páginas. Abaixo a Stored Procedure responsável por devolver apenas os registros que necessitamos:

Como vemos no código acima, a Stored Procedure recebe dois parâmetros que é a página requisitada pelo Usuário e a quantidade de registros por página. Além disso, como dito anteriormente, existe um parâmetro de OUTPUT chamado @TotalClientes que e responsável por retornar a quantidade de Clientes para que seja possível efetuar os cálculos e assim exibindo corretamente a navegação da paginação.

Podemos ver também que é criado uma tabela temporária na linha 19, chamada #ClientesTemp, que é utilizada posteriormente, sendo populada com os registros necessários. Depois disso é criado um Cursor na linha 25 e através dele percorremos a tabela Customers e preenchemos a tabela temporária, anteriormente criada. Feito isso, fechamos o Cursor e o retiramos da memória, e retornamos ao cliente o resultado de um SELECT efetuado nesta tabela temporária na linha 51 e depois apagamos esta tabela (linha 53). E finalmente, apenas atribuimos ao parâmetro de saída a quantidade de registros da tabela Customers na linha 57.

Ainda é possível testá-la no Query Analyser, através do seguinte código:

Como vemos no código acima, o número 10 é a quantidade de registros por página e o [N] refere-se a página que o cliente está requerendo.

Feito isso, o próximo passo é partir para a aplicação ASP.NET, que irá utilizar esta Stored Procedure para popular e paginar os dados em um controle do tipo DataList. Devemos apenas arrastar em nosso WebForm o DataList e quatro controles do tipo LinkButton, que serão responsáveis pela navegação do usuário. Vamos incluir em nosso WebForm um Data Member que será responsável por armazenar a quantidade de registros por páginas:

Logo, temos que criar um procedimento que será responsável por popular o DataList. Esta função se chamará CarregaGrid, e terá como parâmetro um valor inteiro representando a página que o usuário está requerendo. Vejamos abaixo o código deste procedimento:

Analisando o código acima, criamos os parâmetros referente à quantidade de registros por página e a página requerida pelo Usuário e também definimos o parâmetro de OUTPUT chamado @TotalClientes, qual retorna a quantidade total de registros. Depois disso, verificamos se é retornado algum registro através da propriedade HasRows(), que retorna True, caso encontrado algum registro, e com isso populamos o DataList com este DataReader, e depois de fechado o DataReader, recuperamos o valor do parâmetro OUTPUT e invocamos o procedimento ControlePaginacao, que é responsável por exibir a quantidade de páginas e a página atual para o Usuário.

O procedimento ControlePaginacao recebe como parâmetro a quantidade total de Clientes, e baseado nisso, exibe a quantidade total de páginas e a página atual em que o Usuário se encontra:

Agora, no evento Page_Load do WebForm, devemos chamar o procedimento CarregaGrid, passando como parâmetro o número 1, que refere-se a primeira página, lembrando que devemos chamar este procedimento quando não for PostBack. O código abaixo ilustra isso:

Ainda temos mais um procedimento para criar, chamado Navegacao, procedimento qual se encarrega de habilitar/desabilitar os botões de navegação da paginação. Este procedimento também é baseado na página atual que está sendo exibida. Vejamos abaixo o código deste procedimento na íntegra:

Depois disso, nosso controle ficará semelhante à imagem abaixo:

Mas ainda resta codificarmos os eventos Click() dos LinkButton responsáveis pela navegação das páginas. Temos quatro LinkButtons com as seguintes funcionalidades:

• < – Primeira página.
• << – Página anterior.
• >> – Próxima página.
• > – Última página.

Conclusão: Vimos neste artigo como resgatar os dados da base de dados através de uma Stored Procedure, mas limitando os dados da página a ser exibida para proporcionar performance, retornando os dados para uma aplicação ASP.NET, e populando um controle DataList, controlando e exibindo a paginação.

PaginandoDadosStoredProcedure.zip (22.51 kb)