ObservableCollections

You can use CreateView to generate a ISynchronizedView<T, TView>. The view holds transformed values (e.g., converting a Model object to a ViewModel or a UI element) and stays synchronized with the underlying collection. The transform function is called only once during an Add operation, making it efficient for costly object instantiation.

Key features of a View:

• Filtering: Use AttachFilter to dynamically show/hide items. Count returns the filtered count.
• Synchronization: Operations like Sort and Reverse on the source collection are reflected in the view.
• Lifecycle: Views must be Dispose()'d to unsubscribe from the collection's change events.

var list = new ObservableList<int>();
// Transform int to string with a suffix
var view = list.CreateView(x => x.ToString() + "$");

list.Add(10);
list.AddRange(new[] { 30, 40, 50 });

// Attach a filter to show only even numbers
view.AttachFilter(x => x % 2 == 0);

foreach (var v in view)
{
    // Output: 10$, 30$, 40$, 50$
    Console.WriteLine(v);
}

view.Dispose();

Standard views are read-only. If you need to reflect changes made in a UI (like a text box binding) back to the original collection, use CreateWritableView to generate an IWritableSynchronizedView<T, TView>.

Use ToWritableNotifyCollectionChanged with a WritableViewChangedEventHandler to define how changes to the view should be applied to the source collection.

In the handler:

• Set setValue = true to propagate the change to the original collection.
• Set setValue = false to prevent propagation (useful for mutable reference types where you only want to update the view's local state).

var list = new ObservableList<Person> { new() { Age = 10, Name = "John" } };
var view = list.CreateWritableView(x => x.Name);

// Convert to a bindable collection for XAML
var bindable = view.ToWritableNotifyCollectionChanged((string? newName, Person original, ref bool setValue) =>
{
    if (setValue) 
    {
        original.Name = newName;
        // You can choose to set setValue to false to avoid redundant notifications
        setValue = false;
        return original;
    }
    return new Person { Name = newName };
});

bindable[0] = "Bob"; // Updates the original list's Person name to "Bob"

In Unity, install the package via [NuGetForUnity].

ObservableCollections are ideal for CollectionManagers where you need to transform data into Prefabs. Because CreateView is only called once per item, you can instantiate GameObjects and link them to the collection items efficiently.

Use the ViewChanged event on the view to handle the lifecycle of the instantiated GameObjects (e.g., destroying the GameObject when an item is removed from the collection).

// Inside a MonoBehaviour
void Start()
{
    collection = new ObservableRingBuffer<int>();
    view = collection.CreateView(x => {
        var item = GameObject.Instantiate(prefab);
        return item.gameObject;
    });

    view.ViewChanged += (in SynchronizedViewChangedEventArgs<int, GameObject> e) => {
        if (e.Action == NotifyCollectionChangedAction.Remove) {
            GameObject.Destroy(e.OldItem.View);
        }
    };
}

Since IObservableCollection<T> does not implement INotifyCollectionChanged, it cannot be directly bound to XAML. Use ToNotifyCollectionChanged() to convert it into a collection suitable for binding.

Thread Safety: While the collections are thread-safe, XAML platforms require notifications to occur on the UI thread. Use the ICollectionEventDispatcher overload to handle this:

1. Automatic Dispatching: Use ToNotifyCollectionChanged(SynchronizationContextCollectionEventDispatcher.Current) to use the current SynchronizationContext.
2. Custom Dispatching: Implement ICollectionEventDispatcher to use a specific dispatcher (e.g., WPF Dispatcher).

Performance Options:

• ToNotifyCollectionChanged(): Standard conversion.
• ToNotifyCollectionChangedSlim(): The fastest and most memory-efficient option as it shares the actual data, but it does not support range operations (AddRange, InsertRange, RemoveRange), which will cause runtime exceptions in XAML platforms.

// WPF example with automatic synchronization context dispatching
ObservableList<int> list = new ObservableList<int>();
ItemsView = list.ToNotifyCollectionChanged(SynchronizationContextCollectionEventDispatcher.Current);

You can create a synchronized view of an ObservableQueue<T> using the CreateView method. This allows you to project the underlying data into a different type (TView) and apply filtering while staying synchronized with the source queue.

To use it:

1. Call CreateView on your ObservableQueue<T> instance, providing a transformation function Func<T, TView>.
2. Use the resulting ISynchronizedView<T, TView> to access filtered or unfiltered data.
3. Apply filters using AttachFilter or clear them with ResetFilter.
4. Convert the view into specialized list types like ISynchronizedViewList<TView> or NotifyCollectionChangedSynchronizedViewList<TView> for UI binding or iteration.

// Assuming queue is an ObservableQueue<MyModel>
var view = queue.CreateView(model => model.ToString());

// Apply a filter
view.AttachFilter(new MyCustomFilter());

// Get the count of items matching the filter
int count = view.Count;

// Convert to a list for easier consumption
var viewList = view.ToViewList();