EditCommandColumn Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Ein spezieller Spaltentyp für das DataGrid Steuerelement, das die Edit Schaltflächen zum Bearbeiten von Datenelementen in jeder Zeile enthält.
public ref class EditCommandColumn : System::Web::UI::WebControls::DataGridColumnpublic class EditCommandColumn : System.Web.UI.WebControls.DataGridColumntype EditCommandColumn = class
inherit DataGridColumnPublic Class EditCommandColumn
Inherits DataGridColumn- Vererbung
Beispiele
Im folgenden Codebeispiel wird das Hinzufügen eines EditCommandColumn Objekts zu einem DataGrid Steuerelement veranschaulicht.
<%@ 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>
Hinweise
Verwenden Sie die EditCommandColumn Klasse, um eine spezielle Spalte für das DataGrid Steuerelement zu erstellen, das die EditSchaltflächen Updateund Cancel Schaltflächen für jede Datenzeile im Raster enthält. Mit diesen Schaltflächen können Sie die Werte einer Zeile im DataGrid Steuerelement bearbeiten.
Wenn keine Zeile ausgewählt ist, wird eine Edit Schaltfläche im EditCommandColumn Objekt für jede Datenzeile im DataGrid Steuerelement angezeigt. Wenn auf die Edit Schaltfläche für ein Element geklickt wird, wird das EditCommand Ereignis ausgelöst, und die Edit Schaltfläche wird durch die Update Schaltflächen ersetzt Cancel . Sie müssen Code bereitstellen, um das EditCommand Ereignis zu behandeln. Ein typischer Ereignishandler legt die EditItemIndex Eigenschaft auf die ausgewählte Zeile fest und bindet die Daten dann erneut an das DataGrid Steuerelement.
Hinweis
Sie müssen Werte für die CancelText, EditTextund UpdateText Eigenschaften angeben. Andernfalls werden die zugeordneten Schaltflächen nicht in der EditCommandColumn.
Die Schaltflächen in der EditCommandColumn Schaltfläche können so festgelegt werden, dass sie als Links oder Pushtasten angezeigt werden, indem Sie die ButtonType Eigenschaft festlegen.
Durch Klicken auf die Update Schaltfläche wird CancelCancelCommand bzw. das UpdateCommand Ereignis ausgelöst. Sie müssen Code bereitstellen, um diese Ereignisse zu behandeln.
Ein typischer Handler für das UpdateCommand Ereignis aktualisiert die Daten, legt die EditItemIndex Eigenschaft auf -1 (zum Aufheben der Auswahl des Elements) fest und bindet die Daten dann erneut an das DataGrid Steuerelement.
Ein typischer Handler für das CancelCommand Ereignis legt die EditItemIndex Eigenschaft auf -1 (zum Aufheben der Auswahl des Elements) fest, und die Daten werden dann erneut an das DataGrid Steuerelement gebunden.
Vorsicht
Das EditCommandColumn Objekt kann verwendet werden, um Benutzereingaben anzuzeigen, die schädliche Clientskripts enthalten können. Überprüfen Sie alle Informationen, die von einem Client auf ausführbare Skripts, SQL-Anweisungen oder anderen Code gesendet werden, bevor Sie sie in Ihrer Anwendung anzeigen. Sie können Überprüfungssteuerelemente verwenden, um die Benutzereingabe zu überprüfen, bevor Sie den Eingabetext in einem DataGrid Steuerelement anzeigen. ASP.NET stellt eine Eingabeanforderungsüberprüfungsfunktion bereit, um Skripts und HTML in der Benutzereingabe zu blockieren. Weitere Informationen finden Sie unter Sichern von Standardsteuerelementen, Vorgehensweise: Schutz vor Skript-Exploits in einer Webanwendung durch Anwenden von HTML-Codierung auf Zeichenfolgen und Überprüfen von Benutzereingaben in ASP.NET Webseiten.
Standardmäßig wird die Seitenüberprüfung ausgeführt, wenn auf eine Update Schaltfläche im EditCommandColumn Steuerelement geklickt wird. Die Seitenüberprüfung bestimmt, ob die Eingabesteuerelemente, die einem Überprüfungssteuerelement auf der Seite zugeordnet sind, alle Gültigkeitsprüfungsregeln bestehen, die vom Überprüfungssteuerelement angegeben werden. Um zu verhindern, dass die Seitenüberprüfung auftritt, legen Sie die CausesValidation Eigenschaft auf false.
Konstruktoren
| Name | Beschreibung |
|---|---|
| EditCommandColumn() |
Initialisiert eine neue Instanz der EditCommandColumn-Klasse. |
Eigenschaften
| Name | Beschreibung |
|---|---|
| ButtonType |
Dient zum Abrufen oder Festlegen des Schaltflächentyps für die Spalte. |
| CancelText |
Dient zum Abrufen oder Festlegen des Texts, der für die Befehlsschaltfläche in der |
| CausesValidation |
Dient zum Abrufen oder Festlegen eines Werts, der angibt, ob die Überprüfung ausgeführt wird, wenn auf eine |
| DesignMode |
Ruft einen Wert ab, der angibt, ob sich die Spalte im Entwurfsmodus befindet. (Geerbt von DataGridColumn) |
| EditText |
Ruft den Text ab, der für die Schaltfläche in der |
| FooterStyle |
Ruft die Formatvorlageneigenschaften für den Fußzeilenabschnitt der Spalte ab. (Geerbt von DataGridColumn) |
| FooterText |
Dient zum Abrufen oder Festlegen des Texts, der im Fußzeilenabschnitt der Spalte angezeigt wird. (Geerbt von DataGridColumn) |
| HeaderImageUrl |
Dient zum Abrufen oder Festlegen der Position eines Bilds, das im Kopfzeilenabschnitt der Spalte angezeigt werden soll. (Geerbt von DataGridColumn) |
| HeaderStyle |
Ruft die Formatvorlageneigenschaften für den Kopfzeilenabschnitt der Spalte ab. (Geerbt von DataGridColumn) |
| HeaderText |
Dient zum Abrufen oder Festlegen des Texts, der im Kopfzeilenabschnitt der Spalte angezeigt wird. (Geerbt von DataGridColumn) |
| IsTrackingViewState |
Ruft einen Wert ab, der bestimmt, ob das DataGridColumn Objekt zum Speichern des Zustands markiert ist. (Geerbt von DataGridColumn) |
| ItemStyle |
Ruft die Formatvorlageneigenschaften für die Elementzellen der Spalte ab. (Geerbt von DataGridColumn) |
| Owner |
Ruft das DataGrid Steuerelement ab, bei dem es sich bei der Spalte um ein Element handelt. (Geerbt von DataGridColumn) |
| SortExpression |
Dient zum Abrufen oder Festlegen des Namens des Felds oder Ausdrucks, das an die Methode übergeben werden soll, wenn eine Spalte für die OnSortCommand(DataGridSortCommandEventArgs) Sortierung ausgewählt ist. (Geerbt von DataGridColumn) |
| UpdateText |
Dient zum Abrufen oder Festlegen des Texts, der für die Befehlsschaltfläche in der |
| ValidationGroup |
Dient zum Abrufen oder Festlegen der Gruppe von Überprüfungssteuerelementen, für die das EditCommandColumn Objekt eine Überprüfung verursacht, wenn es wieder auf dem Server veröffentlicht wird. |
| ViewState |
Ruft das StateBag Objekt ab, das eine von der DataGridColumn Klasse abgeleitete Spalte zum Speichern seiner Eigenschaften zulässt. (Geerbt von DataGridColumn) |
| Visible |
Dient zum Abrufen oder Festlegen eines Werts, der angibt, ob die Spalte im DataGrid Steuerelement sichtbar ist. (Geerbt von DataGridColumn) |
Methoden
| Name | Beschreibung |
|---|---|
| Equals(Object) |
Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object) |
| GetHashCode() |
Dient als Standardhashfunktion. (Geerbt von Object) |
| GetType() |
Ruft die Type der aktuellen Instanz ab. (Geerbt von Object) |
| Initialize() |
Stellt die Basisimplementierung bereit, um eine von der DataGridColumn Klasse abgeleitete Spalte auf den Anfangszustand zurückzusetzen. (Geerbt von DataGridColumn) |
| InitializeCell(TableCell, Int32, ListItemType) |
Initialisiert eine Zelle innerhalb der Spalte. |
| LoadViewState(Object) |
Lädt den Zustand des DataGridColumn Objekts. (Geerbt von DataGridColumn) |
| MemberwiseClone() |
Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object) |
| OnColumnChanged() |
Ruft die OnColumnsChanged() Methode auf. (Geerbt von DataGridColumn) |
| SaveViewState() |
Speichert den aktuellen Zustand des DataGridColumn Objekts. (Geerbt von DataGridColumn) |
| ToString() |
Gibt die Zeichenfolgendarstellung der Spalte zurück. (Geerbt von DataGridColumn) |
| TrackViewState() |
Bewirkt die Nachverfolgung von Ansichtszustandsänderungen am Serversteuerelement, sodass sie im Objekt des Serversteuerelements StateBag gespeichert werden können. (Geerbt von DataGridColumn) |
Explizite Schnittstellenimplementierungen
| Name | Beschreibung |
|---|---|
| IStateManager.IsTrackingViewState |
Ruft einen Wert ab, der angibt, ob die Spalte Ansichtszustandsänderungen nachverfolgt. (Geerbt von DataGridColumn) |
| IStateManager.LoadViewState(Object) |
Lädt den zuvor gespeicherten Zustand. (Geerbt von DataGridColumn) |
| IStateManager.SaveViewState() |
Gibt ein Objekt zurück, das Zustandsänderungen enthält. (Geerbt von DataGridColumn) |
| IStateManager.TrackViewState() |
Beginnt mit der Nachverfolgung von Zustandsänderungen. (Geerbt von DataGridColumn) |
