Welcome to Software Development on Codidact!
Will you help us build our independent community of developers helping developers? We're small and trying to grow. We welcome questions about all aspects of software development, from design to code to QA and more. Got questions? Got answers? Got code you'd like someone to review? Please join us.
Post History
If you want to use a custom entity framework migration table, you can set it when configuring the database context as shown here: // this code belong to the database context class protected overr...
Answer
#4: Post edited
by
Alexei
·
2021-05-01T15:39:45Z (over 3 years ago)
- If you want to use a custom entity framework migration table, you can set it when configuring the database context as shown [here](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/history-table):
- ```
- // this code belong to the database context class
- protected override void OnConfiguring(DbContextOptionsBuilder options)
- => options.UseSqlServer(
- _connectionString,
- x => x.MigrationsHistoryTable("TheMigrations", "meta"));
- ```
- <hr>
<s>You are getting `dbo` schema for the created table, because this is the default schema for your login (used in the database connection string). There are two ways to configure the schema in a code-first project:[]()- 1. Using `TableAttribute`: `[Table(Schema="custom")] as indicated [here](https://www.entityframeworktutorial.net/code-first/table-dataannotations-attribute-in-code-first.aspx).
- 2. Using fluent API: `modelBuilder.HasDefaultSchema("custom");` as indicated [here](https://www.entityframeworktutorial.net/code-first/configure-entity-mappings-using-fluent-api.aspx).
Personally, I prefer to use data annotations (attributes) whenever possible (you can easily see the configuration by looking at the model, but not all configurations can be done like this), but some prefer the fluent API because it allows a separation between the schema itself and its configuration (keys, constraints, indexes, etc.).
- If you want to use a custom entity framework migration table, you can set it when configuring the database context as shown [here](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/history-table):
- ```
- // this code belong to the database context class
- protected override void OnConfiguring(DbContextOptionsBuilder options)
- => options.UseSqlServer(
- _connectionString,
- x => x.MigrationsHistoryTable("TheMigrations", "meta"));
- ```
- <hr>
- <s>You are getting `dbo` schema for the created table, because this is the default schema for your login (used in the database connection string). There are two ways to configure the schema in a code-first project: </s>
- <s>
- 1. Using `TableAttribute`: `[Table(Schema="custom")] as indicated [here](https://www.entityframeworktutorial.net/code-first/table-dataannotations-attribute-in-code-first.aspx).
- 2. Using fluent API: `modelBuilder.HasDefaultSchema("custom");` as indicated [here](https://www.entityframeworktutorial.net/code-first/configure-entity-mappings-using-fluent-api.aspx).
- </s>
- <s>
- Personally, I prefer to use data annotations (attributes) whenever possible (you can easily see the configuration by looking at the model, but not all configurations can be done like this), but some prefer the fluent API because it allows a separation between the schema itself and its configuration (keys, constraints, indexes, etc.).
- </s>
#3: Post edited
by
Alexei
·
2021-05-01T15:38:58Z (over 3 years ago)
fixed the old text
- If you want to use a custom entity framework migration table, you can set it when configuring the database context as shown [here](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/history-table):
- ```
- // this code belong to the database context class
- protected override void OnConfiguring(DbContextOptionsBuilder options)
- => options.UseSqlServer(
- _connectionString,
- x => x.MigrationsHistoryTable("TheMigrations", "meta"));
- ```
- <hr>
<s>You are getting `dbo` schema for the created table, because this is the default schema for your login (used in the database connection string). There are two ways to configure the schema in a code-first project:- 1. Using `TableAttribute`: `[Table(Schema="custom")] as indicated [here](https://www.entityframeworktutorial.net/code-first/table-dataannotations-attribute-in-code-first.aspx).
- 2. Using fluent API: `modelBuilder.HasDefaultSchema("custom");` as indicated [here](https://www.entityframeworktutorial.net/code-first/configure-entity-mappings-using-fluent-api.aspx).
Personally, I prefer to use data annotations (attributes) whenever possible (you can easily see the configuration by looking at the model, but not all configurations can be done like this), but some prefer the fluent API because it allows a separation between the schema itself and its configuration (keys, constraints, indexes, etc.). </s>
- If you want to use a custom entity framework migration table, you can set it when configuring the database context as shown [here](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/history-table):
- ```
- // this code belong to the database context class
- protected override void OnConfiguring(DbContextOptionsBuilder options)
- => options.UseSqlServer(
- _connectionString,
- x => x.MigrationsHistoryTable("TheMigrations", "meta"));
- ```
- <hr>
- <s>You are getting `dbo` schema for the created table, because this is the default schema for your login (used in the database connection string). There are two ways to configure the schema in a code-first project:[]()
- 1. Using `TableAttribute`: `[Table(Schema="custom")] as indicated [here](https://www.entityframeworktutorial.net/code-first/table-dataannotations-attribute-in-code-first.aspx).
- 2. Using fluent API: `modelBuilder.HasDefaultSchema("custom");` as indicated [here](https://www.entityframeworktutorial.net/code-first/configure-entity-mappings-using-fluent-api.aspx).
- Personally, I prefer to use data annotations (attributes) whenever possible (you can easily see the configuration by looking at the model, but not all configurations can be done like this), but some prefer the fluent API because it allows a separation between the schema itself and its configuration (keys, constraints, indexes, etc.).
#2: Post edited
by
Alexei
·
2021-05-01T15:38:15Z (over 3 years ago)
added response to the actual question
You are getting `dbo` schema for the created table, because this is the default schema for your login (used in the database connection string). There are two ways to configure the schema in a code-first project:- 1. Using `TableAttribute`: `[Table(Schema="custom")] as indicated [here](https://www.entityframeworktutorial.net/code-first/table-dataannotations-attribute-in-code-first.aspx).
- 2. Using fluent API: `modelBuilder.HasDefaultSchema("custom");` as indicated [here](https://www.entityframeworktutorial.net/code-first/configure-entity-mappings-using-fluent-api.aspx).
Personally, I prefer to use data annotations (attributes) whenever possible (you can easily see the configuration by looking at the model, but not all configurations can be done like this), but some prefer the fluent API because it allows a separation between the schema itself and its configuration (keys, constraints, indexes, etc.).
- If you want to use a custom entity framework migration table, you can set it when configuring the database context as shown [here](https://docs.microsoft.com/en-us/ef/core/managing-schemas/migrations/history-table):
- ```
- // this code belong to the database context class
- protected override void OnConfiguring(DbContextOptionsBuilder options)
- => options.UseSqlServer(
- _connectionString,
- x => x.MigrationsHistoryTable("TheMigrations", "meta"));
- ```
- <hr>
- <s>You are getting `dbo` schema for the created table, because this is the default schema for your login (used in the database connection string). There are two ways to configure the schema in a code-first project:
- 1. Using `TableAttribute`: `[Table(Schema="custom")] as indicated [here](https://www.entityframeworktutorial.net/code-first/table-dataannotations-attribute-in-code-first.aspx).
- 2. Using fluent API: `modelBuilder.HasDefaultSchema("custom");` as indicated [here](https://www.entityframeworktutorial.net/code-first/configure-entity-mappings-using-fluent-api.aspx).
- Personally, I prefer to use data annotations (attributes) whenever possible (you can easily see the configuration by looking at the model, but not all configurations can be done like this), but some prefer the fluent API because it allows a separation between the schema itself and its configuration (keys, constraints, indexes, etc.). </s>
#1: Initial revision
by
Alexei
·
2021-04-30T12:43:02Z (over 3 years ago)
You are getting `dbo` schema for the created table, because this is the default schema for your login (used in the database connection string). There are two ways to configure the schema in a code-first project:
1. Using `TableAttribute`: `[Table(Schema="custom")] as indicated [here](https://www.entityframeworktutorial.net/code-first/table-dataannotations-attribute-in-code-first.aspx).
2. Using fluent API: `modelBuilder.HasDefaultSchema("custom");` as indicated [here](https://www.entityframeworktutorial.net/code-first/configure-entity-mappings-using-fluent-api.aspx).
Personally, I prefer to use data annotations (attributes) whenever possible (you can easily see the configuration by looking at the model, but not all configurations can be done like this), but some prefer the fluent API because it allows a separation between the schema itself and its configuration (keys, constraints, indexes, etc.).