DataGrid com Popup

Muitas vezes precisamos exibir um conjunto de dados em um controle do tipo DataGrid e como os dados não estão todos sendo exibidos ao Usuário podemos criar uma nova janela onde passamos como parâmetro para a mesma o ID, identificando o registro, e assim nesta nova janela efetuamos uma nova Query na DB e assim retornamos seu conteúdo na íntegra.

Através do Property Builder do DataGrid, podemos definir a nossa coluna que será o link que abrirá esta nova página para o Usuário como HyperLinkColumn, passando como parâmetro o ID do registro. Através da HyperLinkColumn podemos definir o texto que será o Link, que neste caso será o nome da Categoria vindo da DB, o campo da DB que indentifica o registro e o formato da URL.

Temos que definir todos esses campos para que seja enviado corretamente o valor a nova janela, principalmente na propriedade “URL Format String”, onde informamos a função Javascript que encontra-se no cliente (no arquivo ASPX).

Abaixo uma figura que nos mostra como definir os campos corretamente na HyperLinkColumn no Property Builder do DataGrid:

Depois destes dados definidos, resta criarmos a função “Visualizar” no arquivo ASPX, conforme é mostrado abaixo:

1
2
3
4
5
 
<script language=”javascript”>
    function Visualizar(id){
        window.open(‘Pagina.aspx?ID=’+ id, ”, ”);
    }
</script>
 

Infelizmente o único problema que temos quando definimos os parâmetros no Property Builder é que ele nos permite apenas utilizarmos um parâmetro dinâmico, e caso precise de mais de um, teríamos que interceptar o DataBind do DataGrid, e assim montar o link dinamicamente no código.

Dicas úteis

Depois de receber várias dúvidas via E-Mail, e selecionar algumas dúvidas dos Fóruns que participo, resolvi escrever este artigo colocando diversas funcionalidades que precisamos no dia-à-dia que muitas das vezes não lembramos como se faz.

Nos baseando em ambiente Web, criarei uma WebApplication para dar exemplos dessas funcionalidades. Os tópicos estarão separados, analisando caso por caso.


1 – Como fazer para resgatar valores do arquivo Web.Config

Primeiramente devemos importar o Namespace Configuraton. Depois utilizamos o Propriedade AppSettings da classe ConfigurationSettings passando como parâmetro o nome da Key à ser resgatada.

1
2
 
Imports System.Configuration
Response.Write(ConfigurationSettings.AppSettings(“NomeKEY”))
 
Código 1 – Resgatando valores do WebConfig.

2 – Percorrendo itens de um controle

Algumas vezes precisamos percorrer os itens de algum controle. Quando não podemos utilizar os eventos que façam isso, como o ItemDataBound dos controles DataGrid, DataList ou Repeater, devemos criar uma variável do tipo DataGridItem, DataListItem ou RepeaterItem e juntamente com ela percorremos todos os itens de alguns desses controles através de um laço For…Each. No exemplo abaixo, utilizaremos o evento Click de um Button para percorremos os items de um DataGrid.

1
2
3
4
 
Dim item As DataGridItem
For Each item in Me.dgItens.Items
    ‘Aqui você utiliza as proriedades e métodos de cada item.
Next
 
Código 2 – Percorrendo Itens de um Controle.

3 – Trabalhando com DropDownList

Quando carregamos controles do tipo DropDownList as vezes precisamos definir quais os valores que aparecerão para o Usuário visualizar e quais ficarão como valores para resgatarmos e fazermos comparações ou até mesmo, gravar na Base de Dados. Além disso, precisamos colocar valores Defaults, exemplo: “Selecione…”. Abaixo veremos como podemos fazer isso:

1
2
3
4
5
6
 
Me.cboVeiculos.DataValueField = “VeiculoID”
Me.cboVeiculos.DataTextField = “Nome”
Me.cboVeiculos.DataSource = cmd.ExecuteReader(CommandBehavior.CloseConnection)
Me.cboVeiculos.DataBind()
Me.cboVeiculos.Items.Insert(0, “Selecione…”)
Me.cboVeiculos.SelectedIndex = Me.cboVeiculos.Items.IndexOf(Me.cboVeiculos.Items.FindByText(“Golf”))
 
Código 3 – Percorrendo Itens de um Controle.

OBS.: Nas propriedades DataValueField e DataTextField recebem os campos da Tabela da Base de Dados ou as Propriedades de uma Coleção. Utilizando o método Insert da Propriedade Items passamos a posição qual queremos que seja inserida. No caso acima, coloquei-o na primeira posição à aparecer no DropDownList. Além de tudo isso, ainda podemos posicionar o DropDownList em alguma posição qualquer, deixando à vista um determinado item. Para isso utilize o método FindByText e passe como parâmetro o texto que deseja que fique à mostra. Se você não tiver o valor do Texto, pode utilizar o outro método chamado FindByValue, que faz a mesma coisa, mas baseia a busca nos valores internos do DropDownList.


4 – Limpando todos os valores dos TextBox do WebForm

Para que seja possível limpar todos os valores dos controles do tipo TextBox do WebForm, é necessário a construção de uma função Recursiva, pois temos que levar em consideração que há controles que também podem ter mais controles dentro. Vejamos:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Public Sub Limpar(ByVal controlP As Control)
    Dim ctl As Control
    For Each ctl In controlP.Controls
        If TypeOf ctl Is TextBox Then
            DirectCast(ctl, TextBox).Text = String.Empty
        ElseIf ctl.Controls.Count > 0 Then
            Limpar(ctl)
        End If
    Next
End Sub
 
‘Para chamar a função:
Call Me.Limpar(Me)
 
Código 4 – Limpando o conteúdo de controles TextBox de um WebForm.

5 – Enumeradores

Enumeradores é uma lista de valores constantes, cuja representação é dada por um valor inteiro, começando por 0 (zero). Abaixo veremos como criar uma Enumerador (Enum):

1
2
3
4
5
 
Public Enum Prioridades
    Alta
    Normal
    Baixa
End Enum
 
Código 5 – Criando Enumeradores.

Depois disso, o Intellisense já passa a nos ajudar. Isso garante com que o programador seja obrigado à escolher entre as opções que estão dentro do Enumerador.

Figura 1 – Utilizando Enumeradores.

6 – Utilizando JavaScript nos WebControls

Para utilizar JavaScript em algum WebControl é bem simples. Utilize o método Add da coleção de Atributos para adicionar um script à um determinado contole. Exemplo:

1
 
Me.btnJS.Attributes.Add(“onClick”, “javascript:alert(‘Botão Pressionado’);“)
 
Código 6 – Utilizando JavaScript.

Figura 2 – Botão sendo pressionado.

7 – Utilizando ListBox

Em alguns casos precisamos dispor ao Usuário algumas opções onde ele possa selecioná-las e em seguida atualizar alguma coleção, Base de Dados, etc. Uma saída bastante interessante seria termos dois ListBox no WebForm e deixarmos o Usuário selecionar e ao clicar em um determinado Button, os items selecionados vão para outro ListBox e depois disso, finaliza-se o processo no clicar de um outro Button. Vejamos a idéia abaixo:

Figura 3 – Utilizando ListBox para seleção de múltiplas opções.

Observação: Não colocarei o código aqui para economizar espaço. Mas ao fazer o downloads no fim do artigo, ele se encontrará incluso.


8 – Resgatando o Nome do Arquivo

Muitas vezes temos o arquivo com o seu “path” completo e precisamos resgatar somente o nome desse arquivo. Agora não precisamos mais ficarmos manipulando a String, apenas utilizamos a classe System.IO.Path. Exemplo:

1
2
 
Dim fileName As String = “C:Diretorio1Diretorio2Arquivo.txt”
Response.Write(System.IO.Path.GetFileName(fileName))
 
Código 7 – Resgatando o nome do arquivo.

Conclusão: Bem, espero nesse artigo poder ajudá-los com essas pequenas funcionalidades que sempre precisamos no dia-à-dia no desenvolvimento de sites e sistemas.

Escrevendo Imagens através de Stream

Algumas vezes temos um Stream que contém dados para imprimirmos na tela para o usuário. Um cenário muito usado é quando por exemplo precisamos exibir ao usuário um avatar, ou mesmo uma imagem que está armazenada em uma DB qualquer e para não interferir o processamento da página corrente, criamos uma segunda página, esta responsável por recuperar o arquivo e carregar em um objeto do tipo FileStream, e assim, percorrer este objeto e imprimi-lo no browser.

A classe FileStream está contida dentro do Namespace System.IO, qual temos que importá-lo para a utilização desta classe sem a necessidade de digitarmos o “path” completo da mesma. Apenas como exemplo, utilizaremos um arquivo que está no disco para exibição.

Em primeiro lugar, importamos o Namespace System.IO:

1
 
Imports System.IO
 

Abaixo o código no evento Page_Load do WebForm, que carrega a imagem para o Stream e en seguida, exibimos a imagem no browser:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
Private Sub Page_Load(ByVal sender As Object, ByVal e As _
    System.EventArgs) Handles MyBase.Load
 
    Response.Clear()
    Dim fs As FileStream
    Dim b(1024) As Byte
    Try
        fs = File.Open(Server.MapPath(“Images/Win2003.jpg”), _
            FileMode.Open, FileShare.Read, FileShare.None)
 
        While (fs.Read(b, 0, b.Length) > 0)
            Response.BinaryWrite(b)
        End While
    Finally
        If Not (fs Is Nothing) Then
            fs.Close()
        End If
    End Try
    Response.End()
End Sub
 

Analisando o código acima, através do método Open da Classe File (que também está contida no Namespace System.IO), que nos retorna um objeto do tipo FileStream, atribuímos o seu retorno à um objeto FileStream. Depois disso, percorremos o nosso Stream enquanto o seu conteúdo seja maior que 0, pois através do método Read lemos um bloco de bytes do Stream e escrevemos esses dados em um determinado buffer. E por fim, chamamos o método Response.End() para encerrar a execução, já que a página foi criada apenas para esta finalidade.

Coluna Booleana no DataGrid

Quando exibimos um conteúdo de uma tabela em um DataGrid e algum dos campos da mesma é uma coluna do tipo Booleana, muitas vezes precisamos dar ao usuário uma mensagem mais amigável do que um simples “True” ou “False”.

Neste caso, utilizamos o evento ItemDataBound do DataGrid e assim conseguimos interceptar o Bind no DataGrid, e com isso, verificamos o valor do campo booleano, personalizando assim, a mensagem ao usuário.

O que devemos fazer é depois de arrastar o DataGrid para o nosso WebForm, temos que ir até o Property Builder e consequentemente adicionar coluna booleana para ser exibida, que no caso deste exemplo chama-se “Status”. Vejamos abaixo o código necessário para isso:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Private Sub DataGrid1_ItemDataBound(ByVal sender As Object, ByVal e As _
    System.Web.UI.WebControls.DataGridItemEventArgs) Handles DataGrid1.ItemDataBound
 
    If e.Item.ItemType = ListItemType.AlternatingItem OrElse _
        e.Item.ItemType = ListItemType.Item Then
 
        If Convert.ToBoolean(DirectCast(e.Item.DataItem, DataRowView).Item(“Status”)) Then
            e.Item.Cells(1).Text = “Cliente ativo.”
        Else
            e.Item.Cells(1).Text = “Cliente desabilitado.”
        End if
    End if
End Sub
 

Vale chamar a atenção para a condicional que fazemos, ou seja, convertermos o DataItem (que no caso do Exemplo, a fonte de dados é um Dataset, logo, o DataItem será um DataRowView (para mais informações sobre isso, visite este link)) para booleano, e assim, se for verdadeiro exibimos uma mensagem, dizendo que o cliente está ativo, caso contrário, informamos que o cliente está desabilitado. Observem que “escrevemos” isso na célula 1, que corresponde à célula onde seria exibido o campo “Status”, mas claro, em seu valor original (“True/False”).

Recuperando o codigo HTML de WebControls

Há momentos em que necessitamos recuperar o conteúdo HTML que é renderizado por um determinado controle. Um cenário típico é quando precisamos enviar o código HTML gerado por um controle DataGrid por email para um usuário. Isso evitará percorrer novamente a fonte de dados para montar uma String para definí-la como o corpo do email.

Facilmente, podemos recuperar este conteúdo sem muito código. Como todos os controles WebControls herdam direta ou indiretamente de System.Web.UI.Control, todos implementam o método RenderControl(HtmlTextWriter) e assim nos devolverá o conteúdo (em código HTML), por ele gerado. Veremos o código abaixo, que é necessário para recuperar:

1
2
3
4
5
 
Dim sw As New System.IO.StringWriter
Dim htmlTW As New HtmlTextWriter(sw)
Me.DataGrid1.RenderControl(htmlTW)
Me.TextBox1.Text = sw.ToString()
htmlTW.Close()
 

Como vemos acima, estamos querendo recuperar o código HTML que é gerado pelo DataGrid1. Criamos um objeto do tipo StringWriter, qual armazenará o output do controle. Depois disso, passamos o StringWriter para o HtmlTextWriter que é responsável por recuperar os dados HTML já formatado. Após configurado o HtmlTextWriter, passamos ele para o método RenderControl do DataGrid (ou qualquer outro controle) e este por sua vez armazenará na StringWriter o retorno.

Títulos da Página via CodeBehind

Em ocasiões é necessário darmos um título à página via CodeBehind, onde queremos customizar ainda mais a página à ser exibida ao Usuário final.

Isso é bastante utilizado em seções do site onde o conteúdo é bastante dinâmico, e colocando o título da página já com o assunto específico que a mesma aborda, facilita quando o usuário desejar colocar a página nos favoritos, pois assim, ele não precisará colocar o título, que já virá automaticamente.

Para isso utilizamos o controle Literal do ASP.NET entre as tags de title, que é responsável por renderizar textos estáticos. O código HTML na página ASPX fica semelhante ao código exibido abaixo:

1
 
<title><asp:Literal id=”ltlTitulo” runat=”server”></asp:Literal></title>
 

Agora no CodeBehind fazemos:

1
 
Me.ltlTitulo.Text = “Teste de Título via CodeBehind.”
 

Direção da Coluna com DataList

Há casos em que precisamos exibir os registros da nossa fonte de dados horizontalmente, definindo um número X de colunas. Para isso você pode utilizar o controle DataList, que já fornece instrinsicamente esta funcionalidade. O exemplo abaixo mostra como ficam os registros:

Para que isso seja possível, depois de adicionado o controle DataList em seu WebForm, clique com o botão direito do mouse em cima do DataList e vá até a opção Property Builder. Depois disso você verá a opção Columns e Redirection conforme é ilustrado na imagem abaixo:

A propriedade Columns é onde definimos a quantidade de colunas a serem exibidas. Já a propriedade Direction você define qual a direção em que as colunas serão exibidas. Combinando essas duas propriedades chegamos ao resultado, conforme mostrado na figura 1.

Explorando o GridView – Outras Funcionalidades

DataKeys

Nas versões anteriores do ASP.NET poderia ser definida na propriedade DataKeyField apenas uma string contendo o nome de uma coluna ou propriedade da fonte de dados para ser a identificação da linha, ou seja, torná-la única dentro do controle DataGrid. Mas, em alguns casos, isso é limitado, pois necessitamos ter mais de uma coluna/propriedade para definir a linha como única, vide chaves compostas. Com esta necessidade o controle GridView possibilita definir um array de strings contendo o nome da colunas ou propriedades que farão parte da identificação da linha.

Esta propriedade é chamada de DataKeyNames. É nela que definimos as colunas/propriedades separadas por uma vírgula. O código HTML da página ASPX que demonstra esta definição é exibido abaixo:

<asp:GridView .... DataKeyNames="ID, AnotherID">        					

E para recuperar os valores destas chaves utilizamos o código abaixo:

DataKey keys = this.GridView1.DataKeys[N];
foreach(DictionaryEntry d in keys.Values){
    Response.Write(d.Key.ToString() + ": " + d.Value.ToString() + "<BR>");
}

* Onde N é um número inteiro que corresponde à coluna que deseja recuperar o(s) valor(es).

Quando utilizamos os métodos de exclusão (Delete) e atualização (Update) necessitamos informar aos mesmos o valor do ID do registro para que eles possam executar corretamente o comando. Há uma propriedade nas classes de DataSource chamada OldValuesParameterFormatString. Esta propriedade armazena, por padrão, a seguinte string: “original_{0}” que, em tempo de execução o ASP.NET define o parâmetro (0 (zero)) com o nome do ID que definiremos na propriedade DataKeyNames do controle GridView. Justamente por isso que não precisamos informar estes parâmetros para o objeto (identificações – ID).

Eventos

Evento Descrição
 PageIndexChanged Ocorre quando algum dos botões de paginação for clicado, mas depois da operação ter sido executada.
 PageIndexChanging Ocorre quando algum dos botões de paginação for clicado, mas antes da operação ser executada.
 RowCancelingEdit Ocorre quando o botão de cancelamento da edição é clicado, mas é executado antes da linha sair do modo de edição.
 RowCommand Ocorre sempre quando algum controle do tipo Button for clicado.
 RowCreated Ocorre sempre quando uma linha é criada.
 RowDataBound Ocorre sempre quando uma linha está sendo populada pelos dados.
 RowDeleted Ocorre quando o botão de Delete é clicado, mas depois da linha ser excluída.
 RowDeleting Ocorre quando o botão de Delete é clicado, mas antes da linha ser excluída.
 RowEditing Ocorre quando o botão de Edit é clicado, mas antes da linha entrar em modo de edição.
 RowUpdated Ocorre quando o botão de Update é clicado, mas depois da linha ser atualizada.
 RowUpdating Ocorre quando o botão de Update é clicado, mas antes da linha ser atualizada.
 SelectedIndexChanged Ocorre quando o botão de Select é clicado, mas depois da operação ter sido executada.
 SelectedIndexChanging Ocorre quando o botão de Select é clicado, mas antes de executar a operação.
 Sorted Ocorre quando o link de ordenação é clicado, mas depois da operação ter sido executada.
 Sorting Ocorre quando o link de ordenação é clicado, mas antes de executar a operação.

GridView.zip (674.49 kb)

Explorando o GridView – Utilizando Template Columns

A utilização de colunas do tipo Template é freqüentemente utilizada quando as colunas que já existem por padrão no controle GridView não atendem a nossa necessidade. Através delas conseguimos customizar o controle GridView, adicionando um coluna e podendo manipulá-la do jeito desejado para atingir o objetivo.

Podemos formatar, incluir controles, podendo até incluir um outro controle GridView dentro da coluna do tipo TemplateColumn. Para incluir uma TemplateColumn basta adicionar uma nova coluna do tipo TemplateField, conforme é exibido na imagem abaixo:

Figura 1 – Adicionando uma coluna do tipo TemplateField.

Com esta coluna adicionada no controle GridView podemos, através da Smart Tag, editar esta coluna e assim customizar de acordo com a necessidade. O cenário que utilizaremos é incluir em cada linha do controle GridView que contém os registros provenientes de uma DataSource adicionando um controle DropDownList com alguns dos estados do Brasil. Vejamos abaixo o passo à passo para realizar esta tarefa:

Figura 2 – Editando a coluna TemplateField.

 

Figura 3 – Selecionando a seção que queremos customizar.

 

Figura 4 – Adicionando o controle DropDownList.

Quando temos uma coluna do tipo TemplateField no controle GridView, esta por sua vez, tem várias seções, justamente para customizar cada uma delas. A tabela abaixo mostra algumas destas principais seções:

Seção Descrição
HeaderTemplate É a seção do cabeçalho.
ItemTemplate É a seção que define os itens que serão exibidos.
EditItemTemplate É a seção GridView quando este estiver em modo de edição.
FooterTemplate É a seção do rodapé.

Para o cenário do exemplo deste artigo utilizamos a inserção manual de itens dentro do controle DropDownList, mas é importante salientar que é perfeitamente possível a vinculação deste à um objeto de DataSource. O código HTML da página ASPX resultante desta configuração é exibido abaixo:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    AutoGenerateColumns="False" 
    DataSourceID="SqlDataSource1">
    <Columns>
        <asp:BoundField DataField="Nome" HeaderText="Nome" />
        <asp:TemplateField>
            <ItemTemplate>
                <asp:DropDownList ID="DropDownList1" runat="server">
                    <asp:ListItem>SP</asp:ListItem>
                    <asp:ListItem>MT</asp:ListItem>
                    <asp:ListItem>RJ</asp:ListItem>
                </asp:DropDownList>
            </ItemTemplate>
        </asp:TemplateField>
    </Columns>
</asp:GridView>

Finalmente, depois dessas configurações efetuadas no controle GridView, o resultado do browser é apresentado abaixo:

Figura 5 – A coluna TemplateField em funcionamento.

A quantidade de colunas Templates que podemos ter no controle GridView é indefinida. Apenas devemos utilizá-las quando nenhuma das colunas existentes por padrão no controle GridView não antender as necessidades. Vale lembrar que no ASP.NET 1.x, algumas das colunas, como por exemplo a ImageField e CheckBoxField, era necessário a utilização de colunas Templates, que hoje já não precisamos mais.

GridView.zip (674.49 kb)

Explorando o GridView – Excluindo Registros

O controle GridView disponibiliza também a exclusão de registros dos registros que estão sendo exibidos nele de forma bem simples. Vale lembrar que neste caso, se o controle GridView estiver ligado à algum objeto de DataSource a exclusão já será refletida diretamente em seu repositório.

Nesta seção vamos analisar como efetuar a exclusão de dados utilizando os dois objetos que utilizamos no decorrer deste artigo: SqlDataSource e o ObjectDataSource.

Utilizando o objeto SqlDataSource

Assim como já vimos anteriormente, temos que definir a propriedade SelectCommand através da Smart Tag que irá retornar os dados à serem apresentados no controle GridView. Nesta mesma seção já definimos a propriedade DeleteCommand com o código T-SQL responsável pela exclusão. Para automatizar clique no botão Advanced… e marque a opção “Generate INSERT, UPDATE and DELETE statements“, assim como é mostrado na imagem abaixo:

 

Figura 1 – Definindo a propriedade DeleteCommand.

Depois da propriedade DeleteCommand definida temos, neste momento, que incluir no controle GridView a coluna responsável pela exclusão do registro, ou seja, a inclusão de uma coluna com LinkButtons que executará este processo. A imagem abaixo exibe a inclusão de uma coluna do tipo CommandField para Delete.

Figura 2 – Incluindo a coluna do tipo CommandField no controle GridView.

Depois destas configurações efetuadas o código HTML da página ASPX resultante é exibido abaixo:

<asp:SqlDataSource 
    ID="SqlDataSource1" 
    runat="server" 
    ConnectionString="<%$ ConnectionStrings:ConnString %>"
    SelectCommand="SELECT UsuarioID, Nome, Email FROM Usuario"
    DeleteCommand="DELETE FROM Usuario WHERE UsuarioID = @original_UsuarioID">
</asp:SqlDataSource>

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

Analisando o código acima definimos a query de Delete na propriedade DeleteCommand e assim quando o usuário clicar no botão de exclusão este código T-SQL será executado. Em tempo de execução o ASP.NET define o valor do parâmetro da exclusão “@original_UsuarioID” através das DataKeys (as quais falaremos mais adiante), que neste caso é utilizado a coluna UsuarioID para identificação do registro/linha.

Depois destes passos, o controle GridView é exibido no browser da seguinte forma:

Figura 3 – O controle GridView com a coluna de exclusão definida.

Habilitando a confirmação antes da exclusão

Muitas vezes, antes de efetuarmos definitivamente a exclusão na base de dados, queremos certificar de que o usuário realmente tem certeza de que deseja fazer isso. A solução mais comum neste caso é utilizar Javascript para exibir um aviso questionando o usuário; se ele confirmar, a exclusão é realizada, caso contrário nada acontece.

Primeiramente temos que converter a coluna Delete em Template (não abordaremos isso a fundo agora justamente porque teremos um capítulo específico para explicar esta funcionalidade) como é exibido na imagem abaixo:

Figura 4 – Convertendo a coluna Delete em TemplateColumn.

Para efetuar esta conversão temos apenas que clicar no link (que está marcado em vermelho) chamado “Convert this field into a TemplateField“. Depois desta conversão realizada temos que criar a função Javascript na página ASPX para ser invocada quando o usuário tentar excluir o registro. O código abaixo é a função Javascript que utilizaremos posteriormente:

    function ConfirmaExclusao(){
        return confirm('Deseja realmente excluir este registro?');
    }

Em seguida temos apenas que vincular esta função Javascript ao controle LinkButton, que é responsável por disparar a rotina de exclusão. Devemos definir a propriedade OnClientClick deste controle com o nome da função Javascript e, para isso, a imagem abaixo exibi-nos como fazer para alcançar esta propriedade de um controle que está contido dentro de uma TemplateColumn do GridView:

Figura 5 – Editando a TemplateColumn.

Finalmente temos o código HTML da página ASPX gerado por todas essas configurações:

<asp:GridView 
    ID="GridView1" 
    runat="server" 
    AutoGenerateColumns="False" 
    DataKeyNames="UsuarioID"
    DataSourceID="SqlDataSource1">
    <Columns>
        <asp:TemplateField ShowHeader="False">
            <ItemTemplate>
                <asp:LinkButton 
                    ID="LinkButton1" 
                    runat="server" 
                    CausesValidation="False" 
                    CommandName="Delete"
                    Text="Delete" 
                    OnClientClick="javascript:return ConfirmaExclusao();">
                </asp:LinkButton>
            </ItemTemplate>
        </asp:TemplateField>
        <asp:BoundField 
            DataField="Nome" 
            HeaderText="Nome" />
        <asp:BoundField 
            DataField="UsuarioID" 
            HeaderText="UsuarioID" 
            ReadOnly="True" />
    </Columns>
</asp:GridView>

Ao executar a aplicação, o resultado é mostrado como na imagem abaixo:

Figura 6 – Confirmando a exclusão de um registro/linha.

Utilizando o objeto ObjectDataSource

A utilização do objeto ObjectDataSource é bem semelhante ao que vimos anteriormente com o objeto SqlDataSource. Temos apenas que nos preocupar com a criação de um método na classe de negócios que será responsável pela exclusão do registro. Este método terá apenas um parâmetro que é o ID do registro/linha que queremos excluir. O código deste método é exibido abaixo:

public void Delete(int original_ID)
{
    SqlConnection conn =
        new SqlConnection(
            WebConfigurationManager.ConnectionStrings["ConnString"].ConnectionString);
    SqlCommand cmd =
        new SqlCommand("DELETE FROM Usuario WHERE UsuarioID = @ID", conn);

    cmd.Parameters.AddWithValue("@ID", original_ID);

    try
    {
        conn.Open();
        cmd.ExecuteNonQuery();
    }
    finally
    {
        if (conn != null)
        {
            conn.Close();
        }
    }
}

Se compararmos este código com o código de atualização veremos que é bem semelhante, apenas mudando a query que é executada e a quantidade de parâmetros necessários. Depois deste método criado devemos definir a propriedade DeleteMethod do objeto ObjectDataSource com este método. O código HTML da página ASPX é exibido abaixo:

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

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

Com este código já é possível executar a exclusão de registros de uma determinada fonte de dados através de uma classe de regras de negócio. A única observação importante é que aqui também não vemos a seção DeleteParameters com o parâmetro necessário para a exclusão definido. Isso tem a ver com a propriedade DataKeys do controle GridView, a qual vamos abordar mais detalhadamente em capítulos posteriores.

GridView.zip (674.49 kb)