Immutable Models in MVVM

10-22-04 025
Source: flickr/ Jeff Attaway


The first M stands for Model – an implementation of the application’s domain model that includes a data model along with business and validation logic. Examples of model objects include repositories, business objects, data transfer objects (DTOs), Plain Old CLR Objects (POCOs), and generated entity and proxy objects.

definition source


In object-oriented and functional programming, an immutable object(unchangeable object) is an object whose state cannot be modified after it is created. This is in contrast to a mutable object (changeable object), which can be modified after it is created.

definition source

Why bother?

Imagine the next simple situation, your application downloads a JSON,  deserialises it to an object and then presents the downloaded data. You would expect the downloaded data to be one-to-one to the data on the remote server, however the data can be accidentally or intentionally mutated.

Here is an example of a mutable Model:

public class MyMutableObject
    public long Id { get; set; }
    public string Title { get; set; }
    public List<string> Contents { get; set; }

All the properties has public setters which means that any of those can be changed after the object creation. Even if we make all the setters private, it could be still possible to manipulate data within the List.

Here is an example of immutable Model:

public sealed class MyImmutableObject
    public long Id { get; }
    public string Title { get; }
    public IReadOnlyCollection<string> Contents { get; }

    public MyImmutableObject(
        long id,
        string title,
        IReadOnlyCollection<string> contents)
        Id = id;
        Title = title;
        Contents = contents;

There are no public setters available and mutable collection type is replaced by “immutable” one. There is no option to extend this class as well as changing the data after the object is created.

IReadOnlyCollection is not a real immutable collection but an immutable facade. It is not thread safe and possible to cast to IList and try to manipulate the collection, however System.NotSupportedException will be thrown.

Alternatively we can add a System.Collections.Immutable NuGet package and replace IReadOnlyCollection<T> by IImmutableList<T> if we want a real immutable collection.

JSON Deserialization

Often Models used for deserialization and it can be tricky to deserialize JSON to immutable object. Luckily with Json.NET it is not an issue. We can easily serialize and deserialize MyImmutableObject:

var myImmutableObject = new MyImmutableObject(
        id: 1,
        title: “Test”,
        contents: new List<string> { “One”, “Two”, “Three” });
var json = JsonConvert.SerializeObject(myImmutableObject);
var deserializedObject = JsonConvert.DeserializeObject<MyImmutableObject>(json);

Please note that if your Model has more than one constructor you will need to mark  one for deserialization explicitly,  by adding a JsonConstructor attribute.


With .NET Standard we can use EntityFramework Core in our Xamarin.Forms applications which is great! And it is great twice since we can have a code first  immutable model fully supported by EF.


public sealed class ToDoModel
    public int Id { get; private set; }
    public string Title { get; private set; }
    public string Notes { get; private set; }
    public DateTimeOffset CreatedAt { get; private set; }
    public DateTimeOffset? UpdatedAt { get; private set; }

    ToDoModel() { /* EF requires a parameterless constructor. */ }

    public ToDoModel(
        int id,
        string title,
        string notes,
        DateTimeOffset createdAt,
        DateTimeOffset? updatedAt)
        Id = id;
        Title = title;
        Notes = notes;
        CreatedAt = createdAt;
        UpdatedAt = updatedAt;

When using an “immutable” Model with EF keep in mind:

  • Parameterless constructor – is required, should be private.
  • Setters – are required, should private.
  • Object tracking – should be disabled.


  • SQLite.NET did not work properly with private constructor and setters.
  • We have to count with private setters since it is still possible to change a value with a private setter within the same class.


In this blogpost we discussed how to make immutable Models and checked few common scenarios. I would recommend to start immutable and change to mutable if necessary. Here are few recommendations to keep in mind:

  • Forget about private setters: prop -> propg
  • Make publicly available properties readonly
  • Use constructors
  • Seal classes
  • Use immutable collections or at least IReadOnlyCollection<T>
  • The goal is not to get 100% immutability but to improve code quality

Immutability is a very interesting topic which has pros and cons. For example it may harm performance or introduce unnecessary complexity in some cases, so use it wisely. There are few great resources that I would recommend to get familiar with:



Most common mistakes beginners make in Xamarin.Forms

We live in a great time where technology evolves fast and we need to keep up with it if we want to stay relevant. Beside this, we also have to be productive, use the latest and greatest tools, implement the best available solutions and deliver on time. Following article mentions a list of most common mistakes we tend to do while using Xamarin.Forms.

Continue reading “Most common mistakes beginners make in Xamarin.Forms”

Installing Xamarin components

Xamarin components are easy to install, all you have to do is to download a zip, extract the content and to reference the dlls in your project. This would work if you download the component manually from components gallery. Same thing can be done using Visual Studio in a more robust way via ‘Components’ under the targeting platform projects. Either way, the component will be downloaded and installed only for a specific project.

Sometimes it might be useful to keep the component in cache, so it will be available globally. This is where the XAM file extension comes into play. Generally speaking, it is just an archive, you can change the file extension to zip and use it in a regular way, or vice versa change zip to xam.

Regardless of your OS you have to download xamarin-component.exe.
On Windows execute the next command:

xamain.component.exe install <component.xam>

On MacOS execute the next command with the same executable:

mono xamain.component.exe install <component.xam>

If the command executed successfully, you should see the installed component:

Screen Shot 2017-11-14 at 21.20.30

Please note the “Included in this project” and “Installed on this machine”. Components under the second section will be always there unless you will clean the cache. On MacOS the components will be installed under ‘~/Library/Caches/Xamarin’. Please let me know where the cached components are stored on Windows.