Make links to internal docs consistent

Resolves #2447

Author: smitpatel

entity-framework/core/get-started/index.md

@@ -50,7 +50,7 @@ cd EFGetStarted
 
 ## Install Entity Framework Core
 
-To install EF Core, you install the package for the EF Core database provider(s) you want to target. This tutorial uses SQLite because it runs on all platforms that .NET Core supports. For a list of available providers, see [Database Providers](../providers/index.md).
+To install EF Core, you install the package for the EF Core database provider(s) you want to target. This tutorial uses SQLite because it runs on all platforms that .NET Core supports. For a list of available providers, see [Database Providers](xref:core/providers/index).
 
 ### [.NET Core CLI](#tab/netcore-cli)
 
@@ -89,9 +89,9 @@ Define a context class and entity classes that make up the model.
 
 [!code-csharp[Main](../../../samples/core/GetStarted/Model.cs)]
 
-EF Core can also [reverse engineer](../managing-schemas/scaffolding.md) a model from an existing database.
+EF Core can also [reverse engineer](xref:core/managing-schemas/scaffolding) a model from an existing database.
 
-Tip: This application intentionally keeps things simple for clarity. [Connection strings](../miscellaneous/connection-strings.md) should not be stored in the code for production applications. You may also want to split each C# class into its own file.
+Tip: This application intentionally keeps things simple for clarity. [Connection strings](xref:core/miscellaneous/connection-strings) should not be stored in the code for production applications. You may also want to split each C# class into its own file.
 
 ## Create the database
 
@@ -108,7 +108,7 @@ The following steps use [migrations](xref:core/managing-schemas/migrations/index
   dotnet ef database update
   ```
 
-  This installs [dotnet ef](../miscellaneous/cli/dotnet.md) and the design package which is required to run the command on a project. The `migrations` command scaffolds a migration to create the initial set of tables for the model. The `database update` command creates the database and applies the new migration to it.
+  This installs [dotnet ef](xref:core/miscellaneous/cli/dotnet) and the design package which is required to run the command on a project. The `migrations` command scaffolds a migration to create the initial set of tables for the model. The `database update` command creates the database and applies the new migration to it.
 
 ### [Visual Studio](#tab/visual-studio)
 
@@ -120,7 +120,7 @@ The following steps use [migrations](xref:core/managing-schemas/migrations/index
   Update-Database
   ```
 
-  This installs the [PMC tools for EF Core](../miscellaneous/cli/powershell.md). The `Add-Migration` command scaffolds a migration to create the initial set of tables for the model. The `Update-Database` command creates the database and applies the new migration to it.
+  This installs the [PMC tools for EF Core](xref:core/miscellaneous/cli/powershell). The `Add-Migration` command scaffolds a migration to create the initial set of tables for the model. The `Update-Database` command creates the database and applies the new migration to it.
 
 ---
 

entity-framework/core/index.md

@@ -13,28 +13,28 @@ Entity Framework (EF) Core is a lightweight, extensible, [open source](https://g
 
 EF Core can serve as an object-relational mapper (O/RM), enabling .NET developers to work with a database using .NET objects, and eliminating the need for most of the data-access code they usually need to write.
 
-EF Core supports many database engines, see [Database Providers](providers/index.md) for details.
+EF Core supports many database engines, see [Database Providers](xref:core/providers/index) for details.
 
 ## The Model
 
-With EF Core, data access is performed using a model. A model is made up of entity classes and a context object that represents a session with the database, allowing you to query and save data. See [Creating a Model](modeling/index.md) to learn more.
+With EF Core, data access is performed using a model. A model is made up of entity classes and a context object that represents a session with the database, allowing you to query and save data. See [Creating a Model](xref:core/modeling/index) to learn more.
 
-You can generate a model from an existing database, hand code a model to match your database, or use [EF Migrations](managing-schemas/migrations/index.md) to create a database from your model, and then evolve it as your model changes over time.
+You can generate a model from an existing database, hand code a model to match your database, or use [EF Migrations](xref:core/managing-schemas/migrations/index) to create a database from your model, and then evolve it as your model changes over time.
 
 [!code-csharp[Main](../../samples/core/Intro/Model.cs)]
 
 ## Querying
 
-Instances of your entity classes are retrieved from the database using Language Integrated Query (LINQ). See [Querying Data](querying/index.md) to learn more.
+Instances of your entity classes are retrieved from the database using Language Integrated Query (LINQ). See [Querying Data](xref:core/querying/index) to learn more.
 
 [!code-csharp[Main](../../samples/core/Intro/Program.cs#Querying)]
 
 ## Saving Data
 
-Data is created, deleted, and modified in the database using instances of your entity classes. See [Saving Data](saving/index.md) to learn more.
+Data is created, deleted, and modified in the database using instances of your entity classes. See [Saving Data](xref:core/saving/index) to learn more.
 
 [!code-csharp[Main](../../samples/core/Intro/Program.cs#SavingData)]
 
 ## Next steps
 
-For introductory tutorials, see [Getting Started with Entity Framework Core](get-started/index.md).
+For introductory tutorials, see [Getting Started with Entity Framework Core](xref:core/get-started/index).

entity-framework/core/managing-schemas/ensure-created.md

@@ -8,7 +8,7 @@ uid: core/managing-schemas/ensure-created
 ---
 # Create and Drop APIs
 
-The EnsureCreated and EnsureDeleted methods provide a lightweight alternative to [Migrations](migrations/index.md) for managing the database schema. These methods are useful in scenarios when the data is transient and can be dropped when the schema changes. For example during prototyping, in tests, or for local caches.
+The EnsureCreated and EnsureDeleted methods provide a lightweight alternative to [Migrations](xref:core/managing-schemas/migrations/index) for managing the database schema. These methods are useful in scenarios when the data is transient and can be dropped when the schema changes. For example during prototyping, in tests, or for local caches.
 
 Some providers (especially non-relational ones) don't support Migrations. For these providers, EnsureCreated is often the easiest way to initialize the database schema.
 

entity-framework/core/managing-schemas/index.md

@@ -21,6 +21,6 @@ scaffold a DbContext and the entity type classes by reverse engineering your dat
 > The [create and drop APIs][3] can also create the database schema from your EF Core model. However, they are primarily
 > for testing, prototyping, and other scenarios where dropping the database is acceptable.
 
-  [1]: migrations/index.md
-  [2]: scaffolding.md
-  [3]: ensure-created.md
+  [1]: xref:core/managing-schemas/migrations/index
+  [2]: xref:core/managing-schemas/scaffolding
+  [3]: xref:core/managing-schemas/ensure-created

entity-framework/core/managing-schemas/migrations/providers.md

@@ -76,5 +76,5 @@ if (migrationBuilder.ActiveProvider == "Microsoft.EntityFrameworkCore.SqlServer"
 }
 ```
 
-  [1]: ../../miscellaneous/cli/index.md
-  [2]: projects.md
+  [1]: xref:core/miscellaneous/cli/index
+  [2]: xref:core/managing-schemas/migrations/projects

entity-framework/core/managing-schemas/scaffolding.md

@@ -150,9 +150,9 @@ Finally, the model is used to generate code. The corresponding entity type class
 
 ## Limitations
 
-* Not everything about a model can be represented using a database schema. For example, information about [**inheritance hierarchies**](../modeling/inheritance.md), [**owned types**](../modeling/owned-entities.md), and [**table splitting**](../modeling/table-splitting.md) are not present in the database schema. Because of this, these constructs will never be reverse engineered.
+* Not everything about a model can be represented using a database schema. For example, information about [**inheritance hierarchies**](xref:core/modeling/inheritance), [**owned types**](xref:core/modeling/owned-entities), and [**table splitting**](xref:core/modeling/table-splitting) are not present in the database schema. Because of this, these constructs will never be reverse engineered.
 * In addition, **some column types** may not be supported by the EF Core provider. These columns won't be included in the model.
-* You can define [**concurrency tokens**](../modeling/concurrency.md), in an EF Core model to prevent two users from updating the same entity at the same time. Some databases have a special type to represent this type of column (for example, rowversion in SQL Server) in which case we can reverse engineer this information; however, other concurrency tokens will not be reverse engineered.
+* You can define [**concurrency tokens**](xref:core/modeling/concurrency), in an EF Core model to prevent two users from updating the same entity at the same time. Some databases have a special type to represent this type of column (for example, rowversion in SQL Server) in which case we can reverse engineer this information; however, other concurrency tokens will not be reverse engineered.
 * [The C# 8 nullable reference type feature](/dotnet/csharp/tutorials/nullable-reference-types) is currently unsupported in reverse engineering: EF Core always generates C# code that assumes the feature is disabled. For example, nullable text columns will be scaffolded as a property with type `string` , not `string?`, with either the Fluent API or Data Annotations used to configure whether a property is required or not. You can edit the scaffolded code and replace these with C# nullability annotations. Scaffolding support for nullable reference types is tracked by issue [#15520](https://github.com/aspnet/EntityFrameworkCore/issues/15520).
 
 ## Customizing the model

entity-framework/core/miscellaneous/1x-2x-upgrade.md

@@ -125,7 +125,7 @@ Note that this change only applies to APIs/metadata that is defined for _all_ re
 
 ## Don’t take control of the EF service provider
 
-EF Core uses an internal `IServiceProvider` (a dependency injection container) for its internal implementation. Applications should allow EF Core to create and manage this provider except in special cases. Strongly consider removing any calls to `UseInternalServiceProvider`. If an application does need to call `UseInternalServiceProvider`, then please consider [filing an issue](https://github.com/aspnet/EntityFramework/Issues) so we can investigate other ways to handle your scenario.
+EF Core uses an internal `IServiceProvider` (a dependency injection container) for its internal implementation. Applications should allow EF Core to create and manage this provider except in special cases. Strongly consider removing any calls to `UseInternalServiceProvider`. If an application does need to call `UseInternalServiceProvider`, then please consider [filing an issue](https://github.com/dotnet/efcore/Issues) so we can investigate other ways to handle your scenario.
 
 Calling `AddEntityFramework`, `AddEntityFrameworkSqlServer`, etc. is not required by application code unless `UseInternalServiceProvider` is also called. Remove any existing calls to `AddEntityFramework` or `AddEntityFrameworkSqlServer`, etc. `AddDbContext` should still be used in the same way as before.
 

entity-framework/core/miscellaneous/cli/dotnet.md

@@ -11,7 +11,7 @@ uid: core/miscellaneous/cli/dotnet
 
 The command-line interface (CLI) tools for Entity Framework Core perform design-time development tasks. For example, they create [migrations](/aspnet/core/data/ef-mvc/migrations?view=aspnetcore-2.0), apply migrations, and generate code for a model based on an existing database. The commands are an extension to the cross-platform [dotnet](/dotnet/core/tools) command, which is part of the [.NET Core SDK](https://www.microsoft.com/net/core). These tools work with .NET Core projects.
 
-If you're using Visual Studio, we recommend the [Package Manager Console tools](powershell.md) instead:
+If you're using Visual Studio, we recommend the [Package Manager Console tools](xref:core/miscellaneous/cli/powershell) instead:
 
 * They automatically work with the current project selected in the **Package Manager Console** without requiring that you manually switch directories.
 * They automatically open files generated by a command after the command is completed.

entity-framework/core/miscellaneous/cli/index.md

@@ -12,15 +12,15 @@ uid: core/miscellaneous/cli/index
 The Entity Framework Core tools help with design-time development tasks. They're primarily used to manage Migrations and to scaffold a
 `DbContext` and entity types by reverse engineering the schema of a database.
 
-* The [EF Core Package Manager Console tools](powershell.md) run in
+* The [EF Core Package Manager Console tools](xref:core/miscellaneous/cli/powershell) run in
 the [Package Manager Console](/nuget/tools/package-manager-console) in Visual Studio.
 
-* The [EF Core .NET command-line interface (CLI) tools](dotnet.md) are an extension to the cross-platform [.NET Core CLI tools](/dotnet/core/tools/). These tools require a .NET Core SDK project (one with `Sdk="Microsoft.NET.Sdk"` or similar in the project file).
+* The [EF Core .NET command-line interface (CLI) tools](xref:core/miscellaneous/cli/dotnet) are an extension to the cross-platform [.NET Core CLI tools](/dotnet/core/tools/). These tools require a .NET Core SDK project (one with `Sdk="Microsoft.NET.Sdk"` or similar in the project file).
 
 Both tools expose the same functionality. If you're developing in Visual Studio, we recommend using the **Package Manager Console** tools since
 they provide a more integrated experience.
 
 ## Next steps
 
-* [EF Core Package Manager Console tools reference](powershell.md)
-* [EF Core .NET CLI tools reference](dotnet.md)
+* [EF Core Package Manager Console tools reference](xref:core/miscellaneous/cli/powershell)
+* [EF Core .NET CLI tools reference](xref:core/miscellaneous/cli/dotnet)

entity-framework/core/miscellaneous/cli/powershell.md

@@ -10,7 +10,7 @@ uid: core/miscellaneous/cli/powershell
 
 The Package Manager Console (PMC) tools for Entity Framework Core perform design-time development tasks. For example, they create [migrations](/aspnet/core/data/ef-mvc/migrations?view=aspnetcore-2.0), apply migrations, and generate code for a model based on an existing database. The commands run inside of Visual Studio using the [Package Manager Console](/nuget/tools/package-manager-console). These tools work with both .NET Framework and .NET Core projects.
 
-If you aren't using Visual Studio, we recommend the [EF Core Command-line Tools](dotnet.md) instead. The .NET Core CLI tools are cross-platform and run inside a command prompt.
+If you aren't using Visual Studio, we recommend the [EF Core Command-line Tools](xref:core/miscellaneous/cli/dotnet) instead. The .NET Core CLI tools are cross-platform and run inside a command prompt.
 
 ## Installing the tools
 

entity-framework/core/miscellaneous/configuring-dbcontext.md

@@ -190,4 +190,4 @@ Using dependency injection, this can be achieved by either registering the conte
 ## More reading
 
 - Read [Dependency Injection](/aspnet/core/fundamentals/dependency-injection) to learn more about using DI.
-- Read [Testing](testing/index.md) for more information.
+- Read [Testing](xref:core/miscellaneous/testing/index) for more information.

entity-framework/core/miscellaneous/rc1-rc2-upgrade.md

@@ -80,7 +80,7 @@ If you have RC1 code that passes an `IServiceProvider` to the context, this has
 
 ### Testing
 
-The most common scenario for doing this was to control the scope of an InMemory database when testing. See the updated [Testing](testing/index.md) article for an example of doing this with RC2.
+The most common scenario for doing this was to control the scope of an InMemory database when testing. See the updated [Testing](xref:core/miscellaneous/testing/index) article for an example of doing this with RC2.
 
 ### Resolving Internal Services from Application Service Provider (ASP.NET Core Projects Only)
 

entity-framework/core/modeling/backing-field.md

@@ -23,7 +23,7 @@ In the following sample, the `Url` property is configured to have `_url` as its
 
 [!code-csharp[Main](../../../samples/core/Modeling/Conventions/BackingField.cs#Sample)]
 
-Note that backing fields are only discovered for properties that are included in the model. For more information on which properties are included in the model, see [Including & Excluding Properties](included-properties.md).
+Note that backing fields are only discovered for properties that are included in the model. For more information on which properties are included in the model, see [Including & Excluding Properties](xref:core/modeling/entity-properties).
 
 You can also configure backing fields by using a Data Annotation (available in EFCore 5.0) or the Fluent API, e.g. if the field name doesn't correspond to the above conventions:
 
@@ -48,7 +48,7 @@ See the [PropertyAccessMode enum](/dotnet/api/microsoft.entityframeworkcore.prop
 
 ## Field-only properties
 
-You can also create a conceptual property in your model that does not have a corresponding CLR property in the entity class, but instead uses a field to store the data in the entity. This is different from [Shadow Properties](shadow-properties.md), where the data is stored in the change tracker, rather than in the entity's CLR type. Field-only properties are commonly used when the entity class uses methods instead of properties to get/set values, or in cases where fields shouldn't be exposed at all in the domain model (e.g. primary keys).
+You can also create a conceptual property in your model that does not have a corresponding CLR property in the entity class, but instead uses a field to store the data in the entity. This is different from [Shadow Properties](xref:core/modeling/shadow-properties), where the data is stored in the change tracker, rather than in the entity's CLR type. Field-only properties are commonly used when the entity class uses methods instead of properties to get/set values, or in cases where fields shouldn't be exposed at all in the domain model (e.g. primary keys).
 
 You can configure a field-only property by providing a name in the `Property(...)` API:
 

entity-framework/core/modeling/concurrency.md

@@ -9,7 +9,7 @@ uid: core/modeling/concurrency
 # Concurrency Tokens
 
 > [!NOTE]
-> This page documents how to configure concurrency tokens. See [Handling Concurrency Conflicts](../saving/concurrency.md) for a detailed explanation of how concurrency control works on EF Core and examples of how to handle concurrency conflicts in your application.
+> This page documents how to configure concurrency tokens. See [Handling Concurrency Conflicts](xref:core/saving/concurrency) for a detailed explanation of how concurrency control works on EF Core and examples of how to handle concurrency conflicts in your application.
 
 Properties configured as concurrency tokens are used to implement optimistic concurrency control.
 

entity-framework/core/modeling/constructors.md

@@ -211,8 +211,8 @@ Things to note:
 EF Core can also inject "services" into an entity type's constructor. For example, the following can be injected:
 
 * `DbContext` - the current context instance, which can also be typed as your derived DbContext type
-* `ILazyLoader` - the lazy-loading service--see the [lazy-loading documentation](../querying/related-data.md) for more details
-* `Action<object, string>` - a lazy-loading delegate--see the [lazy-loading documentation](../querying/related-data.md) for more details
+* `ILazyLoader` - the lazy-loading service--see the [lazy-loading documentation](xref:core/querying/related-data) for more details
+* `Action<object, string>` - a lazy-loading delegate--see the [lazy-loading documentation](xref:core/querying/related-data) for more details
 * `IEntityType` - the EF Core metadata associated with this entity type
 
 > [!NOTE]