Freigeben über

Mitgliedschaft und Verwaltung

von Erik Reitan

In dieser Lernprogrammreihe lernen Sie die Grundlagen der Erstellung einer ASP.NET Web Forms-Anwendung mithilfe von ASP.NET 4.5 und Microsoft Visual Studio Express 2013 für Web kennen. Für diese Lernprogrammreihe steht ein Visual Studio 2013-Projekt mit C#-Quellcode zur Verfügung.

In diesem Lernprogramm erfahren Sie, wie Sie die Wingtip Toys-Beispielanwendung aktualisieren, um eine benutzerdefinierte Rolle hinzuzufügen und ASP.NET Identity zu verwenden. Außerdem wird gezeigt, wie Sie eine Verwaltungsseite implementieren, von der der Benutzer mit einer benutzerdefinierten Rolle Produkte von der Website hinzufügen und entfernen kann.

ASP.NET Identity ist das Mitgliedschaftssystem, das zum Erstellen ASP.NET Webanwendung verwendet wird und in ASP.NET 4.5 verfügbar ist. ASP.NET Identity wird in der Visual Studio 2013 Web Forms-Projektvorlage sowie in den Vorlagen für ASP.NET MVC, ASP.NET Web-API und ASP.NET Single Page Application verwendet. Sie können das ASP.NET Identity-System auch mithilfe von NuGet installieren, wenn Sie mit einer leeren Webanwendung beginnen. In dieser Lernprogrammreihe verwenden Sie jedoch die Web Forms-Projektvorlage, die das ASP.NET Identity-System enthält. ASP.NET Identity erleichtert die Integration von benutzerspezifischen Profildaten in Anwendungsdaten. Darüber hinaus können Sie mit ASP.NET Identity das Persistenzmodell für Benutzerprofile in Ihrer Anwendung auswählen. Sie können die Daten in einer SQL Server-Datenbank oder einem anderen Datenspeicher speichern, einschließlich NoSQL-Datenspeichern wie Windows Azure Storage Tables.

Dieses Lernprogramm baut auf dem vorherigen Lernprogramm mit dem Titel "Auschecken und Bezahlen mit PayPal" in der Wingtip Toys-Lernreihe auf.

Was Sie lernen:

  • Verwenden von Code zum Hinzufügen einer benutzerdefinierten Rolle und eines Benutzers zur Anwendung.
  • Einschränken des Zugriffs auf den Verwaltungsordner und die Seite
  • Wie man die Navigation für einen Benutzer bereitstellt, der einer benutzerdefinierten Rolle zugeordnet ist.
  • So verwenden Sie die Modellbindung, um ein DropDownList-Steuerelement mit Produktkategorien zu befüllen.
  • So laden Sie eine Datei mithilfe des FileUpload-Steuerelements in die Webanwendung hoch.
  • So verwenden Sie Validierungssteuerelemente zur Implementierung der Eingabevalidierung.
  • Hinzufügen und Entfernen von Produkten aus der Anwendung

Diese Features sind im Lernprogramm enthalten:

  • ASP.NET Identität
  • Konfiguration und Autorisierung
  • Modellbindung
  • Unauffällige Validierung

ASP.NET Web Forms bietet Mitgliedschaftsfunktionen. Mithilfe der Standardvorlage verfügen Sie über integrierte Mitgliedschaftsfunktionen, die Sie sofort verwenden können, wenn die Anwendung ausgeführt wird. In diesem Lernprogramm erfahren Sie, wie Sie ASP.NET Identity verwenden, um eine benutzerdefinierte Rolle hinzuzufügen und dieser Rolle einen Benutzer zuzuweisen. Sie erfahren, wie Sie den Zugriff auf den Verwaltungsordner einschränken. Sie fügen dem Verwaltungsordner eine Seite hinzu, die es einem Benutzer mit einer benutzerdefinierten Rolle ermöglicht, Produkte hinzuzufügen und zu entfernen und eine Vorschau eines Produkts anzuzeigen, nachdem es hinzugefügt wurde.

Hinzufügen einer benutzerdefinierten Rolle

Mithilfe ASP.NET Identity können Sie eine benutzerdefinierte Rolle hinzufügen und dieser Rolle mithilfe von Code einen Benutzer zuweisen.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Logik ", und erstellen Sie eine neue Klasse.

  2. Benennen Sie die neue Klasse RoleActions.cs.

  3. Ändern Sie den Code so, dass er wie folgt angezeigt wird:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace WingtipToys.Logic
{
    internal class RoleActions
    {
    }
}

  4. Öffnen Sie im Projektmappen-Explorer die Global.asax.cs Datei.

  5. Ändern Sie die Global.asax.cs Datei, indem Sie den gelb hervorgehobenen Code hinzufügen, sodass er wie folgt angezeigt wird:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Optimization;
using System.Web.Routing;
using System.Web.Security;
using System.Web.SessionState;
using System.Data.Entity;
using WingtipToys.Models;
using WingtipToys.Logic;

namespace WingtipToys
{
    public class Global : HttpApplication
    {
        void Application_Start(object sender, EventArgs e)
        {
          // Code that runs on application startup
          RouteConfig.RegisterRoutes(RouteTable.Routes);
          BundleConfig.RegisterBundles(BundleTable.Bundles);

          // Initialize the product database.
          Database.SetInitializer(new ProductDatabaseInitializer());

          // Create the custom role and user.
          RoleActions roleActions = new RoleActions();
          roleActions.AddUserAndRole();
        }
    }
}

  6. Beachten Sie, dass AddUserAndRole rot unterstrichen ist. Doppelklicken Sie auf den AddUserAndRole-Code.
    Der Buchstabe "A" am Anfang der hervorgehobenen Methode wird unterstrichen.

  7. Zeigen Sie mit der Maus auf den Buchstaben "A", und klicken Sie auf die Benutzeroberfläche, mit der Sie einen Methoden-Stub für die AddUserAndRole Methode generieren können.

    Mitgliedschaft und Verwaltung – Methoden-Stub generieren

  8. Klicken Sie auf die Option mit dem Titel:
    Generate method stub for "AddUserAndRole" in "WingtipToys.Logic.RoleActions"

  9. Öffnen Sie die RoleActions.cs Datei aus dem Ordner "Logic ".
    Die AddUserAndRole Methode wurde der Klassendatei hinzugefügt.

  10. Ändern Sie die RoleActions.cs Datei, indem Sie den NotImplementedException gelb hervorgehobenen Code entfernen und hinzufügen, sodass er wie folgt angezeigt wird:

    using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Web;
using WingtipToys.Models;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;

namespace WingtipToys.Logic
{
  internal class RoleActions
  {
    internal void AddUserAndRole()
    {
      // Access the application context and create result variables.
      Models.ApplicationDbContext context = new ApplicationDbContext();
      IdentityResult IdRoleResult;
      IdentityResult IdUserResult;

      // Create a RoleStore object by using the ApplicationDbContext object. 
      // The RoleStore is only allowed to contain IdentityRole objects.
      var roleStore = new RoleStore<IdentityRole>(context);

      // Create a RoleManager object that is only allowed to contain IdentityRole objects.
      // When creating the RoleManager object, you pass in (as a parameter) a new RoleStore object. 
      var roleMgr = new RoleManager<IdentityRole>(roleStore);

      // Then, you create the "canEdit" role if it doesn't already exist.
      if (!roleMgr.RoleExists("canEdit"))
      {
        IdRoleResult = roleMgr.Create(new IdentityRole { Name = "canEdit" });
      }

      // Create a UserManager object based on the UserStore object and the ApplicationDbContext  
      // object. Note that you can create new objects and use them as parameters in
      // a single line of code, rather than using multiple lines of code, as you did
      // for the RoleManager object.
      var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
      var appUser = new ApplicationUser
      {
        UserName = "canEditUser@wingtiptoys.com",
        Email = "canEditUser@wingtiptoys.com"
      };
      IdUserResult = userMgr.Create(appUser, ConfigurationManager.AppSettings["AppUserPasswordKey"]);

      // If the new "canEdit" user was successfully created, 
      // add the "canEdit" user to the "canEdit" role. 
      if (!userMgr.IsInRole(userMgr.FindByEmail("canEditUser@wingtiptoys.com").Id, "canEdit"))
      {
        IdUserResult = userMgr.AddToRole(userMgr.FindByEmail("canEditUser@wingtiptoys.com").Id, "canEdit");
      }
    }
  }
}

Der obige Code richtet zunächst einen Datenbankkontext für die Mitgliedschaftsdatenbank ein. Die Mitgliedschaftsdatenbank wird auch als .mdf Datei im ordner App_Data gespeichert. Sie können diese Datenbank anzeigen, sobald sich der erste Benutzer bei dieser Webanwendung angemeldet hat.

Hinweis

Wenn Sie die Mitgliedschaftsdaten zusammen mit den Produktdaten speichern möchten, können Sie denselben DbContext verwenden, den Sie zum Speichern der Produktdaten im obigen Code verwendet haben.

Das interne Schlüsselwort ist ein Zugriffsmodifizierer für Typen (z. B. Klassen) und Typmelemente (z. B. Methoden oder Eigenschaften). Auf interne Typen oder Member kann nur innerhalb von Dateien zugegriffen werden, die in derselben Assembly enthalten sind (.dll Datei). Beim Erstellen der Anwendung wird eine Assemblydatei (.dll) erstellt, die den Code enthält, der beim Ausführen der Anwendung ausgeführt wird.

Ein RoleStore Objekt, das die Rollenverwaltung bereitstellt, wird basierend auf dem Datenbankkontext erstellt.

Hinweis

Beachten Sie, dass beim Erstellen des RoleStore Objekts ein generischer IdentityRole Typ verwendet wird. Dies bedeutet, dass der RoleStore nur IdentityRole Objekte enthalten darf. Auch durch die Verwendung von Generics werden Ressourcen im Arbeitsspeicher besser behandelt.

Als Nächstes wird das RoleManager Objekt basierend auf dem RoleStore soeben erstellten Objekt erstellt. Das RoleManager-Objekt macht rollenbezogene APIs verfügbar, die verwendet werden können, um Änderungen automatisch in der RoleStore zu speichern. Diesem RoleManager darf nur IdentityRole Objekte enthalten, da der Code den <IdentityRole> Generischen Typ verwendet.

Sie rufen die RoleExists Methode auf, um festzustellen, ob die Rolle "canEdit" in der Mitgliedschaftsdatenbank vorhanden ist. Wenn dies nicht der Fall ist, erstellen Sie die Rolle.

Das Erstellen des UserManager Objekts scheint komplizierter zu sein als das RoleManager Steuerelement, es ist jedoch fast identisch. Sie ist nur in einer Zeile und nicht in mehreren Zeilen codiert. Hier wird der übergebene Parameter als neues Objekt instanziiert, das in der Klammer enthalten ist.

Als Nächstes erstellen Sie den Benutzer "canEditUser", indem Sie ein neues ApplicationUser Objekt erstellen. Wenn Sie den Benutzer dann erfolgreich erstellen, fügen Sie den Benutzer zur neuen Rolle hinzu.

Hinweis

Die Fehlerbehandlung wird im "ASP.NET Fehlerbehandlung" Tutorial später in dieser Tutorialreihe aktualisiert.

Wenn die Anwendung das nächste Mal gestartet wird, wird der Benutzer mit dem Namen "canEditUser" als Rolle namens "canEdit" der Anwendung hinzugefügt. Später in diesem Lernprogramm melden Sie sich als "canEditUser"-Benutzer an, um zusätzliche Funktionen anzuzeigen, die Sie während dieses Lernprogramms hinzugefügt werden. Api-Details zu ASP.NET Identity finden Sie im Microsoft.AspNet.Identity-Namespace. Weitere Informationen zum Initialisieren des ASP.NET Identity-Systems finden Sie im AspnetIdentitySample.

Einschränken des Zugriffs auf die Verwaltungsseite

Die Wingtip Toys-Beispielanwendung ermöglicht es anonymen Benutzern und angemeldeten Benutzern, Produkte anzuzeigen und zu kaufen. Der angemeldete Benutzer mit der benutzerdefinierten Rolle "canEdit" kann jedoch auf eine eingeschränkte Seite zugreifen, um Produkte hinzuzufügen und zu entfernen.

Hinzufügen eines Verwaltungsordners und einer Seite

Als Nächstes erstellen Sie einen Ordner namens "Admin " für den Benutzer "canEditUser", der zur benutzerdefinierten Rolle der Wingtip Toys-Beispielanwendung gehört.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen (Wingtip Toys), und wählen Sie "Hinzufügen ->Neuer Ordner" aus.
  2. Benennen Sie den neuen Ordner "Administrator".
  3. Klicken Sie mit der rechten Maustaste auf den Administratorordner, und wählen Sie dann "Hinzufügen ->Neues Element" aus.
    Das Dialogfeld Neues Element hinzufügen wird angezeigt.
  4. Wählen Sie auf der linken Seite die Gruppe "Visual C#->Webvorlagen " aus. Wählen Sie in der mittleren Liste Webformular mit Gestaltungsvorlage aus, benennen Sie es AdminPage.aspx, und wählen Sie dann "Hinzufügen" aus.
  5. Wählen Sie die Datei "Site.Master" als Gestaltungsvorlage und dann OK aus.

Hinzufügen einer Web.config Datei

Indem Sie dem Administratorordner eine Web.config Datei hinzufügen, können Sie den Zugriff auf die Im Ordner enthaltene Seite einschränken.

  1. Klicken Sie mit der rechten Maustaste auf den Administratorordner, und wählen Sie "Neues Element hinzufügen>" aus.
    Das Dialogfeld Neues Element hinzufügen wird angezeigt.

  2. Wählen Sie in der Liste der Visual C#-Webvorlagen in der mittleren Liste die Webkonfigurationsdateiaus, übernehmen Sie den Standardnamen von Web.config, und wählen Sie dann "Hinzufügen" aus.

  3. Ersetzen Sie den vorhandenen XML-Inhalt in der dateiWeb.config durch Folgendes:

    <?xml version="1.0"?>
<configuration>
  <system.web>
    <authorization>
      <allow roles="canEdit"/>
      <deny users="*"/>
    </authorization>
  </system.web>
</configuration>

Speichern Sie die Datei Web.config . Die Web.config Datei gibt an, dass nur der Benutzer, der zur Rolle "canEdit" der Anwendung gehört, auf die Im Administratorordner enthaltene Seite zugreifen kann.

Benutzerdefinierte Rollennavigation einbeziehen

Damit der Benutzer der benutzerdefinierten "canEdit"-Rolle zum Verwaltungsabschnitt der Anwendung navigieren kann, müssen Sie der Seite "Site.Master " einen Link hinzufügen. Nur Benutzer, die zur Rolle "canEdit" gehören, können den Administratorlink anzeigen und auf den Verwaltungsabschnitt zugreifen.

  1. Suchen Sie im Projektmappen-Explorer die Seite "Site.Master ", und öffnen Sie sie.

  2. Um einen Link für den Benutzer der Rolle "canEdit" zu erstellen, fügen Sie das in Gelb hervorgehobene Markup dem folgenden ungeordneten Listenelement <ul> hinzu, damit die Liste wie folgt angezeigt wird:

    <ul class="nav navbar-nav">
    <li><a runat="server" id="adminLink" visible="false" 
      href="~/Admin/AdminPage">Admin</a></li>
    <li><a runat="server" href="~/">Home</a></li>
    <li><a runat="server" href="~/About">About</a></li>
    <li><a runat="server" href="~/Contact">Contact</a></li>
    <li><a runat="server" href="~/ProductList">Products</a></li>
    <li><a runat="server" href="~/ShoppingCart" 
      ID="cartCount">&nbsp;</a></li>
</ul>

  3. Öffnen Sie die datei Site.Master.cs . Machen Sie den Administratorlink nur für den Benutzer "canEditUser" sichtbar, indem Sie dem Handler den Page_Load gelb hervorgehobenen Code hinzufügen. Der Page_Load Handler wird wie folgt angezeigt:

    protected void Page_Load(object sender, EventArgs e)
{
    if (HttpContext.Current.User.IsInRole("canEdit"))
    {
        adminLink.Visible = true;
    }
}

Wenn die Seite geladen wird, überprüft der Code, ob der angemeldete Benutzer die Rolle "canEdit" hat. Wenn der Benutzer zur Rolle "canEdit" gehört, wird das Span-Element, das den Link zur AdminPage.aspx Seite enthält (und folglich der Link innerhalb der Spanne) sichtbar gemacht.

Aktivieren der Produktverwaltung

Bisher haben Sie die Rolle "canEdit" erstellt und einen "canEditUser"-Benutzer, einen Verwaltungsordner und eine Verwaltungsseite hinzugefügt. Sie haben Zugriffsrechte für den Verwaltungsordner und die Seite festgelegt und der Anwendung einen Navigationslink für den Benutzer der Rolle "canEdit" hinzugefügt. Als Nächstes fügen Sie der AdminPage.aspx Seite markup und Code zur AdminPage.aspx.cs CodeBehind-Datei hinzu, mit der der Benutzer mit der Rolle "canEdit" Produkte hinzufügen und entfernen kann.

  1. Öffnen Sie im Projektmappen-Explorer die AdminPage.aspx Datei aus dem Ordner "Administrator ".

  2. Ersetzen Sie das vorhandene Markup durch Folgendes:

    <%@ Page Title="" Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true" CodeBehind="AdminPage.aspx.cs" Inherits="WingtipToys.Admin.AdminPage" %>
<asp:Content ID="Content1" ContentPlaceHolderID="MainContent" runat="server">
    <h1>Administration</h1>
    <hr />
    <h3>Add Product:</h3>
    <table>
        <tr>
            <td><asp:Label ID="LabelAddCategory" runat="server">Category:</asp:Label></td>
            <td>
                <asp:DropDownList ID="DropDownAddCategory" runat="server" 
                    ItemType="WingtipToys.Models.Category" 
                    SelectMethod="GetCategories" DataTextField="CategoryName" 
                    DataValueField="CategoryID" >
                </asp:DropDownList>
            </td>
        </tr>
        <tr>
            <td><asp:Label ID="LabelAddName" runat="server">Name:</asp:Label></td>
            <td>
                <asp:TextBox ID="AddProductName" runat="server"></asp:TextBox>
                <asp:RequiredFieldValidator ID="RequiredFieldValidator1" runat="server" Text="* Product name required." ControlToValidate="AddProductName" SetFocusOnError="true" Display="Dynamic"></asp:RequiredFieldValidator>
            </td>
        </tr>
        <tr>
            <td><asp:Label ID="LabelAddDescription" runat="server">Description:</asp:Label></td>
            <td>
                <asp:TextBox ID="AddProductDescription" runat="server"></asp:TextBox>
                <asp:RequiredFieldValidator ID="RequiredFieldValidator2" runat="server" Text="* Description required." ControlToValidate="AddProductDescription" SetFocusOnError="true" Display="Dynamic"></asp:RequiredFieldValidator>
            </td>
        </tr>
        <tr>
            <td><asp:Label ID="LabelAddPrice" runat="server">Price:</asp:Label></td>
            <td>
                <asp:TextBox ID="AddProductPrice" runat="server"></asp:TextBox>
                <asp:RequiredFieldValidator ID="RequiredFieldValidator3" runat="server" Text="* Price required." ControlToValidate="AddProductPrice" SetFocusOnError="true" Display="Dynamic"></asp:RequiredFieldValidator>
                <asp:RegularExpressionValidator ID="RegularExpressionValidator1" runat="server" Text="* Must be a valid price without $." ControlToValidate="AddProductPrice" SetFocusOnError="True" Display="Dynamic" ValidationExpression="^[0-9]*(\.)?[0-9]?[0-9]?$"></asp:RegularExpressionValidator>
            </td>
        </tr>
        <tr>
            <td><asp:Label ID="LabelAddImageFile" runat="server">Image File:</asp:Label></td>
            <td>
                <asp:FileUpload ID="ProductImage" runat="server" />
                <asp:RequiredFieldValidator ID="RequiredFieldValidator4" runat="server" Text="* Image path required." ControlToValidate="ProductImage" SetFocusOnError="true" Display="Dynamic"></asp:RequiredFieldValidator>
            </td>
        </tr>
    </table>
    <p></p>
    <p></p>
    <asp:Button ID="AddProductButton" runat="server" Text="Add Product" OnClick="AddProductButton_Click"  CausesValidation="true"/>
    <asp:Label ID="LabelAddStatus" runat="server" Text=""></asp:Label>
    <p></p>
    <h3>Remove Product:</h3>
    <table>
        <tr>
            <td><asp:Label ID="LabelRemoveProduct" runat="server">Product:</asp:Label></td>
            <td><asp:DropDownList ID="DropDownRemoveProduct" runat="server" ItemType="WingtipToys.Models.Product" 
                    SelectMethod="GetProducts" AppendDataBoundItems="true" 
                    DataTextField="ProductName" DataValueField="ProductID" >
                </asp:DropDownList>
            </td>
        </tr>
    </table>
    <p></p>
    <asp:Button ID="RemoveProductButton" runat="server" Text="Remove Product" OnClick="RemoveProductButton_Click" CausesValidation="false"/>
    <asp:Label ID="LabelRemoveStatus" runat="server" Text=""></asp:Label>
</asp:Content>

  3. Öffnen Sie als Nächstes die AdminPage.aspx.cs CodeBehind-Datei, indem Sie mit der rechten Maustaste auf das AdminPage.aspx klicken und dann auf "Code anzeigen" klicken.

  4. Ersetzen Sie den vorhandenen Code in der AdminPage.aspx.cs CodeBehind-Datei durch den folgenden Code:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using WingtipToys.Models;
using WingtipToys.Logic;

namespace WingtipToys.Admin
{
  public partial class AdminPage : System.Web.UI.Page
  {
    protected void Page_Load(object sender, EventArgs e)
    {
      string productAction = Request.QueryString["ProductAction"];
      if (productAction == "add")
      {
        LabelAddStatus.Text = "Product added!";
      }

      if (productAction == "remove")
      {
        LabelRemoveStatus.Text = "Product removed!";
      }
    }

    protected void AddProductButton_Click(object sender, EventArgs e)
    {
      Boolean fileOK = false;
      String path = Server.MapPath("~/Catalog/Images/");
      if (ProductImage.HasFile)
      {
        String fileExtension = System.IO.Path.GetExtension(ProductImage.FileName).ToLower();
        String[] allowedExtensions = { ".gif", ".png", ".jpeg", ".jpg" };
        for (int i = 0; i < allowedExtensions.Length; i++)
        {
          if (fileExtension == allowedExtensions[i])
          {
            fileOK = true;
          }
        }
      }

      if (fileOK)
      {
        try
        {
          // Save to Images folder.
          ProductImage.PostedFile.SaveAs(path + ProductImage.FileName);
          // Save to Images/Thumbs folder.
          ProductImage.PostedFile.SaveAs(path + "Thumbs/" + ProductImage.FileName);
        }
        catch (Exception ex)
        {
          LabelAddStatus.Text = ex.Message;
        }

        // Add product data to DB.
        AddProducts products = new AddProducts();
        bool addSuccess = products.AddProduct(AddProductName.Text, AddProductDescription.Text,
            AddProductPrice.Text, DropDownAddCategory.SelectedValue, ProductImage.FileName);
        if (addSuccess)
        {
          // Reload the page.
          string pageUrl = Request.Url.AbsoluteUri.Substring(0, Request.Url.AbsoluteUri.Count() - Request.Url.Query.Count());
          Response.Redirect(pageUrl + "?ProductAction=add");
        }
        else
        {
          LabelAddStatus.Text = "Unable to add new product to database.";
        }
      }
      else
      {
        LabelAddStatus.Text = "Unable to accept file type.";
      }
    }

    public IQueryable GetCategories()
    {
      var _db = new WingtipToys.Models.ProductContext();
      IQueryable query = _db.Categories;
      return query;
    }

    public IQueryable GetProducts()
    {
      var _db = new WingtipToys.Models.ProductContext();
      IQueryable query = _db.Products;
      return query;
    }

    protected void RemoveProductButton_Click(object sender, EventArgs e)
    {
      using (var _db = new WingtipToys.Models.ProductContext())
      {
        int productId = Convert.ToInt16(DropDownRemoveProduct.SelectedValue);
        var myItem = (from c in _db.Products where c.ProductID == productId select c).FirstOrDefault();
        if (myItem != null)
        {
          _db.Products.Remove(myItem);
          _db.SaveChanges();

          // Reload the page.
          string pageUrl = Request.Url.AbsoluteUri.Substring(0, Request.Url.AbsoluteUri.Count() - Request.Url.Query.Count());
          Response.Redirect(pageUrl + "?ProductAction=remove");
        }
        else
        {
          LabelRemoveStatus.Text = "Unable to locate product.";
        }
      }
    }
  }
}

Im Code, den Sie für die AdminPage.aspx.cs-CodeBehind-Datei eingegeben haben, führt eine Klasse namens AddProducts, die tatsächliche Arbeit des Hinzufügens von Produkten zur Datenbank durch. Diese Klasse ist noch nicht vorhanden, sodass Sie sie jetzt erstellen.

  1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Ordner "Logik", und wählen Sie dann "Hinzufügen ->Neues Element" aus.
    Das Dialogfeld Neues Element hinzufügen wird angezeigt.

  2. Wählen Sie auf der linken Seite die Gruppe "Visual C# ->Code-Vorlagen " aus. Wählen Sie dann "Klasse" aus der mittleren Liste aus, und nennen Sie sie AddProducts.cs.
    Die neue Klassendatei wird angezeigt.

  3. Ersetzen Sie den vorhandenen Code durch folgenden Code:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using WingtipToys.Models;

namespace WingtipToys.Logic
{
    public class AddProducts
    {
        public bool AddProduct(string ProductName, string ProductDesc, string ProductPrice, string ProductCategory, string ProductImagePath)
        {
            var myProduct = new Product();
            myProduct.ProductName = ProductName;
            myProduct.Description = ProductDesc;
            myProduct.UnitPrice = Convert.ToDouble(ProductPrice);
            myProduct.ImagePath = ProductImagePath;
            myProduct.CategoryID = Convert.ToInt32(ProductCategory);

            using (ProductContext _db = new ProductContext())
            {
                // Add product to DB.
                _db.Products.Add(myProduct);
                _db.SaveChanges();
            }
            // Success.
            return true;
        }
    }
}

Auf der AdminPage.aspx-Seite kann der Benutzer, der zur Rolle "canEdit" gehört, Produkte hinzufügen und entfernen. Wenn ein neues Produkt hinzugefügt wird, werden die Details zum Produkt überprüft und dann in die Datenbank eingegeben. Das neue Produkt steht allen Benutzern der Webanwendung sofort zur Verfügung.

Unauffällige Validierung

Die Produktdetails, die der Benutzer auf der AdminPage.aspx-Seite bereitstellt, werden mithilfe von Überprüfungssteuerelementen (RequiredFieldValidator und RegularExpressionValidator) überprüft. Diese Steuerelemente verwenden automatisch eine unauffällige Validierung. Die unauffällige Überprüfung ermöglicht es den Überprüfungssteuerelementen, JavaScript für clientseitige Validierungslogik zu verwenden, was bedeutet, dass die Seite keine Reise zum Server erfordert, um überprüft zu werden. Standardmäßig ist die unauffällige Überprüfung basierend auf der folgenden Konfigurationseinstellung in der Web.config-Datei enthalten:

<add key="ValidationSettings:UnobtrusiveValidationMode" value="WebForms" />

Reguläre Ausdrücke

Der Produktpreis auf der AdminPage.aspx Seite wird mithilfe eines RegularExpressionValidator-Steuerelements überprüft. Dieses Steuerelement überprüft, ob der Wert des zugeordneten Eingabesteuerelements (der "AddProductPrice" TextBox) mit dem Muster übereinstimmt, das durch den regulären Ausdruck angegeben wird. Ein regulärer Ausdruck ist eine Mustervergleichsnotation, mit der Sie bestimmte Zeichenmuster schnell finden und abgleichen können. Das RegularExpressionValidator-Steuerelement enthält eine Eigenschaft mit dem Namen ValidationExpression , die den regulären Ausdruck enthält, der zum Überprüfen der Preiseingabe verwendet wird, wie unten dargestellt:

<asp:RegularExpressionValidator 
    ID="RegularExpressionValidator1" runat="server"
    Text="* Must be a valid price without $." ControlToValidate="AddProductPrice" 
    SetFocusOnError="True" Display="Dynamic" 
    ValidationExpression="^[0-9]*(\.)?[0-9]?[0-9]?$">
</asp:RegularExpressionValidator>

FileUpload-Steuerelement

Zusätzlich zu den Eingabe- und Überprüfungssteuerelementen haben Sie das FileUpload-Steuerelement zur AdminPage.aspx Seite hinzugefügt. Dieses Steuerelement bietet die Möglichkeit, Dateien hochzuladen. In diesem Fall erlauben Sie nur das Hochladen von Bilddateien. In der Code-Behind-Datei (AdminPage.aspx.cs) überprüft der Code beim Klicken auf AddProductButton die HasFile-Eigenschaft des FileUpload-Steuerelements. Wenn das Steuerelement über eine Datei verfügt und der Dateityp (basierend auf der Dateierweiterung) zulässig ist, wird das Bild im Ordner "Images " und im Ordner "Images/Thumbs " der Anwendung gespeichert.

Modellbindung

Weiter oben in dieser Lernprogrammreihe haben Sie die Modellbindung zum Auffüllen eines ListView-Steuerelements , eines FormsView-Steuerelements , eines GridView-Steuerelements und eines DetailView-Steuerelements verwendet. In diesem Lernprogramm verwenden Sie die Modellbindung zum Auffüllen eines DropDownList-Steuerelements mit einer Liste von Produktkategorien.

Das Markup, das Sie der datei AdminPage.aspx hinzugefügt haben, enthält ein DropDownList-Steuerelement namens DropDownAddCategory:

<asp:DropDownList ID="DropDownAddCategory" runat="server" 
        ItemType="WingtipToys.Models.Category" 
        SelectMethod="GetCategories" DataTextField="CategoryName" 
        DataValueField="CategoryID" >
    </asp:DropDownList>

Sie verwenden die Modellbindung, um dieses DropDownList-Objekt aufzufüllen, indem Sie das ItemType Attribut und das SelectMethod Attribut festlegen. Das ItemType Attribut gibt an, dass Sie den WingtipToys.Models.Category Typ beim Auffüllen des Steuerelements verwenden. Sie haben diesen Typ am Anfang dieser Lernprogrammreihe definiert, indem Sie die Category Klasse erstellen (siehe unten). Die Category Klasse befindet sich im Ordner "Models" in der Category.cs Datei.

public class Category
{
    [ScaffoldColumn(false)]
    public int CategoryID { get; set; }

    [Required, StringLength(100), Display(Name = "Name")]
    public string CategoryName { get; set; }

    [Display(Name = "Product Description")]
    public string Description { get; set; }

    public virtual ICollection<Product> Products { get; set; }
}

Das SelectMethod Attribut des DropDownList-Steuerelements gibt an, dass Sie die Methode (siehe unten) verwenden, die in der GetCategories (AdminPage.aspx.cs) enthalten ist.

public IQueryable GetCategories()
{
  var _db = new WingtipToys.Models.ProductContext();
  IQueryable query = _db.Categories;
  return query;
}

Diese Methode gibt an, dass eine IQueryable Schnittstelle verwendet wird, um eine Abfrage anhand eines Category Typs auszuwerten. Der zurückgegebene Wert wird verwendet, um die DropDownList im Markup der Seite aufzufüllen (AdminPage.aspx).

Der für jedes Element in der Liste angezeigte Text wird durch Festlegen des DataTextField Attributs angegeben. Das DataTextField Attribut verwendet die CategoryNameCategory Klasse (siehe oben), um jede Kategorie im DropDownList-Steuerelement anzuzeigen. Der tatsächliche Wert, der übergeben wird, wenn ein Element im DropDownList-Steuerelement ausgewählt wird, basiert auf dem DataValueField Attribut. Das DataValueField-Attribut wird auf CategoryID festgelegt, wie in der Category-Klasse definiert (siehe oben).

Funktionsweise der Anwendung

Wenn der Benutzer, der zur Rolle "canEdit" gehört, zum ersten Mal zur Seite navigiert, wird das DropDownAddCategoryDropDownList-Steuerelement wie oben beschrieben aufgefüllt. Das DropDownRemoveProductDropDownList-Steuerelement wird auch mit Produkten aufgefüllt, die denselben Ansatz verwenden. Der Benutzer, der zur Rolle "canEdit" gehört, wählt den Kategorietyp aus und fügt Produktdetails hinzu (Name, Beschreibung, Preis und Bilddatei). Wenn der Benutzer, der zur Rolle "canEdit" gehört, auf die Schaltfläche " Produkt hinzufügen " klickt, wird der AddProductButton_Click Ereignishandler ausgelöst. Der AddProductButton_Click Ereignishandler in der CodeBehind-Datei (AdminPage.aspx.cs) überprüft die Bilddatei, um sicherzustellen, dass sie den zulässigen Dateitypen entspricht (.gif, .png, .jpeg oder .jpg). Anschließend wird die Bilddatei in einem Ordner der Wingtip Toys-Beispielanwendung gespeichert. Als Nächstes wird das neue Produkt der Datenbank hinzugefügt. Um ein neues Produkt hinzuzufügen, wird eine neue Instanz der AddProducts-Klasse erstellt und als Produkte bezeichnet. Die AddProducts Klasse verfügt über eine Methode namens AddProduct, und das Products-Objekt ruft diese Methode auf, um der Datenbank Produkte hinzuzufügen.

// Add product data to DB.
AddProducts products = new AddProducts();
bool addSuccess = products.AddProduct(AddProductName.Text, AddProductDescription.Text,
    AddProductPrice.Text, DropDownAddCategory.SelectedValue, ProductImage.FileName);

Wenn der Code das neue Produkt erfolgreich zur Datenbank hinzufügt, wird die Seite mit dem Abfragezeichenfolgenwert ProductAction=addneu geladen.

Response.Redirect(pageUrl + "?ProductAction=add");

Wenn die Seite erneut geladen wird, wird die Abfragezeichenfolge in der URL enthalten. Durch erneutes Laden der Seite kann der Benutzer, der zur Rolle "canEdit" gehört, sofort die Aktualisierungen in den DropDownList-Steuerelementen auf der AdminPage.aspx Seite sehen. Außerdem kann die Seite, indem sie die Abfragezeichenfolge mit der URL einbezieht, eine Erfolgsmeldung für den Benutzer anzeigen, der zur Rolle "canEdit" gehört.

Wenn die AdminPage.aspx Seite neu geladen wird, wird das Page_Load Ereignis aufgerufen.

protected void Page_Load(object sender, EventArgs e)
{
    string productAction = Request.QueryString["ProductAction"];
    if (productAction == "add")
    {
        LabelAddStatus.Text = "Product added!";
    }

    if (productAction == "remove")
    {
        LabelRemoveStatus.Text = "Product removed!";
    }
}

Der Page_Load Ereignishandler überprüft den Abfragezeichenfolgenwert und bestimmt, ob eine Erfolgsmeldung angezeigt werden soll.

Ausführen der Anwendung

Sie können die Anwendung jetzt ausführen, um zu sehen, wie Sie Elemente im Warenkorb hinzufügen, löschen und aktualisieren können. Die Gesamtsumme des Einkaufswagens entspricht den Gesamtkosten aller Artikel im Warenkorb.

  1. Drücken Sie im Projektmappen-Explorer F5 , um die Wingtip Toys-Beispielanwendung auszuführen.
    Der Browser wird geöffnet und zeigt die Default.aspx Seite an.

  2. Klicken Sie oben auf der Seite auf den Link "Anmelden ".

    Mitgliedschaft und Verwaltung – Anmeldelink

    Die Login.aspx Seite wird angezeigt.

  3. Geben Sie den Benutzernamen und das Kennwort ein.

    Mitgliedschaft und Verwaltung – Anmeldeseite

  4. Klicken Sie unten auf der Seite auf die Schaltfläche "Anmelden ".

  5. Wählen Sie oben auf der nächsten Seite den Administratorlink aus, um zur AdminPage.aspx Seite zu navigieren.

    Mitgliedschaft und Verwaltung – Administratorlink

  6. Um die Eingabeüberprüfung zu testen, klicken Sie auf die Schaltfläche "Produkt hinzufügen ", ohne Produktdetails hinzuzufügen.

    Mitgliedschaft und Verwaltung – Administratorseite

    Beachten Sie, dass die erforderlichen Feldmeldungen angezeigt werden.

  7. Fügen Sie die Details für ein neues Produkt hinzu, und klicken Sie dann auf die Schaltfläche "Produkt hinzufügen ".

    Mitgliedschaft und Verwaltung – Produkt hinzufügen

  8. Wählen Sie "Produkte " aus dem oberen Navigationsmenü aus, um das neue Produkt anzuzeigen, das Sie hinzugefügt haben.

    Mitgliedschaft und Verwaltung – Neues Produkt anzeigen

  9. Klicken Sie auf den Administratorlink , um zur Verwaltungsseite zurückzukehren.

  10. Wählen Sie im Abschnitt Produkt entfernen der Seite das neue Produkt aus, das Sie in dem DropDownListBox hinzugefügt haben.

  11. Klicken Sie auf die Schaltfläche "Produkt entfernen ", um das neue Produkt aus der Anwendung zu entfernen.

    Mitgliedschaft und Verwaltung – Produkt entfernen

  12. Wählen Sie "Produkte " im oberen Navigationsmenü aus, um zu bestätigen, dass das Produkt entfernt wurde.

  13. Klicken Sie auf "Abmelden ", um den Verwaltungsmodus zu aktivieren.
    Beachten Sie, dass im oberen Navigationsbereich das Menüelement " Administrator " nicht mehr angezeigt wird.

Zusammenfassung

In diesem Lernprogramm haben Sie eine benutzerdefinierte Rolle und einen Benutzer hinzugefügt, der zur benutzerdefinierten Rolle gehört, den Zugriff auf den Verwaltungsordner und die Seite eingeschränkt und die Navigation für den Benutzer bereitgestellt, der zur benutzerdefinierten Rolle gehört. Sie haben die Modellbindung verwendet, um ein DropDownList-Steuerelement mit Daten aufzufüllen. Sie haben das FileUpload-Steuerelement und die Überprüfungssteuerelemente implementiert. Außerdem haben Sie erfahren, wie Sie Produkte aus einer Datenbank hinzufügen und entfernen. Im nächsten Lernprogramm erfahren Sie, wie Sie ASP.NET Routing implementieren.

Zusätzliche Ressourcen

Web.config – Autorisierungselement
ASP.NET Identität
Bereitstellen einer sicheren ASP.NET Web Forms App mit Mitgliedschaft, OAuth und SQL-Datenbank auf einer Azure-Website
Microsoft Azure – Kostenlose Testversion

ZurückWeiter

  • Last updated on