Windows App Development

https://learn.microsoft.com/en-us/windows/apps/
Admin
This documentation provides comprehensive guidance and resources for designing, building, packaging,...
Tokens:3,109,810
Snippets:22,744
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install SDKs after initial setup with winapp init

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/usage

Re-runs winapp init to install SDKs after an initial setup with --setup-sdks none. Preserves existing files such as the manifest. Use --setup-sdks preview or --setup-sdks experimental for preview/experimental SDK versions.

```bash
# Re-run init to install SDKs - preserves existing files (manifest, etc.)
winapp init . --use-defaults --setup-sdks stable
```

--------------------------------

### Install Appium and Windows driver

Source: https://learn.microsoft.com/en-us/windows/apps/develop/testing

Commands to install Appium globally, install the Windows driver, verify the driver installation, and start the Appium server. Requires Node.js (LTS recommended).

```bash
npm install -g appium
```

```bash
appium driver install windows
```

```bash
appium driver list
```

```bash
appium
```

--------------------------------

### winapp run project-mode examples

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/usage

Project-mode examples for winapp CLI. The input defaults to "." when omitted. Use --project to pick a startup project from a solution, --aot to publish with Native AOT, and -p WindowsPackageType=None to force an unpackaged run. --detach prints the PID and forwards arguments after -- to the app.

```bash
# Build and run the project in the current directory (input defaults to ".")
winapp run

# Run a specific project
winapp run ./src/MyApp/MyApp.csproj

# Build and run from a solution (resolves the runnable app project, defines $(SolutionDir))
winapp run ./MyApp.sln

# Pick a startup project when the solution has more than one runnable app
winapp run ./MyApp.sln --project MyApp

# Release build for arm64
winapp run . -c Release --arch arm64

# Publish and run the Release configuration with Native AOT
winapp run . --aot -c Release

# Force an unpackaged run of a packaged project
winapp run . -p WindowsPackageType=None

# Run the existing build output without rebuilding, and capture crash diagnostics
winapp run . --no-build --debug-output

# Show winapp's build decision traces (dotnet build stays at minimal verbosity)
winapp run . --verbose

# Launch and detach (prints PID), forwarding args to the app
winapp run . --detach -- --my-flag value
```

--------------------------------

### Configure OpenTelemetry tracer provider with ActivitySource

Source: https://learn.microsoft.com/en-us/windows/apps/develop/testing

Creates an ActivitySource and starts an activity to demonstrate how OpenTelemetry SDKs listen to ActivitySource instances. This code is part of the OpenTelemetry setup and should be placed after installing the required packages.

```csharp
var activitySource = new System.Diagnostics.ActivitySource("MyApp");
// OpenTelemetry SDKs can listen to ActivitySource instances like this one.
using var activity = activitySource.StartActivity("Startup");
activity?.SetTag("app.version", "1.0.0");

```

--------------------------------

### Download and install Store packaged app silently (C#)

Source: https://learn.microsoft.com/en-us/windows/apps/distribute-through-store/how-to-transition-users-from-your-web-unpackaged-app-to-store-packaged-app

Uses AppInstallManager to get a free user entitlement (or device entitlement if no Store account), then starts the product install with no toast notifications. Monitors progress via StatusChanged and Completed events. Requires the product ID from Partner Center and the application name.

```csharp
    private async Task<bool> DownloadStoreVersionAsync()
    {
        var productId = "<Product Id from Partner Center>";
        var applicationName = "<name of your application>";

        var appInstallManager = new AppInstallManager();
        var entitlement = await appInstallManager.GetFreeUserEntitlementAsync(productId, string.Empty, string.Empty);
        if (entitlement.Status is GetEntitlementStatus.NoStoreAccount)
        {
            entitlement = await appInstallManager.GetFreeDeviceEntitlementAsync(productId, string.Empty, string.Empty);
        }
        if (entitlement.Status is not GetEntitlementStatus.Succeeded)
        {
            return false;
        }

        var options = new AppInstallOptions()
        {
            LaunchAfterInstall = true,
            CompletedInstallToastNotificationMode = AppInstallationToastNotificationMode.NoToast
        };
        var items = await appInstallManager.StartProductInstallAsync(productId, string.Empty, applicationName, string.Empty, options);
        var firstItem = items.FirstOrDefault();
        if(firstItem is null)
        {
            return false;
        }
        firstItem.StatusChanged += StoreInstallation_StatusChanged;
        firstItem.Completed += StoreInstallation_Completed;
        return true;
    }

    private void StoreInstallation_Completed(AppInstallItem sender, object args)
    {
        // Launch the new Store version when ready and close this application
        // The Store version will then be responsible of migrating the data and uninstall the unpackaged version
    }

    private void StoreInstallation_StatusChanged(AppInstallItem sender, object args)
    {
        var status = sender.GetCurrentStatus();
        switch(status.InstallState)
        {
            case AppInstallState.Installing:
                {
                    // Show installing status
                }
                break;
            case AppInstallState.Downloading:
                {
                    // Show download progress using status.PercentComplete
                }
                break;
            ...
        }

```

--------------------------------

### Create addon examples

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/usage

Example invocations for creating addons. The first uses the default name 'nativeWindowsAddon'; the second specifies a custom name with --name. The command supports --template cs or cpp (default cpp) and --verbose.

```bash
# Generate addon with default name
npx winapp node create-addon

# Generate custom named addon
npx winapp node create-addon --name myWindowsAddon

```

--------------------------------

### Install development certificate with winapp cert install

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/guides/electron-packaging

Run as Administrator to install the development certificate for the MSIX package. One-time setup.

```bash
# Run as Administrator:
npx winapp cert install .\devcert.pfx
```

--------------------------------

### Sample output of the query example

Source: https://learn.microsoft.com/en-us/windows/apps/develop/files/list-files-folders

Shows the expected output when the example runs, listing months with file counts and file names.

```text
July ‎2015 (2)
   MyImage3.png
   MyImage4.png
‎December ‎2014 (2)
   MyImage1.png
   MyImage2.png
```

--------------------------------

### Verify winapp CLI installation

Source: https://learn.microsoft.com/en-us/windows/apps/develop/ai-assisted/quickstart

Checks the installed version of the winapp CLI to verify setup.

```powershell
winapp --version

```

--------------------------------

### Set up the UI (XAML)

Source: https://learn.microsoft.com/en-us/windows/apps/develop/security/web-account-manager

Creates a simple XAML UI with a sign-in button and text blocks to display user information.

```XML
<StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
    <Button x:Name="SignInButton" Content="Sign in" Click="SignInButton_Click" />
    <TextBlock x:Name="UserIdTextBlock"/>
    <TextBlock x:Name="UserNameTextBlock"/>
</StackPanel>

```

--------------------------------

### Record command examples

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/ui-automation

Examples of using `winapp ui record` with various options: duration, frames, stdin stop, and screen capture.

```bash
# Record for 10 seconds
winapp ui record -a myapp --duration-sec 10 --fps 15 --output demo.mp4

# Add agent-readable frames
winapp ui record -a myapp --frames --duration-sec 10 --fps 10 --output evidence.mp4 --json

# Stop an unbounded recording through stdin
"" | winapp ui record -a myapp --json --output capture.mp4

# Include screen overlays and popups
winapp ui record -a myapp --capture-screen --duration-sec 5 --output with-popups.mp4
```

--------------------------------

### Sensitive content example (single label)

Source: https://learn.microsoft.com/en-us/windows/apps/develop/windows-integration/recall/recall-content-info-labels

Minimal JSON example for sensitive content, including the informationProtection object with a single label. The labelID and organizationID are example GUIDs.

```json
{
  "@context": "https://schema.org",
  "@type": "DocumentObject",
  "identifier": "doc-123",
  "informationProtection": {
    "@type": "SensitivityLabel",
    "state": "sensitive",
    "labels": [
      {
        "labelID": "F96E0B19-8C3A-4D5A-8B9A-2E8CFC43247B",
        "organizationID": "00aa00aa-bb11-cc22-dd33-44ee44ee44ee"
      }
    ]
  }
}
```

--------------------------------

### Navigate to project and install dependencies

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/guides/tauri

Change into the project directory and install npm dependencies.

```powershell
cd tauri-app
npm install

```

--------------------------------

### Start the transform animation (C#)

Source: https://learn.microsoft.com/en-us/windows/apps/develop/platform/xaml/transforms

C# event handler that starts the Storyboard when the Rectangle is pressed. It is the code-behind for the XAML example.

```C#
void StartAnimation (object sender, RoutedEventArgs e) {
    myStoryboard.Begin();
}
```

--------------------------------

### Get app install directory as StorageFolder

Source: https://learn.microsoft.com/en-us/windows/apps/develop/files/file-access-permissions

Retrieves a StorageFolder representing the app's install directory. Use this to access files and folders in the install directory via StorageFolder methods. The install directory is read-only and cannot be accessed through the file picker.

```C#
Windows.Storage.StorageFolder installedLocation = Windows.ApplicationModel.Package.Current.InstalledLocation;
```

```C++/WinRT
#include <winrt/Windows.Storage.h>
...
Windows::Storage::StorageFolder installedLocation{ Windows::ApplicationModel::Package::Current().InstalledLocation() };
```

--------------------------------

### Install Node.js

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/guides/electron-index

Install Node.js using winget. This is a prerequisite for the development environment.

```bash
winget install OpenJS.NodeJS --source winget
```

--------------------------------

### App OnLaunched with loading page and async initialization

Source: https://learn.microsoft.com/en-us/windows/apps/develop/performance/app-startup-performance

Use the app constructor only for critical data structures. In OnLaunched, create a window, assign lightweight content (LoadingPage), activate the window, and start async initialization. After loading data, replace the window content with GameHomePage.

```C#
public partial class App : Application
{
    public static Window MainWindow { get; private set; } = null!;

    protected override void OnLaunched(LaunchActivatedEventArgs args)
    {
        base.OnLaunched(args);

        MainWindow = new MainWindow();
        MainWindow.Content = new LoadingPage();
        MainWindow.Activate();

        _ = InitializeAsync();
    }

    private async Task InitializeAsync()
    {
        // Asynchronously restore state and load the minimum data needed
        // to create the first interactive UI.
        await LoadInitialDataAsync();

        MainWindow.Content = new GameHomePage();
    }

    private static Task LoadInitialDataAsync()
    {
        // Download data to populate the initial UI.
        return Task.CompletedTask;
    }
}
```

--------------------------------

### Add Electron debug identity (npx winapp node add-electron-debug-identity)

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/guides/electron-js-notification

Adds debug identity to the Electron app so notifications work. This command is already part of the `postinstall` script added in the setup guide, so it runs automatically after `npm install`. Run it manually whenever you modify `Package.appxmanifest`, update app assets, or reinstall dependencies.

```bash
npx winapp node add-electron-debug-identity

```

--------------------------------

### Initialize and start video recording with PrepareLowLagRecordToStorageFileAsync

Source: https://learn.microsoft.com/en-us/windows/apps/develop/camera/basic-photo-capture

Initialize the media recording with a storage file and MediaEncodingProfile, then start capturing video. Uses CreateMp4 for MP4 encoding.

```C#
var myVideos = await Windows.Storage.StorageLibrary.GetLibraryAsync(Windows.Storage.KnownLibraryId.Videos);
StorageFile file = await myVideos.SaveFolder.CreateFileAsync("video.mp4", CreationCollisionOption.GenerateUniqueName);
m_mediaRecording = await m_mediaCapture.PrepareLowLagRecordToStorageFileAsync(
        MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Auto), file);

m_mediaCapture.RecordLimitationExceeded += m_mediaCapture_RecordLimitationExceeded;
await m_mediaRecording.StartAsync();

```

--------------------------------

### winapp get-winapp-path

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/usage

Gets paths to installed Windows SDK components, including workspace directory, package installation directories, and generated header locations.

```APIDOC
## winapp get-winapp-path

### Description
Get paths to installed Windows SDK components.

### Method
CLI

### Command
`winapp get-winapp-path [options]`

### What it returns
- Paths to `.winapp` workspace directory
- Package installation directories
- Generated header locations
```

--------------------------------

### winapp store examples

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/usage

Example invocations of the winapp store command: listing apps in a Microsoft Partner Center account and publishing a package to the Microsoft Store.

```bash
# List all apps in your Microsoft Partner Center account
winapp store app list

# Publish a package to the Microsoft Store
winapp store publish ./myapp.msix --appId <your-app-id>

```

--------------------------------

### Initialize UWP app with msstore init

Source: https://learn.microsoft.com/en-us/windows/apps/publish/msstore-dev-cli/commands

Initializes a UWP project for Microsoft Store publishing. Provide the path to the project root.

```console
msstore init "C:\path\to\uwp_app"
```

--------------------------------

### Get and modify the default OverlappedPresenter

Source: https://learn.microsoft.com/en-us/windows/apps/develop/ui-input/manage-app-windows

Shows how to re-apply the default presenter and then get a reference to it as an OverlappedPresenter to modify its properties. The example disables the maximize and minimize buttons.

```csharp
appWindow.SetPresenter(AppWindowPresenterKind.Default);
OverlappedPresenter defaultPresenter = (OverlappedPresenter)appWindow.Presenter;
defaultPresenter.IsMaximizable = false;
defaultPresenter.IsMinimizable = false;

```

--------------------------------

### Get and set TextBox text in C#

Source: https://learn.microsoft.com/en-us/windows/apps/develop/ui/controls/text-box

C# example of getting and setting the Text property of a TextBox. Use this to read or update the text content programmatically.

```C#
string sampleText = SampleTextBox.Text;
...
SampleTextBox.Text = "Sample text retrieved";

```

--------------------------------

### Install the WPF migration skill with GitHub Copilot CLI

Source: https://learn.microsoft.com/en-us/windows/apps/develop/ai-assisted/migrate/wpf-to-winui

Run this command to install the winui@awesome-copilot plugin for GitHub Copilot CLI, which assists with WPF to WinUI 3 migration.

```PowerShell
gh copilot plugin install winui@awesome-copilot

```

--------------------------------

### winapp cert usage examples

Source: https://learn.microsoft.com/en-us/windows/apps/dev-tools/winapp-cli/usage

Examples for the cert subcommands: generate with a publisher, export a .cer, use JSON output, view certificate details, and install to the machine store.

```bash
# Generate certificate for specific publisher
winapp cert generate --publisher "CN=My Company" --output ./mycert.pfx

# Generate certificate and export public key .cer file
winapp cert generate --publisher "CN=My Company" --export-cer

# Generate certificate with JSON output (for scripting)
winapp cert generate --publisher "CN=My Company" --json

# View certificate details
winapp cert info ./mycert.pfx

# View certificate details as JSON
winapp cert info ./mycert.pfx --json

# Install certificate to machine
winapp cert install ./mycert.pfx

```
Tokens:
Raw