diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 51ce83bb10..e024b30d6f 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -34,7 +34,7 @@ This project includes several key products and libraries that facilitate SQL Ser
 ## 🛠️ Key Features
 - **Connectivity to SQL Server**: Provides robust and secure connections to SQL Server databases, using various authentication methods, such as Windows Authentication, SQL Server Authentication, and Entra ID authentication, e.g. `ActiveDirectoryIntegrated`, `ActiveDirectoryPassword`, `ActiveDirectoryServicePrincipal`,`ActiveDirectoryInteractive`, `ActiveDirectoryDefault`, and `ActiveDirectoryManagedIdentity`.
 - **Connection Resiliency**: Implements connection resiliency features to handle transient faults and network issues, ensuring reliable database connectivity.
-- **TLS Encryption**: Supports secure connections using TLS protocols to encrypt data in transit. Supports TLS 1.2 and higher, ensuring secure communication with SQL Server. Supported encryption modes are: 
+- **TLS Encryption**: Supports secure connections using TLS protocols to encrypt data in transit. Supports TLS 1.2 and higher, ensuring secure communication with SQL Server. Supported encryption modes are:
   - **Optional**: Encryption is used if available, but not required.
   - **Mandatory**: Encryption is mandatory for the connection.
   - **Strict**: Enforces strict TLS requirements, ensuring only secure connections are established.
@@ -123,7 +123,7 @@ When a new issue is created, follow these steps:
 - Ensure the PR passes all CI checks before merging.
 
 ### ✅ Closing Issues
-- Add a comment summarizing the fix and referencing the PR 
+- Add a comment summarizing the fix and referencing the PR
 
 ### ⚙️ Automating Workflows
 - Auto-label PRs based on folder paths (e.g., changes in `src/Microsoft.Data.SqlClient/src/` → `Area\SqlClient`, changes in `tests/` → `Area\Testing`) and whether they add new public APIs or introduce a breaking change.
diff --git a/.github/instructions/ado-pipelines.instructions.md b/.github/instructions/ado-pipelines.instructions.md
index 5dfd35a12c..9260a78b3d 100644
--- a/.github/instructions/ado-pipelines.instructions.md
+++ b/.github/instructions/ado-pipelines.instructions.md
@@ -49,7 +49,7 @@ Key parameters:
 - `runAlwaysEncryptedTests` — include AE test set; default `true`
 - `runLegacySqlTests` — include SQL Server 2016/2017 manual-test legs; default `true`
 - `debug` — enable debug output; default `false`
-- `dotnetVerbosity` — MSBuild verbosity; default `normal`
+- `dotnetVerbosity` — build verbosity; default `normal`
 
 ## Build Stage Order
 
diff --git a/.github/instructions/architecture.instructions.md b/.github/instructions/architecture.instructions.md
index e1578592fe..2fd30c9f55 100644
--- a/.github/instructions/architecture.instructions.md
+++ b/.github/instructions/architecture.instructions.md
@@ -49,7 +49,7 @@ The `netcore/` and `netfx/` directories are legacy artifacts from the old dual-p
 - `netcore/ref/` and `netfx/ref/` — **STILL ACTIVE**. Reference assemblies remain in these directories and define the public API surface for each target framework.
 
 ### OS Targeting with `TargetOs`
-The unified project uses a `TargetOs` MSBuild property to handle OS-specific compilation:
+The unified project uses a `TargetOs` build property to handle OS-specific compilation:
 
 ```xml
 <!-- Automatic OS detection -->
diff --git a/.github/instructions/testing.instructions.md b/.github/instructions/testing.instructions.md
index b5e7d28479..7c415c280e 100644
--- a/.github/instructions/testing.instructions.md
+++ b/.github/instructions/testing.instructions.md
@@ -115,7 +115,7 @@ The default test filter is defined in `build.proj` via `TestFilters`:
 ```xml
 <TestFilters Condition="'$(TestFilters)' == ''">category!=failing&amp;category!=flaky&amp;category!=interactive</TestFilters>
 ```
-This can be overridden via MSBuild property: `msbuild build.proj -t:TestSqlClientUnit -p:TestFilters="your_filter"`.
+This can be overridden via build property: `dotnet build build.proj -t:TestSqlClientUnit -p:TestFilters="your_filter"`.
 
 ### Test Attributes
 ```csharp
@@ -139,19 +139,19 @@ public void TestIntermittentlyFails() { ... }
 
 ## Running Tests
 
-### Using MSBuild (Recommended)
+### Using `build.proj` targets (Recommended)
 ```bash
 # Build and run all unit tests
-msbuild build.proj -t:TestSqlClientUnit
+dotnet build build.proj -t:TestSqlClientUnit
 
 # Run functional tests only
-msbuild build.proj -t:TestSqlClientFunctional
+dotnet build build.proj -t:TestSqlClientFunctional
 
 # Run manual tests for specific framework
-msbuild build.proj -t:TestSqlClientManual -p:TestFramework=net8.0
+dotnet build build.proj -t:TestSqlClientManual -p:TestFramework=net8.0
 
 # Run specific test set
-msbuild build.proj -t:TestSqlClientManual -p:TestSet=1
+dotnet build build.proj -t:TestSqlClientManual -p:TestSet=1
 ```
 
 ### Using dotnet CLI
@@ -325,7 +325,7 @@ AssertExtensions.ThrowsContains<SqlException>(() => action(), "expected message"
 
 ### Running with Coverage
 ```bash
-msbuild build.proj -t:TestSqlClientUnit -p:TestCodeCoverage=true
+dotnet build build.proj -t:TestSqlClientUnit -p:TestCodeCoverage=true
 ```
 
 ### Coverage Targets
@@ -335,16 +335,11 @@ msbuild build.proj -t:TestSqlClientUnit -p:TestCodeCoverage=true
 
 ## Debugging Tests
 
-### Visual Studio
+### IDE
 1. Set breakpoints in test code
-2. Right-click test → Debug Test
+2. Right-click test → Debug Test (or use CodeLens "Debug Test" link)
 3. Use Test Explorer for navigation
 
-### VS Code
-1. Configure C# extension
-2. Use CodeLens "Debug Test" link
-3. Attach to test process
-
 ### Command Line
 ```bash
 # Enable verbose output
diff --git a/.github/plans/apicompat-ref-assembly-validation.md b/.github/plans/apicompat-ref-assembly-validation.md
index b968dbf678..3ae4f0a46d 100644
--- a/.github/plans/apicompat-ref-assembly-validation.md
+++ b/.github/plans/apicompat-ref-assembly-validation.md
@@ -9,7 +9,7 @@ The comparison uses `Microsoft.DotNet.ApiCompat.Tool` in **strict mode**, which
 ## Usage
 
 ```
-dotnet msbuild build.proj /t:CompareRefAssemblies /p:BaselinePackageVersion=6.1.4
+dotnet build build.proj /t:CompareMdsRefAssemblies /p:BaselinePackageVersion=6.1.4
 ```
 
 - `BaselinePackageVersion` is **required** (no default). The user must specify which published package to compare against.
@@ -22,7 +22,7 @@ dotnet msbuild build.proj /t:CompareRefAssemblies /p:BaselinePackageVersion=6.1.
 
 Add an entry for version `9.0.200` alongside the existing `dotnet-coverage` entry. This enables `dotnet apicompat` after `dotnet tool restore`.
 
-### 2. Create `tools/targets/CompareRefAssemblies.targets`
+### 2. Create `tools/targets/CompareMdsRefAssemblies.targets`
 
 A single new file containing all properties, items, and targets (steps 3–11 below). Follows the naming convention of existing files like `GenerateMdsPackage.targets`.
 
@@ -85,7 +85,7 @@ Runs `<Exec Command="dotnet tool restore" WorkingDirectory="$(RepoRoot)" />`.
 - Preceded by `<Message Importance="high">` labelling each comparison
 - Uses item metadata to map `net462` to `$(LegacyNetFxRefDir)` and others to `$(LegacyNetCoreRefDir)`
 
-### 11. `CompareRefAssemblies` target (public entry point)
+### 11. `CompareMdsRefAssemblies` target (public entry point)
 
 - Declared with `DependsOnTargets="_RunRefApiCompat"`
 - Emits a final `<Message>` summarizing completion
@@ -95,12 +95,12 @@ Runs `<Exec Command="dotnet tool restore" WorkingDirectory="$(RepoRoot)" />`.
 Add one line after the existing `.targets` imports (after line 7):
 
 ```xml
-<Import Project="$(ToolsDir)targets\CompareRefAssemblies.targets" />
+<Import Project="$(ToolsDir)targets\CompareMdsRefAssemblies.targets" />
 ```
 
 ## Design Decisions
 
-- **Single new file** at `tools/targets/CompareRefAssemblies.targets` — only one `<Import>` line added to `build.proj`.
+- **Single new file** at `tools/targets/CompareMdsRefAssemblies.targets` — only one `<Import>` line added to `build.proj`.
 - **Internal targets prefixed with `_`** to signal they're not intended to be called directly.
 - **Strict mode** ensures API additions are also flagged — important for detecting accidental public surface changes during file reorganization.
 - **`ContinueOnError="ErrorAndContinue"`** on each apicompat `Exec` so all 8 comparisons run and all differences are reported together.
@@ -111,7 +111,7 @@ Add one line after the existing `.targets` imports (after line 7):
 ## Verification
 
 ```
-dotnet msbuild build.proj /t:CompareRefAssemblies /p:BaselinePackageVersion=6.1.4
+dotnet build build.proj /t:CompareMdsRefAssemblies /p:BaselinePackageVersion=6.1.4
 ```
 
 - Downloads 6.1.4 nupkg, builds both ref project variants, runs 8 comparisons (4 TFMs × 2 variants).
diff --git a/BUILDGUIDE.md b/BUILDGUIDE.md
index 16aa709fe5..a927945c05 100644
--- a/BUILDGUIDE.md
+++ b/BUILDGUIDE.md
@@ -1,3 +1,5 @@
+<!-- markdownlint-disable MD024 -->
+
 # Build Guide for Microsoft.Data.SqlClient and Related Packages
 
 This document provides details on how to build the Microsoft.Data.SqlClient package and the other related packages
@@ -6,9 +8,10 @@ contained within this repository.
 ## Prerequisites
 
 ### .NET SDK
+
 Projects in this repository require the .NET SDK to be installed in order to build. For the exact version required for
-building the current version, see [global.json](global.json). Downloads for .NET SDK can be found at:
-https://dotnet.microsoft.com/en-us/download/dotnet
+building the current version, see [global.json](global.json). Downloads for .NET SDK can be found at
+[.NET Downloads](https://dotnet.microsoft.com/en-us/download/dotnet).
 
 The .NET SDK contains support for building for previous versions of .NET, including support for building .NET Framework
 on operating systems that do not support .NET Framework. As such, it is not necessary to install any version of the
@@ -16,9 +19,11 @@ on operating systems that do not support .NET Framework. As such, it is not nece
 
 ### Miscellaneous
 
-**PowerShell** is required to run several miscellaneous tasks as part of building and packaging. On Windows systems,
-no action is required. On Linux and macOS systems, the `pwsh` command is required to be in the `$PATH` environment
-variable. For specific instructions see: [Install PowerShell](https://learn.microsoft.com/en-us/powershell/scripting/install/install-powershell)
+**PowerShell** is required to run several miscellaneous tasks as part of building and packaging. On
+Windows systems, either the built-in `powershell.exe` will be used, or if installed, the modern
+`pwsh` will be used. On Linux and macOS systems, the `pwsh` command is required to be in the `$PATH`
+environment variable. For specific instructions see: [Install
+PowerShell](https://learn.microsoft.com/en-us/powershell/scripting/install/install-powershell)
 
 The **NuGet** binary is optional for inspection and feed-management workflows, but build and packaging flows in this
 repository are run through `dotnet build` against `build.proj`.
@@ -33,6 +38,8 @@ package the project. The `build.proj` file provides convenient targets to accomp
 > may be noticed, possibly severe. All official build and test infrastructure uses the `build.proj` entrypoint, and it
 > is recommended that `build.proj` is used for local development, as well.
 
+<!-- Avoid MD028 (blank line inside a blockquote - these are 2 separate blockquotes. -->
+
 > [!TIP]
 > This section is not exhaustive of all targets or parameters to `build.proj`. Complete documentation is available in
 > [`build.proj`](build.proj).
@@ -45,11 +52,21 @@ From the root of your repository, run `dotnet build` against `build.proj` with a
 dotnet build build.proj -t:<build_target> [optional_parameters]
 ```
 
+Since `build.proj` is the only project file in the repo root, it can be omitted when building from
+the root:
+
+```bash
+dotnet build -t:<build_target> [optional_parameters]
+```
+
+The command-line examples below will assume that `build.proj` is selected by default and will omit
+it from the `dotnet build` command.
+
 The following build targets can be used to build the following projects. All targets will implicitly build any other
 projects they depend on.
 
 | `<build_target>`            | Description                                                                     |
-|:----------------------------|:--------------------------------------------------------------------------------|
+|-----------------------------|---------------------------------------------------------------------------------|
 | `Build`                     | Builds all projects for all platforms                                           |
 | `BuildAbstractions`         | Builds Microsoft.Data.SqlClient.Extensions.Abstractions                         |
 | `BuildAkvProvider`          | Builds Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider           |
@@ -64,11 +81,15 @@ projects they depend on.
 
 A selection of parameters for build targets in `build.proj` can be found below:
 
+<!-- markdownlint-disable MD060 -->
+
 | `[optional_parameter]`            | Allowed Values                   | Default   | Description                                                                                                                                   |
 |-----------------------------------|----------------------------------|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------|
 | `-p:Configuration=`               | `Debug`, `Release`               | `Debug`   | Build configuration                                                                                                                           |
 | `-p:PackageVersion<TargetPackage>=` | `major.minor.patch[-prerelease]` | `[blank]` | Version to assign to the target package, where `<TargetPackage>` can be one of: `['Abstractions', 'Azure', 'AkvProvider', 'Logging', 'SqlClient', 'SqlServer']`. Assembly and file versions are derived from this, if it is provided. See Versioning for more details |
 
+<!-- markdownlint-enable MD060 -->
+
 For most projects, build output is placed in `artifacts/<package_name>/Project-<configuration>/<tfm>`. `<package_name>`
 is the full name of the package, `<configuration>` is the build configuration, and `<tfm>` is the target framework
 moniker. SqlClient deviates slightly from this convention, since it consists of multiple projects and the
@@ -82,19 +103,19 @@ placed in `artifacts/Microsoft.Data.SqlClient.ref/Project-<configuration>/<tfm>`
 Build all projects:
 
 ```bash
-dotnet build build.proj -t:Build
+dotnet build -t:Build
 ```
 
 Build Microsoft.Data.SqlClient in Release configuration:
 
 ```bash
-dotnet build build.proj -t:BuildSqlClient -p:Configuration=Release
+dotnet build -t:BuildSqlClient -p:Configuration=Release
 ```
 
 Build v1.2.3 of Microsoft.Data.SqlClient.Extensions.Abstractions:
 
 ```bash
-dotnet build build.proj -t:BuildAbstractions -p:PackageVersionAbstractions=1.2.3
+dotnet build -t:BuildAbstractions -p:PackageVersionAbstractions=1.2.3
 ```
 
 ### Testing Projects
@@ -105,7 +126,7 @@ information about test procedures, including config file setup, see [TESTGUIDE.m
 From the root of your repository, run `dotnet build` against `build.proj` with a test target, following this pattern:
 
 ```bash
-dotnet build build.proj -t:<test_target> [optional_parameters]
+dotnet build -t:<test_target> [optional_parameters]
 ```
 
 | `<test_target>`            | Description                                                                                                                                         |
@@ -123,6 +144,8 @@ dotnet build build.proj -t:<test_target> [optional_parameters]
 
 A selection of parameters for test targets in `build.proj` relevant to common developer workflows can be found below:
 
+<!-- markdownlint-disable MD060 -->
+
 | `[optional_parameter]` | Default Value                                            | Description                                                                                                                                                                                         |
 |------------------------|----------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `-p:Configuration=`    | `Debug`                                                  | Build configuration. Can be `Debug` or `Release`.                                                                                                                                                   |
@@ -132,32 +155,38 @@ A selection of parameters for test targets in `build.proj` relevant to common de
 | `-p:TestFramework=`    | `[blank]`                                                | Target framework moniker for the version of .NET to use to execute tests.                                                                                                                           |
 | `-p:TestSet=`          | `[blank]`                                                | The `TestSqlClientManual` project is very large and is split into multiple sets that can be executed individually. This parameter allows selecting between test sets: `1`, `2`, `3`, and `AE`. |
 
+<!-- markdownlint-enable MD060 -->
+
 #### Examples
 
 Run Microsoft.Data.SqlClient unit tests:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientUnit
+dotnet build -t:TestSqlClientUnit
 ```
 
 Run Microsoft.Data.SqlClient manual test set 2:
+
 ```bash
-dotnet build build.proj -t:TestSqlClientManual -p:TestSet=2
+dotnet build -t:TestSqlClientManual -p:TestSet=2
 ```
 
 Run Microsoft.Data.SqlClient functional tests against x86 dotnet:
+
 ```bash
-dotnet build build.proj -t:TestSqlClientFunctional -p:DotnetPath='C:\path\to\dotnet\x86\'
+dotnet build -t:TestSqlClientFunctional -p:DotnetPath='C:\path\to\dotnet\x86\'
 ```
 
 Run all Microsoft.Data.SqlClient.Extensions.Azure unit tests, including interactive, but excluding failing tests:
+
 ```bash
-dotnet build build.proj -t:TestAzure -p:TestFilters=category!=failing
+dotnet build -t:TestAzure -p:TestFilters=category!=failing
 ```
 
 Run Microsoft.Data.SqlClient functional tests against net8.0 runtime:
+
 ```bash
-dotnet build build.proj -t:TestSqlClientFunctional -p:TestFramework=net8.0
+dotnet build -t:TestSqlClientFunctional -p:TestFramework=net8.0
 ```
 
 ### Packaging Projects
@@ -167,10 +196,10 @@ also handled by `build.proj`. From the root of your repository, run `dotnet buil
 following this pattern:
 
 ```bash
-dotnet build build.proj -t:<pack_target> [optional_parameters]
+dotnet build -t:<pack_target> [optional_parameters]
 ```
 
-| `<pack_target>`   | Description                                                                         |
+| `<pack_target>`    | Description                                                                         |
 |--------------------|-------------------------------------------------------------------------------------|
 | `Pack`             | Packages all projects in the repository.                                            |
 | `PackAbstractions` | Packages the Microsoft.Data.SqlClient.Extensions.Abstractions package               |
@@ -185,12 +214,16 @@ dotnet build build.proj -t:<pack_target> [optional_parameters]
 
 A selection of parameters for pack targets in `build.proj` relevant to common developer workflows can be found below:
 
+<!-- markdownlint-disable MD060 -->
+
 | `[optional_parameter]`             | Default Value | Allowed Values        | Description                                                                                                                                                    |
 |------------------------------------|---------------|-----------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `-p:Configuration=`                | `Debug`       | `Debug`, `Release`    | Build configuration. Only applies if project and dependencies are being built.                                                                                 |
 | `-p:PackBuild=`                    | `true`        | `true`, `false`       | Whether or not to build the project before packing. If `false`, project must be built using the same parameters.                                               |
 | `-p:PackageVersion<TargetPackage>=` | `[blank]`     | eg. `1.2.3-dev123`    | Version to assign to the package, where `<TargetPackage>` can be one of: `['Abstractions', 'Azure', 'AkvProvider', 'Logging', 'SqlClient', 'SqlServer']`. If `PackBuild` is `true`, the assembly and file versions will be derived from this version. See Versioning for more details. |
 
+<!-- markdownlint-enable MD060 -->
+
 For `PackSqlClient`, these additional parameters are optional overrides for dependency versions injected into the SqlClient nuspec during pack:
 
 - `-p:PackageVersionAbstractions=<version>`
@@ -201,23 +234,27 @@ If omitted, `PackSqlClient` computes `AbstractionsPackageVersion` and `LoggingPa
 #### Examples
 
 Package Microsoft.Data.SqlClient.Internal.Logging into a NuGet package:
+
 ```bash
-dotnet build build.proj -t:PackLogging
+dotnet build -t:PackLogging
 ```
 
 Package Microsoft.Data.SqlClient:
+
 ```bash
-dotnet build build.proj -t:PackSqlClient
+dotnet build -t:PackSqlClient
 ```
 
 Package version 1.2.3 of Microsoft.Data.SqlClient.Extensions.Abstractions:
+
 ```bash
-dotnet build build.proj -t:PackAbstractions -p:PackageVersionAbstractions=1.2.3
+dotnet build -t:PackAbstractions -p:PackageVersionAbstractions=1.2.3
 ```
 
 Package Microsoft.Data.SqlClient.Extensions.Azure without building it beforehand:
+
 ```bash
-dotnet build build.proj -t:PackAzure -p:PackBuild=false
+dotnet build -t:PackAzure -p:PackBuild=false
 ```
 
 ## Versioning
@@ -255,12 +292,12 @@ build scenarios. For completeness, and debugging of automated builds, this secti
 To switch to "package mode", set the `ReferenceType` parameter in `build.proj` to `Package`. And, optionally, include
 one or more of the following parameters:
 
-* `PackageVersionAbstractions`
-* `PackageVersionAkvProvider`
-* `PackageVersionAzure`
-* `PackageVersionLogging`
-* `PackageVersionSqlClient`
-* `PackageVersionSqlServer`
+- `PackageVersionAbstractions`
+- `PackageVersionAkvProvider`
+- `PackageVersionAzure`
+- `PackageVersionLogging`
+- `PackageVersionSqlClient`
+- `PackageVersionSqlServer`
 
 These parameters pull double duty. In targets where the package is being built, the parameter sets the version of the
 package. In targets where the package is being referenced, the parameter sets the version of the package that is being
@@ -277,22 +314,27 @@ run subsequent `build.proj` targets against them.
 Build Microsoft.Data.SqlClient version 7.1.1 that references Microsoft.Data.SqlClient.Extensions.Abstractions v1.0.1
 and Microsoft.Data.SqlClient.Internal.Logging v2.2.2.
 
+Build v2.2.2 of Logging and copy to packages:
+
 ```bash
-# Build v2.2.2 of Logging and copy to packages
-dotnet build build.proj -t:PackLogging \
-  -p:ReferenceType=Package \
-  -p:PackageVersionLogging=2.2.2
+dotnet build -t:PackLogging -p:ReferenceType=Package -p:PackageVersionLogging=2.2.2
 cp artifacts/Microsoft.Data.SqlClient.Internal.Logging/Debug/*.*pkg packages/
+```
+
+Build v1.0.1 of Abstractions that depends on v2.2.2 of Logging:
 
-# Build v1.0.1 of Abstractions that depends on v2.2.2 of Logging
-dotnet build build.proj -t:PackAbstractions \
+```bash
+dotnet build -t:PackAbstractions \
   -p:ReferenceType=Package \
   -p:PackageVersionAbstractions=1.0.1 \
-  -p:PackageVersionLogging=2.2.2 \
+  -p:PackageVersionLogging=2.2.2
 cp artifacts/Microsoft.Data.SqlClient.Extensions.Abstractions/Package-Debug/*.*pkg packages/
+```
 
-# Build SqlClient
-dotnet build build.proj -t:PackSqlClient \
+Build SqlClient:
+
+```bash
+dotnet build -t:PackSqlClient \
   -p:ReferenceType=Package \
   -p:PackageVersionSqlClient=7.1.1 \
   -p:PackageVersionAbstractions=1.0.1 \
@@ -301,22 +343,17 @@ cp artifacts/Microsoft.Data.SqlClient/Package-Debug/*.*pkg packages/
 ```
 
 Run Microsoft.Data.SqlClient functional tests against the versions built above:
+
 ```bash
-dotnet build build.proj -t:TestSqlClientFunctional \
+dotnet build -t:TestSqlClientFunctional \
   -p:ReferenceType=Package \
   -p:PackageVersionSqlClient=7.1.1 \
   -p:PackageVersionAbstractions=1.0.1 \
   -p:PackageVersionLogging=2.2.2
 ```
 
-----
-
-
 Manual test prerequisites and configuration are covered in [TESTGUIDE.md](TESTGUIDE.md#manual-test-prerequisites).
 
-
----
-
 ## Using Managed SNI on Windows
 
 Managed SNI can be enabled on Windows by enabling the below AppContext switch:
@@ -371,10 +408,14 @@ PowerShell:
 
 Bash:
 
+<!-- markdownlint-disable MD014 -->
+
 ```bash
 $ cd src/Microsoft.Data.SqlClient/tests/PerformanceTests
 ```
 
+<!-- markdownlint-enable MD014 -->
+
 ### Create Database
 
 Create an empty database for the benchmarks to use.  This example assumes
diff --git a/TESTGUIDE.md b/TESTGUIDE.md
index 349674deee..aab773a080 100644
--- a/TESTGUIDE.md
+++ b/TESTGUIDE.md
@@ -26,6 +26,16 @@ Use [build.proj](build.proj) from the repository root:
 dotnet build build.proj -t:<test_target> [optional_parameters]
 ```
 
+Since `build.proj` is the only project file in the repo root, it can be omitted when building from
+the root:
+
+```bash
+dotnet build -t:<test_target> [optional_parameters]
+```
+
+The command-line examples below will assume that `build.proj` is selected by default and will omit
+it from the `dotnet build` command.
+
 Test targets build the projects they depend on, so a separate build step is not required for normal test runs.
 
 ## Test Targets
@@ -45,55 +55,55 @@ Test targets build the projects they depend on, so a separate build step is not
 Run the SqlClient unit tests:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientUnit
+dotnet build -t:TestSqlClientUnit
 ```
 
 Run the SqlClient functional tests:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientFunctional
+dotnet build -t:TestSqlClientFunctional
 ```
 
 Run the SqlClient manual tests:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientManual
+dotnet build -t:TestSqlClientManual
 ```
 
 Run only manual test set 2:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientManual -p:TestSet=2
+dotnet build -t:TestSqlClientManual -p:TestSet=2
 ```
 
 Run manual test sets 1 and 3:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientManual -p:TestSet=13
+dotnet build -t:TestSqlClientManual -p:TestSet=13
 ```
 
 Run Always Encrypted manual tests:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientManual -p:TestSet=AE
+dotnet build -t:TestSqlClientManual -p:TestSet=AE
 ```
 
 Run a specific target framework:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientFunctional -p:TestFramework=net8.0
+dotnet build -t:TestSqlClientFunctional -p:TestFramework=net8.0
 ```
 
 Run functional tests against an x86 `dotnet` installation:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientFunctional -p:DotnetPath='C:\path\to\dotnet\x86\'
+dotnet build -t:TestSqlClientFunctional -p:DotnetPath='C:\path\to\dotnet\x86\'
 ```
 
 Run all Azure extension tests, including `interactive` tests, while still excluding tests marked `failing` or `flaky`:
 
 ```bash
-dotnet build build.proj -t:TestAzure -p:TestFilters=category!=failing
+dotnet build -t:TestAzure -p:TestFilters=category!=failing
 ```
 
 ## Test Parameters
@@ -124,15 +134,22 @@ The most commonly used test parameters are:
 
 Examples:
 
+Run a single test by fully-qualified name:
+
 ```bash
-# Run a single test by fully-qualified name.
-dotnet build build.proj -t:TestSqlClientUnit -p:TestFilters=FullyQualifiedName=Namespace.ClassName.MethodName
+dotnet build -t:TestSqlClientUnit -p:TestFilters=FullyQualifiedName=Namespace.ClassName.MethodName
+```
+
+Run only flaky tests while investigating quarantine failures:
+
+```bash
+dotnet build -t:TestSqlClientManual -p:TestFilters=category=flaky
+```
 
-# Run only flaky tests while investigating quarantine failures.
-dotnet build build.proj -t:TestSqlClientManual -p:TestFilters=category=flaky
+Disable the default filter:
 
-# Disable the default filter.
-dotnet build build.proj -t:TestSqlClientFunctional -p:TestFilters=none
+```bash
+dotnet build -t:TestSqlClientFunctional -p:TestFilters=none
 ```
 
 When passing filter expressions that contain shell-sensitive characters such as `&`, quote or escape the value as
@@ -216,14 +233,14 @@ For SQL Server in a Linux container, WSL, or another host where SQL authenticati
 You can override the config file path with the `MDS_TEST_CONFIG` environment variable:
 
 ```bash
-MDS_TEST_CONFIG=/path/to/config.json dotnet build build.proj -t:TestSqlClientManual -p:TestSet=2
+MDS_TEST_CONFIG=/path/to/config.json dotnet build -t:TestSqlClientManual -p:TestSet=2
 ```
 
 On PowerShell:
 
 ```powershell
 $env:MDS_TEST_CONFIG = "C:\path\to\config.json"
-dotnet build build.proj -t:TestSqlClientManual -p:TestSet=2
+dotnet build -t:TestSqlClientManual -p:TestSet=2
 ```
 
 ## Configuration Properties
@@ -280,26 +297,27 @@ If `TestSet` is omitted, all sets are compiled and run. You can combine sets by
 
 ## Results and Diagnostics
 
-Test results are written to `test_results` by default. Override the location with `TestResultsFolderPath`:
+Test results are written to the `test_results` directory by default. Override the location with
+`TestResultsFolderPath`:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientUnit -p:TestResultsFolderPath=/tmp/sqlclient-test-results
+dotnet build -t:TestSqlClientUnit -p:TestResultsFolderPath=/tmp/sqlclient-test-results
 ```
 
 Hang blame collection is enabled by default with a `10m` timeout. To increase the timeout:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientManual -p:TestBlameTimeout=30m
+dotnet build -t:TestSqlClientManual -p:TestBlameTimeout=30m
 ```
 
 To disable hang blame collection:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientManual -p:TestBlameTimeout=0
+dotnet build -t:TestSqlClientManual -p:TestBlameTimeout=0
 ```
 
 Code coverage is enabled by default. To disable it for a faster local run:
 
 ```bash
-dotnet build build.proj -t:TestSqlClientUnit -p:TestCodeCoverage=false
+dotnet build -t:TestSqlClientUnit -p:TestCodeCoverage=false
 ```
diff --git a/build.proj b/build.proj
index 14db6015ba..971cfb12fa 100644
--- a/build.proj
+++ b/build.proj
@@ -72,7 +72,7 @@
     <!--
       PackBuild
       Applies to:     Pack*
-      Description:    Whether the Pack* targets should buiild the project before packaging. If
+      Description:    Whether the Pack* targets should build the project before packaging. If
                       true, the project will be built as part of packaging. If false, it will not.
 
                       For most developers, building immediately before packing is the norm, and
diff --git a/doc/apps/AzureAuthentication/README.md b/doc/apps/AzureAuthentication/README.md
index a0d9d8b7ba..967a728007 100644
--- a/doc/apps/AzureAuthentication/README.md
+++ b/doc/apps/AzureAuthentication/README.md
@@ -28,7 +28,7 @@ The app is designed to run against both **published NuGet packages** and **local
 
 ## Build Parameters
 
-Package versions are controlled through MSBuild properties. Pass them on the command line with `-p:`
+Package versions are controlled through build properties. Pass them on the command line with `-p:`
 (or `/p:`) to override the defaults defined in `Directory.Packages.props`.
 
 | Property | Default | Description |
diff --git a/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml b/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
index 31bf8be63b..8d051e5167 100644
--- a/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
+++ b/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
@@ -85,7 +85,6 @@ jobs:
     name: ${{parameters.poolName }}
     demands:
     - imageOverride -equals ${{ parameters.imageOverride }}
-    - msbuild
 
   variables:
     - template: /eng/pipelines/libraries/ci-build-variables.yml@self
@@ -130,7 +129,6 @@ jobs:
         buildConfiguration: Release
         referenceType: Project
         build: all
-        assemblyBuildNumber: $(assemblyBuildNumber)
 
   - template: /eng/pipelines/common/templates/steps/ci-project-build-step.yml@self
     parameters:
@@ -139,7 +137,6 @@ jobs:
       referenceType: ${{ parameters.referenceType }}
       operatingSystem: Windows
       build: MDS
-      assemblyBuildNumber: $(assemblyBuildNumber)
       abstractionsPackageVersion: ${{parameters.abstractionsPackageVersion}}
       loggingPackageVersion: ${{ parameters.loggingPackageVersion }}
 
@@ -183,7 +180,6 @@ jobs:
       buildConfiguration: ${{ parameters.buildConfiguration }}
       referenceType: ${{ parameters.referenceType }}
       build: AkvProvider
-      assemblyBuildNumber: $(assemblyBuildNumber)
       abstractionsPackageVersion: ${{parameters.abstractionsPackageVersion}}
       loggingPackageVersion: ${{ parameters.loggingPackageVersion }}
       mdsPackageVersion: ${{ parameters.mdsPackageVersion }}
@@ -192,12 +188,28 @@ jobs:
   - task: DotNetCoreCLI@2
     displayName: 'Create AKV Provider NuGet Package'
     inputs:
-      command: pack
-      packagesToPack: src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.csproj
-      configurationToPack: ${{ parameters.buildConfiguration }}
-      nobuild: true
-      packDirectory: $(packagePath)
-      buildProperties: ReferenceType=${{ parameters.referenceType }};AbstractionsPackageVersion=${{ parameters.abstractionsPackageVersion }};LoggingPackageVersion=${{ parameters.loggingPackageVersion }};SqlClientPackageVersion=${{ parameters.mdsPackageVersion }};AkvProviderPackageVersion=${{ parameters.akvPackageVersion }};BuildNumber=$(Build.BuildNumber);AssemblyBuildNumber=$(assemblyBuildNumber)
+      command: build
+      projects: build.proj
+      arguments: >-
+        -t:PackAkvProvider
+        -p:Configuration=${{ parameters.buildConfiguration }}
+        -p:PackBuild=false
+        -p:ReferenceType=${{ parameters.referenceType }}
+        -p:BuildNumber=$(Build.BuildNumber)
+        -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
+        -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
+        -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
+        -p:PackageVersionAkvProvider=${{ parameters.akvPackageVersion }}
+
+  - task: CopyFiles@2
+    displayName: Copy AKV Package to Output Folder
+    inputs:
+      sourceFolder: artifacts/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/${{ parameters.buildConfiguration }}
+      contents: |
+        **/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider*.nupkg
+        **/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider*.snupkg
+      targetFolder: $(packagePath)
+      flattenFolders: true
 
   - task: PublishPipelineArtifact@1
     displayName: 'Publish Pipeline Artifacts'
diff --git a/eng/pipelines/common/templates/jobs/ci-run-tests-job.yml b/eng/pipelines/common/templates/jobs/ci-run-tests-job.yml
index 8666cd0dbb..5c593e11e3 100644
--- a/eng/pipelines/common/templates/jobs/ci-run-tests-job.yml
+++ b/eng/pipelines/common/templates/jobs/ci-run-tests-job.yml
@@ -215,7 +215,6 @@ jobs:
         build: allNoDocs
         buildConfiguration: ${{ parameters.buildConfiguration }}
         referenceType: Project
-        assemblyBuildNumber: $(assemblyBuildNumber)
 
   - ${{ if ne(parameters.configProperties, '{}') }}:
     - template: /eng/pipelines/common/templates/steps/update-config-file-step.yml@self # update config.json file
diff --git a/eng/pipelines/common/templates/steps/ci-project-build-step.yml b/eng/pipelines/common/templates/steps/ci-project-build-step.yml
index bbd2d10744..fe46ad66a2 100644
--- a/eng/pipelines/common/templates/steps/ci-project-build-step.yml
+++ b/eng/pipelines/common/templates/steps/ci-project-build-step.yml
@@ -46,10 +46,6 @@ parameters:
       - all
       - allNoDocs
 
-  # The build number suffix to apply to all assembly file versions built by this step.
-  - name: assemblyBuildNumber
-    type: string
-
   # Necessary to build MDS when referenceType is Package.  Ignored when referenceType is Project.
   - name: abstractionsPackageVersion
     type: string
@@ -75,18 +71,17 @@ parameters:
 steps:
   # Build MDS
   - ${{ if or(eq(parameters.build, 'MDS'), eq(parameters.build, 'all'), eq(parameters.build, 'allNoDocs')) }}:
-    - task: MSBuild@1
+    - task: DotNetCoreCLI@2
       displayName: 'Build Driver'
       condition: and(succeeded(), eq(variables['Agent.OS'], 'Windows_NT'))
       inputs:
-        solution: build.proj
-        msbuildArchitecture: x64
-        platform: '${{ parameters.platform }}'
-        configuration: '${{ parameters.buildConfiguration }}'
-        msbuildArguments:
+        command: build
+        projects: build.proj
+        arguments: >-
           -t:BuildSqlClient
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:ReferenceType=${{ parameters.referenceType }}
-          -p:BuildNumber=${{ parameters.assemblyBuildNumber }}
+          -p:BuildNumber=${{ parameters.buildNumber }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
@@ -98,14 +93,13 @@ steps:
       condition: and(succeeded(), eq(variables['Agent.OS'], 'Windows_NT'))
       inputs:
         command: build
-        projects: src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.csproj
+        projects: build.proj
         arguments: >-
-          --configuration ${{ parameters.buildConfiguration }}
+          -t:BuildAkvProvider
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:ReferenceType=${{ parameters.referenceType }}
           -p:BuildNumber=${{ parameters.buildNumber }}
-          -p:AssemblyBuildNumber=${{ parameters.assemblyBuildNumber }}
-          -p:AkvProviderPackageVersion=${{ parameters.akvPackageVersion }}
-          -p:AbstractionsPackageVersion=${{ parameters.abstractionsPackageVersion }}
-          -p:LoggingPackageVersion=${{ parameters.loggingPackageVersion }}
-          -p:SqlClientPackageVersion=${{ parameters.mdsPackageVersion }}
-
+          -p:PackageVersionAkvProvider=${{ parameters.akvPackageVersion }}
+          -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
+          -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
+          -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
diff --git a/eng/pipelines/common/templates/steps/run-all-tests-step.yml b/eng/pipelines/common/templates/steps/run-all-tests-step.yml
index e3397e45f0..cf3ce206a4 100644
--- a/eng/pipelines/common/templates/steps/run-all-tests-step.yml
+++ b/eng/pipelines/common/templates/steps/run-all-tests-step.yml
@@ -77,96 +77,91 @@ steps:
 
 - ${{if eq(parameters.operatingSystem, 'Windows')}}:
   - ${{if eq(parameters.referenceType, 'Project')}}:
-    - task: MSBuild@1
+    - task: DotNetCoreCLI@2
       displayName: 'Run Unit Tests ${{parameters.msbuildArchitecture }}'
       condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
       inputs:
-        solution: build.proj
-        msbuildArchitecture: ${{parameters.msbuildArchitecture }}
-        platform: '${{parameters.platform }}'
-        configuration: '${{parameters.buildConfiguration }}'
+        command: build
+        projects: build.proj
         ${{ if eq(parameters.msbuildArchitecture, 'x64') }}:
-          msbuildArguments: >-
+          arguments: >-
             -t:TestSqlClientUnit
             -p:TestFramework=${{ parameters.targetFramework }}
-            -p:ReferenceType=${{ parameters.referenceType }}
+            -p:Configuration=${{ parameters.buildConfiguration }}
             -p:TestResultsFolderPath=TestResults
         ${{ else }}: # x86
-          msbuildArguments: >-
+          arguments: >-
             -t:TestSqlClientUnit
             -p:TestFramework=${{ parameters.targetFramework }}
-            -p:ReferenceType=${{ parameters.referenceType }}
+            -p:Configuration=${{ parameters.buildConfiguration }}
             -p:DotnetPath=${{ parameters.dotnetx86RootPath }}
             -p:TestResultsFolderPath=TestResults
 
-    - task: MSBuild@1
+    - task: DotNetCoreCLI@2
       displayName: 'Run Flaky Unit Tests ${{parameters.msbuildArchitecture }}'
       condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
       inputs:
-        solution: build.proj
-        msbuildArchitecture: ${{parameters.msbuildArchitecture }}
-        platform: '${{parameters.platform }}'
-        configuration: '${{parameters.buildConfiguration }}'
+        command: build
+        projects: build.proj
         ${{ if eq(parameters.msbuildArchitecture, 'x64') }}:
-          msbuildArguments: >-
+          arguments: >-
             -t:TestSqlClientUnit
             -p:TestFramework=${{ parameters.targetFramework }}
-            -p:ReferenceType=${{ parameters.referenceType }}
+            -p:Configuration=${{ parameters.buildConfiguration }}
             -p:TestFilters="category=flaky"
             -p:TestResultsFolderPath=TestResults
             -p:TestCodeCoverage=false
         ${{ else }}: # x86
-          msbuildArguments: >-
+          arguments: >-
             -t:TestSqlClientUnit
             -p:TestFramework=${{ parameters.targetFramework }}
-            -p:ReferenceType=${{ parameters.referenceType }}
+            -p:Configuration=${{ parameters.buildConfiguration }}
             -p:DotnetPath=${{ parameters.dotnetx86RootPath }}
             -p:TestFilters="category=flaky"
             -p:TestResultsFolderPath=TestResults
             -p:TestCodeCoverage=false
       continueOnError: true
 
-  - task: MSBuild@1
+  - task: DotNetCoreCLI@2
     displayName: 'Run Functional Tests ${{parameters.msbuildArchitecture }}'
     condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      solution: build.proj
-      msbuildArchitecture: ${{parameters.msbuildArchitecture }}
-      platform: '${{parameters.platform }}'
-      configuration: '${{parameters.buildConfiguration }}'
+      command: build
+      projects: build.proj
       ${{ if eq(parameters.msbuildArchitecture, 'x64') }}:
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientFunctional
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
           -p:TestResultsFolderPath=TestResults
       ${{ else }}: # x86
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientFunctional
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
           -p:DotnetPath=${{ parameters.dotnetx86RootPath }}
           -p:TestResultsFolderPath=TestResults
 
-  - task: MSBuild@1
-    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
+  - task: DotNetCoreCLI@2
     displayName: 'Run Flaky Functional Tests ${{parameters.msbuildArchitecture }}'
+    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      solution: build.proj
-      msbuildArchitecture: ${{parameters.msbuildArchitecture }}
-      platform: '${{parameters.platform }}'
-      configuration: '${{parameters.buildConfiguration }}'
+      command: build
+      projects: build.proj
       ${{ if eq(parameters.msbuildArchitecture, 'x64') }}:
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientFunctional
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
@@ -174,10 +169,11 @@ steps:
           -p:TestResultsFolderPath=TestResults
           -p:TestCodeCoverage=false
       ${{ else }}: # x86
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientFunctional
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
@@ -187,30 +183,30 @@ steps:
           -p:TestCodeCoverage=false
     continueOnError: true
 
-  - task: MSBuild@1
-    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
+  - task: DotNetCoreCLI@2
     displayName: 'Run Manual Tests ${{parameters.msbuildArchitecture }}'
+    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      solution: build.proj
-      msbuildArchitecture: ${{parameters.msbuildArchitecture }}
-      platform: '${{parameters.platform }}'
-      configuration: '${{parameters.buildConfiguration }}'
+      command: build
+      projects: build.proj
       ${{ if eq(parameters.msbuildArchitecture, 'x64') }}:
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientManual
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:TestSet=${{ parameters.testSet }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
           -p:TestResultsFolderPath=TestResults
       ${{ else }}: # x86
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientManual
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:TestSet=${{ parameters.testSet }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
@@ -218,20 +214,19 @@ steps:
           -p:TestResultsFolderPath=TestResults
     retryCountOnTaskFailure: ${{parameters.retryCountOnManualTests }}
 
-  - task: MSBuild@1
-    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
+  - task: DotNetCoreCLI@2
     displayName: 'Run Flaky Manual Tests ${{parameters.msbuildArchitecture }}'
+    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      solution: build.proj
-      msbuildArchitecture: ${{parameters.msbuildArchitecture }}
-      platform: '${{parameters.platform }}'
-      configuration: '${{parameters.buildConfiguration }}'
+      command: build
+      projects: build.proj
       ${{ if eq(parameters.msbuildArchitecture, 'x64') }}:
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientManual
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:TestSet=${{ parameters.testSet }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
@@ -239,11 +234,12 @@ steps:
           -p:TestResultsFolderPath=TestResults
           -p:TestCodeCoverage=false
       ${{ else }}: # x86
-        msbuildArguments: >-
+        arguments: >-
           -t:TestSqlClientManual
           -p:TestFramework=${{ parameters.targetFramework }}
           -p:TestSet=${{ parameters.testSet }}
           -p:ReferenceType=${{ parameters.referenceType }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
           -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
           -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
@@ -259,124 +255,97 @@ steps:
       displayName: 'Run Unit Tests'
       condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
       inputs:
-        command: custom
+        command: build
         projects: build.proj
-        custom: msbuild
         arguments: >-
           -t:TestSqlClientUnit
           -p:TestFramework=${{ parameters.targetFramework }}
-          -p:ReferenceType=${{ parameters.referenceType }}
-          -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
-          -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
-          -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
           -p:Configuration=${{ parameters.buildConfiguration }}
           -p:TestResultsFolderPath=TestResults
-        verbosityRestore: Detailed
-        verbosityPack: Detailed
 
     - task: DotNetCoreCLI@2
       displayName: 'Run Flaky Unit Tests'
       condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
       inputs:
-        command: custom
+        command: build
         projects: build.proj
-        custom: msbuild
         arguments: >-
           -t:TestSqlClientUnit
           -p:TestFramework=${{ parameters.targetFramework }}
-          -p:ReferenceType=${{ parameters.referenceType }}
-          -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
-          -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
-          -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
           -p:Configuration=${{ parameters.buildConfiguration }}
           -p:TestFilters="category=flaky"
           -p:TestResultsFolderPath=TestResults
           -p:TestCodeCoverage=false
-        verbosityRestore: Detailed
-        verbosityPack: Detailed
       continueOnError: true
 
   - task: DotNetCoreCLI@2
     displayName: 'Run Functional Tests'
     condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      command: custom
+      command: build
       projects: build.proj
-      custom: msbuild
       arguments: >-
         -t:TestSqlClientFunctional
         -p:TestFramework=${{ parameters.targetFramework }}
         -p:ReferenceType=${{ parameters.referenceType }}
+        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
         -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
         -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
-        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:TestResultsFolderPath=TestResults
-      verbosityRestore: Detailed
-      verbosityPack: Detailed
 
   - task: DotNetCoreCLI@2
-    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     displayName: 'Run Flaky Functional Tests'
+    condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      command: custom
+      command: build
       projects: build.proj
-      custom: msbuild
       arguments: >-
         -t:TestSqlClientFunctional
         -p:TestFramework=${{ parameters.targetFramework }}
         -p:ReferenceType=${{ parameters.referenceType }}
+        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
         -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
         -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
-        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:TestFilters="category=flaky"
         -p:TestResultsFolderPath=TestResults
         -p:TestCodeCoverage=false
-      verbosityRestore: Detailed
-      verbosityPack: Detailed
     continueOnError: true
   - task: DotNetCoreCLI@2
     displayName: 'Run Manual Tests'
     condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      command: custom
+      command: build
       projects: build.proj
-      custom: msbuild
       arguments: >-
         -t:TestSqlClientManual
         -p:TestFramework=${{ parameters.targetFramework }}
         -p:TestSet=${{ parameters.testSet }}
         -p:ReferenceType=${{ parameters.referenceType }}
+        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
         -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
         -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
-        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:TestResultsFolderPath=TestResults
-      verbosityRestore: Detailed
-      verbosityPack: Detailed
     retryCountOnTaskFailure: ${{parameters.retryCountOnManualTests }}
 
   - task: DotNetCoreCLI@2
     displayName: 'Run Flaky Manual Tests'
     condition: and(eq(variables['setupSucceeded'], 'true'), succeededOrFailed())
     inputs:
-      command: custom
+      command: build
       projects: build.proj
-      custom: msbuild
       arguments: >-
         -t:TestSqlClientManual
         -p:TestFramework=${{ parameters.targetFramework }}
         -p:TestSet=${{ parameters.testSet }}
         -p:ReferenceType=${{ parameters.referenceType }}
+        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:PackageVersionAbstractions=${{ parameters.abstractionsPackageVersion }}
         -p:PackageVersionLogging=${{ parameters.loggingPackageVersion }}
         -p:PackageVersionSqlClient=${{ parameters.mdsPackageVersion }}
-        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:TestFilters="category=flaky"
         -p:TestResultsFolderPath=TestResults
         -p:TestCodeCoverage=false
-      verbosityRestore: Detailed
-      verbosityPack: Detailed
     continueOnError: true
-
diff --git a/eng/pipelines/jobs/test-abstractions-package-ci-job.yml b/eng/pipelines/jobs/test-abstractions-package-ci-job.yml
index a88d4dc347..226dc1ae2a 100644
--- a/eng/pipelines/jobs/test-abstractions-package-ci-job.yml
+++ b/eng/pipelines/jobs/test-abstractions-package-ci-job.yml
@@ -91,7 +91,7 @@ jobs:
       # dotnet CLI arguments for build/test/pack commands
       - name: buildArguments
         value: >-
-          --configuration ${{ parameters.buildConfiguration }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           --verbosity ${{ parameters.dotnetVerbosity }}
 
       # Explicitly unset the $PLATFORM environment variable that is set by the
diff --git a/eng/pipelines/jobs/test-azure-package-ci-job.yml b/eng/pipelines/jobs/test-azure-package-ci-job.yml
index 0ad4246cb0..cd9b87e103 100644
--- a/eng/pipelines/jobs/test-azure-package-ci-job.yml
+++ b/eng/pipelines/jobs/test-azure-package-ci-job.yml
@@ -149,7 +149,7 @@ jobs:
       # dotnet CLI arguments for build/test/pack commands.
       - name: buildArguments
         value: >-
-          --configuration ${{ parameters.buildConfiguration }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
           --verbosity ${{ parameters.dotnetVerbosity }}
           -p:ReferenceType=${{ parameters.referenceType }}
           -p:AbstractionsPackageVersion=${{ parameters.abstractionsPackageVersion }}
diff --git a/eng/pipelines/onebranch/steps/build-buildproj-step.yml b/eng/pipelines/onebranch/steps/build-buildproj-step.yml
index 69c402792e..9e02243537 100644
--- a/eng/pipelines/onebranch/steps/build-buildproj-step.yml
+++ b/eng/pipelines/onebranch/steps/build-buildproj-step.yml
@@ -47,13 +47,14 @@ steps:
       secureFile: 'netfxKeypair.snk'
     name: keyFile
 
-  - task: MSBuild@1
+  - task: DotNetCoreCLI@2
     displayName: 'build.proj - Build${{ parameters.packageShortName }}'
     inputs:
-      solution: '$(REPO_ROOT)/build.proj'
-      configuration: '${{ parameters.buildConfiguration }}'
-      msbuildArguments: >-
+      command: build
+      projects: '$(REPO_ROOT)/build.proj'
+      arguments: >-
         -t:Build${{ parameters.packageShortName }}
+        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:ReferenceType=Package
         -p:SigningKeyPath="$(keyFile.secureFilePath)"
         -p:BuildNumber="$(Build.BuildNumber)"
diff --git a/eng/pipelines/onebranch/steps/pack-buildproj-step.yml b/eng/pipelines/onebranch/steps/pack-buildproj-step.yml
index 96bba59c20..7a97c260d1 100644
--- a/eng/pipelines/onebranch/steps/pack-buildproj-step.yml
+++ b/eng/pipelines/onebranch/steps/pack-buildproj-step.yml
@@ -56,13 +56,14 @@ parameters:
     type: string
 
 steps:
-  - task: MSBuild@1
+  - task: DotNetCoreCLI@2
     displayName: 'build.proj - Pack${{ parameters.packageShortName }}'
     inputs:
-      solution: '$(REPO_ROOT)/build.proj'
-      configuration: '${{ parameters.buildConfiguration }}'
-      msbuildArguments: >-
+      command: build
+      projects: '$(REPO_ROOT)/build.proj'
+      arguments: >-
         -t:Pack${{ parameters.packageShortName }}
+        -p:Configuration=${{ parameters.buildConfiguration }}
         -p:PackBuild=false
         -p:ReferenceType=Package
         -p:BuildNumber="$(Build.BuildNumber)"
diff --git a/eng/pipelines/onebranch/steps/roslyn-analyzers-buildproj-step.yml b/eng/pipelines/onebranch/steps/roslyn-analyzers-buildproj-step.yml
index ba8cb79c83..1f7c22a554 100644
--- a/eng/pipelines/onebranch/steps/roslyn-analyzers-buildproj-step.yml
+++ b/eng/pipelines/onebranch/steps/roslyn-analyzers-buildproj-step.yml
@@ -13,7 +13,8 @@
 # steps that perform versioning or signing.
 
 parameters:
-  # Optional arguments to pass to msbuild to indicate what version of dependencies should be used.
+  # Optional arguments to pass to dotnet build to indicate what version of dependencies should be
+  # used.
   - name: dependencyArguments
     type: string
     default: ''
@@ -30,7 +31,7 @@ parameters:
       - SqlClient
       - SqlServer
 
-  #  Version to assign to the project to build. This will be passed into msbuild as
+  #  Version to assign to the project to build. This will be passed into dotnet build as
   #  "-p:PackageVersion(packageShortName)".
   # @TODO: Make this optional to enable progressively migrating to single-source versioning.
   - name: packageVersion
diff --git a/eng/pipelines/stress/stress-tests-job.yml b/eng/pipelines/stress/stress-tests-job.yml
index 6eda90890b..a216c23864 100644
--- a/eng/pipelines/stress/stress-tests-job.yml
+++ b/eng/pipelines/stress/stress-tests-job.yml
@@ -105,8 +105,14 @@ jobs:
       - name: project
         value: $(Build.SourcesDirectory)/src/Microsoft.Data.SqlClient/tests/StressTests/SqlClient.Stress.Runner/SqlClient.Stress.Runner.csproj
 
-      # dotnet CLI arguments.
-      - name: dotnetArguments
+      # dotnet CLI arguments for build.
+      - name: buildArguments
+        value: >-
+          --verbosity ${{ parameters.dotnetVerbosity }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
+
+      # dotnet CLI arguments for run.
+      - name: runArguments
         value: >-
           --verbosity ${{ parameters.dotnetVerbosity }}
           --configuration ${{ parameters.buildConfiguration }}
@@ -172,7 +178,7 @@ jobs:
         inputs:
           command: build
           projects: $(project)
-          arguments: $(dotnetArguments)
+          arguments: $(buildArguments)
 
       # Set a flag so test steps can distinguish a build failure from a test failure.
       - pwsh: Write-Host "##vso[task.setvariable variable=buildSucceeded]true"
@@ -202,7 +208,7 @@ jobs:
           inputs:
             command: run
             projects: $(project)
-            arguments: $(dotnetArguments) --no-build -f ${{ runtime }} -e STRESS_CONFIG_FILE=config.json -- $(testArguments)
+            arguments: $(runArguments) --no-build -f ${{ runtime }} -e STRESS_CONFIG_FILE=config.json -- $(testArguments)
 
       # Run the stress tests for each .NET Framework runtime.
       - ${{ each runtime in parameters.netFrameworkTestRuntimes }}:
@@ -213,4 +219,4 @@ jobs:
           inputs:
             command: run
             projects: $(project)
-            arguments: $(dotnetArguments) --no-build -f ${{ runtime }} -e STRESS_CONFIG_FILE=config.json -- $(testArguments)
+            arguments: $(runArguments) --no-build -f ${{ runtime }} -e STRESS_CONFIG_FILE=config.json -- $(testArguments)
diff --git a/tools/targets/CompareMdsRefAssemblies.targets b/tools/targets/CompareMdsRefAssemblies.targets
index 1e89a26bf3..bccfa00930 100644
--- a/tools/targets/CompareMdsRefAssemblies.targets
+++ b/tools/targets/CompareMdsRefAssemblies.targets
@@ -102,9 +102,9 @@
   <!-- ================================================================== -->
   <Target Name="_BuildRefProject" DependsOnTargets="_SetApiCompatProperties">
     <Message Importance="high" Text="Building consolidated ref project (all TFMs)..." />
-    <MSBuild 
-      Targets="Restore;Build" 
-      Projects="$(RefProjectPath)"/>
+    <Exec
+      Command="dotnet build &quot;$(RefProjectPath)&quot; -p:Configuration=$(Configuration) -p:ReferenceType=$(ReferenceType)"
+      WorkingDirectory="$(RepoRoot)" />
   </Target>
 
   <!-- ================================================================== -->
@@ -134,7 +134,7 @@
       Text="--- Comparing %(_RefTfm.Identity) ref vs baseline $(BaselinePackageVersion) ---" />
 
     <Exec
-      Command="dotnet apicompat -l &quot;$(BaselineExtractDir)ref\%(_RefTfm.Identity)\Microsoft.Data.SqlClient.dll&quot; -r &quot;$(RefOutputDir)%(_RefTfm.Identity)\Microsoft.Data.SqlClient.dll&quot; --strict-mode &gt; &quot;$(ApiCompatResultsDir)%(_RefTfm.Identity).txt&quot; 2&gt;&amp;1"
+      Command="dotnet apicompat -l &quot;$(BaselineExtractDir)ref/%(_RefTfm.Identity)/Microsoft.Data.SqlClient.dll&quot; -r &quot;$(RefOutputDir)%(_RefTfm.Identity)/Microsoft.Data.SqlClient.dll&quot; --strict-mode &gt; &quot;$(ApiCompatResultsDir)%(_RefTfm.Identity).txt&quot; 2&gt;&amp;1"
       WorkingDirectory="$(RepoRoot)"
       ContinueOnError="ErrorAndContinue" />