Delen via

De bewerkingsinterface van DataList aanpassen (C#)

door Scott Mitchell

PDF downloaden

In deze zelfstudie maken we een uitgebreidere bewerkingsinterface voor de DataList, een interface met vervolgkeuzelijsten en een selectievakje.

Introductie

De besturingselementen voor markeringen en web in de DataList s EditItemTemplate definiëren de bewerkbare interface. In alle bewerkbare DataList-voorbeelden die we tot nu toe hebben onderzocht, is de bewerkbare interface samengesteld uit webbesturingselementen voor tekstvakken. In de voorgaande zelfstudie hebben we de gebruikerservaring tijdens het bewerken verbeterd door validatiecontroles toe te voegen.

Het EditItemTemplate kan verder worden uitgebreid met andere webbesturingselementen dan het tekstvak, zoals DropDownLists, RadioButtonLists, Agenda's, enzovoort. Net als bij tekstvaken voert u bij het aanpassen van de bewerkingsinterface om andere webbesturingselementen op te nemen de volgende stappen uit:

  1. Voeg het Webbesturingselement toe aan het EditItemTemplate-besturingselement.
  2. Gebruik de syntaxis van databinding om de bijbehorende gegevensveldwaarde toe te wijzen aan de juiste eigenschap.
  3. In de UpdateCommand gebeurtenishandler verkrijgt u programmatisch de waarde van de webcontrole en geeft u deze door aan de juiste BLL-methode.

In deze zelfstudie maken we een uitgebreidere bewerkingsinterface voor de DataList, een interface met vervolgkeuzelijsten en een selectievakje. In het bijzonder maken we een DataList waarin productgegevens worden vermeld en waarmee de productnaam, leverancier, categorie en stopgezette status kunnen worden bijgewerkt (zie afbeelding 1).

De bewerkingsinterface bevat een tekstvak, twee vervolgkeuzelijsten en een selectievakje

Afbeelding 1: De bewerkingsinterface bevat een tekstvak, twee vervolgkeuzelijsten en een selectievakje (klik om de volledige afbeelding weer te geven)

Stap 1: Productgegevens weergeven

Voordat we de bewerkbare interface van DataList kunnen maken, moeten we eerst de alleen-lezeninterface bouwen. Begin met het openen van de CustomizedUI.aspx pagina vanuit de EditDeleteDataList map en voeg vanuit de ontwerpfunctie een DataList toe aan de pagina, waarbij de eigenschap wordt ingesteld ID op Products. Maak vanuit de infotag van DataList een nieuwe ObjectDataSource. Geef deze nieuwe ObjectDataSource ProductsDataSource een naam en configureer deze om gegevens op te halen uit de ProductsBLL klassemethode GetProducts . Net als bij de vorige bewerkbare DataList-zelfstudies werken we de informatie van het bewerkte product bij door rechtstreeks naar de bedrijfslogicalaag te gaan. Stel de vervolgkeuzelijsten in de tabbladen UPDATE, INSERT en DELETE in op (Geen).

Stel de lijsten van de tabbladen UPDATE, INSERT en DELETE Drop-Down in op (Geen)

Afbeelding 2: Stel de tabbladen UPDATE, INSERT en DELETE Drop-Down Lijsten in op (Geen) (Klik om de volledige afbeelding weer te geven)

Nadat u de ObjectDataSource hebt geconfigureerd, maakt Visual Studio een standaardwaarde ItemTemplate voor de DataList met de naam en waarde voor elk van de geretourneerde gegevensvelden. Pas de sjabloon zo ItemTemplate aan dat de productnaam in een <h4> element wordt vermeld, samen met de categorienaam, leveranciernaam, prijs en stopgezette status. Voeg bovendien een knop Bewerken toe en zorg ervoor dat CommandName de eigenschap is ingesteld op Bewerken. De declaratieve markering voor mijn ItemTemplate is als volgt:

<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>

In de bovenstaande markering worden de productgegevens beschreven met behulp van een <h4-kop> voor de productnaam en een vierkolom <table> voor de resterende velden. De ProductPropertyLabel en ProductPropertyValue CSS-klassen, gedefinieerd in Styles.css, zijn besproken in de vorige zelfstudies. In afbeelding 3 ziet u de voortgang wanneer u deze bekijkt via een browser.

De naam, leverancier, categorie, stopgezette status en prijs van elk product wordt weergegeven

Afbeelding 3: De naam, leverancier, categorie, stopgezette status en prijs van elk product wordt weergegeven (klik om de volledige afbeelding weer te geven)

Stap 2: de webbesturingselementen toevoegen aan de bewerkingsinterface

De eerste stap bij het bouwen van de aangepaste Bewerkingsinterface voor DataList is het toevoegen van de benodigde webbesturingselementen aan de EditItemTemplate. In het bijzonder hebben we een vervolgkeuzelijst nodig voor de categorie, een andere voor de leverancier en een selectievakje voor de stopgezette status. Omdat de prijs van het product in dit voorbeeld niet kan worden bewerkt, kunnen we deze blijven weergeven met behulp van een labelwebbesturingselement.

Als u de bewerkingsinterface wilt aanpassen, klikt u op de koppeling Sjablonen bewerken in de infotag van DataList en kiest u de EditItemTemplate optie in de vervolgkeuzelijst. Voeg een DropDownList toe aan EditItemTemplate en stel de ID ervan in op Categories.

Een vervolgkeuzelijst toevoegen voor de categorieën

Afbeelding 4: Een vervolgkeuzelijst toevoegen voor de categorieën (klik om de afbeelding op volledige grootte weer te geven)

Selecteer vervolgens in de smarttag van de DropDownList de optie Gegevensbron kiezen en maak een nieuwe ObjectDataSource met de naam CategoriesDataSource. Configureer deze ObjectDataSource om de CategoriesBLL klasse de GetCategories() methode te gebruiken (zie afbeelding 5). Vervolgens vraagt de wizard Gegevensbronconfiguratie van de vervolgkeuzelijst om de gegevensvelden te specificeren die moeten worden gebruikt voor elke ListItem s Text en Value eigenschap. Laat de vervolgkeuzelijst het CategoryName gegevensveld weergeven en de CategoryID waarde gebruiken, zoals wordt weergegeven in afbeelding 6.

Een nieuwe ObjectDataSource maken met de naam CategoriesDataSource

Afbeelding 5: Een nieuwe ObjectDataSource maken met de naam CategoriesDataSource (klik om de afbeelding op volledige grootte weer te geven)

De Weergave- en Waardevelden van de DropDownList configureren

Afbeelding 6: De weergave- en waardevelden van de vervolgkeuzelijsten configureren (klik om de volledige afbeelding weer te geven)

Herhaal deze reeks stappen om een vervolgkeuzelijst voor de leveranciers te maken. Stel de ID voor deze DropDownList in op Suppliers en geef de objectdatabron SuppliersDataSourceeen naam.

Nadat u de twee vervolgkeuzelijsten hebt toegevoegd, voegt u een selectievakje toe voor de stopgezette status en een tekstvak voor de naam van het product. Stel de ID s voor het selectievakje en tekstvak Discontinued in op respectievelijk ProductName. Voeg een RequiredFieldValidator toe om ervoor te zorgen dat de gebruiker een waarde biedt voor de productnaam.

Voeg ten slotte de knoppen Bijwerken en Annuleren toe. Houd er rekening mee dat voor deze twee knoppen het noodzakelijk is dat hun CommandName eigenschappen zijn ingesteld op Respectievelijk Bijwerken en Annuleren.

Voel je vrij om de bewerkingsinterface naar eigen wens in te delen. Ik heb ervoor gekozen om dezelfde indeling met vier kolommen <table> te gebruiken vanuit de interface met het kenmerk Alleen-lezen, zoals de volgende declaratieve syntaxis en schermafbeelding illustreert:

<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" DataTextField="CompanyName"
                    DataSourceID="SuppliersDataSource"
                    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>

De bewerkingsinterface is ingedeeld zoals de Read-Only-interface

Afbeelding 7: De bewerkingsinterface is ingedeeld zoals de Read-Only-interface (klik om de afbeelding op volledige grootte weer te geven)

Stap 3: de gebeurtenis-handlers EditCommand en CancelCommand maken

Op dit moment is er geen syntaxis voor gegevensbinding in de EditItemTemplate (behalve de UnitPriceLabel, die letterlijk is overgenomen van de ItemTemplate). We voegen de syntaxis van de gegevensbinding tijdelijk toe, maar eerst gaan we de gebeurtenis-handlers maken voor de DataList-s EditCommand en CancelCommand -gebeurtenissen. Zoals u zich herinnert, is de verantwoordelijkheid van de EditCommand gebeurtenishandler om de bewerkingsinterface weer te geven voor het DataList-item waarop de knop Bewerken is geklikt, terwijl de CancelCommand taak is om de DataList terug te brengen naar de status vooraf bewerken.

Maak deze twee gebeurtenis-handlers en laat ze de volgende code gebruiken:

protected void Products_EditCommand(object source, DataListCommandEventArgs e)
{
    // Set the DataList's EditItemIndex property and rebind the data
    Products.EditItemIndex = e.Item.ItemIndex;
    Products.DataBind();
}
protected void Products_CancelCommand(object source, DataListCommandEventArgs e)
{
    // Return to DataList to its pre-editing state
    Products.EditItemIndex = -1;
    Products.DataBind();
}

Als deze twee gebeurtenishandlers zijn ingesteld, wordt bij het klikken op de knop Bewerken de bewerkingsinterface weergegeven en wordt het bewerkte item bij het klikken op de knop Annuleren teruggezet naar de modus Alleen-lezen. Afbeelding 8 toont de DataList nadat op de knop Bewerken is geklikt voor Chef Anton s Gumbo Mix. Omdat we nog geen gegevensbindingsyntaxis aan de bewerkingsinterface hebben toegevoegd, is het ProductName tekstvak leeg, het Discontinued selectievakje is niet aangevinkt, en zijn de eerste items geselecteerd in de Categories en Suppliers vervolgkeuzelijsten.

Schermopname van de DataList EditItemTemplate nadat de gebeurtenis-handlers EditCommand en CancelCommand zijn toegevoegd en de knop Bewerken is geselecteerd.

Afbeelding 8: Als u op de knop Bewerken klikt, wordt de bewerkingsinterface weergegeven (klik om de volledige afbeelding weer te geven)

Stap 4: De DataBinding-syntaxis toevoegen aan de bewerkingsinterface

Om de bewerkingsinterface de huidige productwaarden weer te geven, moeten we de syntaxis van de gegevensbinding gebruiken om de waarden van het gegevensveld toe te wijzen aan de juiste webbeheerwaarden. De syntaxis van de gegevensbinding kan worden toegepast via de ontwerpfunctie door naar het scherm Sjablonen bewerken te gaan en de koppeling DataBindings bewerken te selecteren in de infolabels voor webbesturingselementen. De syntaxis van de gegevensbinding kan ook rechtstreeks aan de declaratieve markering worden toegevoegd.

Wijs de waarde van het ProductName gegevensveld toe aan de ProductName eigenschap TekstvakText, de CategoryID en SupplierID gegevensveldwaarden aan de Categories eigenschappen en Suppliers DropDownLists SelectedValue en de waarde van het Discontinued gegevensveld aan de Discontinued eigenschap Selectievakje.Checked Nadat u deze wijzigingen hebt aangebracht, ofwel via de ontwerper of rechtstreeks via de declaratieve markering, opent u de pagina in een browser en klikt u op de knop Bewerken voor Chef Antons Gumbo Mix. Zoals in afbeelding 9 wordt weergegeven, heeft de syntaxis van de gegevensbinding de huidige waarden toegevoegd aan het tekstvak, de vervolgkeuzelijsten en het selectievakje.

Schermopname van de DataList EditItemTemplate nadat de DataBinding-syntaxis is toegevoegd en de knop Bewerken is geselecteerd.

Afbeelding 9: Als u op de knop Bewerken klikt, wordt de bewerkingsinterface weergegeven (klik om de volledige afbeelding weer te geven)

Stap 5: De wijzigingen van de gebruiker opslaan in de gebeurtenis-handler UpdateCommand

Wanneer de gebruiker een product bewerkt en op de knop Bijwerken klikt, treedt er een postback op en wordt de DataList-gebeurtenis UpdateCommand geactiveerd. In de gebeurtenis-handler moeten we de waarden van de webbesturingselementen in de EditItemTemplate en interface met de BLL lezen om het product in de database bij te werken. Zoals we in eerdere zelfstudies hebben gezien, is het ProductID van het bijgewerkte product toegankelijk via de DataKeys collectie. De door de gebruiker ingevoerde velden worden geopend door programmatisch te verwijzen naar de webbesturingselementen met behulp van FindControl("controlID"), zoals in de volgende code wordt weergegeven:

protected void Products_UpdateCommand(object source, DataListCommandEventArgs e)
{
    // Make sure the page is valid...
    if (!Page.IsValid)
        return;
    // Read in the ProductID from the DataKeys collection
    int productID = Convert.ToInt32(Products.DataKeys[e.Item.ItemIndex]);
    // Read in the product name and price values
    TextBox productName = (TextBox)e.Item.FindControl("ProductName");
    DropDownList categories = (DropDownList)e.Item.FindControl("Categories");
    DropDownList suppliers = (DropDownList)e.Item.FindControl("Suppliers");
    CheckBox discontinued = (CheckBox)e.Item.FindControl("Discontinued");
    string productNameValue = null;
    if (productName.Text.Trim().Length > 0)
        productNameValue = productName.Text.Trim();
    int categoryIDValue = Convert.ToInt32(categories.SelectedValue);
    int supplierIDValue = Convert.ToInt32(suppliers.SelectedValue);
    bool discontinuedValue = discontinued.Checked;
    // Call the ProductsBLL's UpdateProduct method...
    ProductsBLL productsAPI = new ProductsBLL();
    productsAPI.UpdateProduct(productNameValue, categoryIDValue, supplierIDValue,
                              discontinuedValue, productID);
    // Revert the DataList back to its pre-editing state
    Products.EditItemIndex = -1;
    Products.DataBind();
}

De code begint door de Page.IsValid eigenschap te raadplegen om ervoor te zorgen dat alle validatiebesturingselementen op de pagina geldig zijn. Als Page.IsValid is True, wordt de bewerkte productwaarde ProductID gelezen uit de DataKeys verzameling en wordt er programmatically verwezen naar de webcontrols voor gegevensinvoer in de EditItemTemplate. Vervolgens worden de waarden van deze webbesturingselementen ingelezen in variabelen die vervolgens worden doorgegeven aan de juiste UpdateProduct overbelasting. Na het bijwerken van de gegevens wordt de DataList teruggezet naar de staat van vóór het bewerken.

Opmerking

Ik heb de logica voor het afhandelen van uitzonderingen weggelaten die is toegevoegd aan de zelfstudie BLL- en DAL-Level Exceptions om de code en dit voorbeeld gefocust te houden. Voeg als oefening deze functionaliteit toe nadat u deze zelfstudie heeft afgerond.

Stap 6: NULL CategoryID en SupplierID-waarden afhandelen

De Northwind-database biedt NULL waarden voor de Products tabel en CategoryIDSupplierID kolommen. De bewerkingsinterface biedt momenteel echter geen ruimte voor NULL waarden. Als we proberen een product te bewerken met een NULL waarde voor de bijbehorende CategoryID waarde of SupplierID kolommen, krijgen we een ArgumentOutOfRangeException foutbericht dat lijkt op: 'Categories' heeft een SelectedValue die ongeldig is omdat deze niet bestaat in de lijst met items. Er is momenteel ook geen manier om een productcategorie of leverancierwaarde te wijzigen van een niet-waardeNULL in een NULL waarde.

Ter ondersteuning van NULL waarden voor de categorie en de vervolgkeuzelijsten voor leveranciers, moeten we een extra ListItem toevoegen. Ik heb ervoor gekozen om (Geen) als waarde Text hiervoor ListItemte gebruiken, maar u kunt deze desgewenst wijzigen in iets anders (zoals een lege tekenreeks). Vergeet ten slotte niet om de DropDownLists AppendDataBoundItemsTruein te stellen op ; als u dit vergeet, overschrijven de categorieën en leveranciers die zijn gebonden aan de DropDownList de statisch toegevoegde ListItem.

Nadat u deze wijzigingen hebt aangebracht, moeten de vervolgkeuzelijsten in de DataList s EditItemTemplate er ongeveer als volgt uitzien:

<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>

Opmerking

Statische ListItem s kunnen worden toegevoegd aan een vervolgkeuzelijst via de ontwerpfunctie of rechtstreeks via de declaratieve syntaxis. Wanneer u een DropDownList-item toevoegt om een databasewaarde NULL weer te geven, zorg ervoor dat u dit doet via de declaratieve syntaxis ListItem. Als u de ListItem verzamelingseditor in de ontwerpfunctie gebruikt, laat de gegenereerde declaratieve syntaxis de Value instelling helemaal weg wanneer een lege tekenreeks wordt toegewezen, waardoor declaratieve markeringen worden gemaakt zoals: <asp:ListItem>(None)</asp:ListItem> Hoewel dit er ongevaarlijk uitziet, zorgt het ontbreken Value ervoor dat de DropDownList de Text eigenschapswaarde op zijn plaats gebruikt. Dit betekent dat als dit NULLListItem is geselecteerd, zal worden geprobeerd de waarde (Geen) toe te wijzen aan het gegevensveld van het product (CategoryID of SupplierID, in deze handleiding), wat zal resulteren in een uitzondering. Door expliciet in te stellen Value="", wordt er een NULL waarde toegewezen aan het gegevensveld van het product wanneer de NULLListItem waarde is geselecteerd.

Neem even de tijd om onze voortgang via een browser te bekijken. Wanneer u een product bewerkt, moet u er rekening mee houden dat de Categories en Suppliers vervolgkeuzelijst beide aan het begin de optie (Geen) bevat.

De vervolgkeuzelijst Categorieën en Leveranciers bevatten een optie (Geen)

Afbeelding 10: De Categories en Suppliers dropDownLists bevatten een optie (Geen) (Klik om de volledige afbeelding weer te geven)

Als u de optie (Geen) wilt opslaan als een databasewaarde NULL , moet u terugkeren naar de UpdateCommand gebeurtenis-handler. Wijzig de categoryIDValue en supplierIDValue variabelen zodat ze nullable gehele getallen zijn en wijs ze een andere waarde toe dan Nothing alleen als de vervolgkeuzelijst SelectedValue geen lege tekenreeks is.

int? categoryIDValue = null;
if (!string.IsNullOrEmpty(categories.SelectedValue))
    categoryIDValue = Convert.ToInt32(categories.SelectedValue);
int? supplierIDValue = null;
if (!string.IsNullOrEmpty(suppliers.SelectedValue))
    supplierIDValue = Convert.ToInt32(suppliers.SelectedValue);

Met deze wijziging wordt een waarde Nothing doorgegeven aan de UpdateProduct BLL-methode als de gebruiker in een van de vervolgkeuzelijsten de optie (Geen) heeft geselecteerd, dat overeenkomt met een NULL waarde in de database.

Samenvatting

In deze zelfstudie hebben we gezien hoe u een complexere bewerkingsinterface voor DataList maakt met drie verschillende invoerwebbesturingselementen voor een tekstvak, twee vervolgkeuzelijsten en een selectievakje, samen met validatiebesturingselementen. Bij het bouwen van de bewerkingsinterface zijn de stappen hetzelfde, ongeacht de webbesturingselementen die worden gebruikt: begin met het toevoegen van de webbesturingselementen aan de DataList s EditItemTemplate; gebruik de syntaxis van gegevensbinding om de bijbehorende gegevensveldwaarden met de juiste eigenschappen van het webbesturingselement toe te wijzen; en in de UpdateCommand gebeurtenishandler krijgt u programmatisch toegang tot de webbesturingselementen en de bijbehorende eigenschappen, hun waarden doorgeven aan de BLL.

Wanneer u een bewerkingsinterface maakt, ongeacht of deze bestaat uit alleen tekstvakken of een verzameling verschillende webbesturingselementen, moet u databasewaarden NULL correct verwerken. Wanneer u rekening houdt met NULL s, is het noodzakelijk dat u niet alleen een bestaande NULL waarde correct weergeeft in de bewerkingsinterface, maar ook dat u een manier biedt om een waarde als NULLte markeren. Voor DropDownLists in DataLists betekent dit meestal dat u een statische ListItem eigenschap toevoegt waarvan Value de eigenschap expliciet is ingesteld op een lege tekenreeks (Value="") en een beetje code toevoegt aan de UpdateCommand gebeurtenis-handler om te bepalen of de NULL``ListItem eigenschap al dan niet is geselecteerd.

Veel plezier met programmeren!

Over de auteur

Scott Mitchell, auteur van zeven ASP/ASP.NET-boeken en oprichter van 4GuysFromRolla.com, werkt sinds 1998 met Microsoft-webtechnologieën. Scott werkt als onafhankelijk consultant, trainer en schrijver. Zijn laatste boek is Sams Teach Yourself ASP.NET 2.0 in 24 uur. Hij kan worden bereikt op mitchell@4GuysFromRolla.com.

Speciale dank aan

Deze tutorialreeks is beoordeeld door veel behulpzame beoordelers. Hoofdrevisoren voor deze handleiding waren Dennis Patterson, David Suru en Randy Schmidt. Bent u geïnteresseerd in het bekijken van mijn aanstaande MSDN-artikelen? Zo ja, laat iets van je horen via mitchell@4GuysFromRolla.com.

VorigeVolgende

  • Last updated on