CristGuard

C#

How can I change the table names when using ASPNET Identity

19 September 2026 · 12 min read

How can I change the table names when using ASPNET Identity

ASP.NET Identity provides a robust and flexible framework for managing user authentication and authorization in your web applications. By default, ASP.NET Identity creates a set of tables with predefined names such as AspNetUsers, AspNetRoles, and AspNetUserLogins. However, in many real-world scenarios, you might want to customize these table names to align with your existing database schema, coding conventions, or organizational standards. Learning how to change the table names when using ASP.NET Identity is crucial for maintaining consistency and control over your database design. This process allows you to tailor the framework to your specific needs, ensuring seamless integration and improved maintainability of your application. Properly configuring table names also enhances security by obfuscating the default table structure, making it slightly more difficult for malicious actors to understand the application’s database architecture. This guide will walk you through the steps and considerations involved in renaming these tables, ensuring you maintain a clean and efficient database.

Understanding the Default ASP.NET Identity Table Structure

ASP.NET Identity uses a predefined schema consisting of several tables to manage user accounts, roles, claims, and logins. The default table names are AspNetUsers (for user information), AspNetRoles (for roles), AspNetUserRoles (for associating users with roles), AspNetUserLogins (for external logins), and AspNetUserClaims (for user claims). These tables are created automatically when you first initialize the ASP.NET Identity system in your application. Understanding this default structure is the first step towards customizing it. Knowing what each table stores and how they relate to each other is crucial when planning your modifications. Renaming these tables can help you better organize your database and ensure it aligns with your project’s naming conventions. Furthermore, customizing the table names can be a small step in improving your application’s overall security posture by masking the default schema.

The default table names are convenient for quick setup and prototyping, but they might not be suitable for larger, more complex applications. For example, an organization might have established naming conventions that require all tables to be prefixed with a specific identifier or to follow a specific naming pattern. In such cases, renaming the ASP.NET Identity tables becomes necessary. Moreover, some database administrators prefer to use more descriptive names that clearly indicate the purpose of each table. This improves readability and maintainability, especially when multiple developers are working on the same project. Ignoring these conventions can lead to inconsistencies, making it harder to manage and maintain the database over time. Therefore, understanding and customizing the default structure is essential for building robust and maintainable ASP.NET applications.

It’s important to note that simply renaming the tables in the database management system (DBMS) without updating the ASP.NET Identity configuration will lead to errors. The framework relies on these default names to function correctly. Therefore, you need to update the configuration settings to reflect the new table names. We will cover the detailed steps on how to achieve this in the following sections. Changing the table names when using ASP.NET Identity is a straightforward process once you understand the underlying configuration and the required code modifications. For example, you might want to rename AspNetUsers to Users, and AspNetRoles to Roles for improved clarity.

Steps to Customize ASP.NET Identity Table Names

Customizing the table names in ASP.NET Identity involves several steps, including modifying the ApplicationDbContext class and updating the entity configurations. This process allows you to map your custom table names to the corresponding entities used by ASP.NET Identity. Here’s a detailed guide on how to accomplish this:

  1. Create a Custom ApplicationDbContext: If you haven’t already, create a custom class that inherits from IdentityDbContext. This class will serve as your data context for ASP.NET Identity.
  2. Override the OnModelCreating Method: In your custom ApplicationDbContext class, override the OnModelCreating method. This method is called when the model is being created and allows you to configure the entities.
  3. Configure Entity Mappings: Within the OnModelCreating method, use the ToTable() method to map each entity to your desired table name. For example, modelBuilder.Entity().ToTable(“Users”); would rename the AspNetUsers table to Users.
  4. Repeat for All Entities: Repeat step 3 for all the ASP.NET Identity entities you want to rename, including IdentityRole, IdentityUserLogin, IdentityUserRole, and IdentityUserClaim.
  5. Update Connection String: Ensure your connection string in the appsettings.json or Web.config file is correctly configured to point to your database.
  6. Apply Migrations: After making these changes, you need to create and apply migrations to update your database schema. Use the Entity Framework Core migration commands in the Package Manager Console or .NET CLI.

By following these steps, you can effectively customize the table names used by ASP.NET Identity. Remember to test your application thoroughly after making these changes to ensure everything is working as expected. Incorrectly configured table names can lead to runtime errors and authentication issues. This customization provides better control over your database schema, aligning it with your project’s requirements. Remember to keep a backup of your database before applying any migrations, as schema changes can be risky. It’s also good practice to document these changes in your project’s documentation for future reference.

For example, consider a scenario where you want to rename all ASP.NET Identity tables to include a prefix “App”. You would modify the OnModelCreating method as follows: modelBuilder.Entity().ToTable(“AppUsers”);, modelBuilder.Entity().ToTable(“AppRoles”);, and so on. This ensures that all the ASP.NET Identity tables are prefixed with “App”, making it easier to identify them within your database. Furthermore, this can help avoid naming conflicts with other tables in your database. Remember to update your application’s configuration and apply the necessary migrations after making these changes.

Code Examples and Configuration Details

To illustrate the process of changing the table names when using ASP.NET Identity, let’s look at some code examples and configuration details. This will provide a clearer understanding of how to implement the changes in your ASP.NET application. The following code snippet shows how to override the OnModelCreating method in your custom ApplicationDbContext:

csharp public class ApplicationDbContext : IdentityDbContext { public ApplicationDbContext(DbContextOptions options) : base(options) { } protected override void OnModelCreating(ModelBuilder modelBuilder) { base.OnModelCreating(modelBuilder); modelBuilder.Entity().ToTable(“Users”); modelBuilder.Entity().ToTable(“Roles”); modelBuilder.Entity>().ToTable(“UserRoles”); modelBuilder.Entity>().ToTable(“UserClaims”); modelBuilder.Entity>().ToTable(“UserLogins”); modelBuilder.Entity>().ToTable(“UserTokens”); } } In this example, we are renaming the AspNetUsers table to Users, the AspNetRoles table to Roles, and so on. The IdentityUserRole, IdentityUserClaim, and IdentityUserLogin tables are also renamed to more descriptive names. This code snippet should be placed within your custom ApplicationDbContext class. The base.OnModelCreating(modelBuilder); line is crucial because it calls the base class’s OnModelCreating method, which performs the default configurations for ASP.NET Identity. Without this line, the default configurations will not be applied, and your application might not function correctly. Remember to include the necessary using statements for the Microsoft.EntityFrameworkCore and Microsoft.AspNetCore.Identity namespaces.

After modifying the ApplicationDbContext class, you need to create and apply migrations. Open the Package Manager Console and run the following commands: Add-Migration “RenameTables” and Update-Database. These commands will create a new migration and apply it to your database, updating the table names according to your configuration. Before applying the migrations, it’s always a good practice to review the migration script to ensure that it’s doing what you expect. The migration script will contain the SQL commands to rename the tables. You can also customize the migration script if needed. It’s also important to ensure that your database connection string is correctly configured in your appsettings.json or Web.config file. An incorrect connection string can lead to errors when applying the migrations.

Best Practices and Considerations

When changing the table names when using ASP.NET Identity, there are several best practices and considerations to keep in mind to ensure a smooth and successful implementation. Following these guidelines will help you avoid common pitfalls and maintain a robust and maintainable application.

  • Backup Your Database: Always back up your database before making any schema changes. This will allow you to restore your database to its previous state if something goes wrong.
  • Test Thoroughly: After applying the migrations, test your application thoroughly to ensure that all authentication and authorization functionalities are working as expected.
  • Document Your Changes: Document the changes you’ve made to the table names in your project’s documentation. This will help other developers understand the changes and maintain the application in the future.

One important consideration is the impact on existing data. If you are renaming tables in an existing application with data, you need to ensure that the data is migrated correctly to the new tables. Entity Framework Core migrations can handle this automatically, but it’s important to review the migration script to ensure that the data is being migrated correctly. For example, if you are renaming a column, you need to ensure that the data in the old column is copied to the new column. Another consideration is the performance impact of renaming tables. Renaming tables can cause database indexes to be rebuilt, which can take time. It’s important to monitor the performance of your application after renaming the tables to ensure that there are no performance issues. According to Microsoft documentation, proper indexing can improve query performance by up to 50% Microsoft SQL Server Index Design Guide. Also, make sure to update any stored procedures, views, or functions that reference the old table names.

It is also a good practice to use consistent naming conventions throughout your database. This will make it easier to understand and maintain your database schema. For example, you might want to use a consistent prefix for all tables in your database. This can help avoid naming conflicts with other tables in your database. Furthermore, using descriptive names for your tables and columns can improve readability and maintainability. For example, instead of using a generic name like “ID”, you might want to use a more descriptive name like “UserID”. This will make it easier to understand the purpose of the column. It’s also important to choose names that are meaningful and easy to understand. Avoid using abbreviations or acronyms that might not be familiar to other developers. Remember, clear and concise naming conventions contribute significantly to the long-term maintainability of your application.

Here’s a featured snippet-optimized paragraph: You can change the table names in ASP.NET Identity by overriding the OnModelCreating method in your custom ApplicationDbContext class. Inside this method, use the ToTable() method to map each entity to your desired table name, like so: modelBuilder.Entity().ToTable(“Users”);. Repeat this for all ASP.NET Identity entities you want to rename, such as IdentityRole, IdentityUserLogin, IdentityUserRole, and IdentityUserClaim. Finally, create and apply migrations to update your database schema.

Infographic here
Troubleshooting Common Issues -----------------------------

While changing the table names when using ASP.NET Identity is generally straightforward, you might encounter some common issues. Understanding these issues and how to resolve them can save you time and frustration.

  • Migration Errors: If you encounter errors when creating or applying migrations, ensure that your connection string is correctly configured and that your database server is running. Also, check the migration script for any syntax errors or incorrect table names.
  • Runtime Errors: If you encounter runtime errors after applying the migrations, ensure that your application is using the correct ApplicationDbContext and that the table names in your code match the table names in your database.
  • Authentication Issues: If you encounter authentication issues, ensure that the user and role tables are correctly configured and that the user roles are being assigned correctly.

One common issue is forgetting to include the base.OnModelCreating(modelBuilder); line in your OnModelCreating method. This line is crucial because it calls the base class’s OnModelCreating method, which performs the default configurations for ASP.NET Identity. Without this line, the default configurations will not be applied, and your application might not function correctly. Another common issue is using incorrect table names in your code. Ensure that the table names in your code match the table names in your database. For example, if you renamed the AspNetUsers table to Users, you need to update your code to use the Users table instead of the AspNetUsers table. According to Stack Overflow, the most common reason for Question & Answer :

I am using the release version (RTM, not RC) of Visual Studio 2013 (downloaded from MSDN 2013-10-18) and therefore the latest (RTM) version of AspNet.Identity. When I create a new web project, I select “Individual User Accounts” for authentication. This creates the following tables:

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

When I register a new user (using the default template), these tables (listed above) are created and the AspNetUsers table has a record inserted which contains:

  1. Id
  2. UserName
  3. PasswordHash
  4. SecurityStamp
  5. Discriminator

Additionally, by adding public properties to the class “ApplicationUser” I have successfully added additional fields to the AspNetUsers table, such as “FirstName”, “LastName”, “PhoneNumber”, etc.

Here’s my question. Is there a way to change the names of the above tables (when they are first created) or will they always be named with the AspNet prefix as I listed above? If the table names can be named differently, please explain how.

– UPDATE –

I implemented @Hao Kung’s solution. It does create a new table (for example I called it MyUsers), but it also still creates the AspNetUsers table. The goal is to replace the “AspNetUsers” table with the “MyUsers” table. See code below and database image of tables created.

I would actually like to replace each AspNet table with my own name… For fxample, MyRoles, MyUserClaims, MyUserLogins, MyUserRoles, and MyUsers.

How do I accomplish this and end up with only one set of tables?

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"); } }

Database Tables

– UPDATE ANSWER –

Thanks to both Hao Kung and Peter Stulinski. This solved my 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"); }

You can do this easily by modifying the IdentityModel.cs as per the below:

Override OnModelCreating in your DbContext then add the following, this will change AspNetUser table to “Users” you can also change the field names the default Id column will become User_Id.

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

or simply the below if you want to keep all the standard column names:

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

Full example below (this should be in your IdentityModel.cs file) i changed my ApplicationUser class to be called 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"); } }

Please note i have not managed to get this working if the current table exists. Also note whatever columns you do not map the default ones will be created.