Building an Enterprise Mobile Application with Xamarin.Forms

Xamarin.Forms is Microsoft's recommended way of building mobile, cross-platform applications. This course will teach you how to build mobile applications for the enterprise with the MVVM pattern, dependency injection, commanding, testing, and more.
Course info
Rating
(68)
Level
Intermediate
Updated
Jun 25, 2018
Duration
3h 1m
Table of contents
Course Overview
Introduction
Creating a Layered Architecture
Applying the MVVM Pattern
Creating Loose Coupling Through Dependency Injection
Communicating Components Through Messaging
Setting up Navigation and Dialogs Within the Application
Accessing Native Device Features and Controls
Testing the Setup with Unit Tests
Description
Course info
Rating
(68)
Level
Intermediate
Updated
Jun 25, 2018
Duration
3h 1m
Description

Xamarin.Forms is the preferred way for Microsoft developers to build applications that run on Android, iOS, and Windows. To use Xamarin.Forms for real applications that meet today’s requirements for flexibility and testability, you need to structure code according to industry-standard architecture guidelines. In this course, Building an Enterprise Mobile Application with Xamarin.Forms, you will learn how a real-life application is built with Xamarin.Forms. First, you will see a proposed architecture that promotes code-reuse as well as testability and maintainability. Next, you will learn how MVVM can be used in Xamarin.Forms. Then, you will create loose-coupling through messaging patterns and dependency injection, which are integrated in the proposed architecture. By the end of this course, you will have a good understanding of a real-life application architecture for Xamarin.Forms applications.

About the author
About the author

Gill Cleeren is a solution architect, author, and trainer in mobile and web technologies. He's also a Microsoft Regional Director and MVP. He lives in Tienen, Belgium.

More from the author
GitHub Fundamentals
Beginner
4h 16m
24 Sep 2018
Xamarin: The Big Picture
Beginner
2h 15m
28 Mar 2018
More courses by Gill Cleeren
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi everyone, my name is Gill Cleeren and welcome to my course Building an Enterprise Mobile Application with Xamarin. Forms. I'm a freelance solution architect focusing on mobile and web projects. Xamarin is Microsoft's solution for building mobile applications that run on any device and any platform. Building mobile apps is one thing. Building a mobile application for an enterprise is another. It requires a solid architecture that must be easy to test and maintain in the long run. This course will teach you how you can build an enterprise mobile application with Xamarin. Forms. You will learn how the MVVM pattern can help you and you'll see how dependency injection fits in as well. The final application architecture can be used as a starting point in your own applications. Some of the major topics that we'll cover include understand what an architecture for a real live mobile app built with Xamarin. Forms should look like. Get a deep understanding of the MVVM pattern applied in Xamarin. Forms. See how dependency injection and messaging can help us write more loosely coupled code, learn how you can do navigation in MVVM without breaking your testability. By the end of this course, you'll have a good understanding of how you can build an enterprise mobile app with Xamarin. Forms. This course does expect some Xamarin. Forms knowledge. I hope you'll join me on this journey to learn how you can build an enterprise mobile application with Xamarin. Forms with the Building an Enterprise Mobile Application with Xamarin. Forms course here at Pluralsight.

Introduction
Hi there, and welcome to this course titled Building an Enterprise Mobile Application with Xamarin. Forms. It's good to see that's you're interested in how you can build a testable and maintainable mobile application. I'm Gill Cleeren and you can reach me via Twitter @gillcleeren or via my site snowball. be. So as said, in the next 3 hours or so that we'll spending together, you will learn how you can build a Xamarin. Forms mobile application for iOS and Android in a way that I also built my applications for my customers. It's based on an architecture that is focused on maintainability, testability, and loose coupling. The architecture that you'll be seeing used in this course can be your starting point for your own mobile application development with Xamarin. Forms. Let us see what we'll be doing in this very first module. First, I'm going to give you an overview of what you'll take away from this course. I want to set the expectations right before getting started. Next, we'll take a look at the application we'll be working with. We'll be working with this very application throughout the entire course. Seeing it in action and hopefully be blown away by it will keep you hooked for the next couple of hours. Finally, we'll already be doing some technical stuff in this very first module. Since the application is working in combination with a real backend built with ASP. NET Core, I want to give you a good overview of how that is built without going into much detail here. Alright, let us do this.

Creating a Layered Architecture
Hello and welcome to this module called Creating a Layered Architecture in this Pluralsight course where we are looking at how we can build an enterprise mobile application with Xamarin. Forms. I'm Gill Cleeren and I'll be your guide for this module. Don't hesitate to contact me with any questions you may have about this course. As the title is already indicating, in this module we will be starting the exploration of the used architecture in the application. We'll take a look at the global architecture used in the application and we'll dive into the foundational layers here already. Let's get started. First, let me outline what we will be looking at in this module. I'll start by giving you a complete overview of the used architecture for this application. Then we will start with the exploration of the different layers and their purpose. First, we'll see how we can work with the data in this architecture, data which is exposed over REST services. Next, we'll take a look at some ways to optimize how we work with that data on the client, using caching and retry mechanism. I hope this sounds interesting to you. Let's get started.

Applying the MVVM Pattern
Hi again, and welcome to the Applying the MVVM Pattern module. You are watching the Building an Enterprise Mobile Application with Xamarin. Forms course here on Pluralsight. I'm still Gill Cleeren. I don't think there was any good reason to change my name between different modules. Anyway, a new module, and a very important one, since in this module we are going to take a look at the layers we haven't looked at in the previous module just yet, the view and the view model. You'll soon see how I use the MVVM pattern, the Model-View-ViewModel pattern, to build the view part in a loosely coupled way. Let's dive in. As always, let's start with a brief overview of what we are going to look at in this module. Since MVVM is based on the concept of data binding, I will briefly give you an overview of the most fundamental aspects of data binding. We'll then take a look at the concepts of MVVM and I will show you how these are being used in the application, of course. Next, we will explore commanding and how we'll use it to have a UI event, such as a button click, trigger code in the view model. We'll soon see that although commanding is supported, it's unavailable on just every controller, and for that reason I will be talking about behaviors. In the final part of this module, we'll see how we can link the view and the view model, keeping in mind that you are investing a lot of effort in keeping everything loosely coupled. As said, this is a really important module, so let's go. To make sure that we're all on the same page here, in this module we will be looking at the views and the view models in our application architecture. Since we are working with Xamarin. Forms, these are part of the shared code as well.

Creating Loose Coupling Through Dependency Injection
Hello and welcome to another module in the Building an Enterprise Mobile Application with Xamarin. Forms course here at Pluralsight. This module is called Creating Loose Coupling Through Dependency Injection. My name is Gill Cleeren and I will guide you through this module as well. If you have any questions about this course, please let me know via the discussion board here on Pluralsight. So in this module, as you may have already guessed from the title, we are going to talk about dependency injection and how it will help the architecture that we are creating in achieving a higher level of loose coupling. That was one of the main goals we set out with when creating this architecture. Let us take a look at what we will be looking at in this module. I assume most of you are familiar with the concepts of dependency injection, since it is becoming more and more mainstream in a lot of projects. However, I don't want to lose anyone here. So I've decided I will give you a quick overview of what dependency injection is and what the problem is that it will actually solve. Once we're all on the same page here about dependency injection itself, we're going to take a look at how we can use it in our own application architecture. Sounds interesting? I do hope so. Let's get started.

Communicating Components Through Messaging
Hi again, and welcome to this module titled Communicating Components Through Messaging. This module is part of the Building an Enterprise Mobile App with Xamarin. Forms course here at Pluralsight. I'm still Gill Cleeren, and if you have any questions about this module, please let me know via Twitter @gillcleeren or via the Pluralsight discussion board for this course. In the last module we have seen how dependency injection helped us greatly in achieving loose coupling. In this module, we'll continue on the same path and we'll look at how we can have different components talk with each other by introducing messaging. Just like we did with the last module, I'll first introduce you to the concept of messaging and what problem this will solve in our application's architecture. After we have seen what messaging really is, we'll take a look at how we are using messaging together with the built-in messaging center in Xamarin. Forms in our application.

Setting up Navigation and Dialogs Within the Application
Hello and welcome to this module called Setting up Navigation and Dialogs Within the Application, part of this Pluralsight course called Building a Mobile Enterprise Application with Xamarin. Forms. I'm Gill Cleeren and I will be your instructor for this module. Now in this module we are, as the title already gave away, going to be focusing on a number of topics, such as navigation and dialogs, and how we can add these to the application, while still making sure that we follow the principles that we have set out in the beginning. By the end of this module, we'll have understood how we can add all this to the application. Let's get started straight away. As always, at the start we do a short overview of what we are going to cover in this very module. I will kick off the module again with the part that explains the problem and we'll talk about the so-called service classes. We'll then take a look at how we should do navigation in the application and we'll take a look at adding dialogs next. We'll finish this module by taking a look at other types of servicing, so basically how other tasks should be done in the application.

Accessing Native Device Features and Controls
Hi there and welcome to another module in this course on Building a Mobile Enterprise Application with Xamarin. Forms. I'm Gill Cleeren and you can ask any questions about this course via the discussion board here on Pluralsight. In this before last module of this course, we are going to take a look at the different options we have as developers to access native features and native controls, not covered by Xamarin. Forms by default. Of course, we'll do that so that we don't bring our application's architecture in any danger. Good traditions never die, so we'll kick off this module again with a small overview of what we'll see in this module. The first thing that we'll see is the built-in dependency injection system called the Dependency Service. Another dependency injection topic, you may be asking? Well yeah, and it has its very specific purpose. Next, we'll how plugins, created by Microsoft and the community, can be added into our application as well. We'll finish this module by taking a look at how we can bring controls, not included by default in Xamarin. Forms, into our application.

Testing the Setup with Unit Tests
Hi there, this is already the last module of this course. I know, time flies when you're having fun, right? But let's make the best of it, shall we? So welcome to this module called Testing the Setup with Unit Tests. I'll still Gill Cleeren. Also for this last module, I think I'll keep my name unchanged. Alright, as the name of this module is already giving away, working with unit tests is what we will be doing in this module. We've spent a lot of time making sure that the application's architecture lends itself to testability, and so far is basically just me who has been telling you that we can now write unit tests quite easily. But should you believe me? Well let's take a look. The agenda for this module is pretty compact. I'm going to give you a very small overview of unit testing and then in the second part of this module, probably the most important one, we are going to put our architecture to the test, as we will be looking at some unit tests for the view model.