Best way to bind to a mutable list, while retaining immutability through the rest of the pipe.

[giard-alexandre]

Hi! First of all, thanks for the great library! It's been SUPER useful and ergonomic to use.

I'm currently developing an Avalonia app and, since it's more efficient on xaml/mvvm platforms to update existing object inline, I use TransformWithInlineUpdate in my pipe to do that.

My setup is as follows:

• Get data from service and pipe it into a SourceCache
• expose a stream from that sourcecache
• binding my stream to a ReadonlyObservableCollection using SortAndBind
• binding to that ReadonlyObservableCollection from the Avalonia component (TreeDataGrid but it could also be a normal DataGrid)

I just have a few question about the BEST way to do this.

1. Considering I want to maintain DD Filtering and Sorting for my stream while updating the items inline, am I correct in using TransformWithInlineUpdate for this?
2. Since Sort and SortAndBind greatly benefit from having immutable data in order to sort using a Binary Tree, what would be the best way to be able to use this considering I'm using TransformWithInlineUpdate? Could calling the sort IMMEDIATELY after doing the transformation work even though the object is mutable at that point? In my mind, the operators downstream of TransformWithInlineUpdate still get a Refresh for each changed element, so would sorting using the Binary tree still function as expected?
3. If not: should I be looking into writing a SortBindAndTransformWithInlineUpdate operator? 😅 (I would have no idea where to even get started)
4. Is a ReadonlyObservableCollection the right collection to use for binding to UI elements? I know you guys also support BindingList I'm just not sure which to use in this case.

Thanks in advance! Looking forward to a good conversation 🙃

[JakenVeina]

Considering I want to maintain DD Filtering and Sorting for my stream while updating the items inline, am I correct in using TransformWithInlineUpdate for this?

Yup.

Since Sort and SortAndBind greatly benefit from having immutable data in order to sort using a Binary Tree, what would be the best way to be able to use this considering I'm using TransformWithInlineUpdate? Could calling the sort IMMEDIATELY after doing the transformation work even though the object is mutable at that point? In my mind, the operators downstream of TransformWithInlineUpdate still get a Refresh for each changed element, so would sorting using the Binary tree still function as expected?

I'm not familiar with the inner workings of either .Sort() or .SortAndBind() but fundamentally, you're right. Binary sorting is problematic when item mutability comes into play, but it's not impossible. It can still be done if mutation only happens under some specific conditions, mainly that you only mutate items one-at-a-time, and make sure to Refresh each one, after mutating it. I'd need to look at the specific implementations of .Sort() and .SortAndBind() to know how they actually handle this kind of scenario. Unless @RolandPheasant can speak on it.

If not: should I be looking into writing a SortBindAndTransformWithInlineUpdate operator? 😅 (I would have no idea where to even get started)

You certainly could, and that's potentially an operator we could add to DynamicData. The question is how much of a performance boost can you gain by doing all those operations at the same time, compared to just using the separate operators we have already. .SortAndBind() was released because it can, in theory, be a fair bit more performant than just .Sort() and .Bind() separately. That same thing is potentially true for any .Bind() operator, just due to the fact that the operator doesn't have to keep an internal copy of the collection items, when it can just access them on the binding target. But at some point, rolling more work into the .Bind() step is going to stop being worth the potential gains. I would have to see some pretty strong numbers showing that a .SortTransformAndBind() operator beats .Sort().Transform().Bind() in order to get behind adding it.

Is a ReadonlyObservableCollection the right collection to use for binding to UI elements? I know you guys also support BindingList I'm just not sure which to use in this case.

I have precious little experience with Avalonia, or any UI framework other than WPF, but as I understand it, BindingList is a WinForms API. So yeah, you want any of the variations on ObservableCollection for anything WPF-like. ReadOnlyObservableCollection is pretty much what you want to expose on your VMs, so you usually will want the .Bind() overloads that pass you one via an out parameter. Occasionally, you may want direct access to mutate the collection that the Bind() operator mutates, in which case, you'll want ObservableCollectionExtended from DynamicData, which is just an extension of System.ComponentModel.ObservableCollection that supports a few extra operations that .Bind() can optimize for.

On a side note, I think this is yet another excellent example of a use-case that .SortAndBind() cannot really support, and that indicates we should keep .Sort() as a standalone operator. Essentially...

using var binding = source
    .Filter()
    .Sort()
    .Transform(inlineUpdateAction: ...)
    .Bind();

In my mind, this is the ideal scenario for using DynamicData to feed into a WPF-like UI framework, where data is immutable at the source, and translates into mutable VM objects just before being published to the View layer.

[giard-alexandre]

I agree, this seems like a very good pattern for any MVVM and MVVM-like frameworks that depend on INotifyPropertyChanged.

Quick question! You seem to be alluding to the fact that I can Sort, then Transform, then Bind but I thought that adding any operators after the sort actually causes the pipe to lose the sort? (At least I remember seeing that as being true for Caches, which is what I am using, for efficiency 😄 ) Wouldn't that mean that your above code snipper would not work then?

Or am I misunderstanding and you were just making a note of something that COULD be added to DD in the future? 😅

PS: I'd say that your WPF experience is 95% transferrable to Avalonia so if you have WPF-related suggestions, I'll happily take them 😃

[JakenVeina]

I thought that adding any operators after the sort actually causes the pipe to lose the sort? (At least I remember seeing that as being true for Caches

That is correct, I meant to mention that.

[giard-alexandre]

Following the merge of #939 and the subsequent release which included fix #936, SortAndBind now becomes usable to me :)
That got me thinking: would the following scenario work:

dataStream
  .Filter()
  .TransformWithInlineUpdate(createFunc, updateFunc)
  .SortAndBind(sort, out items, sortAndBindOptions)

Where sortAndBindOptions sets UseBinarySearch = true.

Can this option be enabled IF I can ensure that no changes to the transformed object are performed outside the normal IChangeSets of the DD pipe? Do you forsee any potential issues with this?

I think I had looked into creating a SortAndBindInline operator and the main thing that I got stumped with is that the default equality comparer used when looking up items with IndexOf in SortExtensions.GetCurrentPosition just won't work on mutable reference types as the value of change.Previous.Value is not referencing the same item as change.Current. (maybe having access to the method used for the Id of the ChangeSet could be useful here?)

[giard-alexandre]

Just circling back to this before I sink a bunch of time into it just to realize it won't be possible:
How complex do you think it would be to pass the sort information through a Transform? is that even reasonable?

[JakenVeina]

In theory, it's doable. As of right now, I don't believe there are any Transform operators that support this. And the last time I looked, adding it would NOT be trivial, given how much complexity has developed within the sorting operators, over the years, due to various optimizations.