Entwickeln eines Moduls mit .NET

von Mike Volodarsky

Einführung

IIS 7.0 und höher ermöglichen das Erweitern des Servers durch Module, die auf zwei Arten entwickelt werden:

• Verwenden von verwaltetem Code und der ASP.NET Servererweiterungs-APIs
• Verwenden von systemeigenem Code und der NATIVEn IIS-Servererweiterungs-APIs

In der Vergangenheit waren ASP.NET Module in der Funktionalität eingeschränkt, da die ASP.NET Anforderungsverarbeitungspipeline von der Hauptserveranforderungspipeline getrennt war.

In IIS werden verwaltete Module praktisch so leistungsfähig wie systemeigene Module mit der integrierten Pipelinearchitektur. Die wichtigsten Dienste, die verwaltete Module bereitstellen, können jetzt auf alle Anforderungen auf den Server angewendet werden, nicht nur auf Anforderungen an ASP.NET Inhalte wie ASPX-Seiten. Verwaltete Module werden in konsistenter Weise mit nativen Modulen konfiguriert und verwaltet und können in den gleichen Verarbeitungsphasen und Anordnungen wie systemeigene Module ausgeführt werden. Schließlich können verwaltete Module eine breitere Gruppe von Vorgängen ausführen, um die Anforderungsverarbeitung über mehrere hinzugefügte und erweiterte ASP.NET-APIs zu bearbeiten.

In diesem Artikel wird die Erweiterung des Servers mit einem verwalteten Modul veranschaulicht, um die Möglichkeit zum Ausführen der Standardauthentifizierung für einen beliebigen Anmeldeinformationsspeicher hinzuzufügen, z. B. die anbieterbasierte Anmeldeinformationsinfrastruktur im ASP.NET 2.0-Mitgliedschaftssystem.

Dies ermöglicht das Ersetzen der integrierten Unterstützung der Standardauthentifizierung in IIS, die an den Windows-Anmeldeinformationsspeicher gebunden ist, durch einen, der beliebige Anmeldeinformationsspeicher unterstützt, oder eines der vorhandenen Mitgliedschaftsanbieter, die mit ASP.NET 2.0 wie SQL Server, SQL Express oder Active Directory ausgeliefert werden.

In diesem Artikel werden die folgenden Aufgaben untersucht:

• Entwickeln eines verwalteten Moduls mithilfe von ASP.NET-APIs
• Bereitstellen eines verwalteten Moduls auf dem Server

Weitere Informationen zu den Grundlagen der Entwicklung von IIS-Modulen und -Handlern finden Sie unter Entwickeln von IIS7-Modulen und -Handlern mit .NET Framework.

Darüber hinaus finden Sie viele Ressourcen und Tipps zum Schreiben von IIS-Modulen im Blog sowie http://www.mvolo.com/zum Herunterladen vorhandener IIS-Module für Ihre Anwendungen. Einige Beispiele finden Sie unter Umleitungsanforderungen an Ihre Anwendung mit dem HttpRedirection-Modul, schöne Verzeichnisauflistungen für Ihre IIS-Website mit DirectoryListingModule und Das Anzeigen von hübschen Dateisymbolen in Ihren ASP.NET Anwendungen mit IconHandler.

Voraussetzungen

Um die Schritte in diesem Dokument auszuführen, müssen die folgenden IIS-Features installiert sein:

ASP.NET

Installieren Sie ASP.NET über die Windows Vista-Systemsteuerung. Wählen Sie "Programme" – "Windows-Features aktivieren oder deaktivieren" aus. Öffnen Sie dann "Internetinformationsdienste" - "World Wide Web Services" - "Anwendungsentwicklungsfeatures" und aktivieren Sie "ASP.NET".

Wenn Sie über einen Windows Server® 2008-Build verfügen, öffnen Sie "Server-Manager" – "Rollen", und wählen Sie "Webserver (IIS)" aus. Klicken Sie auf "Rollendienste hinzufügen". Aktivieren Sie unter "Anwendungsentwicklung" das Kontrollkästchen "ASP.NET".

Hintergrundinformationen zur Standardauthentifizierung

Die Standardauthentifizierung ist ein Authentifizierungsschema, das im HTTP.1-Protokoll (RFC 2617) definiert ist. Sie verwendet einen standardisierten herausforderungsbasierten Mechanismus, der folgendermaßen funktioniert:

• Der Browser fordert eine URL ohne Anmeldeinformationen an.
• Wenn der Server eine Authentifizierung für diese URL erfordert, antwortet er mit einer Nachricht mit 401 Zugriff verweigert und enthält einen Header, der angibt, dass das Standardauthentifizierungsschema unterstützt wird.
• Der Browser empfängt die Antwort und fordert, falls konfiguriert, den Benutzer auf, einen Benutzernamen/ein Kennwort einzugeben, das er im Klartext in einem Anforderungsheader für die nächste Anfrage an die URL einschließen wird.
• Der Server empfängt den Benutzernamen/das Kennwort in einer Kopfzeile und verwendet sie für die Authentifizierung.

IIS enthält Unterstützung für die Standardauthentifizierung für die Windows-Konten, die im lokalen Kontospeicher oder Active Directory für Domänenkonten gespeichert sind. Wir möchten es unserem Benutzer ermöglichen, sich mit der Standardauthentifizierung zu authentifizieren, aber um Anmeldeinformationen stattdessen mithilfe ASP.NET 2.0-Mitgliedschaftsdiensts zu überprüfen. Dadurch können Benutzerinformationen in einer Vielzahl vorhandener Mitgliedschaftsanbieter, z. B. SQL Server, gespeichert werden, ohne an Windows-Konten gebunden zu sein.

Aufgabe 1: Entwickeln eines Moduls mit .NET

In dieser Aufgabe untersuchen wir die Entwicklung eines Authentifizierungsmoduls, das das HTTP.1-Standardauthentifizierungsschema unterstützt. Dieses Modul wurde mit dem standard ASP.NET Modulmuster entwickelt, das seit ASP.NET v1.0 verfügbar ist. Dieses Muster wird verwendet, um ASP.NET Module zu erstellen, die den IIS-Server erweitern. In der Tat können vorhandene ASP.NET Module, die für frühere Versionen von IIS geschrieben wurden, in IIS verwendet werden und die Vorteile einer besseren ASP.NET Integration nutzen, um mehr Leistungsfähigkeit für die Webanwendungen zu bieten, die sie verwenden.

Ein verwaltetes Modul ist eine .NET-Klasse, die die System.Web.IHttpModule-Schnittstelle implementiert. Die primäre Funktion dieser Klasse besteht darin, ein oder mehrere Ereignisse zu registrieren, die in der IIS-Anforderungsverarbeitungspipeline auftreten, und dann einige nützliche Aufgaben ausführen, wenn IIS die Ereignishandler des Moduls für diese Ereignisse aufruft.

Lassen Sie uns eine neue Quelldatei namens "BasicAuthenticationModule.cs" erstellen und die Modulklasse anlegen (der vollständige Quellcode befindet sich in Anhang A):

public class BasicAuthenticationModule : System.Web.IHttpModule
{
    void Init(HttpApplication context)
    {
    }
    void Dispose()
    {
    }
}

Die primäre Funktion der Init-Methode besteht darin, die Ereignishandlermethoden des Moduls mit den entsprechenden Anforderungspipelineereignissen zu verknüpfen. Die Klasse des Moduls stellt die Ereignishandlemethoden bereit, und sie implementieren die vom Modul bereitgestellte gewünschte Funktionalität. Dies wird ausführlich erörtert.

Die Dispose-Methode wird verwendet, um jeden Modulstatus zu bereinigen, wenn die Modulinstanz verworfen wird. Es wird in der Regel nicht implementiert, es sei denn, das Modul verwendet bestimmte Ressourcen, die freigegeben werden müssen.

Init()

Nach dem Erstellen der Klasse besteht der nächste Schritt darin, die Init-Methode zu implementieren. Die einzige Anforderung besteht darin, das Modul für ein oder mehrere Anforderungspipelineereignisse zu registrieren. Verbinden Sie Modulmethoden, die der Signatur des System.EventHandler-Delegaten folgen, mit den gewünschten Pipelineereignissen, die in der zur Verfügung gestellten System.Web.HttpApplication-Instanz zur Verfügung stehen.

public void Init(HttpApplication context)            
{
   //          
   // Subscribe to the authenticate event to perform the 
   // authentication. 
   // 
   context.AuthenticateRequest += new        
              EventHandler(this.AuthenticateUser);

   // 
   // Subscribe to the EndRequest event to issue the 
   // challenge if necessary. 
   // 
   context.EndRequest += new 
              EventHandler(this.IssueAuthenticationChallenge);
}

Die AuthenticateUser-Methode wird für jede Anforderung während des AuthenticateRequest-Ereignisses aufgerufen. Wir verwenden sie, um den Benutzer basierend auf den anmeldeinformationen zu authentifizieren, die in der Anforderung vorhanden sind.

Die IssueAuthenticationChallenge-Methode wird für jede Anforderung während des EndRequest-Ereignisses aufgerufen. Sie ist dafür verantwortlich, eine Standardauthentifizierungsanforderung an den Client zurückzugeben, wenn das Autorisierungsmodul eine Anforderung ablehnt und die Authentifizierung erforderlich ist.

AuthenticateUser()

Implementieren Sie die AuthenticateUser-Methode . Diese Methode führt die folgenden Aktionen aus:

• Extrahieren Sie die grundlegenden Zugangsdaten, falls in den Headern eingehender Anfragen vorhanden. Informationen zur Implementierung dieses Schritts finden Sie unter der ExtractBasicAuthenticationCredentials-Hilfsmethode .
• Versucht, die bereitgestellten Anmeldeinformationen mittels Mitgliedschaft zu überprüfen (mithilfe des konfigurierten Standardmitgliedschaftsanbieters). Informationen zur Implementierung dieses Schritts finden Sie unter der ValidateCredentials-Hilfsmethode .
• Erstellt einen Benutzerprinzipal, der den Benutzer identifiziert, wenn die Authentifizierung erfolgreich ist, und ordnet ihn der Anforderung zu.

Am Ende dieser Verarbeitung erstellt das Modul, wenn es die Benutzeranmeldeinformationen erfolgreich abrufen und überprüfen konnte, eine authentifizierte Benutzeridentität, die andere Module und der Anwendungscode später in Zugriffsentscheidungen verwenden. Beispielsweise untersucht das URL-Autorisierungsmodul den Benutzer im nächsten Pipelineereignis, um die von der Anwendung konfigurierten Autorisierungsregeln zu erzwingen.

IssueAuthenticationChallenge()

Implementieren Sie die IssueAuthenticationChallenge-Methode . Diese Methode führt die folgenden Aktionen aus:

• Überprüfen Sie den Antwortstatuscode, um festzustellen, ob diese Anforderung abgelehnt wurde.
• Geben Sie in diesem Fall einen Abfrageheader für die Standardauthentifizierung an die Antwort aus, um den Client zur Authentifizierung auszulösen.

Hilfsmethoden

Implementieren Sie die vom Modul verwendeten Hilfsmethoden, einschließlich:

• ExtractBasicAuthenticationCredentials. Diese Methode extrahiert die Grundanmeldeinformationen aus dem Header der Autorisierungsanfrage, laut dem Standardauthentifizierungsschema.
• ValidateCredentials. Diese Methode versucht, Benutzeranmeldeinformationen mithilfe der Mitgliedschaft zu überprüfen. Die Mitgliedschafts-API abstrahiert den zugrunde liegenden Anmeldeinformationsspeicher und ermöglicht die Konfiguration der Implementierungen des Anmeldeinformationsspeichers durch Hinzufügen/Entfernen von Mitgliedschaftsanbietern über die Konfiguration.

Aufgabe 2: Bereitstellen des Moduls in der Anwendung

Nach dem Erstellen des Moduls in der ersten Aufgabe fügen wir es dann der Anwendung hinzu.

Bereitstellen für Anwendung

Stellen Sie zunächst das Modul in der Anwendung bereit. Hier haben Sie mehrere Optionen:

• Kopieren Sie die Quelldatei, die das Modul enthält, in das Verzeichnis "/App_Code " der Anwendung. Dies erfordert keine Kompilierung des Moduls . ASP.NET wird automatisch kompiliert und lädt den Modultyp, wenn die Anwendung gestartet wird. Speichern Sie diesen Quellcode einfach im Verzeichnis "/App_Code" Ihrer Anwendung als BasicAuthenticationModule.cs. Tun Sie dies, wenn Sie sich mit den anderen Schritten nicht wohl fühlen.

• Kompilieren Sie das Modul in eine Assembly, und legen Sie diese Assembly im Verzeichnis "/BIN " der Anwendung ab. Dies ist die typischste Option, wenn Dieses Modul nur für diese Anwendung verfügbar sein soll und Sie die Quelle des Moduls nicht mit Ihrer Anwendung versenden möchten. Kompilieren Sie die Modulquelldatei, indem Sie folgendes an einer Befehlszeilenaufforderung ausführen:

  <PATH_TO_FX_SDK>csc.exe /out:BasicAuthenticationModule.dll /target:library BasicAuthenticationModule.cs

  Dabei <PATH_TO_FX_SDK> handelt es sich um den Pfad zum .NET Framework SDK, das den CSC.EXE Compiler enthält.

• Kompilieren Sie das Modul in eine stark benannte Assembly, und registrieren Sie diese Assembly im GAC. Dies ist eine gute Option, wenn Sie möchten, dass mehrere Anwendungen auf Ihrem Computer dieses Modul verwenden. Weitere Informationen zum Erstellen stark benannter Assemblys finden Sie unter Erstellen und Verwenden von assemblys mit starkem Namen.

Bevor Sie Konfigurationsänderungen in der web.config-Datei der Anwendung vornehmen, müssen wir einige der Konfigurationsabschnitte entsperren, die standardmäßig auf Serverebene gesperrt sind. Führen Sie das Folgende über eine erhöhte Eingabeaufforderung aus (Klicken > Sie mit der rechten Maustaste auf Cmd.exe und wählen Sie "Als Administrator ausführen"):

%windir%\system32\inetsrv\APPCMD.EXE unlock config /section:windowsAuthentication
%windir%\system32\inetsrv\APPCMD.EXE unlock config /section:anonymousAuthentication

Nachdem Sie diese Befehle ausgeführt haben, können Sie diese Konfigurationsabschnitte in der web.config Datei Ihrer Anwendung definieren.

Konfigurieren Sie Ihr Modul so, dass es in der Anwendung ausgeführt wird. Erstellen Sie zunächst eine neue web.config Datei, die die zum Aktivieren und Verwenden des neuen Moduls erforderliche Konfiguration enthält. Fügen Sie zunächst den folgenden Text hinzu, und speichern Sie ihn im Stammverzeichnis Ihrer Anwendung (%systemdrive%\inetpub\wwwroot\web.config wenn Sie die Stammanwendung auf der Standardwebsite verwenden).

<configuration> 
    <system.webServer> 
        <modules> 
        </modules> 
        <security> 
            <authentication> 
                <windowsAuthentication enabled="false"/> 
                <anonymousAuthentication enabled="false"/> 
            </authentication> 
        </security> 
    </system.webServer> 
</configuration>

Deaktivieren Sie vor dem Aktivieren des neuen Standardauthentifizierungsmoduls alle anderen IIS-Authentifizierungsmodule. Standardmäßig sind nur die Windows-Authentifizierung und die anonyme Authentifizierung aktiviert. Da der Browser nicht versuchen soll, mit Ihren Windows-Anmeldeinformationen zu authentifizieren oder anonyme Benutzer zuzulassen, deaktivieren wir sowohl das Windows-Authentifizierungsmodul als auch das Modul "Anonyme Authentifizierung".

Aktivieren Sie nun das Modul, indem Sie es zur Liste der module hinzufügen, die von unserer Anwendung geladen wurden. Öffnen Sie web.config erneut, und fügen Sie den Eintrag in das <modules> Tag ein.

<add name="MyBasicAuthenticationModule" type="IIS7Demos.BasicAuthenticationModule" />

Sie können das Modul auch mithilfe des IIS-Verwaltungstools oder des APPCMD.EXE Befehlszeilentools bereitstellen.

Der endgültige Inhalt der web.config Datei der Anwendung, nachdem diese Änderungen in Anhang B angegeben wurden.

Herzlichen Glückwunsch, Sie haben die Konfiguration des benutzerdefinierten Standardauthentifizierungsmoduls abgeschlossen.

Probieren Sie es aus! Öffnen Sie Internet Explorer, und stellen Sie eine Anforderung an die Anwendung unter der folgenden URL:

http://localhost/

Das Anmeldedialogfeld für die Standardauthentifizierung sollte angezeigt werden. Geben Sie "test" in das Feld "Benutzername:" und "Test" im Feld "Kennwort:" ein, um Zugriff zu erhalten. Beachten Sie, dass sie auch durch Ihr neues BasicAuthenticationModule geschützt werden, wenn Sie HTML, JPG oder andere Inhalte in Ihre Anwendung kopieren.

Zusammenfassung

In diesem Artikel haben Sie erfahren, wie Sie ein benutzerdefiniertes verwaltetes Modul für eine Anwendung entwickeln und bereitstellen und es diesem Modul ermöglichen, Dienste für alle Anforderungen an die Anwendung bereitzustellen.

Sie haben auch die Leistungsfähigkeit der Entwicklung von Serverkomponenten in verwaltetem Code erlebt. Dies ermöglichte die Entwicklung eines standardauthentifizierungsdiensts, der vom Windows-Anmeldeinformationsspeicher entkoppelt wird.

Wenn Sie abenteuerlustig sind, konfigurieren Sie dieses Modul, um die Leistungsfähigkeit der ASP.NET 2.0 Mitgliedschaftsanwendungsdienste zu nutzen, um austauschbare Anmeldeinformationsspeicher zu unterstützen. Weitere Informationen finden Sie in Anhang C.

Hier finden Sie viele Ressourcen und Tipps zum Schreiben von IIS-Modulen im Blog sowie http://www.mvolo.com/zum Herunterladen vorhandener IIS-Module für Ihre Anwendungen. Einige Beispiele finden Sie unter Umleitungsanforderungen an Ihre Anwendung mit dem HttpRedirection-Modul, schöne Verzeichnisauflistungen für Ihre IIS-Website mit DirectoryListingModule und Das Anzeigen von hübschen Dateisymbolen in Ihren ASP.NET Anwendungen mit IconHandler.

Anhang A: Quellcode des Standardauthentifizierungsmoduls

Speichern Sie diesen Quellcode als BasicAuthenticationModule.cs im Verzeichnis "/App_Code", um ihn schnell in Ihrer Anwendung bereitzustellen.

#region Using directives
using System;
using System.Collections;
using System.Text;
using System.Web;
using System.Web.Security;
using System.Security.Principal;
using System.IO;
#endregion
 
namespace IIS7Demos
{
    /// 
    /// This module performs basic authentication. 
    /// For details on basic authentication see RFC 2617. 
    /// 
    /// The basic operational flow is: 
    /// 
    ///     On AuthenticateRequest: 
    ///         extract the basic authentication credentials 
    ///         verify the credentials 
    ///         if succesfull, create the user principal with these credentials 
    /// 
    ///     On SendResponseHeaders: 
    ///         if the request is being rejected with an unauthorized status code (401), 
    ///         add the basic authentication challenge to trigger basic authentication. 
    ///       
    /// 

    public class BasicAuthenticationModule : IHttpModule
    {
        #region member declarations
        public const String     HttpAuthorizationHeader = "Authorization";  // HTTP1.1 Authorization header 
        public const String     HttpBasicSchemeName = "Basic"; // HTTP1.1 Basic Challenge Scheme Name 
        public const Char       HttpCredentialSeparator = ':'; // HTTP1.1 Credential username and password separator 
        public const int        HttpNotAuthorizedStatusCode = 401; // HTTP1.1 Not authorized response status code 
        public const String     HttpWWWAuthenticateHeader = "WWW-Authenticate"; // HTTP1.1 Basic Challenge Scheme Name 
        public const String     Realm = "demo"; // HTTP.1.1 Basic Challenge Realm 
        #endregion

        #region Main Event Processing Callbacks
        public void AuthenticateUser(Object source, EventArgs e)
        {
            HttpApplication application = (HttpApplication)source;
            HttpContext context = application.Context;
            String userName = null;
            String password = null;
            String realm = null;
            String authorizationHeader = context.Request.Headers[HttpAuthorizationHeader];

            // 
            //  Extract the basic authentication credentials from the request 
            // 
            if (!ExtractBasicCredentials(authorizationHeader, ref userName, ref password))
                return;
            // 
            // Validate the user credentials 
            // 
            if (!ValidateCredentials(userName, password, realm))
               return;

            // 
            // Create the user principal and associate it with the request 
            // 
            context.User = new GenericPrincipal(new GenericIdentity(userName), null);
        }

        public void IssueAuthenticationChallenge(Object source, EventArgs e)
        {
            HttpApplication application = (HttpApplication)source;
            HttpContext context = application.Context;

            // 
            // Issue a basic challenge if necessary 
            // 

            if (context.Response.StatusCode == HttpNotAuthorizedStatusCode)
            {
                context.Response.AddHeader(HttpWWWAuthenticateHeader, "Basic realm =\"" + Realm + "\"");
            }
        }
        #endregion

        #region Utility Methods
        protected virtual bool ValidateCredentials(String userName, String password, String realm)
        {
            // 
            //  Validate the credentials using Membership (refault provider) 
            // 
            // NOTE: Membership is commented out for clarity reasons.   
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
            // WARNING: DO NOT USE THE CODE BELOW IN PRODUCTION 
            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
            // return Membership.ValidateUser(userName, password); 
            if (userName.Equals("test") && password.Equals("test"))
            {
                return true;
            }
            else 
            {
                return false;
            }    
        }
      
        protected virtual bool ExtractBasicCredentials(String authorizationHeader, ref String username, ref String password)
        {
            if ((authorizationHeader == null) || (authorizationHeader.Equals(String.Empty)))
               return false;
            String verifiedAuthorizationHeader = authorizationHeader.Trim();
            if (verifiedAuthorizationHeader.IndexOf(HttpBasicSchemeName) != 0)     
                return false;

            // get the credential payload 
            verifiedAuthorizationHeader = verifiedAuthorizationHeader.Substring(HttpBasicSchemeName.Length, verifiedAuthorizationHeader.Length - HttpBasicSchemeName.Length).Trim();
           // decode the base 64 encoded credential payload 
            byte[] credentialBase64DecodedArray = Convert.FromBase64String(verifiedAuthorizationHeader);
            UTF8Encoding encoding = new UTF8Encoding();
            String decodedAuthorizationHeader = encoding.GetString(credentialBase64DecodedArray, 0, credentialBase64DecodedArray.Length);

            // get the username, password, and realm 
            int separatorPosition = decodedAuthorizationHeader.IndexOf(HttpCredentialSeparator);

           if (separatorPosition <= 0)
              return false;
            username = decodedAuthorizationHeader.Substring(0, separatorPosition).Trim();
           password = decodedAuthorizationHeader.Substring(separatorPosition + 1, (decodedAuthorizationHeader.Length - separatorPosition - 1)).Trim();

            if (username.Equals(String.Empty) || password.Equals(String.Empty))
               return false;

           return true;
        }
        #endregion

        #region IHttpModule Members
        public void Init(HttpApplication context)
        {
            // 
            // Subscribe to the authenticate event to perform the 
            // authentication. 
            // 
            context.AuthenticateRequest += new 
                               EventHandler(this.AuthenticateUser);
            // 
            // Subscribe to the EndRequest event to issue the 
            // challenge if necessary. 
            // 
            context.EndRequest += new 
                               EventHandler(this.IssueAuthenticationChallenge);
        }
        public void Dispose()
        {
            // 
            // Do nothing here 
            // 
        }
        #endregion

    }
}

Anhang B: Web.config für das Standardauthentifizierungsmodul

Speichern Sie diese Konfiguration als web.config Datei im Stamm ihrer Anwendung:

<configuration> 
    <system.webServer> 
      <modules> 
           <add name="MyBasicAuthenticationModule" type="IIS7Demos.BasicAuthenticationModule" /> 
      </modules> 
      <security> 
         <authentication> 
          <windowsAuthentication enabled="false"/> 
             <anonymousAuthentication enabled="false"/> 
         </authentication> 
      </security> 
    </system.webServer> 
</configuration>

Anhang C: Konfigurieren der Mitgliedschaft

Mit dem ASP.NET 2.0-Mitgliedschaftsdienst können Anwendungen schnell die Validierung von Anmeldeinformationen und die Benutzerverwaltung implementieren, die für die meisten Authentifizierungs- und Zugriffssteuerungsschemas erforderlich ist. Die Mitgliedschaft isoliert den Anwendungscode von der tatsächlichen Implementierung des Anmeldeinformationsspeichers und bietet eine Reihe von Optionen für die Integration in vorhandene Anmeldeinformationsspeicher.

Um die Mitgliedschaft für dieses Modulbeispiel nutzen zu können, kommentieren Sie den Aufruf von Membership.ValidateUser in der ValidateCredentials-Methode aus und konfigurieren Sie einen Mitgliedschafts-Provider für Ihre Anwendung. Weitere Informationen zum Konfigurieren der Mitgliedschaft finden Sie unter Configuring an ASP.NET Application to Use Membership.