Data binding of a ViewCell in a TableView

I have a ViewCell subclass -- let's call it MyViewCell -- that I use as the ItemTemplate in a ListView. Works great.

I'd like to also use MyViewCell as an item in a TableView, within a TableSection.

When using a ListView my custom ViewCell binds to the fields of the items of the ListView's ItemSource nicely. The individual models of the ItemSource's Collection do not need to implement BindableObject, nor do these model classes need to declare BindableProperties, just normal C# properties, with Property Change support. This makes for a nice, low overhead model.

However, when I try to use MyViewCell in a TableView, none of that automatic data binding magic happens. ViewCells in TableView appear to require MyViewModel to be a BindableObject subclass and also to have BindableProperties, not just vanilla C# properties.

What magic is a ListView doing that the individual members of it's ItemSource can be simple objects, data binding to the ViewCells works -- whereas the model associated with a ViewCell used within a TableView requires the overhead of BindableProperties?

If my understanding (and trial-and-error) of all this is correct, the code below is a simplified demonstration of the different models required.

My model for ListView looks like this:

    public class MyViewModel : INotifyPropertyChanged
    {
        private string _myValue;

        public string Value {
        get {
            return _myValue;
        }
        set {
            if (value == _myValue) {
                return;
            }
            _myValue = value;
            OnPropertyChanged();
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
    }

Whereas for use as the BindingContext of a ViewCell added to a TableView my model must be:

    public class MyTableCellModel : BindableObject
    {
        public static BindableProperty ValueProperty = BindableProperty.Create (
            propertyName: "Value",
            returnType: typeof(string),
            declaringType: typeof(MyViewCell),
            defaultValue: "default",
            defaultBindingMode: BindingMode.OneWay);

        public string Value {
            get { return (string)base.GetValue (ValueProperty); }
            set { base.SetValue (ValueProperty, value); }
        }
    }

Just to be used by the same ViewCell:

public class MyViewCell : ViewCell
{
    public MyViewCell()
    {
        var valueLabel = new Label();
        valueLabel.SetBinding(Label.TextProperty, "Value");
        View = valueLabel;
    }
}

Multiply that by 10 attributes and you have a considerably more bloated model (and you have two model classes where it would be nice to have just one).