Course Outline
1. Introduction to .NET MAUI and Cross-Platform Development
- .NET MAUI architecture and the application lifecycle
- Multi-platform project structure and single-project architecture
- Comprehending handlers, controls, layouts, and platform abstractions
- Platform-specific code implementation and conditional compilation
- Dependency management and the use of NuGet packages
- Utilizing Visual Studio and the .NET CLI for development
- Building and executing applications on Android, iOS, Windows, and macOS
- Exercise: Create and configure a multi-platform .NET MAUI application
2. Advanced MVVM Techniques and Patterns
- Reviewing MVVM principles and the separation of concerns
- Advanced data binding techniques
- Compiled bindings and optimizing binding performance
INotifyPropertyChangedand the use of observable collections- Implementing commands, asynchronous commands, and command parameters
- Utilizing CommunityToolkit.Mvvm and source generators
- Managing ViewModels, services, and application state
- Navigation strategies and navigation-aware ViewModels
- Handling data validation and application state management
- Exercise: Build a multi-page MVVM application with validation and asynchronous operations
3. Dependency Injection and Application Architecture
- Leveraging the built-in .NET dependency injection container
- Understanding service lifetimes: transient, scoped, and singleton
- Registering both platform-specific and shared services
- Constructor injection and effective service composition
- Applying dependency inversion and loose coupling principles
- Implementing repository and service patterns
- Managing application-wide dependencies
- Configuring environment-specific services
- Exercise: Refactor an application to utilize dependency injection
4. Deep Dive into Customizing and Extending .NET MAUI
- Understanding handlers and the .NET MAUI rendering architecture
- Implementing custom handlers for platform-specific behavior
- Mapping .NET MAUI controls to native platform controls
- Extending the functionality of existing controls
- Creating fully custom controls
- Integrating platform-specific behaviors and APIs
- Developing effects, behaviors, and reusable UI extensions
- Determining when to use handlers, behaviors, effects, or custom controls
- Exercise: Create and integrate a customized cross-platform control
5. Building Reusable Components and Libraries
- Designing reusable UI components
- Creating custom controls and ContentViews
- Component parameterization and data binding strategies
- Developing reusable behaviors and value converters
- Organizing shared application functionality
- Creating .NET class libraries specifically for MAUI applications
- Packaging and distributing reusable components
- Fundamentals of creating NuGet packages
- Exercise: Build a reusable component library
6. Advanced UI/UX, Layouts, and Animations
- Advanced layouts and responsive UI design principles
- Designing adaptive interfaces for phones, tablets, and desktops
- Utilizing dynamic resources and styling
- Managing resource dictionaries and themes
- Implementing light and dark themes
- Defining visual states and state-driven UI logic
- Creating advanced animations and transitions
- Implementing gesture recognition
- Custom drawing and graphics manipulation
- Considering accessibility requirements
- Exercise: Create a responsive and animated MAUI interface
7. Handling Complex Data Scenarios
- Consuming REST APIs within .NET MAUI applications
- Using HTTP clients for asynchronous data access
- Handling JSON serialization and deserialization
- Implementing error handling and retry strategies
- Local data persistence methods
- Working with SQLite and local databases
- Applying repository patterns for data access
- Designing offline-first applications
- Synchronizing local and remote data sources
- Strategies for conflict resolution
- Caching mechanisms and cache invalidation
- Exercise: Implement an offline-capable, data-driven application
8. Performance Tuning and Optimization
- Identifying performance bottlenecks
- Optimizing application startup time
- Managing memory and resource usage
- Reducing unnecessary UI updates
- Optimizing bindings and collection rendering
- Implementing efficient image loading and caching
- Writing async code to avoid UI-thread blocking
- Handling background processing tasks
- Reducing overall application size
- Managing memory leaks and object lifetimes
- Exercise: Profile and optimize an intentionally inefficient MAUI application
9. Advanced Debugging and Profiling Techniques
- Debugging cross-platform applications effectively
- Using breakpoints, watches, and exception handling
- Diagnosing UI and lifecycle issues
- Implementing logging and structured diagnostics
- Utilizing .NET diagnostics and profiling tools
- Performing CPU and memory profiling
- Detecting and resolving memory leaks
- Investigating slow UI rendering issues
- Debugging platform-specific issues
- Leveraging device and emulator diagnostics
- Exercise: Diagnose and resolve common performance and runtime problems
10. Architectural Patterns and Best Practices for Large-Scale Applications
- Selecting an appropriate application architecture
- Applying Clean Architecture concepts
- Implementing layered architecture
- Separating UI, business logic, and data access layers
- Using repository and service abstractions
- Applying SOLID principles in MAUI applications
- Managing application state
- Organizing projects based on features
- Designing modular applications
- Considering scalability and maintainability
- Exercise: Design the architecture of a production-scale MAUI application
11. Advanced Testing Strategies
- Unit testing ViewModels and services
- Testing business logic independent of the UI
- Mocking dependencies for isolated testing
- Testing asynchronous code
- Testing navigation flows and application state
- Concepts in UI and integration testing
- Designing a testable application architecture
- Considerations for continuous integration
- Exercise: Create a comprehensive test suite for a MAUI application
12. Security in .NET MAUI Applications
- Designing secure application architectures
- Securely storing sensitive information
- Implementing authentication and authorization
- Managing security tokens
- Addressing API security considerations
- Protecting locally stored data
- Ensuring secure communication with backend services
- Handling credentials and secrets
- Mitigating common mobile application security risks
- Exercise: Implement secure authentication and credential storage
13. Application Deployment and Distribution
- Building applications for different target platforms
- Differences between Release and Debug configurations
- Application signing and certificate management
- Android application packaging
- iOS application deployment concepts
- Windows application packaging
- Versioning and release management strategies
- Configuring environment-specific settings
- Publishing applications to app stores
- CI/CD considerations for MAUI projects
- Exercise: Prepare a MAUI application for production deployment
14. Latest .NET MAUI and Visual Studio Features
- Reviewing recent .NET MAUI improvements and changes
- Exploring new controls, APIs, and development capabilities
- Examining improvements to handlers and platform integration
- Leveraging Visual Studio tooling and productivity features
- Adopting modern .NET development practices
- Evaluating third-party libraries and MAUI Community Toolkit features
- Considerations for migration and upgrades
- Maintaining applications across different .NET versions
15. Capstone Exercise: Building a Production-Ready .NET MAUI Application
- Defining application requirements and architecture
- Designing the MVVM structure
- Configuring dependency injection
- Implementing reusable UI components
- Connecting to remote and local data sources
- Adding caching and synchronization mechanisms
- Implementing validation and error handling
- Applying performance optimizations
- Incorporating security and authentication
- Testing critical application functionality
- Preparing the application for deployment
16. Summary and Next Steps
- Review of advanced .NET MAUI concepts
- Common architectural and performance pitfalls
- Recommended development practices
- Resources for further learning
- Planning the next steps toward production-ready MAUI development
- Q&A and discussion of participants' projects
Requirements
- Strong proficiency in the C# programming language
- A solid grasp of object-oriented programming (OOP) principles
- Working knowledge of the .NET framework
Intended Audience
- Software developers
Custom Corporate Training
Training solutions designed exclusively for businesses.
- Customized Content: We adapt the syllabus and practical exercises to the real goals and needs of your project.
- Flexible Schedule: Dates and times adapted to your team's agenda.
- Format: Online (live), In-company (at your offices), or Hybrid.
Price per private group, online live training, starting from 2900 € + VAT*
Contact us for an exact quote and to hear our latest promotions
Testimonials (5)
The topic in general, the group dynamics,
David Silva Santiago - INSTITUTO MEXICANO DEL PETROLEO
Course - Advanced .NET MAUI
Machine Translated
The course interaction
Marco Aurelio Tellez Quijano - INSTITUTO MEXICANO DEL PETROLEO
Course - Advanced .NET MAUI
Machine Translated
the mastery of the topic by the instructor
Patricia Fernandez Nicolas - INSTITUTO MEXICANO DEL PETROLEO
Course - Advanced .NET MAUI
Machine Translated
As this is a new topic for me, I liked everything, and in fact, I will apply it in a project that I am developing
CARLOS MANUEL CRUZ MALERVA - INSTITUTO MEXICANO DEL PETROLEO
Course - Advanced .NET MAUI
Machine Translated
The exercises, the practical application of the topics
Leonardo Perez Tays - INSTITUTO MEXICANO DEL PETROLEO
Course - Advanced .NET MAUI
Machine Translated