The Advanced Xamarin Developer Masterclass
4.4 (280 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
3,555 students enrolled

The Advanced Xamarin Developer Masterclass

Includes Xamarin University Quality content - This Advanced Xamarin Tutorial Course Focuses on Cross Platform Concepts
4.4 (280 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
3,555 students enrolled
Last updated 7/2020
English
English [Auto], Italian [Auto]
Current price: $69.99 Original price: $99.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 14 hours on-demand video
  • 1 article
  • 1 downloadable resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • You will become a Xamarin expert, using the most powerful features of the platform to create entirely native apps.
  • Learn how to leverage native functionality and even native Java and Objective-C code in your Xamarin Forms apps.
  • Confidently be able to apply for more advanced app-development positions with your newly acquired advanced Xamarin skills.
  • Be able to create a bigger range of apps with more functionality with Xamarin
Course content
Expand all 88 lectures 14:10:48
+ Up and Running
4 lectures 14:26

In this lecture we just breifly talk about what you should be confortable with to be able to take this course, and I just welcome the students to the course 

Preview 02:17

In this lecture I want to show you the finished products that you will have by the end of the course, of course, this will only be a sneak peak, there is a lot more going on under the hood, but this will give you a sense of what you can expect to have mastered by the end of the course 

Preview 03:02

In this lecture we walk through the topics that the course will cover, from XAML to Dependency Services to even adding a bot to an app with the help of Azure, so the student gets a good idea, after watching the apps that we will build, how are they going to achieve that 

What You Will Learn
05:39

In this lecture I talk about where you can get the code, and some of the things you can do to make sure you always have the answer to any questions as you review the code on Udemy or even on GitHub 

The Source Code
03:28
+ XAML Unleashed
7 lectures 01:31:30

In this lecture we will be creating the UI for the application, very quickly we will define some XAML elements, including Entries, ToolbarItems, Pickers and DatePickers, as well as remember how the navigation is performed with the NavigationPage from the App class 

Preview 08:36

In this lecture we will quickly setup the basic functionality for this app, so later we can focus on learning new things. We will create some observable collections, some classes, and some methods, which will be making requests to a SQLite local databases for reading and inserting 

Defining the Logic
11:55

In this lecture we will set some commands to the elements in the itnerface that need to respond to user interaction, including the two ToolbarItems that we have, so methods are executed in response to a click 

Binding Commands
15:07

In this lecture we will bind the properties from the ViewModel, that already implements the INotifyPropertyChanged interface, to the Labels, Picker and DatePicker that we have defined in XAML, for the items to be saved in the SQLite database 

Binding to the Form
08:11

In this lecture you will learn to build collections (List or in our case ObservableCollections) to a picker and some ListViews that have an Item Template (and DataTemplate) containing first a TextCell and then a ViewCell with a ProgressBar 

Binding Collections
17:35

In this lecture we will update the form that we have to use a TableView instead of a StackLayout, and we will take a look at how the binding works in the same way. A quick bug with clearning the ObservableCollection will also be solved. 

Preview 12:34

In this lecture we take a look at scenario where Binding through C# helps bind the unbindable to a TableView, since it doesn't have an ItemsSource, only some C# tricks and C# Binding can help achieve some level of MVVM in this case. 

Binding From C#
17:32
+ Custom Renderers
6 lectures 55:28

In this lecture we will implement a Custom Renderer to a Progress Bar for iOS, changing the height of all the elements in Xamarin Forms by exporting this renderer from the platform soecific iOS project 

Custom Renderer on iOS
11:06

In this lecture we will use the Progress Bar Renderer that we have to add some dimanic coloring to the progress, depending on the value that is being displayed, thanks to the access that we have through the ElementChangedEventArgs for the ProgressBarRenderer 

Dynamic Colors for ProgressBar
07:48

In this lecture we will implement a Custom Renderer to a Progress Bar for iOS, changing the height of all the elements in Xamarin Forms by exporting this renderer from the platform specific iOS project 

Preview 07:01

On iOS native development you can set different types of accessories to the TableViewCells, and of course, this being Xamarin, native functionality is completely available, so in this lecture you will ue a Custom Renderer and a XAML proeprty to set some customized value to the Accessory ot a TableViewCell 

Customizing Text Cells
11:31

For the case of Android, we will use the same ide behind the iOS example of getting a value that is set through XAML and using it in the CustomRenderer to execute some evaluations that will change the way a TextCell looks when the app runs 

Customizing Text Cells Android
05:23
Changing Selection Color in Android Cells
12:39
+ Dependency Services
7 lectures 57:08

In this lecture we will talk about what Dependency Services are, what they help with, and how are they going to be implemented on a Xamarin Forms app, this brief look will help students identify that they need to be familiar with Interfaces to easily follow along the coming lectures 

Intro to Dependency Services
03:01

In this lecture we will start the implementation of Dependency Services into our Xamarin Forms project by defining the Interface that will define the members that have to be implemented in different classes from both Android and iOS proejcts 

The Interface
07:41

In this lecture you will learn how to implement the interface in a new class that will be created on both the Android and iOS projects, and then registering these classes as dependencies that will be injected to the Shared Library Project (.NET Standard) 

Preview 07:48

Now that we have injected the code from Android and iOS to the Shared Libary project, in this lecture, you will learn how to use Dependency Services to create the correct instance of a class as an interface that has access to the required methods, from the .NET Standard Library project 

Using a Dependency
07:04

In this lecture you will code the functionality, native to iOS, that will use UIActivityViewControllers to share a file and some text that will eventually be coming from the Xamarin .NET Standard Library, thanks to the dependency service that we have already implemented 

Sharing a File in iOS
09:33

In this lecture you will code the functionality, native to Android, that will use activities, intents and ActivityFlags to share a file and some text that will eventually be coming from the Xamarin .NET Standard Library, thanks to the dependency service that we have already implemented 

Sharing a File in Android
09:43

In this lecture, now that both the Android and iOS Dependencies are ready, the implementation for sharing complete, we will focus on creating, from the .NET Standard project, code that will generate a txt report of the expenses per category 

Creating a TXT File
12:18
+ Behaviors and Effects
5 lectures 49:33

In this lecture I give a brief introduction to the reason why effects and behaviors are su useful, what they can help developers with, how do they compare to each other, and why are they different than custom renderers in xamarin forms 

Intro to Behaviors and Effects
03:04

In this lecture we will create a new behavior for a ListView, so it behaves in a way that can be easily reused with other ListViews. Simply, we will add the functionality to the Behaviors to navigate to a details page, for which we will have a new ViewModel, a new View, and create a new class, all for the Behaviors array to list now one new behavior inside the ListView 

Behaviors
12:07

In this lecture you will be adding Effects to your Xamarin Forms project, you will first create the Effect in the .NET Standard Library, and make sure that you set a correct id when initializing the RoutingEffect class, then, in each project, you will implement the abstract PlatformEffect class so both Android and iOS export an effect, and register a Group Name 

Implementing Effects
17:19

The Effect is now exported, and the OnAttached is being called in both Android and iOS, but the functionality is not there, so here we use the ColorDrawable to evaluate the current background color of the Control and change it when required 

Android Effect
11:29

The Effect is now exported, and the OnAttached is being called in both Android and iOS, but the functionality is not there, so here we use the UIColor to evaluate the current background color of the Control and change it when required 

iOS Effect
05:34
+ App Center
15 lectures 02:21:30

In this lecture I mention the purpose of this section, talking about how App Center can help you improve your app development process, and how GitHub is going to be part of the process 

Intro to App Center
02:09

During this section we will be working with another project, different to the one we have been using troighout the first part of the course, and so in this lecture I will explain what the View, ViewModel and Model look like, explain the Behavior that was added on XAML. and show how a Frameworks, and the UseSaveArea works on iPhone X, XS, and XS MAX 

A New Project
09:36

In this lecture you will be setting up a GitHub repository and add some branches to it, so you can upload your Xamarin Forms project, have some form of version control, but more importantly, later on be able to add Continuous Delivery with the help of App Center 

GitHub Setup
08:24

In this lecture you will setup a new App Center account, add to it an organization, and a couple of apps for your Android and iOS projects. You will also setup the teams and distribution groups that App Center will be able to manage 

App Center Setup
07:47

In this lecture we will setup the builds inside the App Center projects to happen whenever we push to a specific branch inside our GitHub repo, the the Continuous Delivery is up and running inside the App Center, although we will still need to sign the builds for the distribution to devides to happen. 

App Center Builds
09:18

In this lecture we will be configuring the necessary keys so App Center can sign our Android Builds for them to be installed on devices. This will require us to work with keystores directly from Visual Studio (or Android Studio or the Console) and then uploading this to the App Center 

Signing Android Builds
10:07

In this lecture we will be configuring the necessary keys so App Center can sign our iOS Builds for them to be installed on devices. This will require us to work with provisioning profiles directly from the Apple Developers Portal, work with certificates, and then uploading this to the App Center 

Signing iOS Builds
13:48

In this lecture we will implement the App Center functionality that will help us add crash tracking and error tracking to our Xamarin applications so we as developers get information about what is causing our app to fail when it is deployed. 

Tracking Errors & Crashes
14:26

In this lecture we will implement the App Center functionality that will help us add analytics and event tracking to our Xamarin applications so we as developers get information about how our application is being used, and the type of devices where it is being depolyed. 

Analytics & Tracking Events
09:02

In this lecture I will be showing you how when the app crashes, App Center packages automatically log the information about the crash so we can later inspect it from the portal, but we will also implement a way of identifying if the app had crash, in case we want to tailor the experience to the user if that happened. 

Reacting to Crashes
08:42

Before being able to distribute through App Center to the Play Store, with every push to the master branch, we will need to publish a first version to the Play Store manually, so we cover that in this lecture. 

Publishing Android App
07:41

Before being able to distribute through App Center to the App Store, with every push to the master branch, we will need to publish a first version to the App Store manually, so we cover that in this lecture. 

Publishing iOS App
13:59

Now that we have published a first version of the application to the iOS App Store, from App center we can start tu distribute new builds automatically when new pushes arrive to the corresponding Git branch, so during this lecture we will configure precisely that. 

Distributing to Play Store
07:11

Now that we have published a first version of the application to the Google Play Store, from App center we can start tu distribute new builds automatically when new pushes arrive to the corresponding Git branch, so during this lecture we will configure precisely that. 

Distributing to App Store
06:04

Now that App Center is entirely setup, along with the connection to the stores, in this lecture we will test everything by pushing a new feature to all our users by simply pushing and pulling from GitHub to the corresponding branches to achieve continuous deployment! 

Pushing a New Feature
13:16
+ Push Notifications
7 lectures 01:40:34

In this lecture we will talk a bit about Microsoft's Azure cloud as well as create a new Azure Notification Hub service that will allow us to send push notifications to both our iOS and our Android apps.

Setting Up Azure Notification Hub
09:08

Apple Push Notifications services are greately important, since they will manage the notifications to all iOS devices, hence, we will need to create the required certificates and update our App IDs to enable push notifications in our apps, that is what we cover in this lecture, along with the connection to the Azure Notification Hub.

Setting Up iOS Push Notifications
08:31

Firebase for push notifications is greately important, since they will manage the notifications to all our Android devices, hence, we will need to create the required application in the Firebase portal and setup a JSON file in our android project

Setting Up Android Push Notifications
08:30

In this lecture we take a look at some of the endpoints from the Azure Notification Hub API that will allows us to make a correct request to send push notifications to both our Android and iOS apps, right before implementing this REST requests to an Azure Function

The Notification Hub API
07:24

In this lecture we will use the Notification Hub's REST API to send some notifications using some Python code, as an example of what you could have in the backend of a service that sends notifications to your Xamarin Forms applications.

Sending a Notification from the Backend
18:16

Now that we know how to send the notifications, lets prepare our Android app to handle the notifications and display them to the user.

Receiving the Notifications on Android
26:49

Now that we know how to send the notifications, lets prepare our iOS app to handle the notifications and display them to the user.

Receiving the Notifications on iOS
21:56
+ XAML & Advanced Xamarin Forms
9 lectures 01:07:11

In this lecture I will briefly talk about what you can expect to happen with this section as time passes, since this will be the section dedicated to all important updates to the Xamarin Forms platform. I will also introduce what the section already covers, and why I consider these topics to be advanced to Xamarin Forms and XAML 

Intro to the Section
01:45

In this lecture we will learn about a quick way in which XAML, as of Xamarin.Forms 3.1, enables you to set the Android TabBar (TabbedPage) to the bottom of the screen as you would see on iOS, instead of the default top position, also getting to use some AndroidSpecific code right from XAML in the .NET Standard project 

Bottom Android Tabbar
05:43

Use Safe Area is a property of the iOS pages (ViewControllers) that is of great importance for the experience in the iPhone X and the iPhone Xs (and Xs Max) to be good, because these phones now have notches, and a new "home button" and curved edges, it is important to make sure that our content adapts to that, and it will be as easy as setting this property to true, which we can do from XAML 

iOS Use Safe Area from XAML
07:00

New in Xamarin Forms 3.2 is a feature that I think has been long requested and necessary, the ability to easily, from XAML, change the way the Title in the Title bar looks for both Android and iOS, so during this lecture we will learn how we can change this to improve the looks of our apps. 

Setting a Title View
06:43

In XAML, the OnPlatform extension exists to let you define different values for different platforms, so if you need the UI to use different values depending on the platform that is running, you can do so directly from XAML, in this lecture we explore how to do this in the new Xamarin Forms 3.2 version 

The OnPlatform Extension
07:31

As of Xamarin Forms 3.0, you can now use stylesheets to define the style of your applications, of course, XAML styling is still available, but now you can brind your CSS experience over to Xamarin Forms development and create the styles in those type of files 

CSS & XAML
11:05

In this lecture we will learn how to use one old XAML feature that had been missing from Xamarin for a while, but finally present in Xamarin Forms 3.0: The Visual State Manager, which will allow us to change how the UI will look according to some user interaction with the elements themselves or even with the device 

Visual State Manager
15:02
ImageButton Controls
07:10
Improving ListView Performance
05:12
+ Creating a Bot
10 lectures 01:33:51

In this lecture we will take a look at what this section is going to be about, the things that we will have to build, and the main objective in the section, which will be to learn a thing or two about Xamarin Forms that will help us create a great chat experience inside of the application. 

Intro to the Bot Section
01:17

In this lecture you will create a new Microsoft Azure service that will provide some machine learning to your applications, by allowing your users to ask questions in natural language and get responses based on a knowledge base that you have uploaded to this service 

QnA Maker Service
09:48

In this lecture we are going to connect a new Azure Bot service with a QnA service so the bot is now able to answer to the same questions that the source we added in the previous lecture 

Azure Bot Service
04:53

The bot is ready, all we have to do is connect it to our app, and in this lecture I will show you how to do it with a simple webview by using an embed iFrame to extract the source that contains our bot, and getting the secret from the Azure Bot service. 

Embedding the Bot
10:01

In this lecture you will be using the Azure Bot Framework's API to make REST requests that will create new conversations with the bot, so eventually you use those conversations to send the messages that you need the bot to answer. 

Calling the Bot API
09:25

The conversation has been created, there is already a conversation pending with the bot service from Azure, during this lecture we will learn about the structure of the REST requests that will send a new message to the bot through that conversation, to make sure that our bot will be receiving the message correctly, so it can answer back. 

Sending a Message to the Bot
10:46

In this lecture we are going to setup a web socket to a url that we received when we created the conversation with the bot, so the application can receive the stream of messages that will be coming from the Azure Bot Service 

Receiving Responses from the Bot
11:30

For the Bot Helper to send all the received messages over to the observable collection that we will have in the View Mode for our Chat View, we will need to respond to every time a message is received, and so, we will also need to send some custom arguments when the event is fired. In this lecture, we will setup the View Model which will require a custom EventArgs class 

Custom Event Arguments
10:16

In this lecture, now that our app is sending messages to a bot, and receiving its responses from the stream, we will start tu display the elements inside of the collection in a list view, however, this being a chat, will require more than one type of cell to be displayed. for that the Data Template Selector is going to be quite useful to set the ItemTemplate to the ListView directly from XAML 

ViewCells and Template Selectors
16:30

The bot is ready, and we are already using a TemplateSelector to display the correct type of cell inside the listview, now there are only a couple of improvements that we will make to the listview which include some quick margin setup and the usage of the ScrollTo method from the ListView 

Final UI Improvements
09:25
+ Advanced Xamarin Android
3 lectures 26:59

In this lecture I will talk about what we will cover in the last three sections of the course, which I consider the advanced and "musts" of the course, covering platform-specific things that will up your game as a Xamarin developer, which includes using native Java (Android) and Objective-C libraries inside of the Xamarin projects. 

Intro to the Advanced Sections
02:25

In this lecture we will create an AAR file from an Android Library project that we have on Android Studio, and use it to create a Bindings Library on Visual Studio for later use this new DLL file in the normal Xamarin Android project that is inside our Xamarin.Forms application 

Binding Android (Java) Libraries
14:48

In this lecture we will take a look at the impact that linking assemblies has on the size of the generated APK files for your android application, and how linking assemblies from the SDK is a great option if you want to deploy to the play store 

Linking for APK Sizes
09:46
Requirements
  • Existing skills with Xamarin, C# and XAML are recommended - Consider investing in Eduardo's (course instructor) Complete Xamarin Course on Udemy if you have no exposure to Xamarin first.
  • You will need a Windows Computer with Windows 10 and Visual Studio installed or
  • a macOS computer running High Sierra or later and with Xcode installed for iOS testing and deployment.
Description

If you have some existing Xamarin development experience (perhaps completing or done at least done some of Eduardo's (the courses instructor) Complete Xamarin Course, or another Xamarin course then this course is for you.

If you looking to take your existing Xamarin skills and learn more about the advanced features of Xamarin then this course can help.

Xamarin developers are well paid, and programmers with advanced skills (such as the ones you will learn in this course) are even more valuable to companies and tend to get paid more.

By the end of the course, you will become a Xamarin expert, using the most powerful features of the platform to create entirely native apps.

Along the way, you will learn how to leverage native functionality and even native Java and Objective-C code in your Xamarin Forms apps.

You'll find out how to continuously deploy new versions of your app to your users .

And learn how to use version control for better deployment to other developers, testers, and the App Stores.

The key skills you will learn and master in this course include:-

1. Dependency Services

2. Custom Renderers

3. Using Java Libraries

4. Using Objective-C Libraries

5. App Center

6. Azure Bot Service for Chatbot

7. Behaviours and Effects

8. Azure Functions

9. Push Notifications

10. CSS Styling for Xamarin

What is Xamarin?

Xamarin is a Microsoft owned company, that allows developers, using a C#-shared codebase, to write native Android, iOS (and even Windows and MacOS) apps with native user interfaces and to share code.

This means you can create an application once, and deploy it to both Android and iOS, both which run natively on the platform.  One codebase, two platforms.

Learning to create apps with Xamarin makes you more valuable to your employer or clients as a result.

Is this course for you?

If you've never used Xamarin before, and/or do not know C# then this is NOT the course for you.  In that case we would suggest you purchase Eduardo's Complete Xamarin course first, complete that and come back then to this advanced course.

But if you are familiar with C# and XAML and have some exposure to Xamarin then this course is aimed at you.

Why this course and not other Xamarin courses?

Eduardo already has one of the most comprehensive and popular Xamarin courses on Udemy.  Plus he has extensive experience with Xamarin and is also Xamarin certified.

Here is what just one student had to say about his other Xamarin course.

"I have just finished up to section 4 and loving every single bit about this course because the way Mr Eduardo explains is just amazing, because I have done a lot of other programming related courses where the instructor just displays a bunch of pre written code with alot of talk, and talk, and talk. However, the way Eduardo explains and takes his time to convey the message, simply love him" - Zeshan Hossein Ghayoomi.

By taking this course it means you are learning from someone who has all the professional training, skills, and experience needed to teach you how to become proficient in Xamarin the right way, as fast as possible.

If you are ready to get that first paid programming job, or to move up to a more senior programming position, then this course is for you!

What about if you have questions?

As if this course wasn’t complete enough, you have Eduardo on hand to answer any questions you have in the Q&A section of the course.

This means you’ll never find yourself stuck on one lesson for days on end. With his hand-holding guidance, you’ll progress smoothly through this course without any major roadblocks.

There’s no risk either!

This course comes with a full 30 day money-back guarantee. Meaning if you are not completely satisfied with the course or your progress, simply let us know and they will refund you 100%, every last penny no questions asked.

You either end up with Advanced Xamarin skills, go on to develop great programs and potentially make an awesome career for yourself, or you try the course and simply get all your money back if you don’t like it…

You literally can’t lose.

Ready to get started, developer?

Enrol now using the “Add to Cart” button on the right, and get started on your way to advanced  Xamarin skills. You can also check out some of the course using the preview feature on this page, so you’re 100% certain this course is for you. 

See you on the inside (hurry, the advanced Xamarin class is waiting!)

Who this course is for:
  • Xamarin developers looking to learn advanced Xamarin techniques
  • Anyone with Xamarin experience looking to become more employable and to increase career opportunities