Freigeben über

Migrieren von Daten eines universellen Anbieters in Bezug auf Mitgliedschaften und Benutzerprofilen zu ASP.NET Identity (C#)

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

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

Mit der Veröffentlichung von Visual Studio 2013 hat das ASP.NET-Team ein neues ASP.NET Identity-System eingeführt. Weitere Informationen zu dieser Version finden Sie hier. 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 folgen, zum neuen Identitätsmodell. Der Schwerpunkt dieses Tutorials liegt hauptsächlich 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 verfolgte 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 und 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, um das Identitätssystem für die Benutzer- und Rollenverwaltung zu verwenden. Als Test der Migration sollten sich Benutzer, die mit Universelle Anbieter erstellt wurden, anmelden können, und neue Benutzer sollten in der Lage sein, sich zu registrieren.

Hinweis

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

Zusammenfassung der Profildatenmigration

Bevor Wir mit den Migrationen beginnen, sehen wir uns die Benutzeroberfläche zum Speichern von Profildaten im Anbietermodell an. Profildaten für Anwendungsbenutzer können auf verschiedene Arten gespeichert werden. Dies ist am häufigsten die Verwendung der integrierten Profilanbieter, die zusammen mit dem Universelle Anbieter ausgeliefert werden. Die Schritte umfassen

  1. Fügen Sie eine Klasse hinzu, die über Eigenschaften verfügt, 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 "Profiles" in der Datenbank gespeichert.

Nach der Migration der Anwendung zur Verwendung des neuen ASP.NET Identity-Systems werden die Profilinformationen deserialisiert und als Eigenschaften in der Benutzerklasse gespeichert. Jede Eigenschaft kann dann spalten in der Benutzertabelle zugeordnet werden. Der Vorteil hierbei besteht darin, dass die Eigenschaften direkt mithilfe der Benutzerklasse bearbeitet werden können, ohne dass dateninformationen bei jedem Zugriff serialisiert/deserialisiert werden müssen.

Erste Schritte

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

    Screenshot einer neu erstellten Web Forms-Anwendung in Visual Studio 2012 mithilfe der vorlage Web Forms

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

    Screenshot des neuen Ordners mit dem Namen Modelle, der zum Speichern von Profilinformationen erstellt wurde.

  3. Als Beispiel speichern wir das Geburtsdatum, den Ort, die Größe und die Gewichtung des Benutzers im Profil. Höhe und Gewicht werden als benutzerdefinierte Klasse namens "PersonalStats" gespeichert. Zum Speichern und Abrufen des Profils benötigen wir eine Klasse, die "ProfileBase" erweitert. Erstellen wir 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 Web Forms-Seite 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 Webformularseite mit master Seite "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 überprüfen, ob die Daten in der Tabelle "Profiles" als serialisierte XML-Datei gespeichert werden, indem Sie das Fenster Server Explorer verwenden. Wählen Sie in Visual Studio im Menü "Ansicht" die Option "Server Explorer" aus. Es sollte eine Datenverbindung für die in der web.config-Datei definierte Datenbank vorhanden sein. 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 Option "DefaultConnection", um die Tabellen anzuzeigen. Klicken Sie mit der rechten Maustaste auf Tabellen, und wählen Sie "Neue Abfrage" aus.

Screenshot: Aktualisieren des Schemas in der Identitätsdatenbank durch Auswählen von Neue Abfrage.

Fügen Sie das SQL-Skript aus ein https://raw.github.com/suhasj/UniversalProviders-Identity-Migrations/master/Migration.txt , und führen Sie es aus. Wenn "DefaultConnection" aktualisiert wird, sehen wir, 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 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 sind, und sie in das Identitätssystem einbinden. 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 für unser Beispiel einen benutzerdefinierten Benutzer 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 "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 verfügen über die verbleibenden Modellklassen und die neuen Seiten, die für die Benutzer- und Rollenverwaltung mithilfe der ASP.NET Identity-APIs benötigt werden. Der verwendete Ansatz ähnelt der SQL-Mitgliedschaft, und die ausführliche Erläuterung finden Sie hier.

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

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

Führen Sie code first-Migrationen für die Datenbank aus, um die Tabellen zu ändern.

Kopieren von Profildaten in die neuen Tabellen

Wie bereits erwähnt, müssen wir die XML-Daten in den Profiles-Tabellen deserialisieren und in den Spalten der Tabelle AspNetUsers speichern. Die neuen Spalten wurden im vorherigen Schritt in der Tabelle "users" erstellt, sodass sie nur noch mit den erforderlichen Daten aufgefüllt werden müssen. 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 beendenden Lösung.

    Screenshot: Erstellen 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 Projekt, dann auf "Verweise hinzufügen", dann auf Projektmappe, klicken Sie dann auf das Projekt und dann auf OK.

  4. Kopieren Sie den folgenden Code in die 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 für die 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. Geben Sie außerdem den vollständigen physischen Pfad in der Eigenschaft "AttachDbFilename" an.

  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 mit ASP.NET Identity implementiert wurden, um einen Benutzer aus der alten Datenbank anzumelden. Der Benutzer sollte sich mit den gleichen Anmeldeinformationen anmelden können. Testen 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.

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

Zusammenfassung

In diesem Artikel wurde der Prozess der Migration von Webanwendungen beschrieben, die das Anbietermodell für die Mitgliedschaft in ASP.NET Identity verwendet haben. Im Artikel wurden außerdem die Migration von Profildaten für Benutzer beschrieben, die in das Identitätssystem eingebunden werden sollen. Bitte hinterlassen Sie kommentare unten bei Fragen und Problemen, die bei der Migration Ihrer App auftreten.

Vielen Dank an Rick Anderson und Robert McMurray für die Überprüfung des Artikels.