Updated July 2026

Building Powerful Desktop Apps with WPF

Class Duration

35 hours of live training delivered over 5 days.

Student Prerequisites

Professional C# programming experience
Basic WPF and XAML familiarity (layout, simple bindings), or completion of WPF with MVVM and C#
Familiarity with Git

Target Audience

C# developers who know their way around basic WPF and need to ship complete, professional desktop applications: the kind with demanding data grids, custom controls, rich visuals, background processing, and real deployment requirements. Ideal for teams building or modernizing line-of-business desktop tools, engineering and scientific applications, and internal products with long lifespans. Developers new to WPF should start with WPF with MVVM and C#; this course picks up where it ends and covers the rest of what production desktop applications demand.

Description

This hands-on course covers the full lifecycle of a serious WPF application on .NET 10: architecting with the Generic Host, dependency injection, configuration, and logging; mastering the demanding parts of the UI layer (the ItemsControl family, DataGrid at scale, custom and attached properties, control templating, and fully custom controls); and bringing applications to life with WPF's graphics, animation, and media capabilities. From there the course turns to what production apps actually need: robust data and service integration, application services like dialogs and notifications, Windows integration and native interop, performance profiling and memory-leak hunting, accessibility, migrating .NET Framework-era WPF applications to modern .NET, and finally packaging, deployment, and update strategies. Participants work on a realistic application throughout, with agentic AI coding assistants integrated into the workflow for control scaffolding, performance investigation, and refactoring, always under the developer's review.

Learning Outcomes

Architect WPF applications on .NET 10 with the Generic Host: dependency injection, configuration, and logging.
Build sophisticated data-heavy UI with the ItemsControl family, DataGrid, and UI virtualization.
Create custom controls, attached properties, and reusable control libraries.
Apply WPF's graphics stack (geometry, brushes, animation, and media) to build rich, responsive visuals.
Integrate data and services robustly: async patterns, local storage, REST APIs, and background processing.
Implement application services: dialogs, notifications, settings, and single-instance behavior.
Interoperate with the Windows platform: Win32 and WinRT APIs, native libraries, and shell integration.
Diagnose and fix performance problems: startup time, rendering, binding overhead, and memory leaks.
Upgrade .NET Framework WPF applications to modern .NET using the GitHub Copilot app modernization agent.
Package and deploy desktop applications with MSIX, ClickOnce, and self-contained deployment, including update strategies.
Apply agentic AI coding assistants across the workflow: scaffolding controls, investigating performance, and generating tests for review.

Training Materials

Comprehensive courseware is distributed online at the start of class. All students receive a downloadable MP4 recording of the training.

Software Requirements

A Windows machine with Visual Studio 2026 (Community edition is sufficient), the .NET 10 SDK, and Git. Access to an agentic AI coding assistant is required; a free tier is sufficient.

Training Topics

Architecting the Modern WPF Application

WPF on .NET 10: capabilities and Fluent theming
Generic Host: dependency injection, configuration, logging
Solution structure for long-lived applications
Application lifetime, startup, and shutdown
Agentic AI coding assistants in desktop development

Advanced Layout and UI Composition

Layout system internals: measure and arrange
Adaptive and resizable interfaces
User controls and composition strategies
Regions, docking, and shell patterns
Multi-window applications

The ItemsControl Family in Depth

ItemsControl, ListBox, ListView, TreeView
DataGrid: columns, editing, and validation at scale
UI and data virtualization
Grouping, sorting, and live shaping
Drag-and-drop interactions

Custom Controls and Templating

Dependency properties and attached properties
Control templates and the lookless control model
Building custom controls vs. user controls
Template parts, visual states, and theming support
Packaging reusable control libraries

Graphics, Animation, and Media

Shapes, geometry, and drawing primitives
Brushes, effects, and bitmap caching
Storyboards and animation
Media playback and imaging
When to reach beyond WPF's renderer

Data and Service Integration

Async patterns for responsive UI
Local data: SQLite and EF Core
REST and gRPC service clients
Background work: hosted services and progress reporting
Caching and offline tolerance

Application Services

Dialog and window services done testably
Settings and user preference persistence
Toast notifications and system tray integration
Single-instance applications and IPC
File system integration and recent-file lists

Windows Integration and Interop

Calling Win32 and WinRT APIs
P/Invoke and native library integration
Shell integration: jump lists, file associations
Clipboard, printing, and screen capture

Performance and Diagnostics

Startup time: measurement and reduction
Rendering performance and visual tree cost
Binding performance at scale
Memory leaks: detection and the usual suspects
Profiling tools and AI-assisted diagnosis

Accessibility and Polish

UI Automation and screen reader support
Keyboard navigation and focus management
High contrast and theme awareness
Localization readiness

Modernizing from .NET Framework

Migration paths from .NET Framework 4.8
The GitHub Copilot app modernization agent
API compatibility and the Windows Compatibility Pack
Incremental modernization for large applications

Packaging, Deployment, and Updates

MSIX packaging and distribution
ClickOnce for internal deployment
Self-contained vs. framework-dependent deployment
Update strategies and versioning
Crash reporting and telemetry