Tag Archive : Xamarin.Forms

/ Xamarin.Forms

Wouldn’t be nice if you could try your Xamarin.Forms iOS apps on your Apple device without using a Mac? Yes it would. And now you can!

Follow me and I’ll show you how to deploy your Xamarin.Forms iOS app on you Iphone or iPad without using a Mac thank to Xamarin Hot Restart!

Requirements

To use Xamarin Hot Restart you need:

  • Visual Studio 2019 16.5 or higher
  • iTunes (64-bit, installed on your PC)
  • Apple Developer account and paid Apple Developer Program enrollment
  • Your Xamarin.Forms app for iOS

Do you have everything?

Let’s start having fun

Remember that Xamarin Hot Reload is still in preview so you will need to enable this feature in your Visual Studio.

To do it, go to Tools > Options > Environment > Preview Features > Enable Xamarin Hot Restart.

Enable Hot Reload

Enable it and remember to restart Visual Studio to actually enable it!

Now:

  • Set your iOS project as startup project
  • Set the build configuration to Debug – Iphone
  • In Configuration Manager enable “Deploy” for your iOS project
configuration manager
Enable deploy for iOS

Don’t connect your iPhone/iPad yet (the first time you have to configure this, then it doesn’t matter anymore)

Select “Local Device” and launch your app.

Now follow the instructions and if needed download and install iTunes.

After iTunes is installed, connect your iPhone/iPad to your pc.

Now you need to insert your Apple credentials and then enable the “Automatic provisioning“. This last step is not necessary but trust me, it’s very handy and your machine will automatically setup everything to run the app on your device.

Magic happened

If everything worked (if not you can write here a comment and I’ll try to help you) you will see your device listed among the available devices (where “Local Device” was). Now you can run your app on your local Apple device connected to your pc.

After installing your app on your device, Visual Studio will show a popup telling you to manually run the app. Do it and the popup will disappear and you will be able to test your app on your device.

Xamarin Hot Restart

Not only you can test your Xamarin.iOS app without a Mac, you can now even change your code in real time. After you have done your changes, you just need to press the restart button (next to the stop button on Visual Studio). Visual Studio will compile your changes and quickly relaunch your app. According to Microsoft These are the timing with the new Hot Restart:


Initial BuildInitial DeployIncremental BuildIncremental Deploy
Hot Restart19.49s22.66s2.24s3.89s
w/o Hot Restart163.38s11.24s41.40s8.12s

That’s quite impressive, and you have to consider that it’s just a preview so they can improve it.

Limitations

  • The Hot Restart works only on Xamarin.Forms and iOS devices, only on a Visual Studio (They will add compatibility for Visual Studio for Mac later).
  • Only 64 bit devices are supported
  • Storyboard and Xib files are not supported
  • Static iOS libraries and frameworks are not supported (your app will crash)
  • You still need a Mac to publish your app on the App Store

Conclusions

Xamarin Hot Reload is just a preview but it’s already a great tool to use. We can now try our Xamarin.Forms app on our Apple devices without using a Mac. I tried it with the app I’m currently working on right now and I’m very impressed. I cannot use storyboards (I don’t) and the app crashed if I open Maps (it’s integrated in the app I’m creating) but other than that it works very well and I’m very excited to try it.

Try it yourself and write in the comments what do you think. If you need any help, leave a comment and I’ll reply asap.

Happy Coding! 🙂



There are many reasons why you should download Xamarin.Forms 4.6 right now, but one is extremely important: without it you cannot publish new iOS apps on the app store anymore (UIView deprecated). Is this not enough? 🙂

So ok, let’s see what other new features we have in this new version.

Improved Shell Styling

Shell is a “quite” new feature of Xamarin.Forms that simplifies your app structure. Using it, you can have access to an “already cooked” tabbed navigation or Fly-out menu (use Shell and you’ll have an app and its navigation ready in 2 minutes). Xamarin.Forms 4.6 has improved the Shell styling making very easy to customise your navigation pages.

Navigating Back

Sometimes you don’t know your previous page so you don’t know where to go when the user presses the back button. Now you can co back with a vey easy and intuitive command:

await Shell.Current.GoToAsync("..");

Experimental Features

Thanks to an amazing open source community, Xamarin.Forms progresses really quickly. Sometime, they want to add new features but maybe the users are not fully ready for them, so they use an experimental flag.

To use a new feature you need to add to your App.xaml.cs the following constructor:

Device.SetFlags(new[] {
    "RadioButton_Experimental",
    "AppTheme_Experimental",
    "Markup_Experimental",
    "Expander_Experimental"
} );

Of course you want to add only the features you need in your app.

RadioButton

Should I really have to tell you what they are? Com on, you know what we are talking about. To be sure your radio buttons are part of the same group, you need to set the GroupName.

<StackLayout>
    <RadioButton GroupName="BestOne" Text="Android" />
    <RadioButton GroupName="BestOne" Text="iOS"/>
    <RadioButton GroupName="BestOne" Text="UWP"/>
</StackLayout>

Expander

How many times did you want to show and hide part of your page? Now with the Expander you can. This component shows/hides its content.

<Expander>
    <Expander.Header>      
        <Label Text="My header"/>
    </Expander.Header>                        
    <Label Text="My content">
    </Label>
</Expander>

Easy? Yes, it is!

C# UI Extensions

This is something I personally don’t like as I prefer to write my UI in XAML, but anyway I’m sure thare are many people around that would love this new feature. If you like to write your UI in C#, then you’ll be very happy. This extension enables the use of the fluent syntax.

Font Embedding

This is an amazing feature. I love it as it makes very easy to use custom fonts in our Xamarin.Forms apps. To add a new font, add it as an Embedded Resource to you .netstandard project then in you assemblyInfo.cs file add this line:

[assembly: ExportFont("yourfont.ttf")]

Just remember to replace “yourfont” with your font filename 🙂

then you just have to set the fontfamily every time you want to use that font. For example if we want to set a font for every label in our app we can create a style like this:

<Style TargetType="Label">
    <Setter Property="FontFamily" Value="MyFontName"/>
</Style>

Conclusion

I’ve tested the new version of Xamarin.Forms and I’ve found few things very useful.I think that you should really upgrade your app to Xamarin.Forms 4.6.

Have you tried this version and you are happy or have issues with it? Let me know your experience in the comments!

Do you need the link to download it? Here you go: nuget Xamarin.Forms

Happy Xamarin Coding!

Since ever, one of the most annoying problems of Xamarin Forms on Android was the start up time. A native app takes nothing while even the most basic Xamarin forms apps takes several seconds to show up on Android.

During the years Xamarin has tried hard to make things better, sometimes with very small improvements and other times with a bit better improvements but now with the new Visual Studio release (> 16.5) they did something amazing, something called Startup Tracing with custom Profiles.

Startup Tracing

I’m not going into many details here as the only thing that matters is how we can improve the performances of our Xamarin Forms apps for Android. So I’ll be very clear here. If you go into the Android Options of your Xamarin projects, you’ll see this:

If you enable the AOT Compilation (Ahead of time), your app performances will improve significantly and so the startup time, but your apk size will increase as well. At this point you can decide what is more important for you, performances or apk size.

Don’t answer yet, there is a solution

Since Visual Studio 2019 Version 16.2 you were able to enable the Startup Tracing. If you enable this option, the profiler will do its magic (memory, execution time and some stats) to create a profile for your app to increase the performances without affecting too much your apk size.

According to Xamarin (you can read the full post here), these are the results of enabling these options:

TypeStartup SpeedAPK Size
Normal2s914ms16.1 MB
AOT1s18ms34.6 MB
Startup Tracing1s518ms20.1 MB

It means that AOT is amazing and you should enable it but if you care about the apk size you should definitely enable the Startup tracing as well, so you’ll get an incredible startup speed improvement without affecting too much your apk size.

Amazing but now it’s even better

Since Visual Studio 16.5 (or Visual Studio for Mac 8.5), Xamarin did even better and trust me, the result is more than amazing. I was really impressed by it so do a favour to yourself and continue to read!

We can now generate a Custom Profile of our app! If we do that, the next time our app will run in no time (Cool cool cool cool cool…cit.).

Unfortunately for now there is no UI to generate a Custom Profile (hopefully Microsoft will do it soon), but I’ll show you how to generate your Custom Profile in no time. I’ll try to keep it as easy as I can and as usual, if you have questions or issues, leave a comment here and I’ll reply as soon as possible.

Generate a Custom Profile

Follow this short guide and you’ll get your Custom Profile in no time and you’ll really improve the performances of your Xamarin Forms apps for Android.

  • Open a command prompt in the directory that contains your Android *.csproj file.
  • Connect one (and only one) Android device to your computer.
  • In your Android manifest enable the INTERNET permission.
  • Write and run this command: msbuild /t:BuildAndStartAotProfiling
  • Run your app until is completely loaded (don’t press or do anything on your app!!!).
  • Write and run this command: msbuild /t:FinishAotProfiling (* if you have problems read just below these points)
  • This will create the file custom.aprof to your Android project. Now change the Build Action of this file to AndroidAotProfile.
  • Last step is to add two new properties to your Release configuration:
<PropertyGroup>
    <AndroidEnableProfiledAot>true</AndroidEnableProfiledAot> 
    <AndroidUseDefaultAotProfile>false</AndroidUseDefaultAotProfile>
</PropertyGroup>

Enjoy your new amazing performances!


ONLY IN CASE OF ERROR: When running the command msbuild /t:FinishAotProfiling some people (I had it as well on one of my machines) get the error:

aotprofile-tool: Unable to read profile through local port: 9999

If you do, open the Command prompt with admin privileges and (always in the folder containing you Android .csproj file) write:

set PATH=%PATH%;"C:\Program Files (x86)\Android\android-sdk\platform-tools"
msbuild -t:FinishAotProfiling

This will solve the problem and you will be able to have your custom profile.


Again according to Xamarin (you can read it here) this is the result of their tests:

ReleaseRelease/AOTRelease/Startup Tracing (Default)Release/Startup Tracing(Custom)
Activity Displayed4863ms2086ms3655ms1900ms
APK Size48MB95MB57MB60MB

Conclusions

I’ve personally tried the Startup Tracing with Custom Profiles and trust me, the results are impressive, the first time i couldn’t believe my eyes. When we enable these options we can finally obtain startup performances very similar to a native app (similar, not the same…yet!) so may suggestion here is to enable AOT and Startup Tracing and to create a Custom Profile for every project you are going to create! My suggestion is add this page as preferite as you will need it for every project you are going to create. As usual, add a comment and I’ll try to reply asap!

There are many ways to write an app and many patterns to follow. Some are very useful, others a bit less but there is one that you should always use MVVM, Model View View Model. It allows you to separate your apps in three main parts or layers:

Model: Your data

View: Your UI

View Model: Your logic

This pattern is brilliant so you should really use it. In it, your View knows nothing about the logic of your app and your ViewModel knows nothing about the UI, but they communicate through a mechanism called Data Binding.

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

In this quick example we have associated the text property of our Label to the property “MyTitle” in our ViewModel. Easy, isn’t it?


The problem

MVVM is great (and you should really use it) BUT the data binding has two big problems:

  • Because they are resolved at run-time, you have no validation at compile-time. It means that if in the previous example, instead of MyTitle you write MyTile, you code will compile fine and you will be able to run your app BUT you will not see the text in your label.
  • As we said, they are resolved at run-time through a mechanism called reflection. Reflection is cool but it has an high overhead cost, so every time you load a page with some bindings, your app will consume time.

The solution

Luckily there is a solution to enjoy MVVM and Data Binding, without having to worry about performances and the solution is Compiled Bindings.

To enable the Compiled Binding you have to do two quick steps:

  • Enable XAML compilation.
  • Set the correct x:DataType attributes.

It’s incredibly easy to do it an it’s easier to do that to explain so I’m going to show you how to do it with an example.


If you are starting a new Xamarin.Forms project, the template already has the XAML compilation enabled, but if you need to enable it you can add this attribute:

[XamlCompilation(XamlCompilationOptions.Compile)]

to your page class in your XAML code behind. So the class of your page will be similatr to this:

[XamlCompilation (XamlCompilationOptions.Compile)]
public class HomePage : ContentPage
{
    //Add your content here...
}

Very easy. Now let’s see how to set the correct x:DataType.

First of all, let’s say that our View is called MyExamplePage and our ViewModel is called MyExampleViewModel and that our page has a label with a binding:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:viewModels="clr-namespace:XamarinExpert.ViewModels;assembly=XamarinExpert"
             x:Class="XamarinExpert.Views.MyExamplePage">
    <ContentPage.BindingContext>
        <viewModels:MyExampleViewModel />
    </ContentPage.BindingContext>
    <ContentPage.Content>
        <StackLayout>
            <Label Text="{Binding MyTitle}"
                VerticalOptions="CenterAndExpand" 
                HorizontalOptions="CenterAndExpand" />
        </StackLayout>
    </ContentPage.Content>
</ContentPage>

This is a perfectly correct XAML and if we build and start it, it will run. If the property MyTitle exists in MyExampleViewModel, then we will be able to see the text.

Now let’s add the x:DataType  to enable the Compiled Data Binding. The code will be:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:viewModels="clr-namespace:XamarinExpert.ViewModels;assembly=XamarinExpert"
             x:DataType="viewModels:MyExampleViewModel"
             x:Class="XamarinExpert.Views.MyExamplePage">
    <ContentPage.BindingContext>
        <viewModels:MyExampleViewModel />
    </ContentPage.BindingContext>
    <ContentPage.Content>
        <StackLayout>
            <Label Text="{Binding MyTitle}"
                VerticalOptions="CenterAndExpand" 
                HorizontalOptions="CenterAndExpand" />
        </StackLayout>
    </ContentPage.Content>
</ContentPage>

the only thing we have added is:

x:DataType="viewModels:MyExampleViewModel"

I told you that it was easy.

Now we have obtained two great things:

  • Our code will be faster as we don’t have to use reflection anymore.
  • When we compile the code, the compiler will check if our properties (MyTitle in this case) are actually present in our ViewModel. If not, the compiler will inform you of the error and you will be able to quickly fix it.

Performances

I haven’t done any precise test but I’ve actually seen that enabling the Compiled Binding, made my app UI faster and smoother. So they work. Anywaythere are some numbers, According to Microsoft and Xamarin:

  • A  compiled binding with property-change notification is resolved approximately 8 times quicker than a classic binding.
  • A compiled binding without property-change notification is resolved approximately 20 times quicker than a classic binding.
  • Setting the BindingContext on a compiled binding that uses property change notification is approximately 5 times quicker than setting the BindingContext on a classic binding.
  • Setting the BindingContext on a compiled binding that doesn’t use property change notification is approximately 7 times quicker than setting the BindingContext on a classic binding.

Few Tips

  • Always use the Compiled Bindings
  • If possible, set the x:DataType attribute at the same level in the view hierarchy as the BindingContext is set. (When you set the BindingContext, set the x:DataType too)
  • The x:DataType attribute can be re-defined at any point in a view hierarchy. For example you can set the x:DataType at the ContentPage level (like we did before) and then set it again on a label or on a CollectionView (Really you should use them as I wrote here).
  • If for some reason in your view you need to disable the Compiled Bindings, you can set the x:DataType to null, for example:
<StackLayout x:DataType="{x:Null}">
    <Label Text="{Binding MyTitle}" />
</StackLayout>

Conclusion

Compiled Bindings are extremely useful for two main reasons, they are faster and they discover a lot of problems at compile-time. You should really always use them.

As usual, if you like the article or you have questions, leave a comment down here.

Every time we need to present a list of data in our apps, we use a component called ListView. This component does what we want but its performances are very bad, epsecially as it doesn’t support virtualization.

Luckily with Xamarin.Forms 4.3 we can now use a new component called CollectionView. It does exactly the same thing as a ListView but way better and with better performances.

I definitely suggest you to check your projects and replace your ListViews with the new shiny CollectionViews. I’ve done in in all my projects, it doesn’t require a lot of effort and the performances are definitely better. So do it! I’ll now show you how to do it. I’ve create a repository on GitHub with this example. You can find the link at the end of the post.

In the past we had ListViews…

Until version 4.3 to add a ListView we could add a code like this:

<ListView x:Name="MyListView"
           ItemsSource="{Binding MyItems}">
   <ListView.ItemTemplate>
       <DataTemplate>
           <TextCell Text="{Binding Name}" />
       </DataTemplate>
   </ListView.ItemTemplate>
</ListView>

What we have done is to add a ListView to our page called MyListView (naming an object is not mandatory as ideally using correctly MVVM you don’t have to use this name).

Then we have assigned some data to our list using the ItemsSource. MyItems is an ObservableCollection declared into the ViewModel associated.

After we have associated some Data to the ListView we have to show how they should appear. To do this, we can use the ItemTemplate property. There are standard DataTemplate that we can use with ListView and in this case we are going to use TextCell that is just a text. You can see it in the previous XAML code. Of course you can use all the other available DataTemplate or you can create every custom view you want. In the case of the previous XAML, the result is this:

ListView example
ListView example

…now we have CollectionViews

From Xamarin.Forms 4.3 we can now use the CollectionViews.

CollectionView is an improved component that will give you more control and better performances (much better performances).

There are few differences between ListView and CollectionView but most of the times, the transition from ListView to CollectionView is incredibly easy as we can see in the next XAML code. Here we are going to replace the ListView of the previous example with a CollectionView:

<CollectionView x:Name="MyCollectionView"
                ItemsSource="{Binding MyItems}">
    <CollectionView.ItemTemplate>
        <DataTemplate>
            <Label Text="{Binding Name}" />
        </DataTemplate>
    </CollectionView.ItemTemplate>
</CollectionView>

As you can see there are not many changes. First of all, you have to replace ListView with CollectionView. Same as for the ItemTemplate, replace ListView.ItemTemplate with CollectionView.ItemTemplate.

As you have probably noticed, there is a small difference. For the ListView as DataTemplate we used the TextCell, but this is not available anymore with CollectionViews so we have to write our own view. As we need to show only a text, what we can do is replace the TextCell with a Label.

//From this
<TextCell Text="{Binding Name}" />
//To this
<Label Text="{Binding Name}" />

Now let’s show how the page appears after these small changes:

CollectionView example
CollectionView example

As you can see graphically there are not many differences (but I’d say that the CollectionView appears nicer) but from a performances point of view, the differences are massive,e specially if you are going to add many items to your list.

Conclusion

I really encourage you to replace your ListViews with CollectionViews. It’s probably a matter of minutes but it will improve a lot the performances of your app.

The link for the example showed on this article is:

https://github.com/marcojak/TestCollectionView

As usual if you have any questions, leave a comment and I’ll reply as soon as possible. And if you want more info about CollectionViews and its new features or MVVM (Model-View-ViewModel) let me know and I’ll add some post

With Xamarin Forms it’s definitely possible to create great apps for Android, iOS and Windows: Safe Notes is clearly an example.

As you can see from the gallery, Safe Notes keeps your notes safe using a password and does it in a very stylish way.

Key Features

* Password protection. Protect your notes and checklist with password and lock the whole notepad app with your PIN.

* Offline access. Access your notes even without internet connection.

* Autosave. The notepad will save your notes automatically while you edit them.

* Tags. Organise your notes and to do list with labels to find them easily.

* Search function. Easy search notes and filter tags.

* Preferred Notes. Set note importance.

* Fast memo. Import text data directly from another source. Copy and paste from your phone to your note.

* Simple and intuitive user experience. Create. Edit. Delete.

* Photo support. Add photos and images to your secure notes.

* Colours. Use colours to categorise notes by importance, tags or subject or just make your notepad more fun.

* Tick the completed tasks.

* Share. Send and share individual note to yourself or another contact if you need.

* Unlimited text size.

* Multi languages.

* Off-line security. You are the only one that knows your password and everything that you write and save it is stored only on your phone instead of app and database. You don’t have to trust any other third-party as nobody else have access to it. Nothing is stored online where someone could potentially read it. 100% privacy protection.

* Free (Safe Notes is a free app and ads supported).

Download it from the Stores

Android: https://play.google.com/store/apps/details?id=com.HighTouch.SafeNotes

iOS: To be released

Windows: To be released

MTAdmob is now Open Source

October 16, 2019 | News, Plugin | No Comments

MTAdmob is probably the easiest and best plugin to add Google Admob to your Xamarin Android and iOS apps.

You can add Banners, Interstitials and Rewarded Videos to your app with a single line of code.

And now MTAdmob is Open Source so if you want to know how it works or if you want to contribute to it, you can go on

https://github.com/marcojak/MTAdmob

and have a look or maybe send a pull request with some new features.

Again if you need a tutorial, you can have a look at

https://www.xamarinexpert.it/admob-made-easy/

Have a suggestion or a comment? Write it here or on:

https://github.com/marcojak/MTAdmob

https://bitbucket.org/marcojak81/mtadmob

MarcTron.Admob version 1.4.3 is here

October 7, 2019 | Plugin | No Comments

UPDATE: It seems there is a problem with Xamarin.Google.iOS.MobileAds version 7.47.0 that doesn’t allow you to compile your code. If this happens, downgrade Xamarin.Google.iOS.MobileAds to version 7.38.0

I’eve just released the new version of the best and most complete Google Admob plugin for Xamarin (Android and iOS).

The changes for this version are:

  •      Added Consent option to iOS
  •      Updated Xamarin.Google.iOS.MobileAds to 7.47.0

With this new version it is possible to decide if use personalised Ads or not on iOS.

In addition to this, the new version of Xamarin.Google.iOS.MobileAds should solve some issues with iOS 13.

How to use the plugin

With MarcTron.Admob you can add Banners, Interstitials and Rewarded Videos to your apps with a single line of code.

First of all, install the plugin from Nuget: https://www.nuget.org/packages/MarcTron.Admob/ . Remember to install it in you shared project and in your Android and iOS projects.

After installing it, in your Android project open your AndroidManifest.xaml and inside the application tag insert this code:

    <meta-data android:name="com.google.android.gms.ads.APPLICATION_ID"
               android:value="ca-app-pub-xxxxxxxxxxxxxxxx~xxxxxxxxxx"/>

Remember to use your actual ApplicationID (you can find it in you Admob dashboard).

If on iOS you have problems displaying your ads, install the Xamarin.Google.iOS.MobileAds plugin (it should be installed automatically but sometimes you have to do it manually).

Add a Banner

To add a Banner, in your XAML add the code:

<controls:MTAdView/>

remember to add this line in your XAML:

xmlns:controls="clr-namespace:MarcTron.Plugin.Controls;assembly=Plugin.MtAdmob"

That’s it.

If you have problems showing the Ads, try to set the style in App.xaml:

<OnIdiom x:TypeArguments="x:Double" x:Key="AdsHeight" Phone="50" Tablet="90"/>
            <Style TargetType="controls:MTAdView">
                <Setter Property="HeightRequest" Value="{StaticResource AdsHeight}"/>
            </Style>

Interstitials

You can add an Insterstitial with a single line of code:

CrossMTAdmob.Current.ShowInterstitial();

To load a new one:

CrossMTAdmob.Current.LoadInterstitial("xx-xxx-xxx-xxxxxxxxxxxxxxxxx/xxxxxxxxxx");

Rewarded Video

You can show a Rewarded video with a single line of code:

CrossMTAdmob.Current.ShowRewardedVideo();

To Load a Rewarded Video you can use this line:

CrossMTAdmob.Current.LoadRewardedVideo("xx-xxx-xxx-xxxxxxxxxxxxxxxxx/xxxxxxxxxx");

There is so much more

There are many other things you can do with this great plugin for Admob. You can find the full documentation here: https://www.xamarinexpert.it/admob-made-easy/

Every good app needs to use a database. This database can be local (present in the app itself), or it can be remote (saved somewhere on the internet). The third option (fairly common) is to use both and then use a synchronisation mechanism between the two databases. In the case of a local database, the best possible option for our apps is to use an SQL database and use the SQLite library. This library can be used on mobile phones and PCs and is present on a multitude of different applications.

Use SQLite in Xamarin

In theory (I tell you later a better way) to add and use a SQL database in Xamarin.Forms you need to install the “sqlite-net-pcl” library in your projects (.netstandard, Android, iOS, UWP) and then create Dependencies Services (one for each platform).

The whole procedure is not particularly complicated, but it takes about half an hour. If you multiply half an hour for each project you are going to create, you will see that the amount of time lost becomes considerable.

After so many projects and many lost hours I decided to create and make available for everyone my library based on “sqlite-net-pcl“.

My library is called MtSql and allows you to add a SQL database to Xamarin apps in few seconds and in an extremely easy way. Going from 30 minutes to a few seconds is no small feat so I’ll explain how.

MTSQL

My library works with Xamarin and Windows, so you can use it in practically every project where you need to use a database. As this is a blog about Xamarin, I show you how it works on this platform.

Here are the steps to use a SQLite database in your Xamarin.Forms project.

  • Right click on your solution and select Manage Nuget Packages for Solution
  • Search for “MarcTron” (so you can see my other plugins too 🙂 ) or directly MTSql. Install MarcTron.Sqlite in your projects (.netstandard, Android, iOS, UWP).
  • Finished!!!! You have nothing else to do, right now you are ready to use a SQL database inside your app. Time taken: few seconds 🙂

How to use MTSQL

Now that the library is installed in your solution, we need to tell our app which database to use, so we need to establish a connection with the database. To do this we have several possibilities:

using MarcTron.Plugin;
...

SQLiteConnection conn = MtSql.Current.GetConnection("yourdbname.db3");

in this case we have established a connection with the “yourdbname.db3” database. If we want to create an asynchronous connection, we can instead write:

SQLiteAsyncConnection conn = MtSql.Current.GetConnectionAsync("yourdbname.db3");

Since version 1.2 of MTSql I have created an additional Helper to make everything even easier, so to establish the connection with your database, you can write:

MtSql.Helper.Initialize("yourdbname.db3");

PLEASE NOTE: You must always initialise the database with one of the three previous methods before using it.

In my library, to simplify your life, I’ve created a basic template for the tables in your database. This model is called BaseModel (I write it here just to show it to you):

public class BaseModel
{
    [PrimaryKey]
    public string Id { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}

Using it is very simple. For example, if you have a table called User with a Name field, you can write the class that defines it as:

public class User : BaseModel
{
    public string Name{ get; set; }
}

Doing so your table will have not only the Name field but also a primary Id key and two CreatedAt, UpdatedAt dates, which specify when the data has been created and modified (very useful if you want to sort your tables by creation or update date).

The helper I created has inside a method called Save. This method will deal not only with inserting or updating a record within your tables but also creating a GUID for you (if you have not already created it) and updating the value of CreatedAt and UpdatedAt. FANTASTIC!

PLEASE NOTE: The Save method inserts an object if its primary key value is not present in the table while updating it if its value is already in the table.

You don’t have to use the BaseModel class but I suggest you to do so and now I’ll show you why.

An Example

Now let’s see a quick example to initialise the database, insert an object and then update it:

MtSql.Helper.Initialize("MyDatabase.db3");
MtSql.Helper.CreateTable<User>();

User user = new User() {Name = "Marco"};
MtSql.Helper.Save(user);

user .Name = "Marco Troncone";
MtSql.Helper.Save(user);

In the first line we have initialised the database (Don’t forget it, it is fundamental to do it).

We then created a User table using the User class written above. At this point we created a user and gave him the name Marco.

When we call the method

MtSql.Helper.Save(user);

since user does not have an Id, the Save method will create one automatically (if you want you can assign one yourself) and will add the user to the table, setting CreatedAt and UpdatedAt to the current time.

At this point we try to change the user name and save the change:

user.Name = "Marco Troncone";
MtSql.Helper.Save(user);

This time user has already an Id and this Id is already present in the table, this time the Save method will not add a new object to the table but will update the current object, automatically updating UpdatedAt. Easy right?

Thanks to the MTSql plugin, in exactly 6 lines of code we have initialised our database, created a table, added an object and modified an object.

Other methods inside the Helper

In the previous example, we’ve seen some helper methods (Initialise, CreateTable, Save), let’s see what the other methods we have:

//To insert a single item inside the table
Insert<TType>(TType item);

//To insert multiple items inside the table
InsertAll<TType>(IEnumerable<TType> items);

//To update an item inside the table
Update<TType>(TType item);

//To find an item inside the table
FirstOrDefault<TType>(Expression<Func<TType, bool>> expression);

//To get from the table the item with Id itemId
GetFromId<TType>(string itemId);

//To get from the table the items with parameter quals to value
GetBy<TType>(string parameter, object value);

//To get all the items from the table
GetAll<TType>();

//To delete the item from the table
Delete<TType>(TType item);

//To delete ALL the items from the table. WARNING!!!
DeleteAll<TType>();

//To see if an item exists
Exists<TType>(string itemId);

//To count the number of items in a table
Count<TType>();

The Helper I’ve created has all the main methods to work on your database. If some methods are not available, you can directly access the database (and therefore all its methods) using the command:

MtSql.Helper.Conn

this is a direct link to the database connection and from here you can find all the supported methods.

Conclusions

Creating a database could be a complicated operation but thanks to the MTSql library, creating a database for our Xamarin projects. Forms is incredibly easy. Install the library from Nuget and in a few seconds and a few lines of code, you have a database ready to be used in your Android, iOS and UWP projects.

Do you have any doubts or suggestions? Add a comment below, and if the article and the library were helpful to you, share them.

Many modern apps require a secure authentication for users and Azure Active Directory Authentication Library (ADAL) enables application developers to authenticate users to cloud or on-premises Active Directory (AD). Here I show two different ways to add ADAL to a Xamarin.Forms project.

The short way: MTADAL Plugin

This is a plugin I have created to add ADAL to all my projects and I’ve decided to make it freely available to everyone.The plugin page here: http://www.xamarinexpert.it/plugins/mt-adal/A tutorial to use the plugin is here: http://www.xamarinexpert.it/2018/03/01/adal-made-easy/

Authentication with MTADAL Nuget package
MTADAL Nuget package

This plugin is really easy to use. You just need to install it in your projects (PCL/.NetStandard and platform projects) and write:

AuthenticationResult data = await MTADAL.Current.Authenticate(Authority, GraphResourceUri, ClientId, ReturnUri);

That’s it. Basically in less than a minute you are ready to authenticate your users.

The long way: Write the authentication code

In case you don’t want to use the MTADAL plugin, you can write the code by yourself in your projects.The first thing you need to do is install the ADAL nuget package in your projects (https://www.nuget.org/packages/Microsoft.IdentityModel.Clients.ActiveDirectory/)

Authentication with ADAL package
ADAL package

In our PCL/.NetStanrdard project we need to add this interface:

public interface IAuthenticator
{
    Task<AuthenticationResult> Authenticate(string authority, string resource, string clientId, string returnUri);
    void Logout(string authority);
    bool hasLoginData(string authority);
}

and when we want to authenticate a user we need to use this code:

var auth = DependencyService.Get<IAuthenticator>();
            AuthenticationResult data = await auth.Authenticate(App.Authority, App.GraphResourceUri, App.ClientId, App.ReturnUri);

Before we can authenticate the users, we need to add the code in each of the platform project we need the authentication (eg. Android, iOS, UWP):

Android

Here we need to implement the interface created in our PCL/.NetStandard project.

[assembly: Dependency(typeof(Authenticator))]

namespace YOURNAMESPACE
{
    public class Authenticator : IAuthenticator
    {
        public async Task<AuthenticationResult> Authenticate(string authority, string resource, string clientId, string returnUri)
        {
            try
            {
                var authContext = new AuthenticationContext(authority);
                if (authContext.TokenCache.ReadItems().Any()) 
                    authContext = new AuthenticationContext(authContext.TokenCache.ReadItems().First().Authority);
                var uri = new Uri(returnUri);
                var platformParams = new PlatformParameters((Activity) Forms.Context);
                var authResult = await authContext.AcquireTokenAsync(resource, clientId, uri, platformParams);
                return authResult;
            }
            catch (Exception ecc)
            {
                return null;
            }
        }

        public bool hasLoginData(string authority)
        {
            var authContext = new AuthenticationContext(authority);
            return authContext.TokenCache.ReadItems().Any();
        }

        public void Logout(string authority)
        {
            var authContext = new AuthenticationContext(authority);
            if (authContext.TokenCache.ReadItems().Any()) authContext.TokenCache.Clear();
        }
    }
}

We need to register the class with DependencyService otherwise the code will not work. We can register the class adding this line before the namespace:[assembly: Dependency(typeof(Authenticator))]Don’t forget it otherwise the authentication will not work!Inside your MainActivity class you also need to add this code:

protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
        {
            base.OnActivityResult(requestCode, resultCode, data);
            AuthenticationAgentContinuationHelper.SetAuthenticationAgentContinuationEventArgs(requestCode, resultCode, data);
        }

This will intercept the result from the ADAL activity and will allow you to conclude successfully the authentication.

iOS

We need to add the class to our iOS project:

[assembly: Dependency(typeof(Authenticator))]

namespace YOURNAMESPACE
{
    class Authenticator : IAuthenticator
    {
        public async Task<AuthenticationResult> Authenticate(string authority, string resource, string clientId, string returnUri)
        {
            try
            {
                var authContext = new AuthenticationContext(authority);
                if (authContext.TokenCache.ReadItems().Any())
                    authContext = new AuthenticationContext(authContext.TokenCache.ReadItems().First().Authority);
                var controller = UIApplication.SharedApplication.KeyWindow.RootViewController;
                var uri = new Uri(returnUri);
                var platformParams = new PlatformParameters(controller);
                var authResult = await authContext.AcquireTokenAsync(resource, clientId, uri, platformParams);
                return authResult;
            }
            catch (Exception ecc)
            {
                return null;
            }
        }

        public bool hasLoginData(string authority)
        {
            var authContext = new AuthenticationContext(authority);
            return authContext.TokenCache.ReadItems().Any();
        }

        public void Logout(string authority)
        {
            var authContext = new AuthenticationContext(authority);
            if (authContext.TokenCache.ReadItems().Any()) authContext.TokenCache.Clear();
        }
    }
}

This class is the only thing you need to authenticate your users on iOS.Again, remember to add the line[assembly: Dependency(typeof(Authenticator))]

UWP

We need to add the class to our UWP project:

[assembly: Dependency(typeof(Authenticator))]

namespace YOURNAMESPACE
{
    public class Authenticator : IAuthenticator
    {
        public async Task<AuthenticationResult> Authenticate(string authority, string resource, string clientId, string returnUri)
        {
            try
            {
                var authContext = new AuthenticationContext(authority);
                if (authContext.TokenCache.ReadItems().Any())
                    authContext = new AuthenticationContext(authContext.TokenCache.ReadItems().First().Authority);
                var uri = new Uri(returnUri);
                var platformParams = new PlatformParameters(PromptBehavior.Auto, false);
                var authResult = await authContext.AcquireTokenAsync(resource, clientId, uri, platformParams);
                return authResult;
            }
            catch (Exception ecc)
            {
                return null;
            }
        }

        public void Logout(string authority)
        {
            var authContext = new AuthenticationContext(authority);
            if (authContext.TokenCache.ReadItems().Any()) authContext.TokenCache.Clear();
        }

        public bool hasLoginData(string authority)
        {
            var authContext = new AuthenticationContext(authority);
            return authContext.TokenCache.ReadItems().Any();
        }
    }
}

This class is the only thing you need to authenticate your users on UWP.Again, remember to add the line[assembly: Dependency(typeof(Authenticator))]

Summary

It’s incredibly easy to authenticate users in a Xamarin.Forms projects. You can do it in 2 ways:

  1.  Use the MTADAL Plugin
  2.  Install the ADAL Plugin, add then interface and add the classes above for each of your platform projects!

%d bloggers like this: