Jak mogę zmienić nazwy tabel podczas korzystania z tożsamości ASP.NET?

Używam wersji (RTM, a nie RC) Visual Studio 2013 (pobranej z MSDN 2013-10-18), a zatem najnowszej (RTM) wersji AspNet.Identity. Kiedy tworzę nowy projekt internetowy, wybieram „Indywidualne konta użytkowników” do uwierzytelnienia. Spowoduje to utworzenie następujących tabel:

1. AspNetRoles
2. AspNetUserClaims
3. AspNetUserLogins
4. AspNetUserRoles
5. AspNetUsers

Kiedy rejestruję nowego użytkownika (przy użyciu domyślnego szablonu), te tabele (wymienione powyżej) są tworzone, a tabela AspNetUsers ma wstawiony rekord, który zawiera:

1. ID
2. Nazwa Użytkownika
3. PasswordHash
4. SecurityStamp
5. Dyskryminator

Dodatkowo, dodając właściwości publiczne do klasy „ApplicationUser” z powodzeniem dodałem dodatkowe pola do tabeli AspNetUsers, takie jak „FirstName”, „LastName”, „PhoneNumber” itp.

Oto moje pytanie. Czy istnieje sposób na zmianę nazw powyższych tabel (gdy są tworzone po raz pierwszy), czy zawsze będą one nazywać AspNetprzedrostkiem, jak wymieniłem powyżej? Jeśli nazwy tabel można nazwać inaczej, wyjaśnij, w jaki sposób.

-- AKTUALIZACJA --

Wdrożyłem rozwiązanie @Hao Kung. Tworzy nową tabelę (na przykład nazwałem ją MyUsers), ale nadal tworzy tabelę AspNetUsers. Celem jest zastąpienie tabeli „AspNetUsers” tabelą „MyUsers”. Zobacz kod poniżej i obraz bazy danych utworzonych tabel.

W rzeczywistości chciałbym zastąpić każdą AspNettabelę własną nazwą ... Na przykład MyRoles, MyUserClaims, MyUserLogins, MyUserRoles i MyUsers.

Jak to osiągnąć i skończyć z jednym zestawem tabel?

public class ApplicationUser : IdentityUser
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Address1 { get; set; }
    public string Address2 { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string PostalCode { get; set; }
    public string PhonePrimary { get; set; }
    public string PhoneSecondary { get; set; }
}

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext(): base("DefaultConnection")
    {
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<IdentityUser>().ToTable("MyUsers");
    }
}

- ODPOWIEDŹ NA AKTUALIZACJĘ -

Dzięki zarówno Hao Kungowi, jak i Peterowi Stulinskiemu. To rozwiązało mój problem ...

    protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        modelBuilder.Entity<IdentityUser>().ToTable("MyUsers").Property(p => p.Id).HasColumnName("UserId");
        modelBuilder.Entity<ApplicationUser>().ToTable("MyUsers").Property(p => p.Id).HasColumnName("UserId");
        modelBuilder.Entity<IdentityUserRole>().ToTable("MyUserRoles");
        modelBuilder.Entity<IdentityUserLogin>().ToTable("MyUserLogins");
        modelBuilder.Entity<IdentityUserClaim>().ToTable("MyUserClaims");
        modelBuilder.Entity<IdentityRole>().ToTable("MyRoles");
    }

Możesz to zrobić łatwo, modyfikując plik IdentityModel.cs zgodnie z poniższym opisem:

Zastąp OnModelCreating w swoim DbContext, a następnie dodaj następujące elementy, zmieni to tabelę AspNetUser na „Użytkownicy”. Możesz także zmienić nazwy pól, domyślna kolumna Id stanie się User_Id.

modelBuilder.Entity<IdentityUser>()
                    .ToTable("Users", "dbo").Property(p => p.Id).HasColumnName("User_Id");

lub po prostu poniżej, jeśli chcesz zachować wszystkie standardowe nazwy kolumn:

modelBuilder.Entity<IdentityUser>()
                        .ToTable("Users", "dbo")

Pełny przykład poniżej (powinien znajdować się w pliku IdentityModel.cs) zmieniłem klasę ApplicationUser na User.

public class User : IdentityUser
    {
        public string PasswordOld { get; set; }
        public DateTime DateCreated { get; set; }

        public bool Activated { get; set; }

        public bool UserRole { get; set; }

    }

public class ApplicationDbContext : IdentityDbContext<User>
    {
        public ApplicationDbContext()
            : base("DefaultConnection")
        {
        }

        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<IdentityUser>()
                .ToTable("Users", "dbo").Property(p => p.Id).HasColumnName("User_Id");
            modelBuilder.Entity<User>()
                .ToTable("Users", "dbo").Property(p => p.Id).HasColumnName("User_Id");
        }
    }

Uwaga: nie udało mi się uruchomić tej funkcji, jeśli istnieje bieżąca tabela. Zwróć także uwagę, że kolumny, których nie zamapujesz, zostaną utworzone domyślne.

Mam nadzieję, że to pomaga.

Poniżej znajduje się moje działające rozwiązanie:

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext()
        : base("DefaultConnection", throwIfV1Schema: false)
    {
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder); // This needs to go before the other rules!

        modelBuilder.Entity<ApplicationUser>().ToTable("User");
        modelBuilder.Entity<IdentityRole>().ToTable("Role");
        modelBuilder.Entity<IdentityUserRole>().ToTable("UserRole");
        modelBuilder.Entity<IdentityUserClaim>().ToTable("UserClaim");
        modelBuilder.Entity<IdentityUserLogin>().ToTable("UserLogin");
    }

    public static ApplicationDbContext Create()
    {
        return new ApplicationDbContext();
    }
}

Zobacz to po więcej szczegółów

Możesz spróbować zastąpić tę metodę w klasie DbContext, aby zamapować ją na wybraną tabelę:

    protected override void OnModelCreating(DbModelBuilder modelBuilder) {
        modelBuilder.Entity<IdentityUser>()
            .ToTable("AspNetUsers");

Możesz także utworzyć klasy konfiguracji i określić każdy szczegół każdej ze swoich klas tożsamości, na przykład:

using System.Data.Entity.ModelConfiguration;

public class ApplicationUserConfig : EntityTypeConfiguration<ApplicationUser>
{
    public UserConfig()
    {
        ToTable("Users");
        Property(u => u.LocationName).IsRequired();
    }
}

A następnie włącz te konfiguracje do metody OnModelCreating ():

protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        modelBuilder.Configurations.Add(new ApplicationUserConfig());
        ...
    }

To da ci pełną kontrolę nad każdym aspektem klas tożsamości.

Tylko w celu dokumentacji, dla tego, który przychodzi do tego postu na temat lat, które się pojawią w przyszłości (jak ja XD), Wszystkie odpowiedzi rezygnujące z mojego komentarza są prawidłowe, ale możesz po prostu zastosować tę metodę podaną przez Alexandru Bucur na jego blogu

         //But this method is not longer supported on netcore > 2.2, so I need to fix it
         foreach (var entityType in modelBuilder.Model.GetEntityTypes())
         {
            var table = entityType.Relational().TableName;
             if (table.StartsWith("AspNet"))
             {
                 entityType.Relational().TableName = table.Substring(6);
             }
         };

        //This is the functional way on NetCore > 2.2
        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
        {
            var tableName = entityType.GetTableName();
            if (tableName.StartsWith("AspNet"))
            {
                entityType.SetTableName(tableName.Substring(6));
            }
        }

Możemy zmienić domyślne nazwy tabel asp.net Identity w następujący sposób:

    public class ApplicationDbContext : IdentityDbContext
    {    
        public ApplicationDbContext(): base("DefaultConnection")
        {
        }

        protected override void OnModelCreating(System.Data.Entity.DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<IdentityUser>().ToTable("user");
            modelBuilder.Entity<ApplicationUser>().ToTable("user");

            modelBuilder.Entity<IdentityRole>().ToTable("role");
            modelBuilder.Entity<IdentityUserRole>().ToTable("userrole");
            modelBuilder.Entity<IdentityUserClaim>().ToTable("userclaim");
            modelBuilder.Entity<IdentityUserLogin>().ToTable("userlogin");
        }
    }

Ponadto możemy rozszerzyć każdą klasę i dodać dowolną właściwość do klas takich jak „IdentityUser”, „IdentityRole”, ...

    public class ApplicationRole : IdentityRole<string, ApplicationUserRole>
{
    public ApplicationRole() 
    {
        this.Id = Guid.NewGuid().ToString();
    }

    public ApplicationRole(string name)
        : this()
    {
        this.Name = name;
    }

    // Add any custom Role properties/code here
}


// Must be expressed in terms of our custom types:
public class ApplicationDbContext 
    : IdentityDbContext<ApplicationUser, ApplicationRole, 
    string, ApplicationUserLogin, ApplicationUserRole, ApplicationUserClaim>
{
    public ApplicationDbContext()
        : base("DefaultConnection")
    {
    }

    static ApplicationDbContext()
    {
        Database.SetInitializer<ApplicationDbContext>(new ApplicationDbInitializer());
    }

    public static ApplicationDbContext Create()
    {
        return new ApplicationDbContext();
    }

    // Add additional items here as needed
}

Aby zaoszczędzić czas, możemy użyć rozszerzalnego szablonu projektu AspNet Identity 2.0, aby rozszerzyć wszystkie klasy.

Ale to nie działa w .NET CORE (MVC 6), dlatego musimy zmienić powiązanie na

lubić

protected override void OnModelCreating(ModelBuilder builder)
{
    base.OnModelCreating(builder);

    builder.Entity<IdentityRole>().ToTable("Role");
    builder.Entity<IdentityUser>(entity => 
    {
        entity.ToTable("User");
        entity.Property(p => p.Id).HasColumnName("UserId");
    });
}

Może komuś pomóc :)