Freigeben über

Migrieren von Universellen Anbieterdaten für Mitgliedschafts- und Benutzerprofile zu ASP.NET Identity (C#)

von Pranav Rastogi, Rick Anderson, Robert McMurray, Suhas Joshi

In diesem Lernprogramm werden die Schritte beschrieben, die zum Migrieren von Benutzer- und Rollendaten und Benutzerprofildaten erforderlich sind, die mit universellen Anbietern einer vorhandenen Anwendung zum ASP.NET Identitätsmodell erstellt wurden. Der hier erwähnte Ansatz zum Migrieren von Benutzerprofildaten kann auch in einer Anwendung mit SQL-Mitgliedschaft verwendet werden.

Mit der Version von Visual Studio 2013 hat das ASP.NET Team ein neues ASP.NET Identity System eingeführt, und Sie können hier mehr über diese Version erfahren. Im Anschluss an den Artikel zum Migrieren von Webanwendungen von der SQL-Mitgliedschaft zum neuen Identitätssystem veranschaulicht dieser Artikel die Schritte zum Migrieren vorhandener Anwendungen, die dem Anbietermodell für die Benutzer- und Rollenverwaltung zum neuen Identitätsmodell folgen. Der Schwerpunkt dieses Lernprogramms liegt in erster Linie auf der Migration der Benutzerprofildaten, um sie nahtlos in das neue System zu integrieren. Das Migrieren von Benutzer- und Rolleninformationen ist für die SQL-Mitgliedschaft ähnlich. Der Ansatz zum Migrieren von Profildaten kann auch in einer Anwendung mit SQL-Mitgliedschaft verwendet werden.

Als Beispiel beginnen wir mit einer Web-App, die mit Visual Studio 2012 erstellt wurde, die das Anbietermodell verwendet. Anschließend fügen wir Code für die Profilverwaltung hinzu, registrieren einen Benutzer, fügen Profildaten für die Benutzer hinzu, migrieren das Datenbankschema und ändern dann die Anwendung so, dass das Identitätssystem für die Benutzer- und Rollenverwaltung verwendet wird. Als Test der Migration sollten benutzer, die mit universellen Anbietern erstellt wurden, sich anmelden können, und neue Benutzer sollten sich registrieren können.

Hinweis

Das vollständige Beispiel finden Sie unter https://github.com/suhasj/UniversalProviders-Identity-Migrations.

Zusammenfassung der Profildatenmigration

Bevor wir mit den Migrationen beginnen, betrachten wir die Erfahrung beim Speichern von Profildaten im Anbietermodell. Profildaten für Anwendungsbenutzer können auf mehrere Arten gespeichert werden, wobei sie am häufigsten die integrierten Profilanbieter verwenden, die zusammen mit den universellen Anbietern ausgeliefert werden. Die Schritte würden umfassen

  1. Fügen Sie eine Klasse mit Eigenschaften hinzu, die zum Speichern von Profildaten verwendet werden.
  2. Fügen Sie eine Klasse hinzu, die "ProfileBase" erweitert und Methoden implementiert, um die oben genannten Profildaten für den Benutzer abzurufen.
  3. Aktivieren Sie die Verwendung von Standardprofilanbietern in der web.config-Datei , und definieren Sie die in Schritt 2 deklarierte Klasse für den Zugriff auf Profilinformationen.

Die Profilinformationen werden als serialisierte XML- und Binärdaten in der Tabelle "Profile" in der Datenbank gespeichert.

Nach der Migration der Anwendung zur Verwendung des neuen ASP.NET Identity-Systems werden die Profilinformationen deserialisiert und als Eigenschaften der Benutzerklasse gespeichert. Jede Eigenschaft kann dann zu Spalten in der Benutzertabelle zugeordnet werden. Der Vorteil besteht hier darin, dass die Eigenschaften direkt mithilfe der Benutzerklasse bearbeitet werden können, zusätzlich dazu, dass Dateninformationen nicht bei jedem Zugriff serialisiert/deserialisiert werden müssen.

Erste Schritte

  1. Erstellen Sie eine neue ASP.NET 4.5-Webanwendung in Visual Studio 2012. Im aktuellen Beispiel wird die Webformularvorlage verwendet, Sie können aber auch MVC-Anwendung verwenden.

    Screenshot einer neu erstellten Webanwendung in Visual Studio 2012 mithilfe der Webformularvorlage.

  2. Erstellen eines neuen Ordners "Models" zum Speichern von Profilinformationen

    Screenshot des neuen Ordners namens

  3. Lassen Sie uns beispielsweise das Geburtsdatum, die Stadt, die Höhe und die Gewichtung des Benutzers im Profil speichern. Die Körpergröße und das Gewicht werden als benutzerdefinierte Klasse namens "PersonalStats" gespeichert. Zum Speichern und Abrufen des Profils benötigen wir eine Klasse, die "ProfileBase" erweitert. Erstellen wir nun eine neue Klasse "AppProfile", um Profilinformationen abzurufen und zu speichern.

    public class ProfileInfo
{
    public ProfileInfo()
    {
        UserStats = new PersonalStats();
    }
    public DateTime? DateOfBirth { get; set; }
    public PersonalStats UserStats { get; set; }
    public string City { get; set; }
}

public class PersonalStats
{
    public int? Weight { get; set; }
    public int? Height { get; set; }
}

public class AppProfile : ProfileBase
{
    public ProfileInfo ProfileInfo
    {
        get { return (ProfileInfo)GetPropertyValue("ProfileInfo"); }
    }
    public static AppProfile GetProfile()
    {
        return (AppProfile)HttpContext.Current.Profile;
    }
    public static AppProfile GetProfile(string userName)
    {
        return (AppProfile)Create(userName);
    }
}

  4. Aktivieren Sie das Profil in der web.config Datei. Geben Sie den Klassennamen ein, der zum Speichern/Abrufen von Benutzerinformationen verwendet werden soll, die in Schritt 3 erstellt wurden.

    <profile defaultProvider="DefaultProfileProvider" enabled="true"
    inherits="UniversalProviders_ProfileMigrations.Models.AppProfile">
  <providers>
    .....
  </providers>
</profile>

  5. Fügen Sie eine Webformularseite im Ordner "Konto" hinzu, um die Profildaten vom Benutzer abzurufen und zu speichern. Klicken Sie mit der rechten Maustaste auf das Projekt, und wählen Sie "Neues Element hinzufügen" aus. Fügen Sie eine neue Webformular-Seite mit der Masterseite "AddProfileData.aspx" hinzu. Kopieren Sie Folgendes im Abschnitt "MainContent":

    <h2> Add Profile Data for <%# User.Identity.Name %></h2>
<asp:Label Text="" ID="Result" runat="server" />
<div>
    Date of Birth:
    <asp:TextBox runat="server" ID="DateOfBirth"/>
</div>
<div>
    Weight:
    <asp:TextBox runat="server" ID="Weight"/>
</div>
<div>
    Height:
    <asp:TextBox runat="server" ID="Height"/>
</div>
<div>
    City:
    <asp:TextBox runat="server" ID="City"/>
</div>
<div>
    <asp:Button Text="Add Profile" ID="Add" OnClick="Add_Click" runat="server" />
</div>

    Fügen Sie den folgenden Code im CodeBehind hinzu:

    protected void Add_Click(object sender, EventArgs e)
{
    AppProfile profile = AppProfile.GetProfile(User.Identity.Name);
    profile.ProfileInfo.DateOfBirth = DateTime.Parse(DateOfBirth.Text);
    profile.ProfileInfo.UserStats.Weight = Int32.Parse(Weight.Text);
    profile.ProfileInfo.UserStats.Height = Int32.Parse(Height.Text);
    profile.ProfileInfo.City = City.Text;
    profile.Save();
}

    Fügen Sie den Namespace hinzu, unter dem die AppProfile-Klasse definiert ist, um die Kompilierungsfehler zu entfernen.

  6. Führen Sie die App aus, und erstellen Sie einen neuen Benutzer mit dem Benutzernamen "olduser". Navigieren Sie zur Seite "AddProfileData", und fügen Sie Profilinformationen für den Benutzer hinzu.

    Screenshot der Seite

Sie können mithilfe des Server-Explorer-Fensters überprüfen, ob die Daten als serialisierte XML in der Tabelle "Profile" gespeichert werden. Wählen Sie in Visual Studio im Menü "Ansicht" die Option "Server-Explorer" aus. Es sollte eine Datenverbindung für die datenbank vorhanden sein, die in der web.config-Datei definiert ist. Wenn Sie auf die Datenverbindung klicken, werden verschiedene Unterkategorien angezeigt. Erweitern Sie "Tabellen", um die verschiedenen Tabellen in Ihrer Datenbank anzuzeigen, klicken Sie dann mit der rechten Maustaste auf "Profile", und wählen Sie "Tabellendaten anzeigen" aus, um die in der Tabelle "Profile" gespeicherten Profildaten anzuzeigen.

Screenshot des Fensters

Screenshot der Datentabelle

Migrieren des Datenbankschemas

Damit die vorhandene Datenbank mit dem Identitätssystem funktioniert, müssen wir das Schema in der Identitätsdatenbank aktualisieren, um die Felder zu unterstützen, die wir der ursprünglichen Datenbank hinzugefügt haben. Dies kann mithilfe von SQL-Skripts erfolgen, um neue Tabellen zu erstellen und die vorhandenen Informationen zu kopieren. Erweitern Sie im Fenster "Server-Explorer" die 'DefaultConnection', um die Tabellen anzuzeigen. Klicken Sie mit der rechten Maustaste auf "Tabellen", und wählen Sie "Neue Abfrage" aus.

Screenshot der Aktualisierung des Schemas in der Identitätsdatenbank, indem Sie

Fügen Sie das SQL-Skript aus https://raw.github.com/suhasj/UniversalProviders-Identity-Migrations/master/Migration.txt , und führen Sie es aus. Wenn "DefaultConnection" aktualisiert wird, können wir sehen, dass die neuen Tabellen hinzugefügt werden. Sie können die Daten in den Tabellen überprüfen, um festzustellen, ob die Informationen migriert wurden.

Screenshot der aktualisierten Standardverbindung und der hinzugefügten neuen Tabellen.

Migrieren der Anwendung zur Verwendung ASP.NET Identity

  1. Installieren Sie die Nuget-Pakete, die für ASP.NET Identity erforderlich sind:

    • Microsoft.AspNet.Identity.EntityFramework
    • Microsoft.AspNet.Identity.Owin
    • Microsoft.Owin.Host.SystemWeb
    • Microsoft.Owin.Security.Facebook
    • Microsoft.Owin.Security.Google
    • Microsoft.Owin.Security.MicrosoftAccount
    • Microsoft.Owin.Security.Twitter

    Weitere Informationen zum Verwalten von Nuget-Paketen finden Sie hier.

  2. Um mit vorhandenen Daten in der Tabelle zu arbeiten, müssen wir Modellklassen erstellen, die den Tabellen wieder zugeordnet und im Identitätssystem eingebunden werden. Im Rahmen des Identitätsvertrags sollten die Modellklassen entweder die in der Identity.Core-DLL definierten Schnittstellen implementieren oder die vorhandene Implementierung dieser Schnittstellen erweitern, die in Microsoft.AspNet.Identity.EntityFramework verfügbar sind. Wir verwenden die vorhandenen Klassen für Rollen-, Benutzeranmeldungen und Benutzeransprüche. Wir müssen einen benutzerdefinierten Benutzer für unser Beispiel verwenden. Klicken Sie mit der rechten Maustaste auf das Projekt, und erstellen Sie den neuen Ordner "IdentityModels". Fügen Sie wie unten gezeigt eine neue "User"-Klasse hinzu:

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

namespace UniversalProviders_Identity_Migrations
{
    public class User : IdentityUser
    {
        public User()
        {
            CreateDate = DateTime.UtcNow;
            IsApproved = false;
            LastLoginDate = DateTime.UtcNow;
            LastActivityDate = DateTime.UtcNow;
            LastPasswordChangedDate = DateTime.UtcNow;
            Profile = new ProfileInfo();
        }

        public System.Guid ApplicationId { get; set; }
        public bool IsAnonymous { get; set; }
        public System.DateTime? LastActivityDate { get; set; }
        public string Email { get; set; }
        public string PasswordQuestion { get; set; }
        public string PasswordAnswer { get; set; }
        public bool IsApproved { get; set; }
        public bool IsLockedOut { get; set; }
        public System.DateTime? CreateDate { get; set; }
        public System.DateTime? LastLoginDate { get; set; }
        public System.DateTime? LastPasswordChangedDate { get; set; }
        public System.DateTime? LastLockoutDate { get; set; }
        public int FailedPasswordAttemptCount { get; set; }
        public System.DateTime? FailedPasswordAttemptWindowStart { get; set; }
        public int FailedPasswordAnswerAttemptCount { get; set; }
        public System.DateTime? FailedPasswordAnswerAttemptWindowStart { get; set; }
        public string Comment { get; set; }
        public ProfileInfo Profile { get; set; }
    }
}

    Beachten Sie, dass die 'ProfileInfo' jetzt eine Eigenschaft für die Benutzerklasse ist. Daher können wir die Benutzerklasse verwenden, um direkt mit Profildaten zu arbeiten.

Kopieren Sie die Dateien in den Ordnern IdentityModels und IdentityAccount aus der Downloadquelle ( https://github.com/suhasj/UniversalProviders-Identity-Migrations/tree/master/UniversalProviders-Identity-Migrations ). Diese weisen die verbleibenden Modellklassen und die neuen Seiten auf, die für die Benutzer- und Rollenverwaltung mithilfe der ASP.NET Identity-APIs erforderlich sind. Der verwendete Ansatz ähnelt der SQL-Mitgliedschaft und der detaillierten Erläuterung finden Sie hier.

Einige Befehle werden nicht unterstützt, wenn die App SQLite als Identitätsdatenspeicher verwendet. Aufgrund von Einschränkungen im Datenbankmodul Alter lösen Befehle die folgende Ausnahme aus:

"System.NotSupportedException: SQLite unterstützt diesen Migrationsvorgang nicht."

Verwenden Sie als Workaround Code First-Migrationen auf der Datenbank, um die Tabellen zu ändern.

Kopieren von Profildaten in die neuen Tabellen

Wie bereits erwähnt, müssen wir die XML-Daten in den Tabellen "Profile" deserialisieren und in den Spalten der AspNetUsers-Tabelle speichern. Die neuen Spalten wurden in der Benutzertabelle im vorherigen Schritt erstellt, sodass nur noch diese Spalten mit den erforderlichen Daten aufgefüllt werden. Dazu verwenden wir eine Konsolenanwendung, die einmal ausgeführt wird, um die neu erstellten Spalten in der Benutzertabelle aufzufüllen.

  1. Erstellen Sie eine neue Konsolenanwendung in der bestehenden Lösung.

    Screenshot des Erstellens einer neuen Konsolenanwendung in der beendenden Lösung.

  2. Installieren Sie die neueste Version des Entity Framework-Pakets.

  3. Fügen Sie die oben erstellte Webanwendung als Verweis auf die Konsolenanwendung hinzu. Klicken Sie dazu mit der rechten Maustaste auf das Projekt, dann auf 'Verweise hinzufügen', dann auf Lösung, klicken Sie auf das Projekt und dann auf 'OK'.

  4. Kopieren Sie den folgenden Code in der Program.cs-Klasse. Diese Logik liest Profildaten für jeden Benutzer, serialisiert sie als 'ProfileInfo'-Objekt und speichert sie wieder in der Datenbank.

    public class Program
{
    var dbContext = new ApplicationDbContext();
    foreach (var profile in dbContext.Profiles)
    {
        var stringId = profile.UserId.ToString();
        var user = dbContext.Users.Where(x => x.Id == stringId).FirstOrDefault();
        Console.WriteLine("Adding Profile for user:" + user.UserName);
        var serializer = new XmlSerializer(typeof(ProfileInfo));
        var stringReader = new StringReader(profile.PropertyValueStrings);
        var profileData = serializer.Deserialize(stringReader) as ProfileInfo;
        if (profileData == null)
        {
            Console.WriteLine("Profile data deserialization error for user:" + user.UserName);
        }
        else
        {
            user.Profile = profileData;
        }
    }
    dbContext.SaveChanges();
}

    Einige der verwendeten Modelle werden im Ordner "IdentityModels" des Webanwendungsprojekts definiert, daher müssen Sie die entsprechenden Namespaces einschließen.

  5. Der obige Code funktioniert in der Datenbankdatei im Ordner App_Data des Webanwendungsprojekts, das in den vorherigen Schritten erstellt wurde. Um darauf zu verweisen, aktualisieren Sie die Verbindungszeichenfolge in der app.config Datei der Konsolenanwendung mit der Verbindungszeichenfolge im web.config der Webanwendung. Stellen Sie außerdem den vollständigen physischen Pfad in der Eigenschaft "AttachDbFilename" bereit.

  6. Öffnen Sie eine Eingabeaufforderung, und navigieren Sie zum Ordner "Bin" der obigen Konsolenanwendung. Führen Sie die ausführbare Datei aus, und überprüfen Sie die Protokollausgabe, wie in der folgenden Abbildung dargestellt.

    Screenshot der ausführbaren Datei in der Eingabeaufforderung zum Ausführen und Überprüfen der Protokollausgabe.

  7. Öffnen Sie die Tabelle "AspNetUsers" im Server-Explorer, und überprüfen Sie die Daten in den neuen Spalten, die die Eigenschaften enthalten. Sie sollten mit den entsprechenden Eigenschaftswerten aktualisiert werden.

Überprüfen der Funktionalität

Verwenden Sie die neu hinzugefügten Mitgliedschaftsseiten, die mithilfe ASP.NET Identity implementiert werden, um einen Benutzer aus der alten Datenbank anzumelden. Der Benutzer sollte sich mit denselben Anmeldeinformationen anmelden können. Probieren Sie die anderen Funktionen wie das Hinzufügen von OAuth, das Erstellen eines neuen Benutzers, das Ändern eines Kennworts, das Hinzufügen von Rollen, das Hinzufügen von Benutzern zu Rollen usw. aus.

Die Profildaten für den alten Benutzer und die neuen Benutzer sollten in der Benutzertabelle abgerufen und gespeichert werden. Auf die alte Tabelle sollte nicht mehr verwiesen werden.

Fazit

Der Artikel beschreibt den Prozess der Migration von Webanwendungen, die das Anbietermodell für die Mitgliedschaft zu ASP.NET Identity verwendet haben. Der Artikel beschreibt außerdem die Migration von Profildaten, damit Benutzer in das Identitätssystem integriert werden können. Bitte hinterlassen Sie unten Kommentare zu Fragen und Problemen, die bei der Migration Ihrer App aufgetreten sind.

Vielen Dank an Rick Anderson und Robert McMurray für die Bewertung des Artikels.

  • Last updated on