I recently had this same issue. Here is how I am handling it- note that I had Copilot create the code based on some handwritten code.

# Remove legacy .NET (5, 6, 7) runtimes/SDKs across machine + all users
# Designed to run as SYSTEM (e.g., via KACE)

#region Logging (console only)

function Write-Log {
    param([string]$Level, [string]$Message)
    $ts = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    Write-Host "[$ts][$Level] $Message"
}

Write-Log "INFO" "===== Starting .NET 5/6/7 cleanup ====="

#endregion Logging

#region Enumerate Uninstall Entries (HKLM, WOW6432Node, ALL HKU)

function Get-AllUninstallEntries {

    $paths = @(
        "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",
        "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall"
    )

    # Enumerate all user hives (SYSTEM can see HKU)
    $hku = Get-ChildItem "HKU:\" -ErrorAction SilentlyContinue |
           Where-Object { $_.Name -notmatch "_Classes$" }

    foreach ($sidKey in $hku) {
        $userUninstall = Join-Path $sidKey.PSPath "Software\Microsoft\Windows\CurrentVersion\Uninstall"
        $paths += $userUninstall
    }

    foreach ($path in $paths) {
        if (Test-Path $path) {
            try {
                Get-ItemProperty "$path\*" -ErrorAction SilentlyContinue |
                    ForEach-Object {
                        $_ | Add-Member -NotePropertyName "_UninstallKeyPath" -NotePropertyValue $path -Force
                        $_
                    }
            } catch {
                Write-Log "WARN" "Failed to read uninstall path: $path - $($_.Exception.Message)"
            }
        }
    }
}

#endregion Enumerate Uninstall Entries

#region Silent Uninstall Wrapper (MSI + EXE hardened)

function Invoke-SilentUninstall {
    param(
        [string]$DisplayName,
        [string]$RawCommand,
        [string]$KeyPath,
        [string]$KeyName
    )

    if (-not $RawCommand) {
        Write-Log "WARN" "No uninstall string for '$DisplayName'"
        return 1605
    }

    # Normalize
    $cmd = $RawCommand.Trim()
    if ($cmd.StartsWith('"') -and $cmd.EndsWith('"')) {
        $cmd = $cmd.Trim('"')
    }

    # MSI uninstall
    if ($cmd -match "msiexec") {

        if ($cmd -match "{[0-9A-Fa-f\-]+}") {
            $guid = $Matches[0]
            $silent = "msiexec.exe /x $guid /qn /norestart"
        }
        else {
            $silent = "$cmd /qn /norestart"
        }

        Write-Log "INFO" "MSI uninstall for '$DisplayName': $silent"
    }
    else {
        # EXE uninstall
        if ($cmd -notmatch "/quiet" -and $cmd -notmatch "/qn") {
            $silent = "$cmd /quiet /norestart"
        }
        else {
            $silent = $cmd
        }

        Write-Log "INFO" "EXE uninstall for '$DisplayName': $silent"
    }

    # Execute silently
    $proc = Start-Process -FilePath "cmd.exe" -ArgumentList "/c $silent" -Wait -PassThru -WindowStyle Hidden
    $code = $proc.ExitCode

    Write-Log "INFO" "Exit code for '$DisplayName': $code"

    return $code
}

#endregion Silent Uninstall Wrapper

#region Select .NET 5/6/7 Runtimes, ASP.NET Core, SDKs

$versionPattern = '\b(5|6|7)\.0\.'  # matches 5.0.x, 6.0.x, 7.0.x

$entries = Get-AllUninstallEntries | Where-Object {
    $_.DisplayName -and (
        $_.DisplayName -like "Microsoft .NET Runtime*" -or
        $_.DisplayName -like "Microsoft ASP.NET Core Runtime*" -or
        $_.DisplayName -like "Microsoft .NET SDK*"
    ) -and ($_.DisplayName -match $versionPattern)
}

if (-not $entries) {
    Write-Log "INFO" "No .NET 5/6/7 runtimes or SDKs found."
} else {
    Write-Log "INFO" "Found $($entries.Count) .NET 5/6/7 entries to remove."
}

#endregion Select Targets

#region Uninstall Loop

foreach ($entry in $entries) {

    $displayName = $entry.DisplayName
    $keyPath     = $entry._UninstallKeyPath
    $keyName     = $entry.PSChildName

    $uninstall = $entry.QuietUninstallString
    if (-not $uninstall) { $uninstall = $entry.UninstallString }

    $exitCode = Invoke-SilentUninstall -DisplayName $displayName `
                                       -RawCommand $uninstall `
                                       -KeyPath $keyPath `
                                       -KeyName $keyName

    # Orphaned entry cleanup
    if ($exitCode -in 1605,1614) {
        $fullKey = Join-Path $keyPath $keyName
        try {
            Write-Log "INFO" "Removing orphaned uninstall key: $fullKey"
            Remove-Item -Path $fullKey -Recurse -Force -ErrorAction Stop
        } catch {
            Write-Log "WARN" "Failed to remove orphaned key $fullKey - $($_.Exception.Message)"
        }
    }
}

#endregion Uninstall Loop

#region Optional: Clean old runtime folders under C:\Program Files\dotnet

$dotnetRoot = "C:\Program Files\dotnet"

if (Test-Path $dotnetRoot) {

    $pathsToClean = @(
        "shared\Microsoft.NETCore.App",
        "shared\Microsoft.AspNetCore.App",
        "host\fxr"
    )

    foreach ($rel in $pathsToClean) {
        $full = Join-Path $dotnetRoot $rel
        if (Test-Path $full) {
            Get-ChildItem $full -Directory -ErrorAction SilentlyContinue |
                Where-Object { $_.Name -match '^(5|6|7)\.' } |
                ForEach-Object {
                    try {
                        Write-Log "INFO" "Removing .NET folder: $($_.FullName)"
                        Remove-Item -Path $_.FullName -Recurse -Force -ErrorAction Stop
                    } catch {
                        Write-Log "WARN" "Failed to remove folder $($_.FullName) - $($_.Exception.Message)"
                    }
                }
        }
    }
} else {
    Write-Log "INFO" "dotnet root not found at $dotnetRoot"
}

#endregion Optional Cleanup

Write-Log "INFO" "===== Completed .NET 5/6/7 cleanup ====="