ASP.NET Identity: Verwenden von MySQL-Speicher mit einem EntityFramework-MySQL-Anbieter (C#)

von Maurycy Markowski, Raquel Soares De Almeida, Robert McMurray

In diesem Tutorial erfahren Sie, wie Sie den Standarddatenspeichermechanismus für ASP.NET Identity durch EntityFramework (SQL-Clientanbieter) durch einen MySQL-Anbieter ersetzen.

Die folgenden Themen werden in diesem Tutorial behandelt:

• Erstellen einer MySQL-Datenbank in Azure
• Erstellen einer MVC-Anwendung mithilfe Visual Studio 2013 MVC-Vorlage
• Konfigurieren von EntityFramework für die Zusammenarbeit mit einem MySQL-Datenbankanbieter
• Ausführen der Anwendung zum Überprüfen der Ergebnisse

Am Ende dieses Tutorials verfügen Sie über eine MVC-Anwendung mit dem ASP.NET Identitätsspeicher, der eine MySQL-Datenbank verwendet, die in Azure gehostet wird.

Erstellen einer MySQL-Datenbank instance in Azure

1. Melden Sie sich beim Azure-Portal an.

2. Klicken Sie unten auf der Seite auf NEU , und wählen Sie dann STORE aus:

   

3. Wählen Sie im Assistenten Add-On auswählen die Option ClearDB MySQL-Datenbank aus, und klicken Sie dann unten im Frame auf den Pfeil Weiter :

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern.

4. Behalten Sie den Standardplan Free bei, ändern Sie den NAMEN in IdentityMySQLDatabase, wählen Sie die Region aus, die Ihnen am nächsten liegt, und klicken Sie dann unten im Frame auf den Pfeil Weiter :

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern.

5. Klicken Sie auf das Kontrollkästchen KAUFEN , um die Datenbankerstellung abzuschließen.

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern.

6. Nachdem die Datenbank erstellt wurde, können Sie sie auf der Registerkarte ADD-ONS im Verwaltungsportal verwalten. Um die Verbindungsinformationen für Ihre Datenbank abzurufen, klicken Sie unten auf der Seite auf VERBINDUNGSINFORMATIONEN :

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern.

7. Kopieren Sie die Verbindungszeichenfolge, indem Sie im Feld CONNECTIONSTRING auf die Schaltfläche kopieren klicken, und speichern Sie sie. Verwenden Sie diese Informationen weiter unten in diesem Tutorial für Ihre MVC-Anwendung:

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern.

Erstellen eines MVC-Anwendungsprojekts

Zum Ausführen der Schritte in diesem Abschnitt des Tutorials müssen Sie zuerst Visual Studio Express 2013 für Web oder Visual Studio 2013 installieren. Führen Sie nach der Installation von Visual Studio die folgenden Schritte aus, um ein neues MVC-Anwendungsprojekt zu erstellen:

1. Öffnen Sie Visual Studio 2103.

2. Klicken Sie auf der Startseite auf Neues Projekt, oder Sie können auf das Menü Datei und dann auf Neues Projekt klicken:

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern.

3. Wenn das Dialogfeld Neues Projekt angezeigt wird, erweitern Sie Visual C# in der Liste der Vorlagen, klicken Sie dann auf Web, und wählen Sie ASP.NET Webanwendung aus. Nennen Sie Ihr Projekt IdentityMySQLDemo , und klicken Sie dann auf OK:

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern. ]

4. Wählen Sie im Dialogfeld Neues ASP.NET Projekt die MVC-Vorlage mit den Standardoptionen aus. Dadurch werden einzelne Benutzerkonten als Authentifizierungsmethode konfiguriert. Klicken Sie auf OK:

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern. ]

Konfigurieren von EntityFramework für die Arbeit mit einer MySQL-Datenbank

Aktualisieren der Entity Framework-Assembly für Ihr Projekt

Die MVC-Anwendung, die aus der Visual Studio 2013-Vorlage erstellt wurde, enthält einen Verweis auf das EntityFramework 6.0.0-Paket. Seit der Veröffentlichung wurden jedoch Updates für diese Assembly vorgenommen, die erhebliche Leistungsverbesserungen enthalten. Führen Sie die folgenden Schritte aus, um diese neuesten Updates in Ihrer Anwendung zu verwenden.

1. Öffnen Sie Ihr MVC-Projekt in Visual Studio.

2. Klicken Sie auf Extras, dann auf NuGet-Paket-Manager, und klicken Sie dann auf Paket-Manager-Konsole:

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern. ]

3. Die Paket-Manager-Konsole wird im unteren Abschnitt von Visual Studio angezeigt. Geben Sie "Update-Package EntityFramework" ein, und drücken Sie die EINGABETASTE:

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern.

Installieren des MySQL-Anbieters für EntityFramework

Damit EntityFramework eine Verbindung mit der MySQL-Datenbank herstellen kann, müssen Sie einen MySQL-Anbieter installieren. Öffnen Sie hierzu die Paket-Manager-Konsole , geben Sie "Install-Package MySql.Data.Entity -Pre" ein, und drücken Sie dann die EINGABETASTE.

Hinweis

Dies ist eine Vorabversion der Assembly und kann daher Fehler enthalten. Sie sollten keine Vorabversion des Anbieters in der Produktion verwenden.

[Klicken Sie auf die folgende Abbildung, um sie zu erweitern.]

Vornehmen von Projektkonfigurationsänderungen an der Web.config-Datei für Ihre Anwendung

In diesem Abschnitt konfigurieren Sie Entity Framework für die Verwendung des soeben installierten MySQL-Anbieters, registrieren die MySQL-Anbieterfactory und fügen Ihre Verbindungszeichenfolge aus Azure hinzu.

Hinweis

Die folgenden Beispiele enthalten eine bestimmte Assemblyversion für MySql.Data.dll. Wenn sich die Assemblyversion ändert, müssen Sie die entsprechenden Konfigurationseinstellungen mit der richtigen Version ändern.

1. Öffnen Sie die Web.config-Datei für Ihr Projekt in Visual Studio 2013.

2. Suchen Sie die folgenden Konfigurationseinstellungen, die den Standarddatenbankanbieter und die Factory für Entity Framework definieren:

   <entityFramework>
     <defaultConnectionFactory
         type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
       <parameters>
         <parameter value="v11.0" />
       </parameters>
     </defaultConnectionFactory>
     <providers>
       <provider
         invariantName="System.Data.SqlClient"
         type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
     </providers>
   </entityFramework>
   

3. Ersetzen Sie diese Konfigurationseinstellungen durch folgendes, wodurch Entity Framework für die Verwendung des MySQL-Anbieters konfiguriert wird:

   <entityFramework>
     <providers>
       <provider invariantName="MySql.Data.MySqlClient"
         type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity"/> 
     </providers>
   </entityFramework>
   <system.data>
     <DbProviderFactories>
       <remove invariant="MySql.Data.MySqlClient"></remove>
       <add name="MySQL Data Provider"
         invariant="MySql.Data.MySqlClient"
         description=".Net Framework Data Provider for MySQL"
         type="MySql.Data.MySqlClient.MySqlClientFactory, MySql.Data, Version=6.7.2.0"/>
     </DbProviderFactories>
   </system.data>
   

4. Suchen Sie den <Abschnitt connectionStrings> , und ersetzen Sie ihn durch den folgenden Code, der die Verbindungszeichenfolge für Ihre MySQL-Datenbank definiert, die in Azure gehostet wird (beachten Sie, dass der ProviderName-Wert ebenfalls gegenüber dem ursprünglichen geändert wurde):

   <connectionStrings>
     <add name="DefaultConnection"
       providerName="MySql.Data.MySqlClient"
       connectionString="[Insert your ConnectionString from Azure here]"/>
   </connectionStrings>
   

Hinzufügen eines benutzerdefinierten MigrationsHistory-Kontexts

Entity Framework Code First verwendet eine MigrationsHistory-Tabelle , um Modelländerungen nachzuverfolgen und die Konsistenz zwischen dem Datenbankschema und dem konzeptionellen Schema sicherzustellen. Diese Tabelle funktioniert jedoch nicht standardmäßig für MySQL, da der Primärschlüssel zu groß ist. Um diese Situation zu beheben, müssen Sie die Schlüsselgröße für diese Tabelle verkleinern. Führen Sie dazu die folgenden Schritte aus:

1. Die Schemainformationen für diese Tabelle werden in einem HistoryContext erfasst, der wie jeder andere DbContext geändert werden kann. Fügen Sie dazu dem Projekt eine neue Klassendatei mit dem Namen MySqlHistoryContext.cs hinzu, und ersetzen Sie den Inhalt durch den folgenden Code:

   using System.Data.Common;
   using System.Data.Entity;
   using System.Data.Entity.Migrations.History;
    
   namespace IdentityMySQLDemo
   {
     public class MySqlHistoryContext : HistoryContext
     {
       public MySqlHistoryContext(
         DbConnection existingConnection,
         string defaultSchema)
       : base(existingConnection, defaultSchema)
       {
       }
    
       protected override void OnModelCreating(DbModelBuilder modelBuilder)
       {
         base.OnModelCreating(modelBuilder);
         modelBuilder.Entity<HistoryRow>().Property(h => h.MigrationId).HasMaxLength(100).IsRequired();
         modelBuilder.Entity<HistoryRow>().Property(h => h.ContextKey).HasMaxLength(200).IsRequired();
       }
     }
   }
   

2. Als Nächstes müssen Sie Entity Framework so konfigurieren, dass es den geänderten HistoryContext anstelle der Standardversion verwendet. Dies kann durch die Nutzung von codebasierten Konfigurationsfeatures erreicht werden. Fügen Sie dazu dem Projekt die neue Klassendatei MySqlConfiguration.cs hinzu, und ersetzen Sie den Inhalt durch:

   using System.Data.Entity;
    
   namespace IdentityMySQLDemo
   {
     public class MySqlConfiguration : DbConfiguration
     {
       public MySqlConfiguration()
       {
         SetHistoryContext(
         "MySql.Data.MySqlClient", (conn, schema) => new MySqlHistoryContext(conn, schema));
       }
     }
   }
   

Erstellen eines benutzerdefinierten EntityFramework-Initialisierers für ApplicationDbContext

Der in diesem Tutorial vorgestellte MySQL-Anbieter unterstützt derzeit keine Entity Framework-Migrationen. Daher müssen Sie Modellinitialisierer verwenden, um eine Verbindung mit der Datenbank herzustellen. Da in diesem Tutorial ein MySQL-instance in Azure verwendet wird, müssen Sie einen benutzerdefinierten Entity Framework-Initialisierer erstellen.

Hinweis

Dieser Schritt ist nicht erforderlich, wenn Sie eine Verbindung mit einer SQL Server instance in Azure herstellen oder eine lokal gehostete Datenbank verwenden.

Führen Sie die folgenden Schritte aus, um einen benutzerdefinierten Entity Framework-Initialisierer für MySQL zu erstellen:

1. Fügen Sie dem Projekt eine neue Klassendatei mit dem Namen MySqlInitializer.cs hinzu, und ersetzen Sie den Inhalt durch den folgenden Code:

   using IdentityMySQLDemo.Models;
   using System.Data.Entity;
   using System.Data.Entity.Infrastructure;
   using System.Linq;
   
   namespace IdentityMySQLDemo
   {
     public class MySqlInitializer : IDatabaseInitializer<ApplicationDbContext>
     {
       public void InitializeDatabase(ApplicationDbContext context)
       {
         if (!context.Database.Exists())
         {
           // if database did not exist before - create it
           context.Database.Create();
         }
         else
         {
           // query to check if MigrationHistory table is present in the database 
           var migrationHistoryTableExists = ((IObjectContextAdapter)context).ObjectContext.ExecuteStoreQuery<int>(
             "SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = 'IdentityMySQLDatabase' AND table_name = '__MigrationHistory'");
   
           // if MigrationHistory table is not there (which is the case first time we run) - create it
           if (migrationHistoryTableExists.FirstOrDefault() == 0)
           {
             context.Database.Delete();
             context.Database.Create();
           }
         }
       }
     }
   }
   

2. Öffnen Sie die Datei IdentityModels.cs für Ihr Projekt, das sich im Verzeichnis Models befindet, und ersetzen Sie den Inhalt durch folgendes:

   using Microsoft.AspNet.Identity.EntityFramework;
   using System.Data.Entity;
   
   namespace IdentityMySQLDemo.Models
   {
     // You can add profile data for the user by adding more properties to your ApplicationUser
     // class, please visit https://go.microsoft.com/fwlink/?LinkID=317594 to learn more.
     public class ApplicationUser : IdentityUser
     {
     }
   
     public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
     {
       static ApplicationDbContext()
       {
         Database.SetInitializer(new MySqlInitializer());
       }
   
       public ApplicationDbContext()
         : base("DefaultConnection")
       {
       }
     }
   }
   

Ausführen der Anwendung und Überprüfen der Datenbank

Nachdem Sie die Schritte in den vorherigen Abschnitten ausgeführt haben, sollten Sie Ihre Datenbank testen. Führen Sie dazu die folgenden Schritte aus:

1. Drücken Sie STRG+F5 , um die Webanwendung zu erstellen und auszuführen.

2. Klicken Sie oben auf der Seite auf die Registerkarte Registrieren :

   [Klicken Sie auf die folgende Abbildung, um es zu erweitern. ]

3. Geben Sie einen neuen Benutzernamen und ein neues Kennwort ein, und klicken Sie dann auf Registrieren:

   [Klicken Sie auf die folgende Abbildung, um sie zu erweitern. ]

4. An diesem Punkt werden die ASP.NET Identity-Tabellen in der MySQL-Datenbank erstellt, und der Benutzer wird registriert und bei der Anwendung angemeldet:

   [Klicken Sie auf die folgende Abbildung, um sie zu erweitern. ]

Installieren des MySQL Workbench-Tools zum Überprüfen der Daten

1. Installieren des MySQL Workbench-Tools über die MySQL-Downloadseite

2. Wählen Sie im Installations-Assistenten: Registerkarte Featureauswahl im Abschnitt Anwendungen die Option MySQL Workbench aus.

3. Starten Sie die App, und fügen Sie eine neue Verbindung mithilfe der Verbindungszeichenfolgendaten aus der Azure MySQL-Datenbank hinzu, die Sie zu Beginn dieses Tutorials erstellt haben.

4. Überprüfen Sie nach dem Herstellen der Verbindung die ASP.NET Identitätstabellen, die auf der IdentityMySQLDatabase erstellt wurden.

5. Sie sehen, dass alle erforderlichen ASP.NET Identity-Tabellen wie in der folgenden Abbildung dargestellt erstellt werden:

   [Klicken Sie auf die folgende Abbildung, um sie zu erweitern. ]

6. Überprüfen Sie die Tabelle aspnetusers auf instance, um nach den Einträgen zu suchen, während Sie neue Benutzer registrieren.

   [Klicken Sie auf die folgende Abbildung, um sie zu erweitern. ]