From bbbe411d1895ab2e24f9fd408ff5eb16248788a7 Mon Sep 17 00:00:00 2001
From: Paul Medynski <31868385+paulmedynski@users.noreply.github.com>
Date: Wed, 8 Apr 2026 16:04:28 -0300
Subject: [PATCH 1/5] Task 43695: Use dotnet CLI exclusively

- Removed use of MSBuild in pipelines and documentation.
- Legacy build.proj still uses it, and will be replaced shortly by build2.proj which uses the dotnet CLI exclusively.
---
 .github/copilot-instructions.md               |  4 +-
 .../ado-pipelines.instructions.md             |  2 +-
 .../instructions/architecture.instructions.md |  2 +-
 .github/instructions/testing.instructions.md  | 23 ++---
 .../apicompat-ref-assembly-validation.md      |  4 +-
 BUILDGUIDE.md                                 | 87 +++++++++++--------
 doc/apps/AzureAuthentication/README.md        |  2 +-
 .../templates/jobs/ci-build-nugets-job.yml    | 10 ++-
 8 files changed, 77 insertions(+), 57 deletions(-)

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 0c78f461cb..22330226e0 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..7c2c4a23bd 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:FilterStatement="your_filter"`.
 
 ### Test Attributes
 ```csharp
@@ -139,19 +139,19 @@ public void TestIntermittentlyFails() { ... }
 
 ## Running Tests
 
-### Using MSBuild (Recommended)
+### Using `dotnet build` (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..6bad02e27d 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:CompareRefAssemblies /p:BaselinePackageVersion=6.1.4
 ```
 
 - `BaselinePackageVersion` is **required** (no default). The user must specify which published package to compare against.
@@ -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:CompareRefAssemblies /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 7c8e4acb93..488943befc 100644
--- a/BUILDGUIDE.md
+++ b/BUILDGUIDE.md
@@ -6,6 +6,7 @@ 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
@@ -16,9 +17,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 required to package the Microsoft.Data.SqlClient project. For convenience, this can be be done
 via the PowerShell script [tools/scripts/downloadLatestNuget.ps1](tools/scripts/downloadLatestNuget.ps1), however, any
@@ -45,12 +48,22 @@ package the project. The `build.proj` file provides convenient targets to accomp
 
 ### Building Projects
 
-From the root of your repository, run `msbuild` against `build.proj` with a build target, following this pattern:
+From the root of your repository, run `dotnet build` against `build.proj` with a build target, following this pattern:
+
+```bash
+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
-msbuild build.proj -t:<build_target> [optional_parameters]
+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.
 
@@ -87,17 +100,17 @@ placed in `artifacts/Microsoft.Data.SqlClient.ref/Project-<configuration>/<tfm>`
 
 Build all projects:
 ```bash
-msbuild build.proj -t:Build
+dotnet build -t:Build
 ```
 
 Build Microsoft.Data.SqlClient in Release configuration:
 ```bash
-msbuild 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
-msbuild build.proj -t:BuildAbstractions -p:PackageVersion=1.2.3
+dotnet build -t:BuildAbstractions -p:PackageVersion=1.2.3
 ```
 
 ### Testing Projects
@@ -105,10 +118,10 @@ msbuild build.proj -t:BuildAbstractions -p:PackageVersion=1.2.3
 This section provides a summary and brief example of how to execute tests for projects in this repository. **For more
 information about test procedures, including config file setup, see [TESTGUIDE.md](TESTGUIDE.md).**
 
-From the root of your repository, run `msbuild` against `build.proj` with a test target, following this pattern:
+From the root of your repository, run `dotnet build` against `build.proj` with a test target, following this pattern:
 
 ```bash
-msbuild build.proj -t:<test_target> [optional_parameters]
+dotnet build -t:<test_target> [optional_parameters]
 ```
 
 | `<test_target>`            | Description                                                                                                                                         |
@@ -140,37 +153,37 @@ A selection of parameters for test targets in `build.proj` relevant to common de
 Run Microsoft.Data.SqlClient unit tests:
 
 ```bash
-msbuild build.proj -t:TestSqlClientUnit
+dotnet build -t:TestSqlClientUnit
 ```
 
 Run Microsoft.Data.SqlClient manual test set 2:
 ```bash
-msbuild build.proj -t:TestSqlClientManual -p:TestSet=2
+dotnet build -t:TestSqlClientManual -p:TestSet=2
 ```
 
 Run Microsoft.Data.SqlClient functional tests against x86 dotnet:
 ```bash
-msbuild 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
-msbuild 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
-msbuild build.proj -t:TestSqlClientFunctional -p:TestFramework=net8.0
+dotnet build -t:TestSqlClientFunctional -p:TestFramework=net8.0
 ```
 
 ### Packaging Projects
 
-Just like bulding and testing the various projects in this repository, packaging the projects into NuGet packages is
-also handle by `build.proj`. From the root of your repository, run `msbuild` against `build.proj` with a test target,
+Just like building and testing the various projects in this repository, packaging the projects into NuGet packages is
+also handled by `build.proj`. From the root of your repository, run `dotnet build` against `build.proj` with a test target,
 following this pattern:
 
 ```bash
-msbuild build.proj -t:<pack_target> [optional_parameters]
+dotnet build -t:<pack_target> [optional_parameters]
 ```
 
 | `<build_target>`   | Desription                                                                          |
@@ -198,23 +211,27 @@ A selection of parameters for pack targets in `build.proj` relevant to common de
 #### Examples
 
 Package Microsoft.Data.SqlClient.Internal.Logging into a NuGet package:
+
 ```bash
-msbuild build.proj -t:PackLogging
+dotnet build -t:PackLogging
 ```
 
 Package Microsoft.Data.SqlClient if `nuget.exe` is not in the `$PATH` environment variable:
+
 ```bash
-msbuild build.proj -t:PackSqlClient -p:NugetPath="C:\my\nuget.exe"
+dotnet build -t:PackSqlClient -p:NugetPath="C:\my\nuget.exe"
 ```
 
 Package version 1.2.3 of Microsoft.Data.SqlClient.Extensions.Abstractions:
+
 ```bash
-msbuild build.proj -t:PackAbstractions -p:PackageVersionAbstractions=1.2.3
+dotnet build -t:PackAbstractions -p:PackageVersionAbstractions=1.2.3
 ```
 
 Package version Microsoft.Data.SqlClient.Extensions.Azure without building it beforehand:
+
 ```bash
-msbuild build.proj -t:PackAzure -p:PackBuild=false
+dotnet build -t:PackAzure -p:PackBuild=false
 ```
 
 ## Versioning
@@ -274,21 +291,28 @@ 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
-msbuild build.proj -t:PackLogging \
+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
-msbuild build.proj -t:PackAbstractions \
+Build v1.0.1 of Abstractions that depends on v2.2.2 of Logging:
+
+```bash
+dotnet build -t:PackAbstractions \
   -p:ReferenceType=Package \
   -p:PackageVersionAbstractions=1.0.1 \
   -p:PackageVersionLogging=2.2.2 \
 cp artifacts/Microsoft.Data.SqlClient.Extensions.Abstractions/Package-Debug/*.*pkg packages/
+```
 
-# Build SqlClient
+Build SqlClient:
+
+```bash
 msbuild -t:PackSqlClient \
   -p:ReferenceType=Package \
   -p:PackageVersionSqlClient=7.1.1 \
@@ -298,22 +322,17 @@ cp artifacts/Microsoft.Data.SqlClient/Package-Debug/*.*pkg packages/
 ```
 
 Run Microsoft.Data.SqlClient functional tests against the versions build above:
+
 ```bash
-msbuild 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:
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 afb20ac80e..33020e6901 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
@@ -184,7 +183,14 @@ jobs:
       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)
+      buildProperties: >-
+        ReferenceType=${{ parameters.referenceType }};
+        AbstractionsPackageVersion=${{ parameters.abstractionsPackageVersion }};
+        LoggingPackageVersion=${{ parameters.loggingPackageVersion }};
+        SqlClientPackageVersion=${{ parameters.mdsPackageVersion }};
+        AkvProviderPackageVersion=${{ parameters.akvPackageVersion }};
+        BuildNumber=$(Build.BuildNumber);
+        AssemblyBuildNumber=$(assemblyBuildNumber)
 
   - task: PublishPipelineArtifact@1
     displayName: 'Publish Pipeline Artifacts'

From cdb098bbe9424c79b69d3fa8d8cc23967b3aa91e Mon Sep 17 00:00:00 2001
From: Paul Medynski <31868385+paulmedynski@users.noreply.github.com>
Date: Mon, 27 Apr 2026 09:22:24 -0300
Subject: [PATCH 2/5] Task 43695: Use dotnet CLI exclusively

- Rebased to the latest build.proj and updated everything to use dotnet CLI.
---
 TESTGUIDE.md                                  |  46 +++---
 build.proj                                    |   2 +-
 .../templates/steps/ci-project-build-step.yml |  28 ++--
 .../templates/steps/run-all-tests-step.yml    | 143 +++++++-----------
 .../jobs/test-abstractions-package-ci-job.yml |   2 +-
 .../jobs/test-azure-package-ci-job.yml        |   2 +-
 .../onebranch/steps/build-buildproj-step.yml  |   9 +-
 .../onebranch/steps/pack-buildproj-step.yml   |   9 +-
 .../steps/roslyn-analyzers-buildproj-step.yml |   5 +-
 eng/pipelines/stress/stress-tests-job.yml     |   2 +-
 tools/targets/CompareMdsRefAssemblies.targets |   8 +-
 11 files changed, 115 insertions(+), 141 deletions(-)

diff --git a/TESTGUIDE.md b/TESTGUIDE.md
index fdcb8749ec..cb5b8cd25c 100644
--- a/TESTGUIDE.md
+++ b/TESTGUIDE.md
@@ -23,15 +23,19 @@ These projects target `net8.0`, `net9.0`, and `net10.0` on all platforms. On Win
 Use [build.proj](build.proj) from the repository root:
 
 ```bash
-msbuild build.proj -t:<test_target> [optional_parameters]
+dotnet build build.proj -t:<test_target> [optional_parameters]
 ```
 
-If `msbuild` is not available, use `dotnet msbuild`:
+Since `build.proj` is the only project file in the repo root, it can be omitted when building from
+the root:
 
 ```bash
-dotnet msbuild build.proj -t:<test_target> [optional_parameters]
+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
@@ -51,55 +55,55 @@ Test targets build the projects they depend on, so a separate build step is not
 Run the SqlClient unit tests:
 
 ```bash
-msbuild build.proj -t:TestSqlClientUnit
+dotnet build -t:TestSqlClientUnit
 ```
 
 Run the SqlClient functional tests:
 
 ```bash
-msbuild build.proj -t:TestSqlClientFunctional
+dotnet build -t:TestSqlClientFunctional
 ```
 
 Run the SqlClient manual tests:
 
 ```bash
-msbuild build.proj -t:TestSqlClientManual
+dotnet build -t:TestSqlClientManual
 ```
 
 Run only manual test set 2:
 
 ```bash
-msbuild build.proj -t:TestSqlClientManual -p:TestSet=2
+dotnet build -t:TestSqlClientManual -p:TestSet=2
 ```
 
 Run manual test sets 1 and 3:
 
 ```bash
-msbuild build.proj -t:TestSqlClientManual -p:TestSet=13
+dotnet build -t:TestSqlClientManual -p:TestSet=13
 ```
 
 Run Always Encrypted manual tests:
 
 ```bash
-msbuild build.proj -t:TestSqlClientManual -p:TestSet=AE
+dotnet build -t:TestSqlClientManual -p:TestSet=AE
 ```
 
 Run a specific target framework:
 
 ```bash
-msbuild 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
-msbuild 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
-msbuild build.proj -t:TestAzure -p:TestFilters=category!=failing
+dotnet build -t:TestAzure -p:TestFilters=category!=failing
 ```
 
 ## Test Parameters
@@ -132,13 +136,13 @@ Examples:
 
 ```bash
 # Run a single test by fully-qualified name.
-msbuild 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.
-msbuild build.proj -t:TestSqlClientManual -p:TestFilters=category=flaky
+dotnet build -t:TestSqlClientManual -p:TestFilters=category=flaky
 
 # Disable the default filter.
-msbuild build.proj -t:TestSqlClientFunctional -p:TestFilters=none
+dotnet build -t:TestSqlClientFunctional -p:TestFilters=none
 ```
 
 When passing filter expressions that contain shell-sensitive characters such as `&`, quote or escape the value as
@@ -222,14 +226,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 msbuild 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"
-msbuild build.proj -t:TestSqlClientManual -p:TestSet=2
+dotnet build -t:TestSqlClientManual -p:TestSet=2
 ```
 
 ## Configuration Properties
@@ -289,23 +293,23 @@ If `TestSet` is omitted, all sets are compiled and run. You can combine sets by
 Test results are written to `test_results` by default. Override the location with `TestResultsFolderPath`:
 
 ```bash
-msbuild 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
-msbuild build.proj -t:TestSqlClientManual -p:TestBlameTimeout=30m
+dotnet build -t:TestSqlClientManual -p:TestBlameTimeout=30m
 ```
 
 To disable hang blame collection:
 
 ```bash
-msbuild 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
-msbuild build.proj -t:TestSqlClientUnit -p:TestCodeCoverage=false
+dotnet build -t:TestSqlClientUnit -p:TestCodeCoverage=false
 ```
diff --git a/build.proj b/build.proj
index e32caef276..c2010a127a 100644
--- a/build.proj
+++ b/build.proj
@@ -552,7 +552,7 @@
     <!-- This is a bit hacky, and can be (@TODO:) removed once packaging is done w/o a nuspec from dotnet -->
     <PropertyGroup>
       <GetSqlClientPackageVersionCommand>
-        "$(DotnetPath)dotnet" msbuild "$(SqlClientProjectPath)"
+        "$(DotnetPath)dotnet" build "$(SqlClientProjectPath)"
         -nologo
         -verbosity:quiet
         -getProperty:SqlClientPackageVersion
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..3b9ebf29d0 100644
--- a/eng/pipelines/common/templates/steps/ci-project-build-step.yml
+++ b/eng/pipelines/common/templates/steps/ci-project-build-step.yml
@@ -75,18 +75,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 +97,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 a0e6e02426..a495b982dc 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 40cecf6e93..88615ee87c 100644
--- a/eng/pipelines/stress/stress-tests-job.yml
+++ b/eng/pipelines/stress/stress-tests-job.yml
@@ -102,7 +102,7 @@ jobs:
         value: >-
           --verbosity ${{ parameters.dotnetVerbosity }}
           --artifacts-path $(dotnetArtifactsDir)
-          --configuration ${{ parameters.buildConfiguration }}
+          -p:Configuration=${{ parameters.buildConfiguration }}
 
       # The contents of the config file to use for all tests.  We will write this to a JSON file and
       # then point to it via the STRESS_CONFIG_FILE environment variable.
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" />
 

From eaf06b7ab7d49a580c6f30151a0034b10b0303bc Mon Sep 17 00:00:00 2001
From: Paul Medynski <31868385+paulmedynski@users.noreply.github.com>
Date: Mon, 27 Apr 2026 12:22:16 -0300
Subject: [PATCH 3/5] Task 43695: Use dotnet CLI exclusively

- Converted the CI AKV build/pack steps to use build.proj targets.
---
 build.proj                                    |  2 +-
 .../templates/jobs/ci-build-nugets-job.yml    | 35 ++++++++++++-------
 2 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/build.proj b/build.proj
index c2010a127a..28471d25a8 100644
--- a/build.proj
+++ b/build.proj
@@ -82,7 +82,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/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml b/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
index 33020e6901..9b5a39d4cf 100644
--- a/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
+++ b/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
@@ -178,19 +178,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: src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/src/bin/${{ 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'

From d2769655541701702c67b4847f54d4045bb3d4a5 Mon Sep 17 00:00:00 2001
From: Paul Medynski <31868385+paulmedynski@users.noreply.github.com>
Date: Mon, 27 Apr 2026 15:24:54 -0300
Subject: [PATCH 4/5] Use dotnet-based pipeline steps and fix docs

---
 .github/instructions/testing.instructions.md        |  2 +-
 .github/plans/apicompat-ref-assembly-validation.md  | 12 ++++++------
 BUILDGUIDE.md                                       |  2 +-
 build.proj                                          | 13 ++++++++++++-
 .../common/templates/jobs/ci-build-nugets-job.yml   |  2 +-
 5 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/.github/instructions/testing.instructions.md b/.github/instructions/testing.instructions.md
index 7c2c4a23bd..7a8f077ce4 100644
--- a/.github/instructions/testing.instructions.md
+++ b/.github/instructions/testing.instructions.md
@@ -139,7 +139,7 @@ public void TestIntermittentlyFails() { ... }
 
 ## Running Tests
 
-### Using `dotnet build` (Recommended)
+### Using `build.proj` targets (Recommended)
 ```bash
 # Build and run all unit tests
 dotnet build build.proj -t:TestSqlClientUnit
diff --git a/.github/plans/apicompat-ref-assembly-validation.md b/.github/plans/apicompat-ref-assembly-validation.md
index 6bad02e27d..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 build 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 build build.proj /t:CompareRefAssemblies /p:BaselinePackageVersion=6.1.4
 
 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 build 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 488943befc..81b9cc4404 100644
--- a/BUILDGUIDE.md
+++ b/BUILDGUIDE.md
@@ -306,7 +306,7 @@ Build v1.0.1 of Abstractions that depends on v2.2.2 of Logging:
 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/
 ```
 
diff --git a/build.proj b/build.proj
index 28471d25a8..0f3fe45994 100644
--- a/build.proj
+++ b/build.proj
@@ -551,8 +551,19 @@
 
     <!-- This is a bit hacky, and can be (@TODO:) removed once packaging is done w/o a nuspec from dotnet -->
     <PropertyGroup>
+      <!--
+        This query intentionally uses `dotnet msbuild` instead of `dotnet build`.
+
+        Unlike the other commands in this file, this is not performing a normal build. It is asking
+        MSBuild to evaluate the SqlClient project and print the final value of
+        `SqlClientPackageVersion` so that the nuspec-based pack step can reuse the exact version that
+        the project computed after imports and versioning logic have run.
+
+        `-getProperty` is an MSBuild query switch, so using `dotnet msbuild` here is the most direct
+        and reliable way to express that intent.
+      -->
       <GetSqlClientPackageVersionCommand>
-        "$(DotnetPath)dotnet" build "$(SqlClientProjectPath)"
+        "$(DotnetPath)dotnet" msbuild "$(SqlClientProjectPath)"
         -nologo
         -verbosity:quiet
         -getProperty:SqlClientPackageVersion
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 9b5a39d4cf..d7dbb2b6b0 100644
--- a/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
+++ b/eng/pipelines/common/templates/jobs/ci-build-nugets-job.yml
@@ -194,7 +194,7 @@ jobs:
   - task: CopyFiles@2
     displayName: Copy AKV Package to Output Folder
     inputs:
-      sourceFolder: src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/src/bin/${{ parameters.buildConfiguration }}
+      sourceFolder: artifacts/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/${{ parameters.buildConfiguration }}
       contents: |
         **/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider*.nupkg
         **/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider*.snupkg

From 438d1abb2d1b616991b081c47ff336137dd03fd3 Mon Sep 17 00:00:00 2001
From: Paul Medynski <31868385+paulmedynski@users.noreply.github.com>
Date: Tue, 28 Apr 2026 13:50:11 -0300
Subject: [PATCH 5/5] Fixed a typo in agent testing instructions.

---
 .github/instructions/testing.instructions.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/instructions/testing.instructions.md b/.github/instructions/testing.instructions.md
index 7a8f077ce4..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 build property: `dotnet build build.proj -t:TestSqlClientUnit -p:FilterStatement="your_filter"`.
+This can be overridden via build property: `dotnet build build.proj -t:TestSqlClientUnit -p:TestFilters="your_filter"`.
 
 ### Test Attributes
 ```csharp