WPF Course with the SVILUPPATORE MIGLIORE method
Develop Windows desktop applications with modern, performant and maintainable interfaces. The framework chosen by enterprise companies that refuse to settle for Windows Forms.
1-on-1 Mentor On YOUR code Measurable results
Your team develops Windows desktop applications. Perhaps you still use Windows Forms. Perhaps you have a WPF application built years ago with no clear architecture, code-behind everywhere and XAML that nobody dares touch.
The result is always the same: an application that works but is a nightmare to maintain, slow to evolve and with a user interface that looks like it came out of 2008.
WPF is the most powerful framework Microsoft has ever created for desktop applications. But its power is also its danger: used badly, it produces worse code than Windows Forms.
If you are a CTO with a critical desktop application to modernise, a team leader who wants to introduce MVVM and binding correctly, or a senior developer who wants to master XAML and build UIs that impress, this path is designed for you.
Why WPF is still the right choice for enterprise desktop applications
In a world that talks only about web and cloud, the desktop is not dead. In fact: enterprise desktop applications generate more revenue than ever, ERP software, industrial automation, financial tools, medical applications, engineering tools.
WPF offers what no web framework can provide:
- Native performance
- GPU-accelerated rendering, no browser overhead.
- Full Windows integration
- File system, hardware, drivers, COM, system services.
- Unlimited UI customisation
- Data templates, control templates, styles, animations: everything is customisable without limits.
- Native MVVM
- The cleanest architectural pattern for separating UI and business logic, natively supported by WPF.
With .NET 10, WPF is more alive than ever: full support, improved performance, compatibility with the latest .NET APIs.
What you learn: the complete programme
4 phases, 16 modules of intensive training on YOUR code.
4 phases, 16 modules of intensive training on YOUR code.
PHASE 1: Solid Foundations (Weeks 1-4)
- 1
MVVM Architecture: zero code-behind, fully testable
Code-behind is the quickest way to build WPF applications and the surest way to make them unrecoverable. Every line of logic in the code-behind is a line you cannot test, reuse or maintain without touching the UI itself. Here you learn enterprise MVVM, the version that holds up on projects with millions of lines.
Programma
- MVVM and ViewModelHow to eliminate every line of code-behind making every feature verifiable in isolation
- Native Dependency InjectionHow to integrate .NET DI in WPF and stop creating objects manually scattered throughout the code
- Navigation serviceHow to navigate between screens without Views knowing each other, the only way to add pages without breaking existing ones
- ViewModel lifecycleHow to manage scoping and disposal eliminating memory leaks that slow the app over time
- Unit tests on ViewModelsHow to test every UI logic in milliseconds without opening a window
- WPF anti-patternsHow to recognise the 6 most common mistakes from God ViewModels to event handler leaks that emerge in production
Risultato
Your WPF code is testable, maintainable and every new developer understands the structure in less than an hour. No more fear of touching someone else's code.
- 2
Advanced Data Binding: master the heart of WPF
Data binding is the heart of WPF. But used badly it becomes the worst enemy of the application. Degraded performance, invisible bugs and silent memory leaks are almost always caused by misconfigured bindings. Here you learn to master it with full awareness of the update cycle.
Programma
- Binding Mode and update cycleHow to control exactly when the UI updates without relying on default behaviours
- Source Generators for INPCHow to eliminate INotifyPropertyChanged boilerplate going from 20 lines to 1 without invisible magic
- MultiBinding in XAMLHow to calculate derived values directly in XAML without writing C# in the view
- Real-time validationHow to show automatic visual errors on forms without repetitive validation code
- Binding debuggingHow to find a broken binding in 30 seconds with Snoop and PresentationTraceSources
- Virtualisation on ObservableCollectionHow to keep the UI fluid with millions of rows thanks to virtualisation and batch updates
Risultato
No more bindings broken silently, no more UI that does not update. Every piece of data flows exactly where it should, when it should.
- 3
Layout System: responsive from laptop to 4K
Enterprise applications must work on 15-inch screens and on 4K ultrawide monitors. A layout built without knowing the Measure/Arrange pass breaks silently on different resolutions. Here you learn to build layouts that adapt perfectly to any configuration.
Programma
- Advanced Grid and DockPanelHow to build complex layouts that adapt automatically without a single line of C# code
- Measure/Arrange passHow WPF's layout system works and how to use it to optimise any slow layout
- DPI AwarenessHow to make the app perfect on 1080p and 4K monitors with automatic DPI Awareness
- Responsive UI with DataTriggersHow to build interfaces that adapt automatically without extra code
- Optimised renderingHow to speed up complex layouts with virtualisation and deferred loading for reduced active elements
- UI Automation and accessibilityHow to certify compliance for public administration, healthcare and enterprise clients
Risultato
Your applications work perfectly on any monitor configuration, from a salesperson's laptop to the multi-screen workstation on the factory floor.
- 4
Styling and Theming: from grey application to professional design system
Grey WPF applications from the 2000s do not convey professionalism to clients. Without a centralised design system, every visual change becomes a hunt for duplicates scattered throughout the entire codebase. Here you learn to build professional theming managed from a single point.
Programma
- Scalable Resource DictionaryHow to organise the design system to add a brand colour in one place and see it applied everywhere
- Implicit vs Explicit StylesHow to choose the right type to prevent impossible-to-debug CSS-like conflicts
- Custom ControlTemplatesHow to completely redesign buttons, sliders and DataGrids for a modern look
- Light/dark mode and themingHow to implement theme and brand changes at runtime without touching business logic
- Material and Fluent DesignHow to integrate modern design systems into WPF for a visually contemporary desktop app
- Design token systemHow to manage colours, spacing and fonts in one centralised file with guaranteed consistency throughout the suite
Risultato
Your WPF applications have a modern, professional appearance. You can change theme and branding in minutes, not weeks.
PHASE 2: Intermediate Power (Weeks 5-10)
- 5
Custom Controls: build components your team reuses for years
Custom controls are WPF's superpower: the difference between UI that gets copy-pasted and UI that is truly reused. Confusing UserControl, CustomControl and Templated Control is why third-party controls always seem more flexible than yours. Here you understand when to use what and how to build enterprise-level components.
Programma
- UserControl vs CustomControlHow to choose the correct type for each case, the wrong choice blocks reuse
- Robust Dependency PropertiesHow to build properties with callbacks and coercion for controls that behave like system ones
- Attached PropertiesHow to add reusable behaviours to any control without inheritance and without coupling
- Routed EventsHow to propagate interactions in the visual tree so events reach whoever needs them
- Adorner LayerHow to use the adorner layer for drag, highlight and custom tooltips with professional UX
- NuGet libraryHow to publish and version custom controls to share them across all company projects
Risultato
Build a library of custom controls that the team reuses across all projects. Stop rewriting the same UI for every application.
- 6
DataGrid and Virtualisation: one million rows without freeze
80% of enterprise applications have complex data grids with hundreds of thousands of rows. An unoptimised WPF grid with 50,000 rows locks the interface for seconds on every scroll or sort. Here you learn to handle huge datasets without the user ever seeing the hourglass cursor.
Programma
- Grouping, sorting and filteringHow to implement them in-place on the DataGrid without server round-trips
- UI and Data VirtualisationHow to handle 1 million rows without blocking the interface, configuring what WPF does not activate by default
- ObservableCollection vs CollectionViewSourceHow to choose the right collection to avoid unnecessary re-renders and difficult bugs
- Client-side ICollectionViewHow to filter, group and sort without database round-trips for interactive operations
- Server-side pagination with EFHow to load only the necessary rows from the database, when needed
- Excel, PDF and CSV exportHow to implement the performant export every enterprise user expects without blocking the UI
Risultato
Your grids load instantly even with huge datasets. Users will never see the hourglass cursor during data operations.
- 7
Async/Await in WPF: interface always responsive, zero freeze
90% of WPF app freezes come from blocking operations executed on the UI thread. A synchronous network call in the code-behind is all it takes to block the interface for seconds. Here you learn to write asynchronous code that keeps the UI always responsive.
Programma
- Async/Await without deadlocksHow to write the 5 correct patterns and avoid the 3 anti-patterns that cause deadlocks in production
- Dispatcher and SynchronizationContextHow to update the UI from worker threads without InvalidOperationException at runtime
- Task.Run vs async/awaitWhen to use each pattern correctly to avoid freezes or race conditions in the interface
- IProgress and accurate progress barsHow to show real progress instead of an infinite spinner with IProgress
- CancellationTokenHow to make any long operation cancellable with immediate stop without ghost operations in the background
- Async commands with statesHow to build commands that reflect loading, success and error states in the interface
Risultato
Your applications are always responsive, even during heavy operations. The user can always interact, cancel and see progress in real time.
- 8
Graphics and Dashboards: visualisations that impress
WPF has a very powerful graphics engine based on DirectX, but most developers barely use it. The same applications that seem dull and flat could have real-time dashboards and visualisations that impress. Here you learn to exploit WPF's graphics power to the fullest.
Programma
- WPF Drawing APIHow to build maps, floor plans and network diagrams with precise geometric visualisations in XAML
- WriteableBitmap at 60fpsHow to build oscilloscopes, industrial monitors and real-time heatmaps without external frameworks
- Chart library comparisonHow to choose between LiveCharts2, OxyPlot and ScottPlot based on your specific use case
- Interactive CanvasHow to build diagram editors and clickable floor plans with zoom, pan and selection
- Viewport3DHow to integrate industrial models, machine simulations and digital twins in the desktop application
- Storyboards and animationsHow to build smooth transitions with easing functions that communicate state without distracting
Risultato
You create dashboards and visualisations that impress clients and management. Real-time charts, interactive diagrams, interfaces that communicate complex data at a glance.
PHASE 3: Enterprise Architecture (Weeks 11-16)
- 9
Service Integration: WPF connected to the real world
Enterprise applications do not live in isolation: they communicate with backends, external services and legacy systems. A misconfigured REST call in WPF blocks the interface and shows an infinite spinner to users. Here you learn the patterns that make service integration solid and testable.
Programma
- HttpClient with resilienceHow to configure retry, timeout and circuit breaker to not block the interface when the server is slow
- SignalR in WPFHow to receive real-time updates from the server with data that updates without the user pressing F5
- gRPC for microservicesHow to integrate high-performance communications faster than REST for intensive operations
- WCF migrationHow to proceed gradually without rewriting everything, with old and new service coexisting
- Offline-first with SQLiteHow to make the application work without a connection with automatic synchronisation when back online
- RabbitMQ and Azure Service BusHow to integrate message queues for push notifications and total decoupling between app and backend
Risultato
Your WPF applications communicate robustly with any backend. They work even offline and synchronise automatically when the network returns.
- 10
Plugin Architecture: the app that grows without becoming a monolith
Enterprise applications grow over time. Adding features to a monolith means risking regressions every time. A plugin architecture allows installing new modules without stopping or redeploying the application. Here you learn to design this architecture with MEF and Prism.
Programma
- Plugin system with MEFHow to build dynamic assembly loading to install new modules without stopping the application
- Prism and UI regionsHow to manage areas of the interface that load only when needed without code in the shell
- Event AggregatorHow to make independent modules communicate without direct dependencies between components
- Composite UIHow to design shell and pluggable modules to add features by distributing a single file
- Permissions and licences per moduleHow to show each client only the features they have purchased
- Plugin versioningHow to maintain backward compatibility for updates that do not break third-party modules
Risultato
Your application grows organically without becoming an unmanageable monolith. New features are added as plugins without risk of regressions.
- 11
WPF Testing: release with confidence, zero regressions
Testing WPF applications seems impossible to those with code-behind everywhere. With correct MVVM, every ViewModel is testable in isolation without opening a window. Here you learn complete testing strategies covering from business logic to UI automation.
Programma
- ViewModel tests with xUnitHow to verify UI logic in milliseconds in the CI pipeline without opening a window
- End-to-end integration testsHow to cover the entire application flow to discover bugs before deployment
- UI automation with FlaUIHow to build bots that click buttons, fill in forms and verify results like a human tester
- Snapshot testingHow to block visual regressions so the test signals every unexpected change before release
- Realistic code coverageHow to set sensible goals for WPF without obsessing over 100%, covering what matters
- Roslyn analyzers and SonarQubeHow to detect bugs and code smells while writing code, not 3 months later in production
Risultato
Release with confidence. Automated tests catch bugs before they reach production. Regressions become a thing of the past.
- 12
DevOps and Distribution: one button, a thousand workstations updated
The best code in the world is useless if you cannot distribute it reliably. A manual deployment of a WPF application is an inexhaustible source of human errors and misaligned versions. Here you automate everything: from build to packaging, from testing to crash reports in production.
Programma
- CI/CD for WPFHow to build pipelines with GitHub Actions or Azure DevOps for automatic build, test and packaging on every commit
- MSIX distributionHow to guarantee clean installation, atomic updates and automatic rollback in case of errors
- ClickOnce vs MSIX vs WinGetHow to choose the right distribution solution for each scenario, without months of trial and error
- Silent auto-updateHow to ensure users find the updated version on startup without any action required from them
- Structured logging with SerilogHow to have a complete trace of what happened when a bug report arrives
- Automatic crash reportingHow to see production errors before the user opens a support ticket
Risultato
Release a new version by pressing a button. Users receive updates automatically. Crashes are reported before they are even reported by users.
PHASE 4: Mastery and Specialisation (Weeks 17-24)
- 13
Performance Optimisation: from 30 seconds to 2 seconds startup
When the application becomes large, performance becomes critical and the causes are often invisible. Optimising without measuring is like searching in the dark: hours are wasted on the wrong code. Here you learn to profile, diagnose and optimise with real numbers.
Programma
- WPF Performance ProfilerHow to find bottlenecks in minutes with optimisations based on measurements, not intuitions
- Visual tree optimisationHow to reduce the number of active elements to free CPU and leverage the GPU with Freezable
- Hardware accelerationHow to enable Rendering Tier to let the GPU do the heavy work and free the CPU
- Memory leaks with Memory ProfilerHow to find objects never released and event handlers never disconnected
- Optimised startupHow to reduce startup time with lazy loading and assembly optimisation to get to work immediately
- BenchmarkDotNet for measurementsHow to measure the real impact of every optimisation to justify decisions to management
Risultato
Your application starts in 2 seconds, not 30. Operations are instant. Users stop complaining about performance.
- 14
WPF and Artificial Intelligence: the desktop becomes smart
Artificial intelligence is not just for web applications. Desktop apps can become truly intelligent. A WPF application with integrated ML.NET predicts, suggests and automates without cloud round-trips. Here you learn to bring AI directly into the application your users already use every day.
Programma
- ML.NET integrated in WPFHow to add predictions and anomaly detection that warn operators before a fault occurs
- Azure Cognitive ServicesHow to integrate OCR and voice recognition for input from scanners, cameras and microphones
- Semantic Kernel and LLMsHow to integrate an AI assistant in the desktop application users work with every day
- Intelligent UIsHow to build contextual suggestions and autocomplete for faster input with fewer errors
- OpenCV in WPFHow to process images in real time for visual inspection, defect recognition and industrial QR reading
- Local vs cloud AIHow to decide where to process for each use case while guaranteeing the privacy of company data
Risultato
Your WPF applications become intelligent: they suggest, predict, automate. Your users have an AI assistant integrated in the software they use every day.
- 15
Strategic Migration: protect the investment and prepare for the future
WPF is not eternal and technologies change. Planning for the future is an architect's responsibility. Migrating without a strategy means rewriting everything and losing the investment made in years of development. Here you learn to modernise gradually, protecting what already works.
Programma
- Blazor in WPF with WebView2How to bring web features into the desktop application without rewriting the entire suite
- WPF vs MAUIWhen to migrate and when not to, with objective criteria that avoid months of wasted work
- XAML IslandsHow to introduce modern WinUI components inside the legacy app without touching existing code
- Shared cross-framework librariesHow to extract business logic to share between WPF, Blazor and MAUI
- Strangler Fig PatternHow to migrate module by module while keeping the application running in production
- Realistic technology roadmapHow to build a 12-24 month plan based on costs, risks and value, not on hype
Risultato
You have a clear roadmap for the future. You protect the existing WPF investment and prepare for tomorrow's technologies without disrupting anything today.
- 16
Capstone Project: your enterprise application reviewed by the architect
Put together everything you have learned in a complete real project. Applying patterns in a fictional project does not prepare you for the challenges of real company code. Here you work on YOUR code with direct architect review and solutions tailored to your specific context.
Programma
- Enterprise design from scratchHow to define architecture, layers, modules and dependencies before writing the first line
- Professional code reviewHow to receive concrete feedback on real company code, not invented exercises
- Guided refactoringHow to take a codebase from spaghetti code to solid architecture, module by module, without stopping the business
- Communicating architectural decisionsHow to present technical choices to management so they obtain approval and budget
- Post-course maintenance planHow to build an evolutionary roadmap that keeps the code healthy over time
- Q&A with the architectHow to tackle the specific challenges of your context with tailored solutions, not generic answers
Risultato
You leave the path with a complete WPF enterprise application, consolidated best practices and the confidence to tackle any WPF challenge fully autonomously.
The method: Architecture of Progressive Mastery
We use the Architecture of Progressive Mastery applied to WPF: bi-weekly sessions on real code, with initial assessment of the existing application, definition of the target architecture and progressive porting.
If you have a WinForms application to modernise, the path includes a migration strategy that does not require rewriting everything from scratch: we migrate module by module, keeping the application running throughout the process.
- Assessment, We analyse existing code, identify technical debt, define the roadmap.
- MVVM Architecture, We build the reference architecture with DI, navigation, messaging.
- UI modernisation, Progressive redesign of the interface with Material/Fluent Design.
- Testing, We introduce unit tests on ViewModels and integration tests.
- Autonomy, The team becomes autonomous in evolving the application.
Who this path is for
Developer who wants to specialise
You know C# but have never worked with WPF, or have used it briefly and want to build solid foundations. You start from scratch with the framework but have the right mindset to grow quickly.
WPF developer who wants to make the leap
You have used WPF for years but feel your code could be better. You want to go from 'it works' to 'it is well designed'. MVVM, testing, modular architecture: everything you need to become senior.
Team lead or CTO with critical WPF applications
You have WPF applications in production that generate revenue but are difficult to maintain. You want to modernise them, train the team and reduce technical risk without stopping the business.
Who is Matteo Migliore
What professionals who have followed the path say
Those who study with Matteo have the opportunity to access a very meaningful and concrete experience, entering the world of software development with a reliable and competent guide.
His training is a real opportunity for young people who want to pursue a career as a software architect.
I definitely recommend him, especially for the professionalism he has always shown and his ability to explain numerous topics that are normally not covered in these types of courses.
The WPF course I had the fortune to take with Matteo Migliore literally opened up an incredible world for me, allowing me to acquire all the techniques that will enable me to tackle increasingly important projects.
I definitely recommend Matteo for the technical content and the experience he brings; the training journey was also rich in anecdotes where he shared his experiences going all the way back to when he was a child.
I recommend Matteo's course especially to beginners and anyone who needs to learn how to structure an application, because this way you can start already with a correctly built architecture.
One difference I notice compared to other courses is a great passion for training, understood in a very broad sense. It is a mission for them, and beyond the specific WPF course topics, I always find tips and suggestions on cross-cutting subjects like design, software control and testing — which gives me something extra in my overall development approach.
Often there is little time and great difficulty managing on your own the issues you encounter daily, and if you tend to limit yourself to your own knowledge you end up stuck in your own mistakes.
Going back over things I had studied at university, explained step by step in a new language I had not studied before, was extremely useful.
I turned to our consultant, Matteo Migliore, to enter this new world.
Thanks to the course I learned a programming approach built in a much more sensible way than what I was doing before.
I recommend Matteo because he is a very competent person who loves his work and cares about helping others, making them more productive and more capable of mastering technology.
What I liked most was the new management of the project structure: separating the UI from the design layer, and in particular not writing code directly in the UI but structuring it properly.
Matteo doesn't simply read from a pre-prepared script but is able to go deeper into syntactic elements and design patterns, perfectly following the needs of whoever is learning.
Investment and path
Paths are structured to measure based on the number of participants, duration and complexity of the project.
Fill in the form to receive the complete programme and a personalised quote based on your specific needs.
Individual Path
1 participant, personalised mentoring
- 16 complete modules (6 months)
- Live bi-weekly 1-on-1 sessions
- Direct work on your company code
- 12-month platform access
- Chat support between sessions
Team Path
2-3 participants, department transformation
- 16 complete modules (6 months)
- Reference architecture on company codebase
- Shared component library
- Intensive code review of production code
- 12-month platform access for everyone
Intensive Workshop
1-3 days on specific topics
- Focus on specific modules of your choice
- Up to 5 participants
- Complete teaching material
- Follow-up session at 30 days
Fill in the form and receive all the information about the WPF path. We will analyse your current level and the most suitable path for your needs.
Free analysis We assess your current level and the state of your WPF application
Talk to Matteo Not with a salesperson, but with a real expert who will guide you
Practical guidance Receive useful guidance even if you decide not to continue