Collections and complex ViewModel graphs

We have already discussed how to handle change tracking in collections and in complex models and we have introduced how to handle change tracking in a MVVM based model.
We want to start where we left adding a collection to the Person class and setup the entire editing pipeline for the collection too.
1
class Person
2
{
3
    public Person()
4
    {
5
        this.Addresses = new List<Address>();
6
    }
7
    
8
    public String FirstName { get; set; }
9
    public String LastName { get; set; }
10
    public IList<Address> Addresses { get; private set; }
11
}
12
​
13
class Address
14
{
15
    public String Street { get; set; }
16
    public String City { get; set; }
17
}
Copied!
If we look at the considerations we did for the simple view model is obvious that the Address class itself needs a ViewModel and an editor and also the collection exposed by the Person class needs an editor and potentially a ViewModel depending on the type of editing that we want to support.
We need to face a couple more issues related to the fact that having one graph coming from a persistent storage and one different graph bound to the UI we need to keep them in sync.
The AddressViewModel will be as simple as the PersonViewModel we already saw:
1
class AddressViewModel : MementoEntity
2
{
3
    public void Initialize( Address address, Boolean registerAsTransient )
4
    {
5
        if( registerAsTransient )
6
        {
7
            this.RegisterTransient();
8
        }
9
​
10
        this.SetInitialPropertyValue( () => this.Street, address.With( a => a.Street ).Return( s => s, "" ) );
11
        this.SetInitialPropertyValue( () => this.City, address.With( a => a.City ).Return( c => c, "" ) );
12
    }
13
​
14
    public String Street
15
    {
16
        get { return this.GetPropertyValue( () => this.Street ); }
17
        set { this.SetPropertyValue( () => this.Street, value ); }
18
    }
19
​
20
    public String City
21
    {
22
        get { return this.GetPropertyValue( () => this.City ); }
23
        set { this.SetPropertyValue( () => this.City, value ); }
24
    }
25
}
Copied!
Nothing new, except for the With/Return syntax that is simply a monad like way to guard against null adding a default value.
Things get much more interesting as we look at the PersonViewModel, that revisited, now handle the Addresses list:
1
public class PersonViewModel : MementoEntity
2
{
3
    MementoEntityCollection<AddressViewModel> addressesDataSource;
4
​
5
    public void Initialize( Person person, Boolean registerAsTransient )
6
    {
7
        if( registerAsTransient )
8
        {
9
            this.RegisterTransient();
10
        }
11
        
12
        this.SetInitialPropertyValue( () => this.FirstName, person.FirstName );
13
        this.SetInitialPropertyValue( () => this.LastName, person.LastName );
14
​
15
        this.addressesDataSource = new MementoEntityCollection<AddressViewModel>();
16
        this.addressesDataSource.BulkLoad( person.Addresses, a =>
17
        {
18
            return this.CreateAddressViewModel( a, registerAsTransient );
19
        } );
20
​
21
        this.Addresses = this.addressesDataSource.DefaultView;
22
        this.Addresses.AddingNew += ( s, e ) =>
23
        {
24
            e.NewItem = this.CreateAddressViewModel( null, true );
25
            e.AutoCommit = true;
26
        };
27
    }
28
​
29
    AddressViewModel CreateAddressViewModel( Address a, Boolean registerAsTransient )
30
    {
31
        var vm = new AddressViewModel();
32
        vm.Initialize( a, registerAsTransient );
33
        return vm;
34
    }
35
​
36
    protected override void OnMementoChanged( IChangeTrackingService newMemento, IChangeTrackingService oldMemento )
37
    {
38
        base.OnMementoChanged( newMemento, oldMemento );
39
        if( oldMemento != null )
40
        {
41
            oldMemento.Detach( this.addressesDataSource );
42
        }
43
        if( newMemento != null )
44
        {
45
            newMemento.Attach( this.addressesDataSource );
46
        }
47
    }
48
​
49
    public String FirstName
50
    {
51
        get { return this.GetPropertyValue( () => this.FirstName ); }
52
        set { this.SetPropertyValue( () => this.FirstName, value ); }
53
    }
54
​
55
    public String LastName
56
    {
57
        get { return this.GetPropertyValue( () => this.LastName ); }
58
        set { this.SetPropertyValue( () => this.LastName, value ); }
59
    }
60
​
61
    public IEntityView<AddressViewModel> Addresses
62
    {
63
        get;
64
        private set;
65
    }
66
}
Copied!
We are using a MementoEntityCollection<T> to keep track of changes that occurs to the collection structure, such as add or address removal, we are using the BulkLoad API to achieve 2 goals:
1.
Add a transformation on load, we are basically iterating over Address instances adding to the collection AddressViewModel instances, and the transformation is done in the delegate via the CreateAddressViewModel that simply wraps the Address instance, if any, into the AddressViewModel instance initializing it as we saw for the Person / PersonViewModel relationship;
2.
disable at once collection notifications, a IEntityCollection<T> has built-in support for changes notification, and a MementoEntityCollection<T> for change tracking, the BulkLoad API will disable notifications and tracking for the entire load process re-enabling both at the end;
We then expose our Addresses list as an IEntityView, that is an IBindingListView implementation, achieving 2 goals:
1.
In the View we can now bind the collection to a DataGrid, for example, gaining full support for sorting, filtering and column generation;
2.
We can have control, very easily, over new items generation even if the request is done by a DataGrid control: simply add a EventHandler to the AddingNew event of the IEntityView and create the expected instance;
The last thing to do is to manually propagate the current ChangeTrackingService instance to the collection owned by the PersonViewModel class, we do that overriding the OnMementoChanged method that is called every time the current memento tracking this instance changes.
The last thing is to update the EditorViewModel to create a sample data set; we also add a couple of commands to manage the Addresses collection and a property to keep track of the currently selected address:
1
class EditorViewModel : AbstractViewModel
2
{
3
    readonly IChangeTrackingService service = new ChangeTrackingService();
4
​
5
    public EditorViewModel()
6
    {
7
        var observer = MementoObserver.Monitor( this.service );
8
​
9
        this.UndoCommand = DelegateCommand.Create()
10
            .OnCanExecute( o => this.service.CanUndo )
11
            .OnExecute( o => this.service.Undo() )
12
            .AddMonitor( observer );
13
​
14
        this.RedoCommand = DelegateCommand.Create()
15
            .OnCanExecute( o => this.service.CanRedo )
16
            .OnExecute( o => this.service.Redo() )
17
            .AddMonitor( observer );
18
​
19
        this.CreateNewAddressCommand = DelegateCommand.Create()
20
            .OnExecute( o => 
21
            {
22
                this.SelectedAddress = this.Entity.Addresses.AddNew();
23
            } );
24
​
25
        this.DeleteAddressCommand = DelegateCommand.Create()
26
            .OnCanExecute( o => this.SelectedAddress != null )
27
            .OnExecute( o => 
28
            {
29
                this.SelectedAddress.Delete();
30
                this.SelectedAddress = this.Entity.Addresses.FirstOrDefault();
31
            } )
32
            .AddMonitor( PropertyObserver.For( this ).Observe( v => v.SelectedAddress ) );
33
​
34
        var person = new Person()
35
        {
36
            FirstName = "Mauro",
37
            LastName = "Servienti"
38
        };
39
​
40
        person.Addresses.Add( new Address( person )
41
        {
42
            City = "My town",
43
            Street = "Where I live"
44
        } );
45
​
46
        var entity = new PersonViewModel();
47
        entity.Initialize( person, false );
48
        this.service.Attach( entity );
49
        this.Entity = entity;
50
    }
51
​
52
    public ICommand UndoCommand { get; private set; }
53
    public ICommand RedoCommand { get; private set; }
54
    public ICommand CreateNewAddressCommand { get; private set; }
55
    public ICommand DeleteAddressCommand { get; private set; }
56
​
57
    public PersonViewModel Entity
58
    {
59
        get { return this.GetPropertyValue( () => this.Entity ); }
60
        private set { this.SetPropertyValue( () => this.Entity, value ); }
61
    }
62
​
63
    public IEntityItemView<AddressViewModel> SelectedAddress
64
    {
65
        get { return this.GetPropertyValue( () => this.SelectedAddress ); }
66
        private set { this.SetPropertyValue( () => this.SelectedAddress, value ); }
67
    }
68
}
Copied!

Simple ViewModel graphs

Next - Presentation

Validation and Validation Services

Last modified 16d ago

Copy link