[build] Provision .NET SDK via standard scripts, drop xaprepare's installer

[jonathanpeppers]

Context

Today, dotnet/android provisions the .NET SDK with bespoke C# code in
build-tools/xaprepare/xaprepare/Steps/Step_InstallDotNetPreview.cs
(220 lines) — fetching dotnet-install.{sh,ps1} from a hard-coded URL,
running it with config-driven args, and supporting a --with-archive
override for offline scenarios. Other .NET repos (dotnet/sdk,
dotnet/runtime, dotnet/aspnetcore) all use Arcade's standard
eng/common/dotnet-install.{sh,ps1} flow — there's no reason for us to
maintain a custom one.

Phase 1 of a longer migration

This PR is the SDK-provisioning slice of a larger effort to delete
xaprepare entirely so the build collapses to:

./eng/install-dotnet.sh                 # one-time bootstrap
dotnet build Xamarin.Android.sln        # everything else

xaprepare today is 333 KB / 116 files but only 4 step files have real
logic (Step_PrepareDotNetWorkloads, Step_GenerateFiles,
Step_GenerateFiles.Windows, Step_GenerateCGManifest). Once each step
has an MSBuild equivalent, the surrounding 332 KB of plumbing
(Application/, ToolRunners/, OperatingSystems/) can also be
deleted. Follow-up PRs are planned for each remaining step.

What changes here

New: eng/install-dotnet.{sh,ps1}

Thin bootstrap wrappers that:

1. Read <MicrosoftNETSdkPackageVersion> from eng/Versions.props
   (single source of truth, kept up to date by darc when
   Microsoft.NET.Sdk flows from dotnet/dotnet).
2. Download Microsoft's official dotnet-install.{sh,ps1} from
   https://builds.dotnet.microsoft.com/dotnet/scripts/v1/ (cached
   under bin/$Configuration/dotnet/).
3. Invoke it with --version <pinned> and --install-dir bin/$Configuration/dotnet.

Install location stays at bin/$Configuration/dotnet/ (where xaprepare
put it) so dotnet-local.{cmd,sh} continues to work unchanged.

Wired in everywhere xaprepare ran the install before

• Makefile: prepare: target now depends on a new install-dotnet
  target that calls ./eng/install-dotnet.sh.
• build-tools/scripts/PrepareWindows.targets: new _InstallDotNet
  target runs eng/install-dotnet.ps1 before _BuildXAPrepare.
• build.cmd: unchanged — the existing dotnet msbuild ... -t:Prepare
  flow still works because _BuildXAPrepare now installs the SDK first.

Step_InstallDotNetPreview → Step_PrepareDotNetWorkloads

The old 220-line installer step is deleted. A new ~120-line
Step_PrepareDotNetWorkloads.cs replaces it and only does
Android-specific workload prep (NuGet cleanup, package-download.proj
restore with 3-attempt retry, and workload manifest copy). Everything
SDK-install-related (download script, archive override,
InstallDotNetAsync etc.) is gone.

global.json:tools.dotnet — NOT added

I originally tried pinning the SDK version in global.json:tools.dotnet
(the standard Arcade convention), but verified in
arcade-services/.../DependencyFileManager.cs that darc
does not auto-update global.json:tools.dotnet when the
Microsoft.NET.Sdk asset flows. Only specific Arcade/Helix SDK names
and the literal name dotnet are special-cased. So a tools.dotnet
pin would have permanently drifted from the auto-flowed
eng/Versions.props:MicrosoftNETSdkPackageVersion.

The wrappers therefore read the version from Versions.props directly
and bypass Arcade's eng/common/tools.{sh,ps1} (which would otherwise
strict-mode-read $GlobalJson.tools). Single source of truth = the
darc-flowed eng/Versions.props.

Other cleanups

• Configurables.{Unix,Windows}.cs: removed Urls.DotNetInstallScript
  (no longer needed).
• Context.cs + Main.cs: removed LocalDotNetSdkArchive /
  --dotnet-sdk-archive plumbing. (The replacement is the standard
  DOTNET_INSTALL_DIR env var that anyone needing offline support can
  set themselves.)

Verified on Windows

Action	Time
Cold eng/install-dotnet.ps1 (with download)	~12s
Warm re-run (idempotent fast path)	~2.5s
Full dotnet msbuild Xamarin.Android.sln -t:Prepare	~88s

The dotnet --list-sdks output after a cold install correctly shows
11.0.100-preview.5.26268.112 at
bin/Debug/dotnet/sdk. Re-running Prepare is silent (no spurious
re-installs, no extra workload restores).

Migration path for the rest of xaprepare (future PRs)

Step	Migration target
Step_PrepareDotNetWorkloads	MSBuild .targets file
Step_GenerateCGManifest	CI yaml step or .targets file
Step_GenerateFiles[.Windows]	Per-file MSBuild targets with Inputs/Outputs
(everything)	Delete build-tools/xaprepare/ and PrepareWindows.targets

End state: ./eng/install-dotnet.sh + dotnet build. Nothing else.

[Copilot]

Pull request overview

This PR migrates dotnet/android’s .NET SDK provisioning from xaprepare’s custom C# installer to the standard dotnet-install.{sh,ps1} flow, keeping the install location at bin/$Configuration/dotnet/ and moving Android-specific workload prep into a standalone MSBuild project.

Changes:

• Add eng/install-dotnet.{sh,ps1} wrappers that read the pinned SDK version from eng/Versions.props, download dotnet-install.{sh,ps1}, and install into bin/$Configuration/dotnet.
• Wire the new install/workload-prep flow into Makefile, Windows PrepareWindows.targets, and CI templates; remove xaprepare’s SDK-install step and related plumbing.
• Introduce src/workloads/workloads.csproj to restore required runtime packs + workload manifest packages and copy manifests into the locally installed SDK.

Reviewed changes

Copilot reviewed 24 out of 24 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
src/Xamarin.Installer.Build.Tasks/README.md	Updates developer instructions to use eng/install-dotnet.* + build workloads project.
src/workloads/workloads.csproj	New MSBuild project to restore runtime packs/manifests and copy manifests into the local SDK.
Makefile	Adds install-dotnet prerequisite and runs workloads provisioning during prepare.
eng/install-dotnet.sh	New Unix bootstrap script to install pinned SDK into bin/$Configuration/dotnet.
eng/install-dotnet.ps1	New Windows bootstrap script to install pinned SDK into bin\$Configuration\dotnet.
build-tools/xaprepare/xaprepare/Steps/Step_InstallDotNetPreview.cs	Deletes the bespoke xaprepare SDK installer step.
build-tools/xaprepare/xaprepare/Scenarios/Scenario_Standard.cs	Removes SDK install step from the standard xaprepare scenario.
build-tools/xaprepare/xaprepare/Scenarios/Scenario_AndroidTestDependencies.cs	Removes SDK install step from Android test dependency scenario.
build-tools/xaprepare/xaprepare/package-download.proj	Deletes the old runtime-pack restore project used by xaprepare.
build-tools/xaprepare/xaprepare/Main.cs	Removes --dotnet-sdk-archive option plumbing.
build-tools/xaprepare/xaprepare/ConfigAndData/Configurables.Windows.cs	Removes DotNet install script URL configurable (no longer needed).
build-tools/xaprepare/xaprepare/ConfigAndData/Configurables.Unix.cs	Removes DotNet install script URL configurable (no longer needed).
build-tools/xaprepare/xaprepare/ConfigAndData/Configurables.cs	Removes workload manifest path helpers tied to the deleted step.
build-tools/xaprepare/xaprepare/Application/Context.cs	Removes LocalDotNetSdkArchive property.
build-tools/scripts/PrepareWindows.targets	Ensures SDK install runs before building xaprepare; adds workloads provisioning to Prepare.
build-tools/automation/yaml-templates/stage-package-tests.yaml	Removes xaprepare scenario parameter usage from test setup.
build-tools/automation/yaml-templates/stage-msbuild-emulator-tests.yaml	Removes xaprepare scenario parameter usage from test setup.
build-tools/automation/yaml-templates/setup-test-environment.yaml	Removes xaprepareScenario parameter pass-through.
build-tools/automation/yaml-templates/setup-test-environment-steps.yaml	Replaces xaprepare invocation with eng/install-dotnet.* + workloads provisioning.
build-tools/automation/yaml-templates/setup-test-environment-public.yaml	Removes xaprepareScenario parameter pass-through.
build-tools/automation/yaml-templates/run-xaprepare.yaml	Deletes the shared pipeline template that ran xaprepare.
build-tools/automation/yaml-templates/run-emulator-tests.yaml	Removes xaprepare scenario parameter usage from test setup.
build-tools/automation/azure-pipelines-public.yaml	Removes xaprepare scenario parameter usage from test environment setup.
build-tools/automation/azure-pipelines-nightly.yaml	Removes xaprepare scenario parameter usage from test environment setup.

[jonathanpeppers]

/review

[github-actions]

✅ Android PR Reviewer completed successfully!

[github-actions]

🤖 Android PR Review — [build] Provision .NET SDK via standard scripts, drop xaprepare's installer

I reviewed the diff independently before reading the description. This is a well-scoped, largely subtractive change: the bespoke ~220-line Step_InstallDotNetPreview + package-download.proj are replaced by thin eng/install-dotnet.{sh,ps1} bootstrappers and a src/workloads/workloads.csproj (Microsoft.Build.NoTargets) that PackageDownloads the runtime packs / workload manifests and copies the manifests into the locally-installed SDK. Good direction — collapsing toward dotnet-install + dotnet build is a real maintainability win.

Verified OK (potential concerns I checked and dismissed)

• ✅ No dangling references to the removed symbols (Step_InstallDotNetPreview, DotNetInstallScript, the MicrosoftNETWorkloadMono*Dir configurables, package-download.proj).
• ✅ Every xaprepareScenario / run-xaprepare.yaml consumer was removed — no orphaned YAML parameters that would break pipeline parsing.
• ✅ No provisioning silently dropped: androidsdk.csproj (SDK/JDK) and emulator setup are untouched; the affected scenarios were effectively no-ops apart from the removed step.
• ✅ Property/import ordering in workloads.csproj is fine — DotNetStableTargetFramework, MicrosoftNETCoreAppRefPackageVersion, and the manifest bands resolve via Directory.Build.props → eng/Versions.props (auto-imported before the body); XAPackagesDir / DotNetPreviewPath exist by the time the target runs. Microsoft.Build.NoTargets is pinned in global.json.
• ✅ Backslash path separators in the copy target normalize correctly on Linux/macOS (verified empirically).
• ✅ Makefile passes -p:Configuration=$(CONFIGURATION) to prepare-workloads, matching the install-dotnet install path (bin/$Configuration/dotnet).

Findings (none merge-blocking)

Sev	Area	Note
⚠️	install scripts	A failed/partial download poisons the cached dotnet-install.{sh,ps1} — no temp-then-move, and an empty cached script silently "succeeds".
⚠️	workloads	Drops the old forced stale-cache cleanup before copy; possible stale runtime packs/manifests if an internal version string is reused.
💡	workloads target	_CopyWorkloadManifests has no Inputs/Outputs and uses AfterTargets="Build".
💡	formatting	<Error> Condition should come first (Postmortem #33).

Notes

• 📝 The PR description is slightly stale — it refers to a Step_PrepareDotNetWorkloads.cs replacement, but the actual change introduces src/workloads/workloads.csproj (and deletes package-download.proj). Worth updating so reviewers/git log archaeologists aren't misled.
• ⏳ CI for the head commit (11dc706) is still in progress (combined status pending; the dotnet-android build is queued/running). Please confirm it goes green before merging — an earlier commit's legs passed, but the current head hasn't completed.

Nice cleanup overall. 👍

Generated by Android PR Reviewer for issue #11636 · 1.7K AIC · ⌖ 66.1 AIC · ⊞ 37.8K
_{Comment /review to run again}

[github-actions]

🤖 ⚠️ Error handling — A failed or interrupted download leaves a partial/empty file at $install_script. On the next run, [[ ! -f "$install_script" ]] is false, so the truncated script is reused — and an empty bash script exits 0, so dotnet-install silently never runs and the SDK isn't installed (the failure then surfaces much later, confusingly). Download to a temp path and mv into place only on success (the removed Step_InstallDotNetPreview.DownloadDotNetInstallScript used exactly this temp-then-copy pattern). eng/install-dotnet.ps1 has the same issue with Invoke-WebRequest -OutFile.

(Rule: Atomic download to avoid a poisoned cache)

[jonathanpeppers]

Fixed in 12fa9b8 — both scripts now download to dotnet-install.{sh,ps1}.tmp.$PID and atomically rename into place only on success.

[github-actions]

🤖 ⚠️ Patterns — The removed Step_InstallDotNetPreview deliberately deleted the microsoft.netcore.app.runtime.mono.android* and Mono workload package dirs from the NuGet cache and rm'd each manifest destination before copying — "as we could possibly be using a new runtime commit with a previously installed version." This flow instead relies on the NuGet cache plus SkipUnchangedFiles="true", so a rolling internal build that reuses a version string with changed content can serve a stale runtime pack / manifest. Please confirm that's intentional now (e.g. darc always bumps the version), or restore the pre-copy clean. (The old step also wrapped the restore in a 3× retry with backoff; NuGet's built-in HTTP retry likely covers it, but worth a glance since CI feed flakiness was the original motivation.)

(Rule: Preserve behavior when replacing logic)

[jonathanpeppers]

Intentional — internal builds bump the version string when content changes, and SkipUnchangedFiles="true" handles re-extraction inside the NuGet cache. The 3× retry is similarly delegated: dotnet restore already does HTTP retries, and CI re-runs cover the rare case where a feed is truly flaky for minutes. Happy to add a stamp-based cache bust later if we ever see this hurt.

[github-actions]

🤖 💡 Formatting — Put the Condition attribute first on this <Error> element so it's immediately clear when the task fires:

<Error
    Condition=" !Exists('$(_DotNetSdk)') "
    Text="Expected .NET SDK at '$(_DotNetSdk)' but the directory does not exist. Run eng/install-dotnet.sh (or eng/install-dotnet.ps1) first."
/>

(Rule: Condition attribute first (Postmortem #33))

[jonathanpeppers]

Fixed in 12fa9b8.

[github-actions]

🤖 💡 MSBuild targets — _CopyWorkloadManifests writes files but has no Inputs/Outputs, so it re-globs and re-runs on every invocation (the SkipUnchangedFiles="true" avoids timestamp churn, but the work still happens). Also, AfterTargets="Build" runs even if Build failed. Consider a stamp file in the intermediate dir (or Inputs/Outputs) so MSBuild can skip it once the manifests are in place. Minor for a prep-only project, but it's the repo convention for file-writing targets.

(Rule: Targets that write files need Inputs/Outputs)

[jonathanpeppers]

Skipping for now — SkipUnchangedFiles="true" makes the warm path essentially free (~0.5s and no file writes), and this project is only invoked from make prepare / PrepareWindows / the CI setup template, never from a hot inner loop. Happy to add Inputs/Outputs if we see it cause incremental-build noise.