Como usar o Realm de forma eficaz em um aplicativo Xamarin.Forms

1
public class UserInfoDTO
2
{
3
    public Guid Id { get; set; }
4
    public string Name { get; set; }
5
6
    public UserInfo ToModel()
7
    {
8
        return new UserInfo
9
        {
10
            Id = Id,
11
            Name = Name,
12
        };
13
    }
14
15
    public static UserInfoDTO FromModel(UserInfo user)
16
    {
17
        return new UserInfoDTO
18
        {
19
            Id = user.Id,
20
            Name = user.Name,
21
        };
22
    }
23
}

1
public static class RealmService
2
{
3
    public static Realm GetRealm() => Realm.GetInstance();
4
}

1
public static async Task RetrieveUsers()
2
{
3
    try
4
    {
5
        //Retrieve data from the API
6
        var users = await RestAPIClient.GetAllUsers();
7
8
        //Persist data in Realm
9
        using var realm = RealmService.GetRealm();
10
        realm.Write(() =>
11
        {
12
            realm.Add(users.Select(u => u.ToModel()), update: true);
13
        });
14
    }
15
    catch (HttpRequestException) //Offline/Service is not reachable
16
    {
17
    }
18
}

1
public class UserInfo : RealmObject
2
{
3
    [PrimaryKey]
4
    public Guid Id { get; set; }
5
    public string Name { get; set; }
6
}
7
8
public class GroceryItem : EmbeddedObject
9
{
10
    public string Name { get; set; }
11
    public bool Purchased { get; set; }
12
}
13
14
public class ShoppingList : RealmObject
15
{
16
    [PrimaryKey]
17
    public Guid Id { get; set; } = Guid.NewGuid();
18
    public string Name { get; set; }
19
    public ISet<UserInfo> Owners { get; }
20
    public IList<GroceryItem> Items { get; }
21
}

1
public class ShoppingListsCollectionViewModel : BaseViewModel
2
{
3
    private readonly Realm realm;
4
    private bool loaded;
5
6
    public ICommand AddListCommand { get; }
7
    public ICommand OpenListCommand { get; }
8
9
    public IEnumerable<ShoppingList> Lists { get; }
10
11
    public ShoppingList SelectedList
12
    {
13
        get => null;
14
        set
15
        {
16
            OpenListCommand.Execute(value);
17
            OnPropertyChanged();
18
        }
19
    }
20
21
    public ShoppingListsCollectionViewModel()
22
    {
23
        //1
24
        realm = RealmService.GetRealm();
25
        Lists = realm.All<ShoppingList>();
26
27
        AddListCommand = new AsyncCommand(AddList);
28
        OpenListCommand = new AsyncCommand<ShoppingList>(OpenList);
29
    }
30
31
    internal override async void OnAppearing()
32
    {
33
        base.OnAppearing();
34
35
        IDisposable loadingIndicator = null;
36
37
        try
38
        {
39
            //2
40
            if (!loaded)
41
            {
42
                //Page is appearing for the first time, sync with service
43
                //and retrieve users and shopping lists
44
                loaded = true;
45
                loadingIndicator = DialogService.ShowLoading();
46
                await DataService.TrySync();
47
                await DataService.RetrieveUsers();
48
                await DataService.RetrieveShoppingLists();
49
            }
50
            else
51
            {
52
                DataService.FinishEditing();
53
            }
54
        }
55
        catch
56
        {
57
            await DialogService.ShowAlert("Error", "Error while loading the page");
58
        }
59
        finally
60
        {
61
            loadingIndicator?.Dispose();
62
        }
63
    }
64
65
    //3
66
    private async Task AddList()
67
    {
68
        var newList = new ShoppingList();
69
        newList.Owners.Add(DataService.CurrentUser);
70
        realm.Write(() =>
71
        {
72
            return realm.Add(newList, true);
73
        });
74
75
        await OpenList(newList);
76
    }
77
78
    private async Task OpenList(ShoppingList list)
79
    {
80
        DataService.StartEditing(list.Id);
81
        await NavigationService.NavigateTo(new ShoppingListViewModel(list));
82
    }
83
}

1
<ContentPage.Content>
2
    <!--A-->
3
    <ListView ItemsSource="{Binding Lists}"
4
                    SelectionMode="Single"
5
                    SelectedItem="{Binding SelectedList, Mode=TwoWay}">
6
        <ListView.ItemTemplate>
7
            <DataTemplate>
8
                <!--B-->
9
                <TextCell Text="{Binding Name}" />
10
            </DataTemplate>
11
        </ListView.ItemTemplate>
12
    </ListView>
13
</ContentPage.Content>

1
public class ShoppingListViewModel : BaseViewModel
2
{
3
    private readonly Realm realm;
4
5
    public ShoppingList ShoppingList { get; }
6
    public IEnumerable<GroceryItem> CheckedItems { get; }
7
    public IEnumerable<GroceryItem> UncheckedItems { get; }
8
9
    public ICommand DeleteItemCommand { get; }
10
    public ICommand AddItemCommand { get; }
11
    public ICommand DeleteCommand { get; }
12
13
    public ShoppingListViewModel(ShoppingList list)
14
    {
15
        realm = RealmService.GetRealm();
16
17
        ShoppingList = list;
18
19
        //1
20
        CheckedItems = ShoppingList.Items.AsRealmQueryable().Where(i => i.Purchased);
21
        UncheckedItems = ShoppingList.Items.AsRealmQueryable().Where(i => !i.Purchased);
22
23
        DeleteItemCommand = new Command<GroceryItem>(DeleteItem);
24
        AddItemCommand = new Command(AddItem);
25
        DeleteCommand = new AsyncCommand(Delete);
26
    }
27
28
    //2
29
    private void AddItem()
30
    {
31
        realm.Write(() =>
32
        {
33
            ShoppingList.Items.Add(new GroceryItem());
34
        });
35
    }
36
37
    private void DeleteItem(GroceryItem item)
38
    {
39
        realm.Write(() =>
40
        {
41
            ShoppingList.Items.Remove(item);
42
        });
43
    }
44
45
    private async Task Delete()
46
    {
47
        var confirmDelete = await DialogService.ShowConfirm("Deletion",
48
            "Are you sure you want to delete the shopping list?");
49
50
        if (!confirmDelete)
51
        {
52
            return;
53
        }
54
55
        var listId = ShoppingList.Id;
56
        realm.Write(() =>
57
        {
58
            realm.Remove(ShoppingList);
59
        });
60
61
        await NavigationService.GoBack();
62
    }
63
}

1
<ContentPage.Content>
2
    <ScrollView>
3
        <!--A-->
4
        <StackLayout Orientation="Vertical" Margin="20" Spacing="10">
5
            <!--B-->
6
            <Editor Text="{Binding ShoppingList.Name}" HorizontalOptions="Fill"
7
                    Placeholder="Shopping List Name"/>
8
            <!--C-->
9
            <StackLayout BindableLayout.ItemsSource="{Binding UncheckedItems}">
10
                <BindableLayout.ItemTemplate>
11
                    <DataTemplate>
12
                        <!--G-->
13
                        <StackLayout Orientation="Horizontal">
14
                            <!--H-->
15
                            <CheckBox IsChecked="{Binding Purchased}" VerticalOptions="Center"  />
16
                            <!--I-->
17
                            <Entry Text="{Binding Name}"
18
                                    Keyboard="Email"
19
                                    HorizontalOptions="FillAndExpand"
20
                                    VerticalOptions="Center"/>
21
                            <!--J-->
22
                            <Button Text="X" FontSize="Title"
23
                                Command="{Binding Path=BindingContext.DeleteItemCommand, Source={x:Reference page}}"
24
                                CommandParameter="{Binding .}"/>
25
                        </StackLayout>
26
                    </DataTemplate>
27
                </BindableLayout.ItemTemplate>
28
            </StackLayout>
29
             <!--D-->
30
            <Button Text="+ Add Item" Command="{Binding AddItemCommand}"/>
31
             <!--E-->
32
            <BoxView Color="Gray" HeightRequest="1"/>
33
            <Label Text="{Binding CheckedItems.Count, StringFormat='{0} ticked'}"/>
34
            <!--F-->
35
            <StackLayout BindableLayout.ItemsSource="{Binding CheckedItems}">
36
                <BindableLayout.ItemTemplate>
37
                    <DataTemplate>
38
                        <StackLayout Orientation="Horizontal">
39
                            <CheckBox IsChecked="{Binding Purchased}" VerticalOptions="Center"  />
40
                            <Label Text="{Binding Name}" TextDecorations="Strikethrough"
41
                                    HorizontalOptions="FillAndExpand"
42
                                    VerticalOptions="Center"/>
43
                            <Button Text="X" FontSize="Title"
44
                                Command="{Binding Path=BindingContext.DeleteItemCommand, Source={x:Reference page}}"
45
                                CommandParameter="{Binding .}"/>
46
                        </StackLayout>
47
                    </DataTemplate>
48
                </BindableLayout.ItemTemplate>
49
            </StackLayout>
50
        </StackLayout>
51
    </ScrollView>
52
</ContentPage.Content>

1
public static void StartEditing(Guid listId)
2
{
3
    PreferencesManager.SetEditingListId(listId);
4
}
5
6
public static void FinishEditing()
7
{
8
    var editingListId = PreferencesManager.GetEditingListId();
9
10
    if (editingListId == null)
11
    {
12
        return;
13
    }
14
15
    //1
16
    PreferencesManager.RemoveEditingListId();
17
    //2
18
    PreferencesManager.AddReadyForSyncListId(editingListId.Value);
19
20
    //3
21
    Task.Run(TrySync);
22
}
23
24
public static async Task TrySync()
25
{
26
    //4
27
    var readyForSyncListsId = PreferencesManager.GetReadyForSyncListsId();
28
29
    //5
30
    var editingListId = PreferencesManager.GetEditingListId();
31
32
    foreach (var readyForSyncListId in readyForSyncListsId)
33
    {
34
        //6
35
        if (readyForSyncListId == editingListId)  //The list is still being edited
36
        {
37
            continue;
38
        }
39
40
        //7
41
        var updateSuccessful = await UpdateShoppingList(readyForSyncListId);
42
        if (updateSuccessful)
43
        {
44
            //8
45
            PreferencesManager.RemoveReadyForSyncListId(readyForSyncListId);
46
        }
47
    }
48
}

1
private async Task OpenList(ShoppingList list)
2
{
3
    DataService.StartEditing(list.Id);
4
    await NavigationService.NavigateTo(new ShoppingListViewModel(list));
5
}

1
internal override async void OnAppearing()
2
{
3
    base.OnAppearing();
4
5
        if (!loaded)
6
        {
7
            ....
8
            await DataService.TrySync();
9
            ....
10
        }
11
        else
12
        {
13
            DataService.FinishEditing();
14
        }
15
    }
16
17
}