Anpassen der Oberfläche für die Bearbeitung von DataList (VB)

von Scott Mitchell

PDF herunterladen

In diesem Tutorial erstellen wir eine umfangreichere Bearbeitungsschnittstelle für dataList, die DropDownLists und ein CheckBox-Element enthält.

Einführung

Die Markup- und Websteuerelemente in den DataList-Steuerelementen EditItemTemplate definieren die bearbeitbare Schnittstelle. In allen bearbeitbaren DataList-Beispielen, die wir bisher untersucht haben, besteht die bearbeitbare Schnittstelle aus TextBox-Websteuerelementen. Im vorherigen Tutorial haben wir die Benutzeroberfläche für die Bearbeitungszeit verbessert, indem Wir Validierungssteuerelemente hinzugefügt haben.

Die EditItemTemplate kann weiter erweitert werden, um andere Websteuerelemente als textBox einzuschließen, z. B. DropDownLists, RadioButtonLists, Kalender usw. Wie bei TextBoxes führen Sie beim Anpassen der Bearbeitungsoberfläche, um andere Websteuerelemente einzuschließen, die folgenden Schritte aus:

1. Fügen Sie das Websteuerelement zu hinzu EditItemTemplate.
2. Verwenden Sie die Datenbindungssyntax, um der entsprechenden Eigenschaft den entsprechenden Datenfeldwert zuzuweisen.
3. Greifen Sie im UpdateCommand Ereignishandler programmgesteuert auf den Wert des Websteuerelements zu, und übergeben Sie ihn an die entsprechende BLL-Methode.

In diesem Tutorial erstellen wir eine umfangreichere Bearbeitungsschnittstelle für dataList, die DropDownLists und ein CheckBox-Element enthält. Insbesondere erstellen wir eine DataList, die Produktinformationen auflistet und die Aktualisierung des Produktnamens, des Lieferanten, der Kategorie und der eingestellten status zulässt (siehe Abbildung 1).

Abbildung 1: Die Bearbeitungsoberfläche enthält ein TextBox, zwei DropDownLists und ein CheckBox (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 1: Anzeigen von Produktinformationen

Bevor wir die bearbeitbare DataList-Schnittstelle erstellen können, müssen wir zunächst die schreibgeschützte Schnittstelle erstellen. Öffnen Sie zunächst die CustomizedUI.aspx Seite aus dem EditDeleteDataList Ordner, und fügen Sie der Seite im Designer eine DataList hinzu, und legen Sie ID die -Eigenschaft auf festProducts. Erstellen Sie aus dem Smarttag DataList eine neue ObjectDataSource. Nennen Sie diese neue ObjectDataSourceProductsDataSource, und konfigurieren Sie sie so, dass Daten aus der s-Methode GetProducts der ProductsBLL Klasse abgerufen werden. Wie bei den vorherigen bearbeitbaren DataList-Tutorials aktualisieren wir die bearbeiteten Produktinformationen, indem wir direkt zur Geschäftslogikebene wechseln. Legen Sie daher die Dropdownlisten auf den Registerkarten UPDATE, INSERT und DELETE auf (Keine) fest.

Abbildung 2: Festlegen der Registerkarten UPDATE, INSERT und DELETE Drop-Down Listen auf (Keine) (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Nach dem Konfigurieren der ObjectDataSource erstellt Visual Studio eine Standardeinstellung ItemTemplate für dataList, in der der Name und der Wert für jedes zurückgegebene Datenfeld aufgelistet werden. Ändern Sie den ItemTemplate , sodass die Vorlage den Produktnamen in einem <h4> Element zusammen mit dem Kategorienamen, dem Lieferantennamen, dem Preis und dem eingestellten status. Fügen Sie außerdem eine Schaltfläche Bearbeiten hinzu, und stellen Sie sicher, dass deren CommandName Eigenschaft auf Bearbeiten festgelegt ist. Das deklarative Markup für my ItemTemplate folgt:

<ItemTemplate>
    <h4>
        <asp:Label ID="ProductNameLabel" runat="server"
            Text='<%# Eval("ProductName") %>' />
    </h4>
    <table border="0">
        <tr>
            <td class="ProductPropertyLabel">Category:</td>
            <td class="ProductPropertyValue">
                <asp:Label ID="CategoryNameLabel" runat="server"
                    Text='<%# Eval("CategoryName") %>' />
            </td>
            <td class="ProductPropertyLabel">Supplier:</td>
            <td class="ProductPropertyValue">
                <asp:Label ID="SupplierNameLabel" runat="server"
                    Text='<%# Eval("SupplierName") %>' />
            </td>
        </tr>
        <tr>
            <td class="ProductPropertyLabel">Discontinued:</td>
            <td class="ProductPropertyValue">
                <asp:Label ID="DiscontinuedLabel" runat="server"
                    Text='<%# Eval("Discontinued") %>' />
            </td>
            <td class="ProductPropertyLabel">Price:</td>
            <td class="ProductPropertyValue">
                <asp:Label ID="UnitPriceLabel" runat="server"
                    Text='<%# Eval("UnitPrice", "{0:C}") %>' />
            </td>
        </tr>
        <tr>
            <td colspan="4">
                <asp:Button runat="Server" ID="EditButton"
                    Text="Edit" CommandName="Edit" />
            </td>
        </tr>
    </table>
    <br />
</ItemTemplate>

Im obigen Markup werden die Produktinformationen anhand einer <h4-Überschrift> für den Produktnamen und einer vierspaltigen <table> Spalte für die verbleibenden Felder angegeben. Die ProductPropertyLabel in Styles.cssdefinierten CSS-Klassen und ProductPropertyValue wurden in vorherigen Tutorials erläutert. Abbildung 3 zeigt unseren Fortschritt, wenn er über einen Browser angezeigt wird.

Abbildung 3: Name, Lieferant, Kategorie, Nicht mehr eingestellter Status und Preis jedes Produkts werden angezeigt (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 2: Hinzufügen der Websteuerelemente zur Bearbeitungsoberfläche

Der erste Schritt beim Erstellen der benutzerdefinierten DataList-Bearbeitungsschnittstelle besteht darin, der die erforderlichen Websteuerelemente hinzuzufügen EditItemTemplate. Insbesondere benötigen wir eine DropDownList für die Kategorie, eine andere für den Lieferanten und ein CheckBox-Element für den status "Discontinued". Da der Preis des Produkts in diesem Beispiel nicht bearbeitet werden kann, können wir es weiterhin mithilfe eines Label Web-Steuerelements anzeigen.

Klicken Sie zum Anpassen der Bearbeitungsoberfläche im Smarttag DataList auf den Link Vorlagen bearbeiten, und wählen Sie die EditItemTemplate Option in der Dropdownliste aus. Fügen Sie dem eine DropDownList hinzu EditItemTemplate , und legen Sie auf ID fest Categories.

Abbildung 4: Hinzufügen einer DropDownList für die Kategorien (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Wählen Sie als Nächstes im Smarttag DropDownList die Option Datenquelle auswählen aus, und erstellen Sie eine neue ObjectDataSource mit dem Namen CategoriesDataSource. Konfigurieren Sie diese ObjectDataSource für die Verwendung der CategoriesBLL Klasse s GetCategories() -Methode (siehe Abbildung 5). Als Nächstes fordert der Assistent zum Konfigurieren von Datenquellen von DropDownList zur Eingabe der Datenfelder auf, die für die einzelnen ListItem Eigenschaften und Value verwendet Text werden sollen. Lassen Sie dropDownList das CategoryName Datenfeld anzeigen, und verwenden Sie als CategoryID Wert, wie in Abbildung 6 dargestellt.

Abbildung 5: Erstellen einer neuen ObjectDataSource namens CategoriesDataSource (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Abbildung 6: Konfigurieren der DropDownList-Felder "Anzeige" und "Wert" (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Wiederholen Sie diese Schritte, um eine DropDownList für die Lieferanten zu erstellen. Legen Sie für ID diese DropDownList auf fest, Suppliers und nennen Sie objectDataSource SuppliersDataSource.

Nachdem Sie die beiden DropDownLists hinzugefügt haben, fügen Sie ein CheckBox-Element für den nicht mehr eingestellten Zustand und ein TextBox-Element für den Namen des Produkts hinzu. Legen Sie die ID s für checkBox und TextBox auf Discontinued bzw ProductName. fest. Fügen Sie einen RequiredFieldValidator hinzu, um sicherzustellen, dass der Benutzer einen Wert für den Produktnamen bereitstellt.

Fügen Sie abschließend die Schaltflächen Aktualisieren und Abbrechen hinzu. Denken Sie daran, dass für diese beiden Schaltflächen unbedingt ihre CommandName Eigenschaften auf Aktualisieren bzw. Abbrechen festgelegt sind.

Sie können die Bearbeitungsoberfläche beliebig gestalten. Ich habe mich für dasselbe vierspaltige <table> Layout der schreibgeschützten Schnittstelle entschieden, wie die folgende deklarative Syntax und der Screenshot veranschaulichen:

<EditItemTemplate>
    <h4>
        <asp:Label ID="ProductNameLabel" runat="server"
            Text='<%# Eval("ProductName") %>' />
    </h4>
    <table border="0">
        <tr>
            <td class="ProductPropertyLabel">Name:</td>
            <td colspan="3" class="ProductPropertyValue">
                <asp:TextBox runat="server" ID="ProductName" Width="90%" />
                <asp:RequiredFieldValidator ID="RequiredFieldValidator1"
                    ControlToValidate="ProductName"
                    ErrorMessage="You must enter a name for the product."
                    runat="server">*</asp:RequiredFieldValidator>
            </td>
        </tr>
        <tr>
            <td class="ProductPropertyLabel">Category:</td>
            <td class="ProductPropertyValue">
                <asp:DropDownList ID="Categories" runat="server"
                    DataSourceID="CategoriesDataSource"
                    DataTextField="CategoryName" DataValueField="CategoryID" />
            </td>
            <td class="ProductPropertyLabel">Supplier:</td>
            <td class="ProductPropertyValue">
                <asp:DropDownList ID="Suppliers"
                    DataSourceID="SuppliersDataSource" DataTextField="CompanyName"
                    DataValueField="SupplierID" runat="server" />
            </td>
        </tr>
        <tr>
            <td class="ProductPropertyLabel">Discontinued:</td>
            <td class="ProductPropertyValue">
                <asp:CheckBox runat="server" id="Discontinued" />
            </td>
            <td class="ProductPropertyLabel">Price:</td>
            <td class="ProductPropertyValue">
                <asp:Label ID="UnitPriceLabel" runat="server"
                    Text='<%# Eval("UnitPrice", "{0:C}") %>' />
            </td>
        </tr>
        <tr>
            <td colspan="4">
                <asp:Button runat="Server" ID="UpdateButton" CommandName="Update"
                    Text="Update" />
                 
                <asp:Button runat="Server" ID="CancelButton" CommandName="Cancel"
                    Text="Cancel" CausesValidation="False" />
            </td>
        </tr>
    </table>
    <br />
    <asp:ObjectDataSource ID="CategoriesDataSource" runat="server"
        OldValuesParameterFormatString="original_{0}" SelectMethod="GetCategories"
        TypeName="CategoriesBLL">
    </asp:ObjectDataSource>
    <asp:ObjectDataSource ID="SuppliersDataSource" runat="server"
        OldValuesParameterFormatString="original_{0}" SelectMethod="GetSuppliers"
        TypeName="SuppliersBLL">
    </asp:ObjectDataSource>
</EditItemTemplate>

Abbildung 7: Die Bearbeitungsschnittstelle ist wie die Read-Only-Schnittstelle angeordnet (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 3: Erstellen der Ereignishandler EditCommand und CancelCommand

Derzeit gibt es keine Datenbindungssyntax in der EditItemTemplate (mit Ausnahme von , die UnitPriceLabelwörtlich aus dem ItemTemplatekopiert wurde). Wir fügen die Datenbindungssyntax vorübergehend hinzu, lassen Sie uns jedoch zunächst die Ereignishandler für die DataList-Ereignisse EditCommand und CancelCommand -Ereignisse erstellen. Denken Sie daran, dass der EditCommand Ereignishandler dafür verantwortlich ist, die Bearbeitungsschnittstelle für das DataList-Element zu rendern, auf dessen Schaltfläche Bearbeiten geklickt wurde, während der CancelCommand Auftrag von s darin besteht, die DataList in den Vorbearbeitungszustand zurückzugeben.

Erstellen Sie diese beiden Ereignishandler, und lassen Sie sie den folgenden Code verwenden:

Protected Sub Products_EditCommand(source As Object, e As DataListCommandEventArgs) _
    Handles Products.EditCommand
    ' Set the DataList's EditItemIndex property to the
    ' index of the DataListItem that was clicked
    Products.EditItemIndex = e.Item.ItemIndex
    ' Rebind the data to the DataList
    Products.DataBind()
End Sub
Protected Sub Products_CancelCommand(source As Object, e As DataListCommandEventArgs) _
    Handles Products.CancelCommand
    ' Set the DataList's EditItemIndex property to -1
    Products.EditItemIndex = -1
    ' Rebind the data to the DataList
    Products.DataBind()
End Sub

Wenn diese beiden Ereignishandler vorhanden sind, wird durch Klicken auf die Schaltfläche Bearbeiten die Bearbeitungsoberfläche angezeigt, und durch Klicken auf die Schaltfläche Abbrechen wird das bearbeitete Element in den schreibgeschützten Modus versetzt. Abbildung 8 zeigt die DataList, nachdem für Chef Anton es Gumbo Mix auf die Schaltfläche Bearbeiten geklickt wurde. Da wir der Bearbeitungsschnittstelle noch keine Datenbindungssyntax hinzufügen müssen, ist textBox ProductName leer, checkBox Discontinued deaktiviert und die ersten Elemente aus den DropDownLists und Suppliers ausgewähltCategories.

Abbildung 8: Klicken auf die Schaltfläche "Bearbeiten" zeigt die Bearbeitungsoberfläche an (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 4: Hinzufügen der DataBinding-Syntax zur Bearbeitungsschnittstelle

Damit die Bearbeitungsoberfläche die aktuellen Produktwerte anzeigt, müssen wir die Datenfeldwerte den entsprechenden Websteuerelementwerten mithilfe der Datenbindungssyntax zuweisen. Die Datenbindungssyntax kann über die Designer angewendet werden, indem Sie zum Bildschirm Vorlagen bearbeiten navigieren und in den Smarttags für Websteuerelemente den Link DataBindings bearbeiten auswählen. Alternativ kann die Datenbindungssyntax direkt dem deklarativen Markup hinzugefügt werden.

Weisen Sie den Wert des ProductName Datenfelds der ProductName TextBox-EigenschaftText, die CategoryID Datenfeldwerte und SupplierID die Datenfeldwerte den Categories Eigenschaften und Suppliers DropDownLists und den Wert des Discontinued Datenfelds SelectedValue der Discontinued CheckBox s-Eigenschaft Checked zu. Nachdem Sie diese Änderungen vorgenommen haben, entweder über die Designer oder direkt über das deklarative Markup, rufen Sie die Seite über einen Browser erneut auf, und klicken Sie auf die Schaltfläche Bearbeiten für Chef Anton es Gumbo Mix. Wie abbildung 9 zeigt, hat die Datenbindungssyntax die aktuellen Werte zu TextBox, DropDownLists und CheckBox hinzugefügt.

Abbildung 9: Klicken auf die Schaltfläche "Bearbeiten" zeigt die Bearbeitungsoberfläche an (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 5: Speichern der Änderungen des Benutzers im UpdateCommand-Ereignishandler

Wenn der Benutzer ein Produkt bearbeitet und auf die Schaltfläche Aktualisieren klickt, erfolgt ein Postback, und das DataList-Ereignis UpdateCommand wird ausgelöst. Im Ereignishandler müssen wir die Werte aus den Websteuerelementen in der - und - EditItemTemplate Schnittstelle mit der BLL lesen, um das Produkt in der Datenbank zu aktualisieren. Wie wir in vorherigen Tutorials gesehen haben, ist der ProductID des aktualisierten Produkts über die DataKeys Sammlung zugänglich. Auf die vom Benutzer eingegebenen Felder wird durch programmgesteuertes Verweisen auf die Websteuerelemente mit FindControl("controlID")zugegriffen, wie im folgenden Code gezeigt:

Protected Sub Products_UpdateCommand(source As Object, e As DataListCommandEventArgs) _
    Handles Products.UpdateCommand
    If Not Page.IsValid Then
        Exit Sub
    End If
    ' Read in the ProductID from the DataKeys collection
    Dim productID As Integer = Convert.ToInt32(Products.DataKeys(e.Item.ItemIndex))
    ' Read in the product name and price values
    Dim productName As TextBox = CType(e.Item.FindControl("ProductName"), TextBox)
    Dim categories As DropDownList=CType(e.Item.FindControl("Categories"), DropDownList)
    Dim suppliers As DropDownList = CType(e.Item.FindControl("Suppliers"), DropDownList)
    Dim discontinued As CheckBox = CType(e.Item.FindControl("Discontinued"), CheckBox)
    Dim productNameValue As String = Nothing
    If productName.Text.Trim().Length > 0 Then
        productNameValue = productName.Text.Trim()
    End If
    Dim categoryIDValue As Integer = Convert.ToInt32(categories.SelectedValue)
    Dim supplierIDValue As Integer = Convert.ToInt32(suppliers.SelectedValue)
    Dim discontinuedValue As Boolean = discontinued.Checked
    ' Call the ProductsBLL's UpdateProduct method...
    Dim productsAPI As New ProductsBLL()
    productsAPI.UpdateProduct(productNameValue, categoryIDValue, supplierIDValue, _
        discontinuedValue, productID)
    ' Revert the DataList back to its pre-editing state
    Products.EditItemIndex = -1
    Products.DataBind()
End Sub

Der Code beginnt mit der Page.IsValid -Eigenschaft, um sicherzustellen, dass alle Validierungssteuerelemente auf der Seite gültig sind. Wenn Page.IsValid ist True, wird der Wert des ProductID bearbeiteten Produkts aus der DataKeys Auflistung gelesen, und auf die Dateneintrags-Websteuerelemente in der EditItemTemplate wird programmgesteuert verwiesen. Als Nächstes werden die Werte aus diesen Websteuerelementen in Variablen eingelesen, die dann an die entsprechende UpdateProduct Überladung übergeben werden. Nach dem Aktualisieren der Daten wird dataList in den Zustand vor der Bearbeitung zurückgegeben.

Hinweis

Ich habe die Ausnahmebehandlungslogik ausgelassen, die im Tutorial Behandeln von BLL- und DAL-Level Ausnahmen hinzugefügt wurde, um den Code und dieses Beispiel im Fokus zu behalten. Fügen Sie diese Funktionalität als Übung hinzu, nachdem Sie dieses Tutorial abgeschlossen haben.

Schritt 6: Behandeln von NULL-CategoryID- und SupplierID-Werten

Die Northwind-Datenbank ermöglicht NULL Werte für die Products Tabellenspalten CategoryID und SupplierID Spalten. Die Bearbeitungsoberfläche passt jedoch derzeit nicht zu NULL Werten. Wenn wir versuchen, ein Produkt zu bearbeiten, das über einen NULL Wert für seine CategoryID Oder-Spalten SupplierID verfügt, erhalten wir eine ArgumentOutOfRangeException Fehlermeldung ähnlich der folgenden: "Kategorien" hat einen SelectedValue, der ungültig ist, da es in der Liste der Elemente nicht vorhanden ist. Außerdem gibt es derzeit keine Möglichkeit, den Wert einer Produktkategorie oder eines Lieferanten von einem Nicht-WertNULL in einen wert NULL zu ändern.

Um Werte für die DropDownLists der Kategorie und des Lieferanten zu unterstützen NULL , müssen wir einen zusätzlichen ListItemhinzufügen. Ich habe mich für die Text Verwendung von (None) als Wert für diesen ListItementschieden, aber Sie können es in etwas anderes ändern (z. B. eine leere Zeichenfolge), wenn Sie möchten. Denken Sie schließlich daran, die DropDownLists auf Truefestzulegen. Wenn Sie dies AppendDataBoundItems vergessen, überschreiben die an die DropDownList gebundenen Kategorien und Lieferanten die statisch hinzugefügte ListItem.

Nachdem Sie diese Änderungen vorgenommen haben, sollte das DropDownLists-Markup in den DataList s EditItemTemplate wie folgt aussehen:

<asp:DropDownList ID="Categories" DataSourceID="CategoriesDataSource"
    DataTextField="CategoryName" DataValueField="CategoryID"  runat="server"
    SelectedValue='<%# Eval("CategoryID") %>' AppendDataBoundItems="True">
    <asp:ListItem Value=" Selected="True">(None)</asp:ListItem>
</asp:DropDownList>
...
<asp:DropDownList ID="Suppliers" DataSourceID="SuppliersDataSource"
    DataTextField="CompanyName" DataValueField="SupplierID" runat="server"
    SelectedValue='<%# Eval("SupplierID") %>' AppendDataBoundItems="True">
    <asp:ListItem Value=" Selected="True">(None)</asp:ListItem>
</asp:DropDownList>

Hinweis

Statische ListItem s können einer DropDownList über die Designer oder direkt über die deklarative Syntax hinzugefügt werden. Wenn Sie ein DropDownList-Element zum Darstellen eines Datenbankwerts NULL hinzufügen, müssen Sie die ListItem über die deklarative Syntax hinzufügen. Wenn Sie die ListItem Sammlung Editor im Designer verwenden, lässt die generierte deklarative Syntax die Value Einstellung ganz aus, wenn eine leere Zeichenfolge zugewiesen wird, wodurch deklaratives Markup wie folgt erstellt wird. <asp:ListItem>(None)</asp:ListItem> Dies kann zwar harmlos aussehen, aber das Fehlende Value bewirkt, dass die DropDownList den Text Eigenschaftswert an ihrer Stelle verwendet. Das bedeutet, dass bei Auswahl NULLListItem des Werts (None) versucht wird, dem Produktdatenfeld (CategoryID oder SupplierID) in diesem Tutorial zugewiesen zu werden, was zu einer Ausnahme führt. Durch explizites Festlegen Value=""wird dem Produktdatenfeld ein NULL Wert zugewiesen, wenn ausgewählt NULLListItem wird.

Nehmen Sie sich einen Moment Zeit, um unseren Fortschritt über einen Browser anzuzeigen. Beachten Sie beim Bearbeiten eines Produkts, dass sowohl die CategoriesSuppliers DropDownLists als auch die DropDownList-Option (Keine) am Anfang der DropDownList enthalten.

Abbildung 10: Die Categories DropDownLists und Suppliers die DropDownLists enthalten eine Option (Keine) (Klicken Sie, um das bild in voller Größe anzuzeigen)

Um die Option (Keine) als Datenbankwert NULL zu speichern, müssen wir zum UpdateCommand Ereignishandler zurückkehren. Ändern Sie die categoryIDValue Variablen und supplierIDValue in ganze NULL-Werte, und weisen Sie ihnen einen anderen Wert zu, als Nothing nur, wenn die DropDownList s SelectedValue keine leere Zeichenfolge ist:

Dim categoryIDValue As Nullable(Of Integer) = Nothing
If Not String.IsNullOrEmpty(categories.SelectedValue) Then
    categoryIDValue = Convert.ToInt32(categories.SelectedValue)
End If
Dim supplierIDValue As Nullable(Of Integer) = Nothing
If Not String.IsNullOrEmpty(suppliers.SelectedValue) Then
    supplierIDValue = Convert.ToInt32(suppliers.SelectedValue)
End If

Mit dieser Änderung wird ein Wert von Nothing an die UpdateProduct BLL-Methode übergeben, wenn der Benutzer die Option (Keine) aus einer der Dropdownlisten ausgewählt hat, die einem NULL Datenbankwert entspricht.

Zusammenfassung

In diesem Tutorial haben wir erfahren, wie Sie eine komplexere DataList-Bearbeitungsschnittstelle erstellen, die drei verschiedene Eingabewebsteuerelemente enthält, ein TextBox, zwei DropDownLists und ein CheckBox-Steuerelement zusammen mit Validierungssteuerelementen. Beim Erstellen der Bearbeitungsschnittstelle sind die Schritte unabhängig von den verwendeten Websteuerelementen identisch: Beginnen Sie mit dem Hinzufügen der Websteuerelemente zu den DataLists; verwenden Sie die Datenbindungssyntax EditItemTemplate, um die entsprechenden Datenfeldwerte mit den entsprechenden Websteuerelementeigenschaften zuzuweisen; und greifen Sie im UpdateCommand Ereignishandler programmgesteuert auf die Websteuerelemente und die entsprechenden Eigenschaften zu. übergeben ihre Werte an die BLL.

Wenn Sie eine Bearbeitungsschnittstelle erstellen, unabhängig davon, ob sie nur aus TextBoxes oder einer Sammlung verschiedener Websteuerelemente besteht, stellen Sie sicher, dass Datenbankwerte NULL ordnungsgemäß verarbeitet werden. Bei der Berücksichtigung von NULL s ist es unbedingt erforderlich, dass Sie nicht nur einen vorhandenen NULL Wert in der Bearbeitungsschnittstelle ordnungsgemäß anzeigen, sondern auch ein Mittel zum Markieren eines Werts als NULLanbieten. Für DropDownLists in DataLists bedeutet dies in der Regel das Hinzufügen einer statischen ListItem Eigenschaft, deren Value Eigenschaft explizit auf eine leere Zeichenfolge (Value="") festgelegt ist, und ein Wenig Code zum Ereignishandler hinzufügen, um UpdateCommand zu bestimmen, ob ausgewählt NULL``ListItem wurde oder nicht.

Viel Spaß beim Programmieren!

Zum Autor

Scott Mitchell, Autor von sieben ASP/ASP.NET-Büchern und Gründer von 4GuysFromRolla.com, arbeitet seit 1998 mit Microsoft-Webtechnologien. Scott arbeitet als unabhängiger Berater, Trainer und Autor. Sein neuestes Buch ist Sams Teach Yourself ASP.NET 2.0 in 24 Stunden. Er kann unter mitchell@4GuysFromRolla.comoder über seinen Blog erreicht werden, der unter http://ScottOnWriting.NETzu finden ist.

Besonderen Dank an

Diese Tutorialreihe wurde von vielen hilfreichen Prüfern überprüft. Leitende Prüfer für dieses Tutorial waren Dennis Patterson, David Suru und Randy Schmidt. Möchten Sie meine anstehenden MSDN-Artikel lesen? Wenn dies der Fall ist, legen Sie eine Zeile unter abmitchell@4GuysFromRolla.com.

Zurück