Mobile First Cloud First

A blog by Geert van der Cruijsen on Apps, Cloud & ALM

Tag: Xamarin.Android

Xamarin apps: Sqlite vs Realm. What’s the best mobile DB solution?

Last week introduced Realm for Xamarin. Realm promises an easy object database with full query options and better performance than existing solutions (so also sqlite which is probably the most used database solution). Time to put both sqlite and Realm to the test. which is better?

SqlitevsRealm (2)

When comparing these solutions i wanted to test out the full relational options of the database because that is what Realm advertises with. if we are looking at just plain key value storing we could use something like akavache (based on sqlite back end) which is probably faster because of lots of optimisations in queries. I do recommend using akavache for caching scenarios or when you are just storing simple types of data that do not require complex querying.

To test sqlite and Realm i’ve created a simple datamodel with orders and order lines. each order has a list of order lines and i would like to be able to query orders and get the underlying orders back immediately. but also the other way around. i would like to query certain orders which have order lines that contain a certain product. those kind of queries happen often when you are working in a real world business app.

So now we have this datamodel + some queries we want to execute. lets define some criteria on how to score both solutions. I came up with the following critters: Ease of use, speed, & maintainability.

let’s talk about these criteria in a bit more depth. I’ve created a sample project on github that has the samples and source code for you to experiment.

You can download the source here:

Ease of use

Sqlite and Realm are both pretty easy to set up. I’ve used Sqlite in the past before and had never used Realm so i had to do some reading up on Realm. I didn’t have to read that much though because the basic explanation of Xamarin.Realm on the site explains the most used features and all the features i need for this first test.

Realm is actually really simple to set up. Where Sqlite does require some plumbing (getting a location for a file to store your DB in and creating a SqlAsyncConnection) this is not needed for Realm. In Realm you can just call the GetInstance(); method and you are ready to go. For both we need to install nuget packages of course which can be though for sqlite as well since there are so many different packages it’s sometimes hard to know which ones to use.

Sqlite needs 3 nuget packages for the basic functionality:  SQLite.Net-PCL, SQLite.Net.Core-PCL and SQLite.Net.Async-PCL. next to that i use 2 extra packages to give me some extra extension methods: SQLiteNetExtensions & SQLiteNetExtensions.Async.

For Realm we just need to add Realm nuget package to all our projects.

After we have an instance of both Sqlite and Realm we can start inserting some data into our database. Below is some sample code to insert 1000 orders which each have 5 order lines. I want to be able to insert all of them and make sure that there is a relation stored between the orders and the order lines so i can retrieve both in 1 query.

Looking at the code Realm just works a bit easier. we don’t have to think about doing sql transactions (if you forget/remove the transaction it is about 3x slower.) We just need to create the objects in a Realm.Write block and Realm will handle all the things for us. I do have to say i’m no fan of having my database objects have to inherit from RealmObject and that the constructor has to be Realm.CreateObject() but more on that in the Maintainability criteria. When looking at ease of use only i have to say Realm is easier because it does all the plumbing and yak shaving for you. Winner: Realm


Realm promised us a faster database than the competition so this was the reason i started this investigation. Sqlite can be slow some times but most often this is because of bad use. Paul Betts (creator of Akavache) did a great session at Xamarin Evolve this year on why sqlite is often slow and how to use it properly. To test the speed I’ve created a xamarin forms app and ran some tests on both Android and iOS. speeds do change a bit from platform to platform and also there is a some difference in using a device or emulator/simulator. Overall Realm seemed a bit faster in querying complex queries and it seems to use some caching looking at the query that took 0 ms on iOS. A note here is that Sqlite can probably be even a bit faster when you optimize the queries. What i used now for Sqlite is just a generic query to retrieves all objects with it’s children.

Screen Shot 2016-05-17 at 13.52.12 Screenshot_20160517-135540

After looking at the test data there are some differences and sometimes Sqlite is faster then Realm and the other way around. Sqlite can be fast if you know what you are doing and Realm seems to do the job quite well without any special thought on how to do things like transactions. scoring points for ease of use again.

Winner: No clear winner between Sqlite & Realm purely regarding speed


The last criteria on which i wanted to test these 3 solutions is maintainability. Sure the ease of use of Realm seems nice but how would this work in actual apps that need to be maintained and tested for long periods of time.

The first think i noticed when looking at Realm is that all your database object need to inherit from RealmObject. Because of this inheritance Realm knows how to do all it’s magic but i really don’t like this approach. creating objects cannot be done by using a simple constructor you always need to use Realm.CreateObject, creating a tight reference to Realm. Same goes for the lists of objects within a RealmObject which have to be of the type RealmList<T>. I like Sqlites approach much better where you just use simple POCOs (Plain Old CLR Objects) with some attributes attached so Sqlite knows how to store certain things.

In a proper testable software architecture you want to keep the dependency on either Realm or Sqlite to a minimum of places and preferably only in the classes that handle the database communication. for Sqlite this is possible however for Realm this will be quite hard since creating new objects can only be done by Realm.CreatObject. You could do a mapping from Realm to POCOs in your repository but that defeats the purpose of the ease of use of Realm which offers functionality for listeners on object changes to easily update your UI.

another thing that is really missing from Realm is support for Async. In my opinion every mobile library should have async features as default (or as only option). It is on the “missing features” list of Realm so they are aware that this is an important feature. But at it’s current state in the beta it’s not in.

The last thing i noticed was the Fody Weaver that is being used by Realm. At first it’s not that important for you as a developer because it just works. the weaver will do some changes to your IL to add stuff Realm needs. As long as everything works it’s no problem, however when you run into problems you might have issues finding the issue because the code that is being executed is actually a bit different from what you wrote.

Combining these things related to maintainability i think Sqlite is a clear winner here.

Winner: Sqlite


Looking at these 3 criteria i think Sqlite is still the best solution. Sure Realm is pretty fast and needs almost no plumbing i think the maintainability of Sqlite will win it in the end. I do see some use for Realm, especially for POC’s or small projects. (although for POCs i have to much experience of POCs running in production in the end or growing to larger apps, if that is the case i would pick Sqlite).

We have to take into account that Realm is still in beta and Sqlite has been there for ages but the things i don’t like about Realm are basically in it’s base so i don’t see them changing that quite soon. I’ll be watching Realm to see what they are up to in the future but for now i’ll keep using Sqlite.

Let me know your experiences with Realm in the comments below. i’m curious if people have different opinions than me after playing with it for a few days.

Happy Coding

Geert van der Cruijsen

Continuous deployment of Xamarin Android apps to Hockeyapp using VSTS

Continuous integration and continuous deployments are a hot topic in the web world and are becoming a common practice there.  In the mobile world however this is not the case “yet”.

Microsoft seems to have everything in place now for a full Mobile ALM suite. Building your cross platform apps with Xamarin (which they just acquired yesterday), storing your code and builds in VSTS (Visual Studio Team Services) and deploying your app to Hockeyapp. Usage and bug tracking can be done by either Xamarin insights, Hockeyapp or Microsoft Application insights (although the last one is deprecated). In the end I believe these 3 applications will merge into 1. So how do we set up these continuous deployments of our apps to hockeyapp? I’ll be describing this in a series of 3 blogposts (1 for each platform).

There are quite some differences in deploying the apps for the 3 platforms to Hockeyapp so that’s why I’ve decided to split them up into separate blog posts.

We’ll start with Android because this is the easiest and most straight forward. (who would have expected that?)



Context: the app we are going to deploy

I’ve created a simple solution in Visual Studio containing an average Xamarin project. 1 PCL, 1 Android app, 1 iOS app and 1 Windows 10 UWP app.


This solution is checked into my GIT repository stored in VSTS so lets move to there to start building the Android

Setting up the build in VSTS

in VSTS open your team project and go to the BUILD tab. in here we’re going to create a new build definition by clicking the green + sign.


Select the Xamarin.Android template which is already created by Microsoft for you.

image_thumb-2 (1)

Select the  repository containing the solution and select the branch you want to deploy. you can even choose to build apps that are stored in different sources such as GitHub or remote Git repositories.

After everything is set click on Create


A build definition will be created and several build steps are generated for you. We’ll go over them one by one.

image_thumb-4 (1)

The first step is setting up your Xamarin license steps that will activate and deactivate your Xamarin license which is needed to execute the build of your Xamarin.Android project.

In this step you have to enter your email and password. Please note that the password field is a plain textbox and no password box. to fix this go to the “Variables” tab and create a variable with your password while you check the lock icon on the right. now you can store your password without other people being able to see it.

image_thumb-5 (1)

After you’ve created the Variable enter your email address and password variable into the 2 Xamarin License Steps (1 for activation and 1 for deactivation)

image_thumb-4 (1)

Please note that the deactivation step is set  to always run (even if the build crashes half way)

Next we’ll be removing the Xamarin Test cloud build step in our build. Xamarin test cloud is a very nice tool to test your app on real devices but for this blogpost it’s a bit off topic. if you want to know more about how this works let me know and I’ll write another blog post about it.

I’ll also be deleting the MSBuild step that would build the unit test projects since my sample project did not have any unit tests.

image_thumb-7 (1)

Now the Xamarin license is set up we will start building the actual Android app. to do this we first need to build the PCL project. Add 2 extra build steps to our build definition by pressing the Add Build Step button

image_thumb-8 (1)

First Add a Nuget Installer step.

image_thumb-9 (1)

after that add a Visual Studio Build step.

image_thumb-10 (1)

Drag both steps to the top so the Nuget Installer is the first step and the Visual Studio Build step is the second.

The nuget installer step will be configured so it will install and update all nuget packages that are part of our solution. select your solution file in the “Path to Solution” field.

image_thumb-11 (1)

This is all we have to set up for the nuget packages. If you don’t have any nuget packages (is that possible these days?) you can remove this build step.

Next we’re going to set up the build of the PCL project. select the Visual Studio Build Step and select all the csproj file(s) that are part of your project.

Set the build platform to AnyCPU and make sure the configuration takes the $(BuildConfiguration) variable.

image_thumb-12 (1)

So now the PCL project builds lets move to the actual Android App build step.

Select your Android csproj file and make sure that the output directory is set to $(build.binariesdirectory)\$(BuildConfiguration) and the Configuration is set to $(BuildConfiguration)

image_thumb-13 (1)

Now all projects are being built and the only thing we need to do is publish the build artifacts so we can deploy them to Hockeyapp.

Set the Path to publish to $(build.binariesdirectory)\$(BuildConfiguration) and set the Artifact name to drop and the artifact type to Server.

image_thumb-14 (1)

Save your build and give it a test spin by clicking “Queue Build” you can also set the build to run automatically by adding a trigger in the Triggers tab.


if all is correct your build should now pass. on to the next step deploying a release to Hockeyapp!

Setting up Hockeyapp

I assume you’ve already created an account at Hockeyapp otherwise just sign up at (It’s free for 2 apps or less) once you’ve logged in go and create your first app by pressing the New App Button


Hockeyapp will ask you to upload a build. we’re not going to do that since we’re setting up automatic deployments. choose to add the app manually


Choose Android as your platform and select Alpha or Beta for release type. (whatever fits your app builds best). Give the app a title and fill in the Package Name and click save.


Now the app is created and it will show up on your dashboard. click on your app and copy your App ID. we’ll need it later.


To be able to deploy from VSTS we need to set up an API token we can use in VSTS. Click on your user icon in the top right and select API Tokens from the menu on the left.

Create a new API token and call it VSTS. Copy this API token. we’ll need it in VSTS


Move back to VSTS and  open up the marketplace (top right next to your name) and click manage extensions. browse the marketplace and install the Hockeyapp extension


After installing the extension go back to your VSTS team project and navigate to the settings window. in the settings menu go to Services and add a new service Endpoint of type “Hockeyapp”

Give the endpoint a proper name and copy in the API token you’ve generated earlier. now save the service endpoint.


Now all the plumbing with Hockeyapp is done we can actually start deploying our app to hockeyapp

Deploying your automated build to Hockeyapp

Go back to your team project in VSTS and navigate to the Release tab


Choose an Empty deployment template and press OK.


First go to the Artifact tab and select the build we’ve created earlier as supplier of the artifacts we’re going to release to hockeyapp.



Go back to Environments, name your deployment template and add a new Task


This list should now contain a Hockeyapp step since we installed that as our extension


Configure the Hockeyapp step by selecting the Hockeyapp connection from the list. (the service connection you’ve created earlier should be listed here) Enter the APP ID you copied earlier and select the .apk file that was generated by the build.


The last step is setting the trigger to automatically start your hockeyapp deployment after each successful build.  go to triggers, select Continuous deployment and make sure that the environment trigger is set to “Automated: after release creation.”


Save the deployment template and now you are ready to go. you can now manually create a new release using the deployment template or start a new build and you should see your app show up in Hockeyapp so your testers can download the app.

If you have any questions let me know via twitter @geertvdc or by commenting below.

Hopefully you’ll be back tomorrow for the next post explaining all the steps for Windows 10 UWP apps.

Geert van der  Cruijsen