EditCommandColumn Classe

Definição

Um tipo especial de coluna para o DataGrid controle que contém os botões Edit para edição de itens de dados em cada linha.

public ref class EditCommandColumn : System::Web::UI::WebControls::DataGridColumn
public class EditCommandColumn : System.Web.UI.WebControls.DataGridColumn
type EditCommandColumn = class
    inherit DataGridColumn
Public Class EditCommandColumn
Inherits DataGridColumn
Herança
EditCommandColumn

Exemplos

O exemplo de código a seguir demonstra como adicionar um EditCommandColumn objeto a um DataGrid controle .


<%@ Page Language="C#" AutoEventWireup="True" %>
<%@ Import Namespace="System.Data" %>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
   <script runat="server">
 
      // The Cart and CartView objects temporarily store the data source
      // for the DataGrid control while the page is being processed.
      DataTable Cart = new DataTable();
      DataView CartView;   
 
      void Page_Load(Object sender, EventArgs e) 
      {
 
         // With a database, use an select query to retrieve the data. Because 
         // the data source in this example is an in-memory DataTable, retrieve
         // the data from session state if it exists; otherwise, create the data
         // source.
         GetSource();

         // The DataGrid control maintains state between posts to the server;
         // it only needs to be bound to a data source the first time the page
         // is loaded or when the data source is updated.
         if (!IsPostBack)
         {

            BindGrid();

         }
                   
      }
 
      void ItemsGrid_Edit(Object sender, DataGridCommandEventArgs e) 
      {

         // Set the EditItemIndex property to the index of the item clicked 
         // in the DataGrid control to enable editing for that item. Be sure
         // to rebind the DateGrid to the data source to refresh the control.
         ItemsGrid.EditItemIndex = e.Item.ItemIndex;
         BindGrid();

      }
 
      void ItemsGrid_Cancel(Object sender, DataGridCommandEventArgs e) 
      {

         // Set the EditItemIndex property to -1 to exit editing mode. 
         // Be sure to rebind the DateGrid to the data source to refresh
         // the control.
         ItemsGrid.EditItemIndex = -1;
         BindGrid();

      }
 
      void ItemsGrid_Update(Object sender, DataGridCommandEventArgs e) 
      {

         // Retrieve the text boxes that contain the values to update.
         // For bound columns, the edited value is stored in a TextBox.
         // The TextBox is the 0th control in a cell's Controls collection.
         // Each cell in the Cells collection of a DataGrid item represents
         // a column in the DataGrid control.
         TextBox qtyText = (TextBox)e.Item.Cells[3].Controls[0];
         TextBox priceText = (TextBox)e.Item.Cells[4].Controls[0];
 
         // Retrieve the updated values.
         String item = e.Item.Cells[2].Text;
         String qty = qtyText.Text;
         String price = priceText.Text;
        
         DataRow dr;
 
         // With a database, use an update command to update the data. 
         // Because the data source in this example is an in-memory 
         // DataTable, delete the old row and replace it with a new one.
 
         // Remove the old entry and clear the row filter.
         CartView.RowFilter = "Item='" + item + "'";
         if (CartView.Count > 0)
         {
            CartView.Delete(0);
         }
         CartView.RowFilter = "";
 
         // ***************************************************************
         // Insert data validation code here. Be sure to validate the
         // values entered by the user before converting to the appropriate
         // data types and updating the data source.
         // ***************************************************************

         // Add the new entry.
         dr = Cart.NewRow();
         dr[0] = Convert.ToInt32(qty);
         dr[1] = item;

         // If necessary, remove the '$' character from the price before 
         // converting it to a Double.
         if(price[0] == '$')
         {
            dr[2] = Convert.ToDouble(price.Substring(1));
         }
         else
         {
            dr[2] = Convert.ToDouble(price);
         }

         Cart.Rows.Add(dr);
 
         // Set the EditItemIndex property to -1 to exit editing mode. 
         // Be sure to rebind the DateGrid to the data source to refresh
         // the control.
         ItemsGrid.EditItemIndex = -1;
         BindGrid();

      }
 
      void BindGrid() 
      {

         // Set the data source and bind to the Data Grid control.
         ItemsGrid.DataSource = CartView;
         ItemsGrid.DataBind();

      }

      void GetSource()
      {

         // For this example, the data source is a DataTable that is stored
         // in session state. If the data source does not exist, create it;
         //  otherwise, load the data.
         if (Session["ShoppingCart"] == null) 
         {     

            // Create the sample data.
            DataRow dr;  
 
            // Define the columns of the table.
            Cart.Columns.Add(new DataColumn("Qty", typeof(Int32)));
            Cart.Columns.Add(new DataColumn("Item", typeof(String)));
            Cart.Columns.Add(new DataColumn("Price", typeof(Double)));

            // Store the table in session state to persist its values 
            // between posts to the server.
            Session["ShoppingCart"] = Cart;
             
            // Populate the DataTable with sample data.
            for (int i = 1; i <= 9; i++) 
            {
               dr = Cart.NewRow();
               if (i % 2 != 0)
               {
                  dr[0] = 2;
               }
               else
               {
                  dr[0] = 1;
               }
               dr[1] = "Item " + i.ToString();
               dr[2] = (1.23 * (i + 1));
               Cart.Rows.Add(dr);
            }

         } 

         else
         {

            // Retrieve the sample data from session state.
            Cart = (DataTable)Session["ShoppingCart"];

         }         
 
         // Create a DataView and specify the field to sort by.
         CartView = new DataView(Cart);
         CartView.Sort="Item";

         return;

      }

      void ItemsGrid_Command(Object sender, DataGridCommandEventArgs e)
      {

         switch(((LinkButton)e.CommandSource).CommandName)
         {

            case "Delete":
               DeleteItem(e);
               break;

            // Add other cases here, if there are multiple ButtonColumns in 
            // the DataGrid control.

            default:
               // Do nothing.
               break;

         }

      }

      void DeleteItem(DataGridCommandEventArgs e)
      {

         // e.Item is the table row where the command is raised. For bound
         // columns, the value is stored in the Text property of a TableCell.
         TableCell itemCell = e.Item.Cells[2];
         string item = itemCell.Text;

         // Remove the selected item from the data source.         
         CartView.RowFilter = "Item='" + item + "'";
         if (CartView.Count > 0) 
         {     
            CartView.Delete(0);
         }
         CartView.RowFilter = "";

         // Rebind the data source to refresh the DataGrid control.
         BindGrid();

      }
 
   </script>
 
<head runat="server">
    <title>DataGrid Editing Example</title>
</head>
<body>
 
   <form id="form1" runat="server">

      <h3>DataGrid Editing Example</h3>
 
      <asp:DataGrid id="ItemsGrid"
           BorderColor="black"
           BorderWidth="1"
           CellPadding="3"
           OnEditCommand="ItemsGrid_Edit"
           OnCancelCommand="ItemsGrid_Cancel"
           OnUpdateCommand="ItemsGrid_Update"
           OnItemCommand="ItemsGrid_Command"
           AutoGenerateColumns="false"
           runat="server">

         <HeaderStyle BackColor="#aaaadd">
         </HeaderStyle>
 
         <Columns>

            <asp:EditCommandColumn
                 EditText="Edit"
                 CancelText="Cancel"
                 UpdateText="Update" 
                 HeaderText="Edit item">

               <ItemStyle Wrap="False">
               </ItemStyle>

               <HeaderStyle Wrap="False">
               </HeaderStyle>

            </asp:EditCommandColumn>

            <asp:ButtonColumn 
                 HeaderText="Delete item" 
                 ButtonType="LinkButton" 
                 Text="Delete" 
                 CommandName="Delete"/>  
 
            <asp:BoundColumn HeaderText="Item" 
                 ReadOnly="True" 
                 DataField="Item"/>
 
            <asp:BoundColumn HeaderText="Quantity" 
                 DataField="Qty"/>
 
            <asp:BoundColumn HeaderText="Price"
                 DataField="Price"
                 DataFormatString="{0:c}"/>
 
         </Columns>
 
      </asp:DataGrid>

   </form>
 
</body>
</html>

<%@ Page Language="VB" AutoEventWireup="True" %>
<%@ Import Namespace="System.Data" %>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
   <script runat="server">
 
      ' The Cart and CartView objects temporarily store the data source
      ' for the DataGrid control while the page is being processed.
      Dim Cart As DataTable = New DataTable()
      Dim CartView As DataView    
 
      Sub Page_Load(sender As Object, e As EventArgs) 
 
         ' With a database, use an select query to retrieve the data. Because 
         ' the data source in this example is an in-memory DataTable, retrieve
         ' the data from session state if it exists; otherwise create the data
         ' source.
         GetSource()

         ' The DataGrid control maintains state between posts to the server;
         ' it only needs to be bound to a data source the first time the page
         ' is loaded or when the data source is updated.
         If Not IsPostBack Then

            BindGrid()

         End If
                   
      End Sub
 
      Sub ItemsGrid_Edit(sender As Object, e As DataGridCommandEventArgs) 

         ' Set the EditItemIndex property to the index of the item clicked 
         ' in the DataGrid control to enable editing for that item. Be sure
         ' to rebind the DateGrid to the data source to refresh the control.
         ItemsGrid.EditItemIndex = e.Item.ItemIndex
         BindGrid()

      End Sub
 
      Sub ItemsGrid_Cancel(sender As Object, e As DataGridCommandEventArgs) 

         ' Set the EditItemIndex property to -1 to exit editing mode.
         ' Be sure to rebind the DateGrid to the data source to refresh
         ' the control.
         ItemsGrid.EditItemIndex = -1
         BindGrid()

      End Sub
 
      Sub ItemsGrid_Update(sender As Object, e As DataGridCommandEventArgs) 

         ' Retrieve the text boxes that contain the values to update.
         ' For bound columns, the edited value is stored in a TextBox.
         ' The TextBox is the 0th control in a cell's Controls collection.
         ' Each cell in the Cells collection of a DataGrid item represents
         ' a column in the DataGrid control.
         Dim qtyText As TextBox = CType(e.Item.Cells(3).Controls(0), TextBox)
         Dim priceText As TextBox = CType(e.Item.Cells(4).Controls(0), TextBox)
 
         ' Retrieve the updated values.
         Dim item As String = e.Item.Cells(2).Text
         Dim qty As String = qtyText.Text
         Dim price As String = priceText.Text
        
         Dim dr As DataRow
 
         ' With a database, use an update command to update the data. 
         ' Because the data source in this example is an in-memory 
         ' DataTable, delete the old row and replace it with a new one.
 
         ' Remove the old entry and clear the row filter.
         CartView.RowFilter = "Item='" & item & "'"
         If CartView.Count > 0 Then
       
            CartView.Delete(0)
         
         End If 
         CartView.RowFilter = ""
 
         ' ***************************************************************
         ' Insert data validation code here. Be sure to validate the
         ' values entered by the user before converting to the appropriate
         ' data types and updating the data source.
         ' ***************************************************************

         ' Add the new entry.
         dr = Cart.NewRow()
         dr(0) = Convert.ToInt32(qty)
         dr(1) = item

         ' If necessary, remove the '$' character from the price before 
         ' converting it to a Double.
         If price.Chars(0) = "$" Then
         
            dr(2) = Convert.ToDouble(price.Substring(1))
         
         Else
         
            dr(2) = Convert.ToDouble(price)
         
         End If

         Cart.Rows.Add(dr)
 
         ' Set the EditItemIndex property to -1 to exit editing mode.
         ' Be sure to rebind the DateGrid to the data source to refresh
         ' the control.
         ItemsGrid.EditItemIndex = -1
         BindGrid()

      End Sub
 
      Sub BindGrid() 

         ' Set the data source and bind to the Data Grid control.
         ItemsGrid.DataSource = CartView
         ItemsGrid.DataBind()

      End Sub

      Sub GetSource()

         ' For this example, the data source is a DataTable that is stored
         ' in session state. If the data source does not exist, create it;
         ' otherwise, load the data.
         If Session("ShoppingCart") Is Nothing Then 

            ' Create the sample data.
            Dim dr As DataRow  
 
            ' Define the columns of the table.
            Cart.Columns.Add(new DataColumn("Qty", GetType(Int32)))
            Cart.Columns.Add(new DataColumn("Item", GetType(String)))
            Cart.Columns.Add(new DataColumn("Price", GetType(Double)))

            ' Store the table in session state to persist its values
            ' between posts to the server.
            Session("ShoppingCart") = Cart
             
            ' Populate the DataTable with sample data.
            Dim i As Integer

            For i = 1 To 9 
            
               dr = Cart.NewRow()
               If (i Mod 2) <> 0 Then

                  dr(0) = 2
               
               Else
               
                  dr(0) = 1
               
               End If

               dr(1) = "Item " & i.ToString()
               dr(2) = (1.23 * (i + 1))
               Cart.Rows.Add(dr)
            
            Next i

         Else

            ' Retrieve the sample data from session state.
            Cart = CType(Session("ShoppingCart"), DataTable)

         End If         
 
         ' Create a DataView and specify the field to sort by.
         CartView = New DataView(Cart)
         CartView.Sort="Item"

         Return

      End Sub

      Sub ItemsGrid_Command(sender As Object, e As DataGridCommandEventArgs)

         Select (CType(e.CommandSource, LinkButton)).CommandName

            Case "Delete"
               DeleteItem(e)

            ' Add other cases here, if there are multiple ButtonColumns in 
            ' the DataGrid control.

            Case Else
               ' Do nothing.

         End Select

      End Sub

      Sub DeleteItem(e As DataGridCommandEventArgs)

         ' e.Item is the table row where the command is raised. For bound 
         ' columns, the value is stored in the Text property of a TableCell.
         Dim itemCell As TableCell = e.Item.Cells(2)
         Dim item As String = itemCell.Text

         ' Remove the selected item from the data source.         
         CartView.RowFilter = "Item='" & item + "'"
         If CartView.Count > 0 Then 
              
            CartView.Delete(0)

         End If
         
         CartView.RowFilter = ""

         ' Rebind the data source to refresh the DataGrid control.
         BindGrid()

      End Sub
 
   </script>
 
<head runat="server">
    <title>DataGrid Editing Example</title>
</head>
<body>
 
   <form id="form1" runat="server">

      <h3>DataGrid Editing Example</h3>
 
      <asp:DataGrid id="ItemsGrid"
           BorderColor="black"
           BorderWidth="1"
           CellPadding="3"
           OnEditCommand="ItemsGrid_Edit"
           OnCancelCommand="ItemsGrid_Cancel"
           OnUpdateCommand="ItemsGrid_Update"
           OnItemCommand="ItemsGrid_Command"
           AutoGenerateColumns="false"
           runat="server">

         <HeaderStyle BackColor="#aaaadd">
         </HeaderStyle>
 
         <Columns>

            <asp:EditCommandColumn
                 EditText="Edit"
                 CancelText="Cancel"
                 UpdateText="Update" 
                 HeaderText="Edit item">

               <ItemStyle Wrap="False">
               </ItemStyle>

               <HeaderStyle Wrap="False">
               </HeaderStyle>

            </asp:EditCommandColumn>

            <asp:ButtonColumn 
                 HeaderText="Delete item" 
                 ButtonType="LinkButton" 
                 Text="Delete" 
                 CommandName="Delete"/>  
 
            <asp:BoundColumn HeaderText="Item" 
                 ReadOnly="True" 
                 DataField="Item"/>
 
            <asp:BoundColumn HeaderText="Quantity" 
                 DataField="Qty"/>
 
            <asp:BoundColumn HeaderText="Price"
                 DataField="Price"
                 DataFormatString="{0:c}"/>
 
         </Columns>
 
      </asp:DataGrid>

   </form>
 
</body>
</html>

Comentários

Use a EditCommandColumn classe para criar uma coluna especial para o DataGrid controle que contém os Editbotões , Updatee Cancel para cada linha de dados na grade. Esses botões permitem editar os valores de uma linha no DataGrid controle .

Se nenhuma linha for selecionada, um Edit botão será exibido no EditCommandColumn objeto para cada linha de dados no DataGrid controle. Quando o Edit botão de um item é clicado, o EditCommand evento é acionado e o Edit botão é substituído pelos Update botões e Cancel . Você precisa fornecer código para manipular o EditCommand evento. Um manipulador de eventos típico define a EditItemIndex propriedade como a linha selecionada e, em seguida, reassocia os dados ao DataGrid controle.

Observação

Você deve fornecer valores para as CancelTextpropriedades , EditTexte UpdateText . Caso contrário, os botões associados não aparecerão no EditCommandColumn.

Os botões no EditCommandColumn podem ser definidos para serem exibidos como hiperlinks ou botões de push definindo a ButtonType propriedade .

Clicar no Update botão ou Cancel aciona o UpdateCommand evento ou CancelCommand , respectivamente. Você precisa fornecer código para lidar com esses eventos.

Um manipulador típico para o UpdateCommand evento atualiza os dados, define a EditItemIndex propriedade -1 como (para desmarcar o item) e, em seguida, reassocia os dados ao DataGrid controle.

Um manipulador típico para o CancelCommand evento define a EditItemIndex propriedade -1 como (para desmarcar o item) e, em seguida, reassocia os dados ao DataGrid controle.

Cuidado

O EditCommandColumn objeto pode ser usado para exibir a entrada do usuário, que pode incluir script de cliente mal-intencionado. Verifique as informações enviadas de um cliente para script executável, instruções SQL ou outro código antes de exibi-lo em seu aplicativo. Você pode usar controles de validação para verificar a entrada do usuário antes de exibir o texto de entrada em um DataGrid controle . ASP.NET fornece um recurso de validação de solicitação de entrada para bloquear script e HTML na entrada do usuário. Para obter mais informações, consulte Protegendo controles padrão, Como proteger contra explorações de script em um aplicativo Web aplicando codificação HTML a cadeias de caracteres e Validando a entrada do usuário em ASP.NET Páginas da Web.

Por padrão, a validação de página é executada quando um Update botão no EditCommandColumn controle é clicado. A validação de página determina se os controles de entrada associados a um controle de validação na página passam todas as regras de validação especificadas pelo controle de validação. Para impedir que a validação de página ocorra, defina a CausesValidation propriedade como false.

Construtores

EditCommandColumn()

Inicializa uma nova instância da classe EditCommandColumn.

Propriedades

ButtonType

Obtém ou define o tipo de botão para a coluna.

CancelText

Obtém ou define o texto a ser exibido para o botão de comando Cancel no EditCommandColumn.

CausesValidation

Obtém ou define um valor que indica se a validação é realizada quando um botão Update no objeto EditCommandColumn é clicado.

DesignMode

Obtém um valor que indica se a coluna está no modo de design.

(Herdado de DataGridColumn)
EditText

Obtém ou define o texto a ser exibido para o botão Edit no EditCommandColumn.

FooterStyle

Obtém as propriedades de estilo da seção de rodapé da coluna.

(Herdado de DataGridColumn)
FooterText

Obtém ou define o texto exibido na seção de rodapé da coluna.

(Herdado de DataGridColumn)
HeaderImageUrl

Obtém ou define o local de uma imagem a ser exibida na seção de cabeçalho da coluna.

(Herdado de DataGridColumn)
HeaderStyle

Obtém as propriedades de estilo para a seção de cabeçalho da coluna.

(Herdado de DataGridColumn)
HeaderText

Obtém ou define o texto exibido na seção de cabeçalho da coluna.

(Herdado de DataGridColumn)
IsTrackingViewState

Obtém um valor que determina se o objeto DataGridColumn está marcado para salvar seu estado.

(Herdado de DataGridColumn)
ItemStyle

Obtém as propriedades de estilo para as células do item da coluna.

(Herdado de DataGridColumn)
Owner

Obtém o controle DataGrid do qual a coluna é membro.

(Herdado de DataGridColumn)
SortExpression

Obtém ou define o nome do campo ou expressão a ser passado para o método OnSortCommand(DataGridSortCommandEventArgs) quando uma coluna for selecionada para classificação.

(Herdado de DataGridColumn)
UpdateText

Obtém ou define o texto a ser exibido para o botão de comando Update no EditCommandColumn.

ValidationGroup

Obtém ou define o grupo de controles de validação para qual o objeto de EditCommandColumn causa a validação quando ele executa um postback para o servidor.

ViewState

Obtém o objeto StateBag que permite que uma coluna derivada da classe DataGridColumn armazene suas propriedades.

(Herdado de DataGridColumn)
Visible

Obtém ou define um valor que indica se a coluna está visível no controle DataGrid.

(Herdado de DataGridColumn)

Métodos

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.

(Herdado de Object)
Initialize()

Fornece a implementação base para redefinir uma coluna derivada da classe DataGridColumn para seu estado inicial.

(Herdado de DataGridColumn)
InitializeCell(TableCell, Int32, ListItemType)

Inicializa uma célula dentro da coluna.

LoadViewState(Object)

Carrega o estado do objeto DataGridColumn.

(Herdado de DataGridColumn)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
OnColumnChanged()

Chama o método OnColumnsChanged().

(Herdado de DataGridColumn)
SaveViewState()

Salva o estado atual do objeto DataGridColumn.

(Herdado de DataGridColumn)
ToString()

Retorna a representação de cadeia de caracteres da coluna.

(Herdado de DataGridColumn)
TrackViewState()

Causa o acompanhamento das alterações de estado de exibição para o controle de servidor, para que elas possam ser armazenadas no objeto StateBag do controle de servidor.

(Herdado de DataGridColumn)

Implantações explícitas de interface

IStateManager.IsTrackingViewState

Obtém um valor que indica se a coluna está controlando suas alterações de estado de exibição.

(Herdado de DataGridColumn)
IStateManager.LoadViewState(Object)

Carrega o estado salvo anteriormente.

(Herdado de DataGridColumn)
IStateManager.SaveViewState()

Retorna um objeto que contém as alterações de estado.

(Herdado de DataGridColumn)
IStateManager.TrackViewState()

Inicia o controle de alterações de estado.

(Herdado de DataGridColumn)

Aplica-se a

Confira também