Xamarin.Forms is the embodying of Microsoft’s idea of writing code once and running it on a multitude of devices. Using XAML and C#, existing .NET developers can easily build iOS, Android and UWP applications, all sharing a maximum amount of code. While the framework is rather complete, developers will need to go off the beaten track and write controls and native interactions with features of the devices, for which native Xamarin will be used.Mer information & fakta
In this course, students will get a deep-dive in the different ways of building Xamarin applications. The used tooling as well as other interesting tooling will be explained. The main focus of the course is Xamarin.Forms, where we will start from the basics. Students will also get a good understanding of the XAML language, which is the best approach to build Xamarin.Forms apps. After this course, students will feel confident about building apps with Xamarin.Forms.
Next, the focus of the course will move to MVVM, the pattern typically used for building XAML-based applications. First, students will understand the concepts of MVVM (including the view model, commanding, behaviours, messaging…). Next, they will see how to build a proven architecture based on MVVM that isn’t using any actual frameworks.
All of this will be supported with both hands-on labs (step-by-step instructions) as well as challenges where students can work alone or in groups of 2 to build Xamarin.Forms applications.
Note that we will cover UWP only briefly but students will get to play with UWP during the labs as well.
- C# knowledge is expected, as this course (and Xamarin.Forms) use C#.
Please note that it might be good that students who aren’t familiar with C# spend some time with some Pluralsight courses to at least have the basics before coming to this course.
- XAML knowledge is not required.
- A PC with Visual Studio 2017 with at least Update 15.9 is required per student.
- A Mac is only required if the student wants to run labs on iOS
Chapter 1: Introduction to cross-platform development with Xamarin
In the first chapter, we are looking at a complete, high-level overview of the Xamarin platform. We will look at the different development environments (Visual Studio and Visual Studio for Mac) and explore all the different building blocks that make up the Xamarin toolset. An overview of the setup when creating your own environment is also included.
- Hello Xamarin!
- C# everywhere
- How Xamarin works
- Xamarin components
- Visual Studio integration
- Visual Studio for Mac
- Xamarin Forms and XAML
- Xamarin Test Cloud/ Visual Studio App Center
- Preparing your environment for Xamarin
Chapter 2: Cross-platform code-sharing approaches and architectural considerations
In chapter 2, we are exploring the different approaches which are possible to create cross-platform applications which share code between UWP, iOS and Android. This chapter focuses mostly on the architectural considerations.
- Code sharing options
- Architecture of a Cross-platform Xamarin application
- Shared Projects
- Portable Class Libraries (legacy)
- .NET Standard
Chapter 3: Introduction to Xamarin.Forms
Using Forms, we can easily create apps using a single code-base, including the UI, targeting iOS, Android and UWP, while still creating a native app. In this chapter, we will explore the basics of Xamarin.Forms.
- Introduction to Xamarin Forms
- Project structure
- Lists and Cells
- Platform features
- Working with the DependencyService
- Using Xamarin Plugins
- Custom renderers
- App Lifecycle
Chapter 4: XAML and databinding in Xamarin.Forms
Forms lends itself to being used with XAML and even supports data binding. This chapter will look at how we can use these. It will also make sure that everyone is fully up-to-speed with XAML.
- What is XAML?
- Building an app with XAML
- XAML Syntax
- XAML Markup Extensions
- Data binding
- Binding Modes
Chapter 5: Creating Xamarin.Forms applications using MVVM
MVVM is a UI pattern that allows us to build more maintainable and testable applications. It turns out that this pattern also works great in combination with Xamarin and it allows us to reach a level of code reuse which is very high. In this chapter, we are going to learn how to create MVVM-based Xamarin applications.
- Hello MVVM
- View model locators
- Testing MVVM-based applications with unit tests
Chapter 6: Building an enterprise application architecture with Xamarin.Forms
In this chapter, we will basically apply what we have learned in the previous chapter and we will see how a pre-made enterprise application based on the MVVM pattern. Different patterns, typically used in enterprise, data-driven applications will be used here, including DI.
- Application architecture
- Working with data and repositories
- Navigation and wrappers for navigation
- Bootstrapping the application
- Dependency injection (Autofac)
- Unit testing
Chapter 7: Navigation patterns in Xamarin.Forms
Building a demo application is easy. Building a complex application requires more thought. One of the important areas is navigation. It’s important for an app to have a good navigation path throughout its contents, making it friendly for its users. In this chapter, we will explore the most commonly used navigation patterns including master detail and the drawer navigation.
Chapter 8: Working with custom renderers and effects
The amount of controls available in Xamarin.Forms is limited. However, it’s an extension point and developers can, using custom renderers, extend the behaviour of applications. Custom renderers are very powerful but also sometimes take quite some time to create. Effects solve this and we’ll explore these here as well.
Since XF 3, it’s also possible to more easily integrate Xamarin.Forms and classic Xamarin. We will explore that here as well.
During a lab, students will get to extend the Xamarin.Forms platform as well!
Chapter 9: More layout in Xamarin.Forms
Basic layout gets you on your way to build Xamarin.Forms applications. But real-life applications require more work. In this chapter, we will explore in much more detail how we can create more complex types of layouts using Xamarin.Forms. We will also explore the new FlexLayout and the option to perform a layout using stylesheets. Finally, we will also explore control template and the Visual State Manager, another new feature of Xamarin.Forms 3.
Chapter 10: The ListView in-depth
The ListView is probably one of the most flexible controls built into Xamarin.Forms. It’s really extensible and comes with a lot of options. In this chapter, we will explore things like DataTemplateSelector, headers & footers, context actions and more. In a lab, students will get the chance to use the ListView in a more advanced scenario.
Chapter 11: Working with data (databases and cloud/services)
Almost all applications out there use data, there’s no denying that. In this chapter, we will explore what we can do in Xamarin.Forms to get that data into the application. We will see how applications can connect with all types of services (REST, WCF…). We will also look at how we can bring several cloud services into our applications (storage, mobile services…). Once we have the data in the data in the application, we will also need to store it. This can be done in files or a local database.
After exploring the options, students will get the chance to apply the knowledge again in a lab.
Chapter 12: Xamarin.Forms Essentials
What started as an open-source project has evolved into a large set of useful components we can use in our Xamarin.Forms applications. In this chapter, we will explore XF Essentials and use it to add cool features to our apps – with ease!
Chapter 13: Miscellaneous topics
In this final chapter, students will learn several other topics used commonly in Xamarin.Forms applications.
- Application lifecycle
- Using custom fonts
- Material design in our apps
- Using Gestures
- Localizing applications
- Drawing with SkiaSharp
- Storing secrets in Xamarin.Forms applications
- Performance optimizations in Xamarin.Forms
- Integrating with the platform more closely
- What’s new in Xamarin.Forms 4