Build Native Cross-Platform Mobile Applications with a Shared UI for iOS, Android, and UWP in C# .NET with Xamarin.Forms (40542A)

Build Native Cross-Platform Mobile Applications with a Shared UI for iOS, Android, and UWP in C# .NET with Xamarin.Forms (40542A)


Duration : 5 Days

During this course, developers will learn to use a variety of techniques, from beginner to advanced, to develop cross-platform apps with Xamarin.Forms. Topics begin with the basics of mobile application development with C# and .NET and then advance to include data storage with SQLite, using REST-based services, designing a shared UI with XAML, displaying data, and using effects and renderers to create enterprise quality cross-platform applications.


After completing this course, students will be able to:

  • Use a variety of techniques to lay out, style, store, access, and display data.
  • Create and apply data bindings and use effects and renderers to build an Enterprise quality cross-platform Xamarin. Forms application.
  • Identify mobile development trends.
  • Identify the different approaches to mobile development.
  • Describe the Xamarin approach to development.
  • Set up and validate their development environment.
  • Create a single screen cross-platform application.
  • Cross Platform Applications with Xamarin.
  • Arrange the UI using Layouts.
  • Use platform-specific features in shared code.
  • Share code across Windows, Android and iOS using a Shared Project.
  • Share code across Windows, Android and iOS using Portable Class Libraries.
  • Share code using .NET Standard Libraries.
  • Identify the differences between Microsoft XAML and XAML for Xamarin.Forms.
  • Write XAML for Xamarin.Forms.
  • Access elements in code behind.
  • Handle events.
  • Use device-specific values.
  • Use markup extensions.
  • Use ContentView to share XAML.
  • Compile XAML
  • Size views.
  • Add views to a StackLayout in code and XAML
  • Specify layout orientation.
  • Use Expands to request extra space.
  • Apply an Attached Property in code.
  • Apply an Attached Property in XAML.
  • Specify grid row and column sizes.
  • Add children to grid cells.
  • Use ScrollView to add scrolling.
  • Set the scroll direction.
  • Use page-level Resources.
  • Dynamically update Resources.
  • Create and apply a Style.
  • Use Style inheritance to avoid repeated Setters.
  • Create App.xaml.
  • Use application-wide resources.
  • Apply a built-in Style.
  • Customize a built-in Style.
  • Map data to visuals.
  • Create bindings in code.
  • Create bindings in XAML.
  • Work with binding context.
  • Change binding modes.
  • Implement property change notifications.
  • Perform textual conversions in XAML.
  • Create a value converter.
  • Apply a value converter in XAML.
  • Define the layers in MVVM.
  • Create a View Model.
  • Control and activate events with selection.
  • Utilize properties to define Visual Behavior.
  • Employ Data Triggers.
  • Implement the ICommand interface.
  • Generalize a command.
  • Define a Factory.
  • Assign a dependency to a Factory.
  • Access the Factory from shared code.
  • Define a Service Locator.
  • Register dependencies with a Service Locator.
  • Resolve dependencies from a Service Locator.
  • Register dependencies with an IoC container.
  • Inject dependencies.
  • Automate dependence injection.
  • Determine if the device has a connection.
  • Obtain the device’s connection type.
  • Determine when network availability changes.
  • Identify REST services.
  • Utilize URLs in REST.
  • Describe guidelines for using REST.
  • Identify REST services.
  • Utilize URLs in REST.
  • Describe guidelines for using REST.
  • Customize the HttpClient handler.
  • Leverage platform network stacks.
  • Use App Transport Security on iOS.
  • Identify data storage options.
  • Select a storage location.
  • Get the storage path for each platform.
  • Add a SQLite Portable Class Library to the project.
  • Define SQLite table schema using attributes.
  • Create and connect to a SQLite database.
  • Perform basic CRUD operations.
  • Refactor database connection to use SQLiteAsyncConnection.
  • Refactor table creation to use Async counterpart.
  • Refactor CRUD operations to use Async counterparts.
  • Provide data to a ListView.
  • Manage selection in a ListView.
  • Add, remove and update data in the ListView.
  • Make UI-safe collection changes.
  • Modify collections in the background.
  • Alter the row visuals.
  • Use Data Templates.
  • Change the ListView separator.
  • Use built-in cell templates.
  • Use ViewCells to define custom cells.
  • Create Data Templates in code.
  • Define unique Row Visuals.
  • Use ViewCells to define custom cells.
  • Create Data Templates in code.
  • Define unique Row Visuals.
  • Sort data in a ListView.
  • Filter data in a ListView.
  • Group data in a ListView.
  • Group header data.
  • Group Templates.
  • Implement performance optimizations for ListView(s).
  • Change element properties.
  • Use platform themes to update native control appearance.
  • Resolve an effect.
  • Apply an effect programmatically.
  • Wrap an effect with RoutingEffect.
  • Apply an effect in XAML.
  • Create an effect.
  • Update platform specific UI.
  • Respond to UI changes and notifications.
  • Export an effect.
  • Add attached properties to an effect.
  • Use and update attached properties.
  • Define a native control.
  • Add a native control to a Xamarin.Forms layout.
  • Extend an existing renderer.
  • Apply a customized renderer.
  • Create a custom element.
  • Create a renderer for a custom element.
  • Send from renderer to element.
  • Send from element to renderer.

Course Outline

Module 1: Getting Started with Xamarin (XAM101)

By the end of this module, you will be able to choose the Xamarin approach that is right for you. You will also set up your development machine and run an app on Windows, the iOS simulator, and an Android emulator. 


  • Define the state of mobile technology today
  • Discuss mobile app trends
  • Identify approaches to development
  • Discover the Xamarin Approach
  • Setup your development environment

Lab : Building Cross Platform Applications with Xamarin

  • Demonstration - Cross Platform Applications with Xamarin
  • Demonstration – View a Xamarin.Forms Project
  • Setup Validation – Validate your development environment ready

Module 2: Introduction to Xamarin.Forms (XAM120)

Maximize your ability to share code, during this module, you will create a new Xamarin.Forms application and define your shared UI in code. You will also see how to access platform-specific features such as the phone dialer that do not have a shared-programming model integrated into Xamarin.Forms.


  • Create a single screen cross-platform application
  • Cross Platform Applications with Xamarin
  • Arrange the UI using Layouts
  • Use platform-specific features in shared code

Lab : Using Xamarin.Forms to build a single screen cross-platform application

  • Create your first Xamarin.Forms application (Group Exercise)
  • Create Xamarin.Forms Phoneword
  • Add support for dialing the phone

Module 3: Introduction to Cross-platform Development (XAM110)

In this module, we will explore ways to structure your shared code using Portable Class Libraries, .NET Standard libraries, and Shared Asset Projects. We will look at the pros and cons of each approach and see how to access platform-specific features in each model.


  • Add shared components to your application
  • Share code using Shared Projects
  • Share code using Portable Class Libraries
  • Share code using .NET Standard Libraries

Lab : Share code across Windows, Android and iOS

  • Display content from a shared JSON file onto Windows, Android and iOS
  • Use a portable library to display content on Windows, Android and iOS
  • Demonstration: Create a .NET Standard library and use .NET Standard APIs
  • Demonstration: Upgrade from PCL to .NET Standard Libraries

Module 4: XAML in Xamarin.Forms (XAM130)

This module shows you how to define your UI in XAML. You will create pages and add controls, all in markup. You will also see how to access UI elements from code so you can subscribe to UI events and update UI properties as your data changes.


  • Examine XAML Syntax
  • Add behavior to XAML-based pages
  • Explore XAML capabilities

Lab : Create a XAML-based calculator app with behaviour and tailor the UI to each platform

  • Create a XAML-based version of a calculator
  • Add behavior to the app
  • Cleanup the XAML code and tailor the UI to the platform

Module 5: Layout in Xamarin.Forms (XAM135)

This module contains in-depth coverage of StackLayout and Grid, the two most popular layout containers in Xamarin.Forms. You will also learn how to add support for scrolling when your UI is too large for the available screen area. 


  • Specify the size of a view
  • Arrange views with StackLayout
  • Apply Attached Properties
  • Arrange views with Grid
  • Scroll a layout with ScrollView

Lab : Build user interfaces using stack and grid layouts

  • Use StackLayout to build a UI
  • Use a Grid Layout to build a UI

Module 6: Resources and Styles (XAM140)

This module teaches you how to create a consistent and dynamic style for your application using Resources in XAML.


  • Avoid duplicate XAML with Resources
  • Create consistent UI with Styles
  • Make your Resources and Styles available across your entire app
  • Apply the user's Accessibility choices with built-in Styles

Lab : Use resources to style an application

  • Group Exercise: Examine an app with repeated code
  • Use page-level resources
  • Dynamically update resources
  • Create an apply a style
  • Use style inheritance to refactor repeated code

Module 7: Data Binding in Xamarin.Forms (XAM270)

Use Data Binding in Xamarin.Forms to connect your application's data to your UI.


  • Use data binding to decouple code-behind from UI
  • Use value converters to bind incompatible types

Lab : Use Data Binding in Xamarin.Forms

  • Group Exercise: Use Data Binding in a Xamarin.Forms Application
  • Keep the UI and data in sync using Bindings
  • Use Value Converters

Module 8: Model-View-ViewModel (XAM320)

In this module you will learn how to design your applications using MVVM. You will create View Models and use data binding and commanding to connect them to your UI. You will also use the Xamarin.Forms MessagingCenter to communicate between View Models.


  • Decide where to place code in Model-View-ViewModel
  • Define Visual Behavior
  • Use Commands
  • Test MVVM based apps

Lab : Create an application using MVVM

  • Define a ViewModel
  • Create ViewModel Collections
  • Drive behavior through properties
  • Group Exercise: Use command to run behavior
  • Demonstration: Add unit tests for View

Module 9: Patterns for Cross-Platform Development (XAM250)

Use the Factory pattern, the Service Locator pattern, and Dependency Injection to access platform-specific APIs from shared code in a loosely-coupled manner.


  • Locate dependencies using the Factory Pattern
  • Use a Service Locator to register and retrieve dependencies
  • Use an IoC container to automatically inject dependencies

Lab : Define, locate and use dependencies

  • Use the Factory Pattern to access a dependency from shared code
  • Group Exercise: Build a Service Locator
  • Use Dependency Injection

Module 10: Consuming REST-based Web Services (XAM150)

You will also learn some common strategies for dealing with the unique challenges that mobile devices face when communicating over the network.


  • Obtain the device’s network capabilities
  • Introduce REST
  • Consume REST services with Xamarin
  • Integrate with platform-specific network features

Lab : Use, consume and communicate with REST services

  • Determine the network connectivity
  • Communicate with a Book Service
  • Demonstration: Leverage the native platform network stack

Module 11: SQLite and Mobile Data (XAM160)

During this module, you will learn how to identify the proper location for your database file and how to insert, update, retrieve, and delete data efficiently using asynchronous I/O calls. 


  • Choose a data storage strategy
  • Store data locally with SQLite
  • Use SQLite asynchronously

Lab : Utilize SQLite to store and access data

  • Determine your database file path
  • Add SQLite.Net to your projects
  • Access a SQLite database with SQLite.Net
  • Access a SQLite database using asynchronous methods

Module 12: ListView in Xamarin.Forms (XAM280)Use the Xamarin.Forms ListView control to display scrolling lists of interactive data.


  • Display a collection with ListView
  • Add and remove items dynamically
  • Customize ListView rows

Lab : Use ListView in Xamarin.Forms

  • Display a list of items with a ListView
  • Select a row
  • Work with mutable lists
  • Add Pull to Refresh support

Module 13: Customizing ListViews (XAM312)

During this module you will learn how to use and customize the ListView in Xamarin.Forms. You will be able to define a row template, add headers/footers, and display grouped data. You will also survey several performance-tuning strategies including cell caching.


  • Create custom cell definitions
  • Add headers and footers
  • Separate your data into Groups
  • Performance-tune your ListViews

Lab : Customizing ListView in Xamarin.Forms

  • Provide a custom cell template for our ListView
  • Add a header and footer to the ListView
  • Group Exercise: Add Grouping support to our Character List
  • Add a quick index
  • Turn on recycle caching

Module 14: Xamarin.Forms Effects (XAM330)

This module teaches you how to use Effects to access and customize the native peer controls. This gives you the same power to modify the appearance of your UI as a native developer.


  • Customize control appearance
  • Apply effects to controls
  • Create an effect

Lab : Implement Effects in Xamarin.Forms

  • Use platform-specific themes
  • Add and use an existing effect
  • Create a Routing Effect
  • Create a custom Effect
  • Add an attached property

Module 15: Xamarin.Forms Renderers (XAM335)

In this module, you will see how to use a Renderer to implement the UI and behavior for a fully custom control. In addition, you will use a Renderer to modify the behavior of an existing control to meet your app’s specific needs.


  • Embed native controls into Xamarin.Forms
  • Customize a renderer for an existing control
  • Create a renderer for a custom control
  • Send notifications between renderer and element

Lab : Implementing Automation

  • Add a native control to a Xamarin.Forms layout
  • Create a hyperlink label renderer
  • Create a custom control
  • Create a renderer for a custom control
  • Interact with the renderer

Before attending this course, students must have the following technical knowledge:

  • Basic knowledge of C# and six months of experience developing using .NET.
Course ID:

Show Schedule for:

Please provide as much information as possible for us to help you with your enquiry.