How to maximize TableViewCell reactive binding performances? - ios

Question

I'm currently working on an Xamarin based app for iOS.
Among other features, the app is displaying items in a tableview (pretty classic). I noticed that the binding performance was quite bad, as scrolling really fast the table view will show some lag.
I've created a really simple project replicating the issue, available on Github.
To sum up briefly.
This project has an implementation for each of the following viewmodel interface:
public interface IItemViewModel : INotifyPropertyChanged, IActivatableViewModel
{
/// <summary>
/// A title
/// </summary>
string Title { get; }
/// <summary>
/// A value
/// </summary>
string Value { get; }
}
public interface IItemListViewModel : INotifyPropertyChanged, IActivatableViewModel
{
/// <summary>
/// Minimun count of items possible in the <see cref="Items"/> collection
/// </summary>
int MinItems { get; }
/// <summary>
/// Maximum count of items possible in the <see cref="Items"/> collection
/// </summary>
int MaxItems { get; }
/// <summary>
/// <see cref="Items"/>'s count.
/// Changing the value will update the <see cref="Items"/> collection accordingly.
/// </summary>
int ItemCount { get; set; }
ReadOnlyObservableCollection<IItemViewModel> Items { get; }
}
The view is implemented on iOS using one UIViewController displaying the VM's collection in a UITableView. A slider is bound to the VM's ItemCount property to update easily the item collection's count.
The ViewController is implemented as follow:
public partial class ViewController : ReactiveViewController<IItemListViewModel>
{
public ViewController(IntPtr intPtr) : base(intPtr)
{
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
this.ItemTableView.RegisterNibForCellReuse(ItemViewCell.Nib, ItemViewCell.Key);
this.WhenActivated(disposables =>
{
this.Bind(this.ViewModel, vm => vm.ItemCount, v => v.ItemCountSlider.Value, v => (float)Convert.ToDouble(v), Convert.ToInt32)
.DisposeWith(disposables);
this.OneWayBind(this.ViewModel, vm => vm.ItemCount, v => v.ItemCountLabel.Text, Convert.ToString)
.DisposeWith(disposables);
this.WhenAnyValue(x => x.ViewModel.Items)
.BindTo<ItemViewModel, ItemViewCell>(this.ItemTableView, ItemViewCell.Key, 80, cell => cell.Initialize())
.DisposeWith(disposables);
});
this.ViewModel = new ItemListViewModel();
this.ItemCountSlider.MinValue = this.ViewModel.MinItems;
this.ItemCountSlider.MaxValue = this.ViewModel.MaxItems;
}
}
And the ViewCell rendering the IItemViewModel is:
public partial class ItemViewCell : ReactiveTableViewCell<IItemViewModel>
{
public static readonly NSString Key = new NSString("ItemViewCell");
public static readonly UINib Nib = UINib.FromName("ItemViewCell", NSBundle.MainBundle);
protected ItemViewCell(IntPtr handle) : base(handle)
{
// Note: this .ctor should not contain any initialization logic.
this.WhenActivated(disposables =>
{
this.OneWayBind(this.ViewModel, vm => vm.Title, v => v.TitleLabel.Text)
.DisposeWith(disposables);
this.OneWayBind(this.ViewModel, vm => vm.Value, v => v.ValueLabel.Text)
.DisposeWith(disposables);
});
}
public void Initialize()
{
}
}
When I deploy the app on an iPad 4, set the collection item count to something like few thousands, scrolling (very) fast become quite "laggy".
I know the device is old (built late 2015). But in my test project only two properties are bound to the ViewCell UI components.
In my real app, the viewmodel exposes around 10 properties, thus the lag appears as well on modern devices like the iPad pro.
I'm wondering if there is a better way to perform view cell bindings, or is it a technical limitation?
Thanks.