[WIP] Add async/await versions for DISM API long-running methods

[Copilot]

• Add AddPackageAsync to DismApi.AddPackage.cs
• Add AddCapabilityAsync to DismApi.AddCapability.cs
• Add CheckImageHealthAsync to DismApi.CheckImageHealth.cs
• Add CommitImageAsync to DismApi.CommitImage.cs
• Add DisableFeatureAsync to DismApi.DisableFeature.cs
• Add EnableFeatureAsync, EnableFeatureByPackageNameAsync, EnableFeatureByPackagePathAsync to DismApi.EnableFeature.cs
• Add MountImageAsync (by index and by name) to DismApi.MountImage.cs
• Add RemoveCapabilityAsync to DismApi.RemoveCapability.cs
• Add RemovePackageByNameAsync, RemovePackageByPathAsync to DismApi.RemovePackage.cs
• Add RestoreImageHealthAsync to DismApi.RestoreImageHealth.cs
• Add UnmountImageAsync to DismApi.UnmountImage.cs
• Update PublicAPI.Unshipped.txt with all new public API signatures
• Build and verify

Original prompt

Summary

Add async/await versions of all long-running DISM API methods that currently accept a DismProgressCallback. This addresses Issue #82 in the upstream repo (jeffkl/ManagedDism), which is labeled help wanted and enhancement.

Background

The current API is entirely synchronous. Every long-running method (e.g. AddPackage, EnableFeature, MountImage, etc.) blocks the calling thread while the native DISM operation runs. This causes UI freezes in WPF/WinForms/MAUI apps.

Current Pattern (example: AddPackage)

public static void AddPackage(DismSession session, string packagePath, bool ignoreCheck, bool preventPending, DismProgressCallback? progressCallback, object? userData)
{
    DismProgress progress = new DismProgress(progressCallback, userData);
    int hresult = NativeMethods.DismAddPackage(session, packagePath, ignoreCheck, preventPending, progress.EventHandle, progress.DismProgressCallbackNative, IntPtr.Zero);
    DismUtilities.ThrowIfFail(hresult, session);
}

Key classes involved:

• DismProgress (in src/Microsoft.Dism/DismProgress.cs) — wraps the native callback, has Cancel property that signals an EventWaitHandle, has Current/Total/UserData properties
• DismProgressCallback (in src/Microsoft.Dism/DismProgressCallback.cs) — public delegate: public delegate void DismProgressCallback(DismProgress progress);
• The internal native callback delegate is: internal delegate void DismProgressCallback(UInt32 current, UInt32 total, IntPtr userData);

Requirements

1. Add *Async methods to all DismApi partial classes that have long-running operations

For each method that currently accepts a DismProgressCallback, add an async counterpart. The async methods should:

• Follow the MethodNameAsync naming convention
• Accept IProgress<DismProgress>? instead of DismProgressCallback? for progress reporting (standard .NET pattern)
• Accept CancellationToken for cancellation (standard .NET pattern)
• Return Task (since the sync methods return void)
• Use Task.Run to offload the blocking native P/Invoke call to a thread pool thread
• Wire CancellationToken cancellation to DismProgress.Cancel = true (which signals the native EventWaitHandle)
• Throw OperationCanceledException when cancelled

2. Example of what an async method should look like

/// <summary>
/// Asynchronously adds a single .cab or .msu file to a Windows® image.
/// </summary>
/// <param name="session">A valid DISM Session.</param>
/// <param name="packagePath">A relative or absolute path to the .cab or .msu file.</param>
/// <param name="ignoreCheck">Specifies whether to ignore the internal applicability checks.</param>
/// <param name="preventPending">Specifies whether to add a package if it has pending online actions.</param>
/// <param name="progress">Optional. An IProgress instance to report progress.</param>
/// <param name="cancellationToken">A cancellation token to cancel the operation.</param>
/// <returns>A task representing the asynchronous operation.</returns>
/// <exception cref="DismException">When a failure occurs.</exception>
/// <exception cref="OperationCanceledException">When the operation is canceled.</exception>
public static Task AddPackageAsync(DismSession session, string packagePath, bool ignoreCheck, bool preventPending, IProgress<DismProgress>? progress = null, CancellationToken cancellationToken = default)
{
    return Task.Run(() =>
    {
        var dismProgress = new DismProgress(
            progress != null ? p => progress.Report(p) : null,
            null);

        using var registration = cancellationToken.Register(() => dismProgress.Cancel = true);

        int hresult = NativeMethods.DismAddPackage(session, packagePath, ignoreCheck, preventPending, dismProgress.EventHandle, dismProgress.DismProgressCallbackNative, IntPtr.Zero);

        cancellationToken.ThrowIfCancellationRequested();
        DismUtilities.ThrowIfFail(hresult, session);
    }, cancellationToken);
}

3. Methods that need async versions

Look through ALL DismApi.*.cs files in src/Microsoft.Dism/ and add async versions for every public method that has a DismProgressCallback parameter. These include but are not limited to:

• AddPackage → AddPackageAsync
• AddDriver → AddDriverAsync
• ApplyUnattend → ApplyUnattendAsync (if it has progress)
• CheckImageHealth → CheckImageHealthAsync
• CleanupMountpoints → CleanupMountpointsAsync (if it has progress)
• CommitImage → CommitImageAsync
• DisableFeature → DisableFeatureAsync
• EnableFeature / EnableFeatureByPackageName / EnableFeatureByPackagePath → async versions
• MountImage → MountImageAsync
• RemountImage → RemountImageAsync (if it has progress)
• RemovePackage / RemovePackageByName / RemovePackageByPath → async versions
• RestoreImageHealth → RestoreImageHealthAsync
• `UnmountIma...

This pull request was created from Copilot chat.

---

⚡ Quickly spin up Copilot coding agent tasks from anywhere on your macOS or Windows machine with Raycast.