I am very exiced to write this blog post. First time I seen EF was in ASPNET MVC and I fall in love with it, now when I am also very active in Xamarin Development, Entity Framework is something that I miss from my ASP.NET dev "world". With version Core 2.0 all platforms Android, iOS and UWP (uwp soon) are supported so I decided to write this blog post.

When I learn something I like to see it from zero to some CRUD operations in the app, so this blog post will be like that. We will have couple of tables (two), our context class and CRUD operations in Xamarin.Forms.

Hope that you will like it.


First of all our shared project need to be .NET Standard Library 2.0 and here is a good article about it: https://blog.xamarin.com/building-xamarin-forms-apps-net-standard/

You can also check out these great blog posts from Adam Pedley:

• https://xamarinhelp.com/entity-framework-core-xamarin-forms/
• https://xamarinhelp.com/dot-net-standard-pcl-xamarin-forms

If you have any question about migrating to .NET Standard please comment down bellow and I will try to make special blog post about that.

Create new Xamarin.Forms app as always I will use PCL and I will migrate to the .NET Standard Library 2.0.. and add our three standard folders: Models, Views, ViewModels and additional ones are Helpers and DataAccess.
Like this:

Note: At this moment EF Core 2.0 is working on all platforms but UWP is not supporting .NET Standard 2.0 at it will be supported by the end of the year. 
More info here: https://github.com/dotnet/standard/blob/master/docs/versions.md

But when UWP become .NET Standard 2.0 "friendly" I will update this blog post.

Note #2: At this moment EF Core is not supporting lazy load.
More info here: https://github.com/aspnet/EntityFrameworkCore/issues/3797. 
And here is a couple of word from Rowan Miller: "Just to add one data point to the discussion. Lazy Loading isn't going to be in 2.0 but we are adding some features that are groundwork for implementing it. The biggest one is Life Cycle Hooks, which combined with the EntityEntry APIs we added in 1.1, will allow a rudimentary roll-your-own lazy loading pattern."


Community: "Entity Framework Core 2.0 is available in Xamarin.Forms to all platforms (UWP is coming very very soon)"

Me:



Ok we can start with tutorial now :

First  we need to add nuget packages to use EF in our app, in your .NET Standard class library and Android and iOS project add this nuget: Microsoft.EntityFrameworkCore.Sqlite


When you finish installing the nuget you want to add this line in iOS project in AppDelagate.cs:
Now you are ready to follow the tutorial.

I will use MVVM for this tutorial and that is my advice to you also, the main focus of this tutorial will be Entity Framework, so if anything is blurry for you about MVVM, you can checkout some of my previous tutorials and blog posts about MVVM.

First thing we need to do is to make our models, our entity models which will represent the tables in our database. For this tutorial I will use two classes/tables with one-to-many relationship with Team and Player.

These classes looks like this:

Team.cs:
and Player.cs:
That are the classes which we will use in our database.

If you are familiar with EntityFramework you will know that we need some class which will represent the context of our database.

So we need one class which will inherent from DbContext class and it will hold our two table classes with in this case two DbSet properties.

Here you can see a code snippet for our DatabaseContext and some additional code lines that will be described in the next few paragraphs:
in the constructor at line 17. We are calling the method called EnsureCreated (without it you will get an exception).

It ensures that the database for the context exists. If it exists, no action is taken. If it does not exist then the database and all its schema are created. If the database exists, then no effort is made to ensure it is compatible with the model for this context.

Also inside of DatabaseContext class we have method OnConfiguring where you can set some options for database. In this particular case we need to get sqlite database path for every platform that is used in our solution. To get these values best approach is to use DependencyService which is built in Xamarin.Forms.

Code lines for getting sqlite database path for platforms:

In this example I am using the DependencyService, you will see the whole code in github repo. I will write another blog post about DependencyService in Xamarin.Forms. If you don't want to go with DependencyService you can simply pass this string that you get from from code lines above to the App.cs in your shared project from platforms specific projects and store it in some public static string property and access it from db context. The decision is yours. 😎

Now our database is ready and we can now implement CRUD operations in our App.


BaseViewModel:

As I mentioned early I will use MVVM in this app example so first thing that I want to make is a Base-view-model which will hold the OnPropertyChanged() method implementation so it is easier to us just to inherit from it and use it with our properties in view model.

Our BaseViewModel:

READ:

Main idea in this app is to list all the teams, view details about them, add players to the team... So first view will be ListPage for our Teams.

Create new content page called TeamsListPage.xaml and it should look like this:
As you can see we have our controls ready to do binding from viewmodel.

code behind class called TeamsListPage.xaml.cs:

and the main part is our view-model:
From XAML code you can see that we have one listview and we are binding that listview to an ObservableCollection of the type Team.

We are populating this collection with list of teams from database, so in constructor of view-model we need to initialize DatabaseContext object with known linq syntax we are getting all teams from database.

Next step is to implement Create operation with Entity Framework.

CREATE:

Create new page inside of Views folder called AddTeamPage.xaml. This page is simple "form" layout with couple of entry controls for Team properties.

XAML code looks like this:
Code behind:
View-model for this page is:

We have standard binding from controls to the view-model properties, also there is one command which will trigger SaveTeam() method for the adding team to database.

That method is interesting for us.

We are creating new object of type Team, and for Team properties we are setting those from View-model which also represents the data from xaml controls (Using MVVM and Binding).

Now we are ready to add that entry to database, with standard approach using .Add(objectToInsert) method, and of course we need to commit that insert with .SaveChanges().

Now we will test this:

DELETE:

When user clicks on list view item on the TeamListPage we want to open new page called TeamDetailsPage and show basic info about this team. So let's implement that, if you scroll up you will see that in our TeamListPage we have one event for openning new page.
TeamDetailsPage XAML:

Code behind:
... and a view-model:
Code is pretty much self explanatory, most interesting part for us is DeleteTeam() method, inside of it you can see usage of Remove() method with EF.

First step is to get a an team by Id using Find() method, when we have our team to delete we can call Remove() method and as parameter send the object to remove from database, and as always commit that with SaveChanges().

Let's test this:

UPDATE:

In our TeamDetailsPage we have toolbar item for opening an EditTeamPage so there we will implement Update operations for team class/table.
XAML code:
Code-behind:
View-Model:
SaveTeam() is method where the update code is located.

First thing is to get existing team from database by Id, this is very important because we will make changes on this object and later save/update it to database.

After we have our object of type team to update, we will change its values by those from our view-model, from user input from XAML.

Now we need to save those changes with two approaches, one is to use Update and other approach is with EntityState.

Now we can test this:


It works! With this example we have completed our CRUD on Team table.

Now we can continue to do some operations with Player class/table in our db. If you followed this tutorial from start to this point you will be able to do this by yourself if you want. But I will finish this tutorial with those operations so if you want you can follow me to the end.

Add new Player:

In TeamDetailsPage you can find toolbar item for adding new player for that team, so we will use it to open new page called AddPlayerPage.xaml, and in that page we are passing the teamId just to know in which team we are adding that new player.

Xaml:
Code behind:
View Model:

SavePlayer() method will handle the adding new player to the database, inside of it we are getting the values from our viewmodel and creating new player object with that values, and for property "foreign key" TeamId we will set teamId that we passed from TeamDetailsPage.

After that we just add it to dbcontext like always, and commit that with SaveChanges().

Let's test this:

Edit Player:

... and edit is pretty same approach, only difference is that we will update it. To edit player we need to tap it on the list of player in TeamDetailsPage, we will pass the playerId to the EditPlayerPage.

Xaml:
Code-behind:
View-model:


In SavePlayer() method we are setting new values from our view to the player object that we get from database by playerId, and committing changes using SaveChanges() (nothing new).

Let's test this:



With this example we are done!

And that is it, we have our app done, we have implemented all CRUD operations using Entity Framework 2.0 with Xamarin.Forms.

Code for this example is available on the my GitHub repo more about it here:

https://github.com/almirvuk/Xamarin.Forms_EFCore


I hope this tutorial was helpful for you. My goal with this tutorial was to show CRUD examples using Entity Framework Core 2.0. If anything was blurry you can write me in the comment section down bellow. If this was helpful you can also write it, and share it with your friends.

Best regards! Almir Vuk