EditCommandColumn Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Um tipo de coluna especial para o DataGrid controle que contém os Edit botões para editar itens de dados em cada linha.
public ref class EditCommandColumn : System::Web::UI::WebControls::DataGridColumnpublic class EditCommandColumn : System.Web.UI.WebControls.DataGridColumntype EditCommandColumn = class
inherit DataGridColumnPublic Class EditCommandColumn
Inherits DataGridColumn- Herança
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 o Edit, Updatee Cancel botões para cada linha de dados na grade. Esses botões permitem editar os valores de uma linha no DataGrid controle.
Se nenhuma linha estiver 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 lidar com o EditCommand evento. Um manipulador de eventos típico define a EditItemIndex propriedade como a linha selecionada e, em seguida, vincula os dados ao DataGrid controle.
Observação
Você deve fornecer valores para o CancelText, EditTexte UpdateText propriedades. 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 ou levantar o UpdateCommand evento CancelCommand , respectivamente. Você precisa fornecer código para lidar com esses eventos.
Um manipulador típico do UpdateCommand evento atualiza os dados, define a EditItemIndex propriedade como -1 (para desmarcar o item) e, em seguida, vincula os dados ao DataGrid controle.
Um manipulador típico para o CancelCommand evento define a EditItemIndex propriedade como -1 (para desmarcar o item) e, em seguida, vincula 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 todas 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 Como proteger 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
| Nome | Description |
|---|---|
| EditCommandColumn() |
Inicializa uma nova instância da classe EditCommandColumn. |
Propriedades
| Nome | Description |
|---|---|
| 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 |
| CausesValidation |
Obtém ou define um valor que indica se a validação é executada quando um |
| 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 |
| FooterStyle |
Obtém as propriedades de estilo para a seção rodapé da coluna. (Herdado de DataGridColumn) |
| FooterText |
Obtém ou define o texto exibido na seção 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 DataGridColumn objeto está marcado para salvar seu estado. (Herdado de DataGridColumn) |
| ItemStyle |
Obtém as propriedades de estilo para as células de item da coluna. (Herdado de DataGridColumn) |
| Owner |
Obtém o DataGrid controle 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 OnSortCommand(DataGridSortCommandEventArgs) método quando uma coluna é selecionada para classificação. (Herdado de DataGridColumn) |
| UpdateText |
Obtém ou define o texto a ser exibido para o |
| ValidationGroup |
Obtém ou define o grupo de controles de validação para o qual o EditCommandColumn objeto causa validação quando ele retorna ao servidor. |
| ViewState |
Obtém o StateBag objeto que permite que uma coluna derivada da DataGridColumn classe armazene suas propriedades. (Herdado de DataGridColumn) |
| Visible |
Obtém ou define um valor que indica se a coluna está visível no DataGrid controle. (Herdado de DataGridColumn) |
Métodos
| Nome | Description |
|---|---|
| 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 para seu DataGridColumn estado inicial. (Herdado de DataGridColumn) |
| InitializeCell(TableCell, Int32, ListItemType) |
Inicializa uma célula dentro da coluna. |
| LoadViewState(Object) |
Carrega o estado do DataGridColumn objeto. (Herdado de DataGridColumn) |
| MemberwiseClone() |
Cria uma cópia superficial do Objectatual. (Herdado de Object) |
| OnColumnChanged() |
Chama o OnColumnsChanged() método. (Herdado de DataGridColumn) |
| SaveViewState() |
Salva o estado atual do DataGridColumn objeto. (Herdado de DataGridColumn) |
| ToString() |
Retorna a representação de cadeia de caracteres da coluna. (Herdado de DataGridColumn) |
| TrackViewState() |
Causa o acompanhamento de alterações de estado de exibição no controle do servidor para que possam ser armazenadas no objeto do controle do StateBag servidor. (Herdado de DataGridColumn) |
Implantações explícitas de interface
| Nome | Description |
|---|---|
| IStateManager.IsTrackingViewState |
Obtém um valor que indica se a coluna está acompanhando 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 alterações de estado. (Herdado de DataGridColumn) |
| IStateManager.TrackViewState() |
Inicia o acompanhamento de alterações de estado. (Herdado de DataGridColumn) |
