Tag Archive : Xamarin.Forms

/ Xamarin.Forms

You want to create a mobile multi platform app and you really like C#.Xamarin is the perfect solution for you and if you don’t have any major experience with native mobile development, Xamarin.Forms is just a day-dream.So let’s see how we can create our first Xamarin.Forms projects and how it works.

Create the Project

From Visual Studio 2017 create a New project…Under “Visual C#” select “Cross-Platform” (1) then select “Cross-Platform App (Xamarin.Forms)” (2), choose name and location for your project (3) and press Ok (4).Now we need to configure our project. In this case we start with a Blank app that is perfect to explain how a Xamarin.Forms solution works. Under Platform choose the platforms you need. In this case I’ve chosen Android, iOS, Windows (UWP). Under UI Technology select Xamarin.Forms and under “Code Sharing Strategy” choose .NET Standard.After we press ok, Visual Studio will take several seconds (or minutes according to your machine) to create your solution.Inside the Solution Explorer we see now that we have a .NET Standard project (our common library, where we are going to write almost all our code), and Android project, an iOS project and a UWP project. The projects are already working so if we try to run one of the projects (Android, iOS, UWP) this is what we get:That’s brilliant, few second and we already have a working project for Android, iOS and UWP.Now it’s time to understand how a Xamarin.Forms project works so we are going now to analyze the projects we have in our solution.

.NET Standard

This is common project shared by all the other projects. It’s here that we are going to write our app. Here we write the UI and the logic and if our project it’s easy enough, we don’t need to write code in the other projects of our solution.Inside our project there are 2 file, App.xaml and MainPage.xaml. App.xaml is the entry point of our .NetStandard project. From this file Xamarin loads the first Page of the app and usually we initialize other parts of the project like Resources, Databases and so on.Now let’s see the structure of the code-behind file App.xaml.cs

using Xamarin.Forms;

namespace Tutorial01
    public partial class App : Application
        public App()
            MainPage = new Tutorial01.MainPage();

        protected override void OnStart()
            // Handle when your app starts


        protected override void OnSleep()
            // Handle when your app sleeps

        protected override void OnResume()
            // Handle when your app resumes

Inside the constructor we initialize the XAML file with “InitializeComponent()” and load the first page with “MainPage = new Tutorial01.MainPage();”.As you have seen, MainPage is the actual page displayed on-screen, so every time we want to change a page, we need to assign a new value to MainPage (We’ll see that there are also other ways to do it).OnStart is called when the app is started. OnSleep and OnResume are called every time the app appears and goes in background.Now it’s time for the MainPage file. This is the page that will be displayed when we will launch the app. This is the XAML file:

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"             
    <Label Text="Welcome to Xamarin.Forms!"            
           HorizontalOptions="Center" />

What we have here is a ContentPage and inside a single element, a Label with text (“Welcome to Xamarin.Forms!”) and alignment options, so where are saying that we want to show that text at the centre of the screen (we have seen it before).And this is the code-behind file:

using Xamarin.Forms;

namespace Tutorial01
    public partial class MainPage : ContentPage
        public MainPage()

We see that MainPage inherits from a ContentPage (as the XAML file) and inside the constructor we need to call InitializeComponent to load the XAML file.Because the app does nothing, this file is basically empty otherwise here you can add the logic of your page (unless you want to follow an MVVM approach…I’ll add a link here as soon as the MVVM guide is ready).

Android Project

Let’s see the structure of the project:Inside the Resources folder you will add all your resources like images, styles and native layouts.MainActivity is the entry point of your Android app:

namespace Tutorial01.Droid
    [Activity(Label = "Tutorial01", Icon = "@drawable/icon", Theme = "@style/MainTheme", MainLauncher = true,
        ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]
    public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
        protected override void OnCreate(Bundle bundle)
            TabLayoutResource = Resource.Layout.Tabbar;
            ToolbarResource = Resource.Layout.Toolbar;
            global::Xamarin.Forms.Forms.Init(this, bundle);
            LoadApplication(new App());

Inside the method OnCreate we need to initialize Xamarin.Forms and load the .NetStandard project.Usually you don’t have to edit this file unless you have to load external plugins or intercept events like OnActivityResult (when you launch another activity, after it terminates you’ll get the result here) or OnResume (when the app goes in foreground).

iOS Project

Let’s see the structure of the project:Inside the Resources folder you will add all your resources like images or storyboards (you are not going to use them in Xamarin.Forms).The AppDelegate file is the entry point of your iOS app:

namespace Tutorial01.iOS
{ // The UIApplicationDelegate for the application. This class is responsible for launching the
    // User Interface of the application, as well as listening (and optionally responding) to
    // application events from iOS.
    public partial class AppDelegate : global::Xamarin.Forms.Platform.iOS.FormsApplicationDelegate
        // This method is invoked when the application has loaded and is ready to run. In this
        // method you should instantiate the window, load the UI into it and then make the window
        // visible.
        // You have 17 seconds to return from this method, or iOS will terminate your application.
        //        public override bool FinishedLaunching(UIApplication app, NSDictionary options)
            LoadApplication(new App());
            return base.FinishedLaunching(app, options);

Inside the method FinishedLaunching we need to initialize Xamarin.Forms and load the .NetStandard project.Usually you don’t have to edit this file unless you have to load external plugins.

UWP Project

Let’s see the structure of the project:This project seems a bit more complicated as it has two file: App.xaml and MainPage.xaml. In UWP, Xamarin.Forms is initialized inside the App.xaml file.

protected override void OnLaunched(LaunchActivatedEventArgs e) {
    Frame rootFrame = Window.Current.Content as Frame; // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    if (rootFrame == null) { 

There is a lot of code but don’t worry, probably you will never have to edit it. The only thing to remember is that here the Xamarin Forms library is initialized.The MainPage.xaml is extremely simple:

namespace Tutorial01.UWP
    public sealed partial class MainPage
        public MainPage()
            LoadApplication(new Tutorial01.App());

The only thing we do here is to load our .Net Standard project.


During this tutorial we have seen the structure of a Xamarin.Forms project: When we create a new Xamarin.Forms project, Visual Studio creates for us:

  • .NetStandard project where we write the logic and the UI of our app
  • a project per each platform we want our app on.

We need to write code in these platform projects only if we need to initialize a plugin, write a custom renderer (I’ll write a tutorial for Custom Renderers) or in general write code for a particular platform.

Sqlite for Xamarin made easy

May 31, 2019 | Plugin, Tutorial | 13 Comments

Let’s see how we can add a Sqlite database to your Xamarin projects in an incredibly easy way.

To help you to speed up your Xamarin development, I?ve created a set of plugins, one of them is MTSQL. Thanks to this plugin you can add a Sqlite database with a single line of code. The plugin is built on top of the Sqlite-net plugin by Frank A. Krueger.

A couple of useful link you can find useful:

Nuget link:https://www.nuget.org/packages/MarcTron.SQL

Project website:http://www.xamarinexpert.it/plugins/mt-sql/

To report any issue:https://bitbucket.org/marcojak81/mtsql

And now let?s see how to integrate the plugin inside your Xamarin Forms solution.

First of all we need to install the plugin. To do that, do a right-click on your solution and click on Manage NuGet Packages for Solution

Now search the package MarcTron.Sqlite, click on it and remember to select all your projects (.Net Standard project + all the main application projects) then click Install.

The Plugin will take care to install for you also the Sqlite-net plugin byFrank A. Krueger.

If everything worked as expected, you will see the version of the plugin next to each of the projects you have selected in the previous step.

Now it’s time to try the plugin to see how easy it is.

Inside the MainPage constructor you can see that the only line of code you need to create your database and open a connection to it is

SQLiteConnection conn = MTSql.Current.GetConnection("YOURDBNAME.db3");

Remember to replace the string with the name you want for your database.

using MarcTron.Plugin.MTSql;
using SQLite;
using Xamarin.Forms;

    public partial class MainPage : ContentPage
        class TestTable
            [PrimaryKey, AutoIncrement]
            public int Id { get; set; }

            public string name { get; set; }

            public TestTable()

            public TestTable(string name)
                this.name = name;

        public MainPage()
            InitializeComponent(); //The only line you need to create your database.
            SQLiteConnection conn = MTSql.Current.GetConnection("YOURDBNAME.db3"); 

            //This in case you want to use an async connection
            //SQLiteAsyncConnection connAsync = MTSql.Current.GetConnectionAsync();

            //This is just for test...
            //Create the table TestTable
            //Insert some elements
            conn.Insert(new TestTable("A"));
            conn.Insert(new TestTable("B"));
            conn.Insert(new TestTable("C"));
            //Verify that the elements are there
            Label1.Text = "Rows:" + conn.Table<TestTable>().Count();

As you can see in the image after we obtain a connection to the database, we can create a table and add some elements to it. Just for test I have added 3 items. If everything works as expected we should see inside the text “Rows:3” on screen. And this is exactly what we get launching the app on UWP.

So, thanks to this plugin, you have your Sqlite database inside your app with only 1 line of code.

What do you think? Add your comment at the end of the page.

Let’s see how we can make the Active Directory authentication incredibly easy for your Xamarin projects.

To help you to speed up your Xamarin development, I’ve created a set of plugins, one of them is MTADAL. Thanks to this plugin you can authenticate users in your projects with a single line of code.

A couple of useful link you can find useful

Nuget link: https://www.nuget.org/packages/MarcTron.ADAL\

Project website: https://www.xamarinexpert.it/Plugin/MTADALh

To report any issue: https://bitbucket.org/marcojak81/mtadal

And now let’s see how to integrate the plugin inside your Xamarin Forms solution.

Add the Active Directory Plugin

First of all we need to install the plugin. To do that, do a right-click on your solution and click on “Manage NuGet Packages for Solution…”

manage nuget

Manage the Nuget packages

Now search the package MarcTron.ADAL, click on it and remember to select all your projects (.Net Standard project + all the main application projects).

MTADAL Nuget package

The Plugin will take care to install for you also the Nuget package Microsoft.IdentityModel.Clients.ActiveDirectory so you need to accept the Microsoft License.

If everything worked as expected, you will see the version of the plugin next to each of the projects you have selected in the previous step.

Nuget package installed successfully

Now it’s time to try the plugin to see how easy it is.

Authenticate your users

Inside the Button_OnClicked method, you can see the only line of code you need to authenticate the user:

AuthenticationResult data = await MTADAL.Current.Authenticate(Authority, GraphResourceUri, ClientId, ReturnUri);
using System;
using MarcTron.Plugin.ADAL;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Xamarin.Forms;

    public partial class MainPage : ContentPage
        public const string ClientId = "YOUR CLIENT ID";
        public static readonly string ReturnUri = "YOUR RETURN URI";
        public const string GraphResourceUri = "YOUR Graph Resource Uri";
        private const string AadInstance = "YOUR AAD Instance";
        private const string Tenant = "YOUR TENANT";
        public static readonly string Authority = $"{AadInstance}{Tenant}";

        public MainPage()

        private async void Button_OnClicked(object sender, EventArgs e)
            AuthenticationResult data = await MTADAL.Current.Authenticate(Authority, GraphResourceUri, ClientId, ReturnUri);

            if (data != null)
                await DisplayAlert("MTADAL", "Hello " + data.UserInfo.GivenName, "Ok");

Of course you need to set Authority, GraphResourceUri, ClientId, ReturnUriaccording to your Active Directory credentials.

If we run this simple code and we insert the correct email and password this is what we seeAuthentication completed! And with only a single line of code!


To use this plugin on Android, add the following line inside the OnCreate method of your MainActivity:


Add that line just after the Xamarin Forms initialization

Xamarin.Forms.Forms.Init(this, bundle);

What do you think? Add your comment at the end of the page.

Xamarin eXpert is proud to present you a new amazing tool to create the icons for your apps for free and with a single click of your mouse: iconsgenerator.com

App icons generator

How it works

The app icons generator, allow to generate the icon for your app and all the icon set for the button, tabs and other UI components.

App icon

Drag your icon over the grey box with the text: “Drag and drop your icon here”. You will see a preview of your image. Now press the “Download” button to download your icons.

After extracting the zip file, you can simply copy the Android icons in your Android project and the iOS icons in your iOS project. The iOS icons contain also the Contents.json file so if you copy the icons and this file inside your Assets.xcassets folder, Xamarin (or xcode) will automatically recognize all the icons for the different sizes (so cool!).

Thanks to iconsgenerator.com, the process of creating the icons for your Android and iOS project will take only few seconds.

Icon Set

Iconsgenerator.com allows you to generate also the icons for your UI elements (buttons, tabs…). As you know, you shouldn’t have a single size icon but you should have different sizes according to the phone/tablet screen. In android you should create 5 icons for each image and they should go under these folder:

  • drawable-mdpi,
  • drawable- hdpi,
  • drawable- xhdpi,
  • drawable- xxhdpi,
  • drawable- xxxhdpi.

Under iOS, you should have 3 icons for each image with the names written with this logic:

The process can be quite laborious and long but thanks to
iconsgenerator.com, it will require just few seconds.

Drag your icon over the grey box with the text: “Drag and drop your icon here”. You will see a preview of your image. If you want you can change the name of your icons. Now press the “Download” button to download your icons. In just a second you will have all the 8 icons resized for your Android and iOS project.

all for FREE…

Yes, it’s right…the tool is completely free. Use it as mush as you like, for all the times you need.

If you want, it would be nice if you could share this article and talk about

Then, if you feel generous, you can buy me a coffee going here: Buy me a coffee.

If you need help to use the tool, or you have suggestions to improve it, write a comment here or send me an e-mail.

Thank you for your support.

Microsoft has released a new preview version of the new Visual Studio 2019.

The good thing is that it can be installed without affecting your current Visual Studio installation, so if you want to try it now, you can install it for free from here.

We love Visual Studio but in particular we love Xamarin, so let’s see what are the news related to it:

Build and Deploy time

It seems that this new version of Visual Studio brings a massive improvement in Build and Deploy time.

According to Pierce Boggan: “Incremental build times in the Visual Studio 2019 Preview for the SmartHotel360 app are 29.66% better than the Visual Studio 2017 version 15.8 release, and deployment times are over twice as fast

First Build01:04.2000:50.13-21.95%
Incremental Build (XAML Change)00:10.6200:07.47-29.66%
Deploy (XAML Change)00:09.0300:04.44-50.83%

Considering that we spend most of our days building and deploying apps, even few seconds are more than appreciated and here we are talking about 30%. Not bad!

Enhanced Fast Deployment for Android

Visual Studio 2019 Preview 2 adds support for enhanced fast deployment. It means that it will generate a new APK only when necessary.

To enable this feature, add these lines to your Android file project:



In Visual Studio 2019 we can use a property panel to help us writing our XAML files. We just need to select a control and all its properties will appear in the property panel.

XAML IntelliSense

Visual Studio 2019 has a better IntelliSense and will include IntelliCode that will recommend us the common items putting them on top of the completion list according to the context.


The Android designer adds support for Android Pie (9.0) while now IntelliSense is supported for Android XML files.

The iOS Designer adds support to render custom controls that need to load native dynamic libraries or frameworks.

What else

Visual Studio 2019 produces faster Android Apps with smaller APKs thanks to d8 and r8.

To enable these two features add these lines to your Android project file:





Visual Studio 2019 also adds the Xamarin Forms Shell Template.

There are many other improvements to Visual Studio 2019, so I’ll suggest you to try it and maybe give your feedback to Microsoft.

What do you think about Visual Studio 2019 Preview 2? Tell us writing a comment…

On September 2013 I released Safe Photo a native application for Android that allows you to hide pictures on your phone.

The app was quite successful with over 100.000 downloads and an impressive rating of 4.1.

During these years I’ve stopped to write native apps to concentrate entirely on Xamarin. So the logic consequence of that is that I’ve now created a new version of the app with Xamarin.Forms: Safe Photo 2.

Get it on Google Play
Get the app on Google Play Store

The idea behind the app is always the same: Safe Photo 2 will allow you to hide your secret pictures behind the security of the app.


  • Protect the photos on your smartphone or tablet
  • Take new photos directly from the application, they will be protected automatically
  • Import photos from the public gallery (then delete them from the public gallery)
  • Protect your privacy with a numeric password
  • Organise your photos in galleries
  • Share your photos with whoever you want and how you want
  • The application can run on an external memory card so you will not consume the internal memory of your smartphone
  • Your photos are invisible also connecting the phone to a PC
  • Delete one or more images or galleries in one click
  • Compatible with smartphones and tablets
  • And it’s free


Xamarin : How the app is made

To store all the data, Safe Photo 2 uses a SQLite database and of course the app uses the Sqlite Plugin For Xamarin And Windows (Nuget package).

The app also uses a Google Admob to show ads as banners and interstitials. As soon as possible I’ll create a package to easily add Admob to your Xamarin applications. If you prefer to write code yourself instead of using the plugin, I’ll also add a tutorial on how to add Admob on Xamarin.Android, Xamarin.iOS and Ads on UWP.

The app also uses some Dependency Services to execute some code on the native platforms. We use them to

  • Share a picture
  • Save, Copy and delete Files
  • Implement banners and interstitials for Admob

Do you want to know more about the app code or about Xamarin? Let me know and I’ll tell you more.

Have you seen how amazing are the Admob Rewarded video Ads? If you are creating a game or an app, the Rewarded Videos are something you should add to your app.

UPDATE: I’ve added on github the source code of a project to test this Admob plugin. You can find it here: https://github.com/marcojak/TestMTAdmob

Do you think that are difficult to implement and it takes hours of your time? WRONG!

Thanks to my plugin MarcTron.Admob (https://www.nuget.org/packages/MarcTron.Admob) you can add Rewarded Videos with a single line of code!!!

Exactly!!! Install the MarcTron.Admob free plugin and in less than few seconds you can show Rewarded Videos in your Android and iOS apps!

HOW (It’s super easy!!!)

  • Install the MarcTron.Admob plugin in your projects (.netstandard, Android and iOS).
  • That’s it! No other things to do!!!

Now, if you want to show a rewarded video you just have to write this code:


Of course remember to replace the xxx with your video ID that you can find on your Google Admob page.


We all love events 🙂 If you love them as well. There are 7 events that you can use with Rewarde Videos:

OnRewarded                          When the user gets a reward
OnRewardedVideoAdClosed             When the ads is closed
OnRewardedVideoAdFailedToLoad       When the ads fails to load
OnRewardedVideoAdLeftApplication    When the users leaves the application
OnRewardedVideoAdLoaded             When the ads is loaded
OnRewardedVideoAdOpened             When the ads is opened
OnRewardedVideoStarted              When the ads starts


We have just seen how to add Rewarded Videos (with the plugin you can add Banners and Interstitials as well) in less than few seconds.

Basically it’s a dream 🙂 But it’s all TRUE!


Now here some links that you can use:

A detailed tutorial on how to use the plugin: https://www.xamarinexpert.it/blog/admob-made-easy/

The nuget package link:


The bitbucket project site to report/view issues:


Github test project to try the plugin: https://github.com/marcojak/TestMTAdmob

Sometimes we need to show a custom value in our XAML and this operation is not always immediate but with this tutorial you’ll discover how easy it is.

Let’s say that in our photo app we have a setting for the size of our photo. We store this setting as an integer but of course we want to show a better information to the user. Let’s say that

  • 0: Small
  • 1:Medium
  • 2: Large
  • 3: Full Size

This is what we want to achieve (Image Size):

A first idea could be to add a label with a simple text and to change the text from the code behind. Something like this:

<Label  Text="{Binding MyText}"/>

But we are better developers than that so we want to use an integer and a Converter:

<Label  Text="{Binding ImageSize, StringFormat='Image Size ({0})', Converter={StaticResource IntToImageSizeConverter}}"/>

As you have seen, instead of using a text, here we use our integer value, a converter and a StringFormat to format our text.

In our converter we receive an integer value and we return an element of the PhotoSize enum. This is the source code of the converter:

IValueConverter implementation public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
            if (value is int b)
                switch (b)
                    case 0: return PhotoSize.Small;
                    case 1: return PhotoSize.Medium;
                    case 2: return PhotoSize.Large;
                    case 3: return PhotoSize.Full;

            return value;

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
            throw new NotImplementedException();

The latest thing to do is to register the converter in our dictionary:

<helpers:IntToImageSizeConverter x:Key="IntToImageSizeConverter"/>

With this code we can use our integer variable to show a more meaningful text. Easy. Isn’t it?

If you want to know more or you need more info, write a comment here. If you liked the article share it!

Xamarin.Forms 4.0 is finally out

May 22, 2019 | News | No Comments

Every release of Xamarin.Forms improves the performances and adds new features. It has been a long time since the first Xamarin.Forms came out. That version was very basic and to be honest not very great. Then Xamarin.Forms 2 came out and it was better, finally something that could be used for a production app. When Xamarin.Forms 3 came out, it was great, better performances, new features. Xamarin.Forms 3 has been a great tool to create amazing multiplatform apps and now Xamarin.Forms 4.0 promises even more, again better performances and new features. Let’s see together the main news of this release.

The Shell

Shell is a new way to create our apps. First of all it allows us to add easily flyouts and menus to our apps. It also adds the concept of URI navigation.

That’s great but what is even better is that it uses “fast renderers” (see later). To use the shell, on Visual Studio 2019 starting a new Xamarin.Forms app, you can select the Shell template. To get more info about Shell, you can use this documentation:

Android Fast Renderers

Android Fast Renderers were introduced in Xamarin.Forms 2.4 but disabled by default. The idea behind them is to reduce the number of views required to render a particular control. Honestly you could see improved performances so now they are enabled by default. This means that you will notice better perfomances with the enw Xamarin.Forms.

Image Source Unification

From Xamarin.Forms 3.5, they have introduced the FontImageSource to use the font glyphs but was not possible to use it everywhere. From version 4.0using ImageSource you can use them wherever you want.


From Xamarin Forms 4.0 we can now control the focus order directly in X.F. To do this, we can use the TabIndex property available on any VisualElement.


I will personally test Xamarin.Forms 4.0 and in particular the Shell to see how great that is. I will also test the new navigation pattern (URI Navigation) to see if there are improvements here. I will also evaluate the new performances to see if the app can be faster or more fluid.

And what do you think about Xamarin.Forms 4.0?

If you are using the Syncfusion library together with Xamarin.Forms > 3.4 you should definitely continue to read.

Since the new release of Xamarin.Form 3.5, if you try to use the Syncfusion Listview (SfListView) in Release mode on Android, your app will crash.

In this moment there are two things that you can do:

  • Use a version of Xamarin.Forms < 3.5
  • Set the Linking to None (in this case your final APK will be bigger than usual).

Unless you are using some of the new features of Xamarin.Forms > 3.4, I’d suggest you to continue to use Xamarin.Forms 3.4 otherwise in you Android project, set the Linking to None and it will solve your problem.

I will update this post, as soon as Synfusion and Xamarin will solve this massive issue.

Meanwhile you can follow the progress of this bug here: https://github.com/xamarin/Xamarin.Forms/issues/5288

%d bloggers like this: