zhaoyushun1999/ObservableCollections
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #82 from zerodev1200/Change-WritableView-implementation

Browse Source 
Change WritableView implementation
This commit is contained in:
Yoshifumi Kawai 2024-10-18 18:30:30 +09:00 committed by GitHub
commit b000cc8521
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
6 changed files with 450 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
sandbox/WpfApp/MainWindow.xaml
View File

@ -5,19 +5,20 @@
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:WpfApp"
mc:Ignorable="d"
Title="MainWindow" Height="450" Width="800">
<!--<Grid>
Title="MainWindow" Height="800" Width="800">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="*" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition />
<ColumnDefinition />
<ColumnDefinition Width="*" />
<ColumnDefinition Width="*" />
</Grid.ColumnDefinitions>
<ListView ItemsSource="{Binding ItemsView}"></ListView>
<Button Grid.Column="1" Click="Button_Click">Insert</Button>
</Grid>-->
<StackPanel>
<!-- original -->
<StackPanel Grid.Row="0" Grid.ColumnSpan="2" Orientation="Vertical">
<ListBox ItemsSource="{Binding ItemsView}" />
<Button Content="Add" Command="{Binding AddCommand}" />
<Button Content="AddRange" Command="{Binding AddRangeCommand}" />
@ -27,7 +28,39 @@
<Button Content="Clear" Command="{Binding ClearCommand}" />
<Button Content="Reverse" Command="{Binding ReverseCommand}" />
<Button Content="Sort" Command="{Binding SortCommand}" />
<Button Content="AttachFilter" Command="{Binding AttachFilterCommand}" />
<Button Content="ResetFilter" Command="{Binding ResetFilterCommand}" />
</StackPanel>
<!-- Upper left (NotWritable, NonFilter) -->
<GroupBox Grid.Row="1" Grid.Column="0" Header="NotWritable, NonFilter">
<StackPanel Orientation="Vertical">
<DataGrid ItemsSource="{Binding NotWritableNonFilterView}" />
</StackPanel>
</GroupBox>
<!-- Upper right (Writable, NonFilter) -->
<GroupBox Grid.Row="1" Grid.Column="1" Header="Writable, NonFilter">
<StackPanel Orientation="Vertical">
<DataGrid ItemsSource="{Binding WritableNonFilterPersonView}" />
</StackPanel>
</GroupBox>
<!-- Lower left (NotWritable, Filter) -->
<GroupBox Grid.Row="2" Grid.Column="0" Header="NotWritable, Filter">
<StackPanel Orientation="Vertical">
<DataGrid ItemsSource="{Binding NotWritableFilterView}" />
<Button Content="AttachFilter" Command="{Binding AttachFilterCommand2}" />
<Button Content="ResetFilter" Command="{Binding ResetFilterCommand2}" />
</StackPanel>
</GroupBox>
<!-- Lower right (Writable, Filter) -->
<GroupBox Grid.Row="2" Grid.Column="1" Header="Writable, Filter">
<StackPanel Orientation="Vertical">
<DataGrid ItemsSource="{Binding WritableFilterPersonView}" />
<Button Content="AttachFilter" Command="{Binding AttachFilterCommand3}" />
<Button Content="ResetFilter" Command="{Binding ResetFilterCommand3}" />
</StackPanel>
</GroupBox>
</Grid>
</Window>

101
sandbox/WpfApp/MainWindow.xaml.cs
View File

@ -87,6 +87,18 @@ namespace WpfApp
public ReactiveCommand<Unit> AttachFilterCommand { get; } = new ReactiveCommand<Unit>();
public ReactiveCommand<Unit> ResetFilterCommand { get; } = new ReactiveCommand<Unit>();
private ObservableList<Person> SourceList { get; } = [];
private IWritableSynchronizedView<Person, Person> writableFilter;
private ISynchronizedView<Person, Person> notWritableFilter;
public NotifyCollectionChangedSynchronizedViewList<Person> NotWritableNonFilterView { get; }
public NotifyCollectionChangedSynchronizedViewList<Person> NotWritableFilterView { get; }
public NotifyCollectionChangedSynchronizedViewList<Person> WritableNonFilterPersonView { get; }
public NotifyCollectionChangedSynchronizedViewList<Person> WritableFilterPersonView { get; }
public ReactiveCommand<Unit> AttachFilterCommand2 { get; } = new ReactiveCommand<Unit>();
public ReactiveCommand<Unit> ResetFilterCommand2 { get; } = new ReactiveCommand<Unit>();
public ReactiveCommand<Unit> AttachFilterCommand3 { get; } = new ReactiveCommand<Unit>();
public ReactiveCommand<Unit> ResetFilterCommand3 { get; } = new ReactiveCommand<Unit>();
public ViewModel()
{
observableList.Add(1);
@ -156,8 +168,97 @@ namespace WpfApp
{
view.ResetFilter();
});
SourceList.Add(new() { Name = "a", Age = 1 });
SourceList.Add(new() { Name = "b", Age = 2 });
SourceList.Add(new() { Name = "c", Age = 3 });
SourceList.Add(new() { Name = "d", Age = 4 });
//NotWritable, NonFilter
NotWritableNonFilterView = SourceList.ToNotifyCollectionChanged();
//NotWritable, Filter
notWritableFilter = SourceList.CreateView(x => x);
NotWritableFilterView = notWritableFilter.ToNotifyCollectionChanged();
//Writable, NonFilter
WritableNonFilterPersonView = SourceList.ToWritableNotifyCollectionChanged();
//WritableNonFilterPersonView = SourceList.ToWritableNotifyCollectionChanged(x => x, (Person newView, Person original, ref bool setValue) =>
//{
// if (setValue)
// {
// // default setValue == true is Set operation
// original.Name = newView.Name;
// original.Age = newView.Age;
// // You can modify setValue to false, it does not set original collection to new value.
// // For mutable reference types, when there is only a single,
// // bound View and to avoid recreating the View, setting false is effective.
// // Otherwise, keeping it true will set the value in the original collection as well,
// // and change notifications will be sent to lower-level Views(the delegate for View generation will also be called anew).
// setValue = false;
// return original;
// }
// else
// {
// // default setValue == false is Add operation
// return new Person { Age = newView.Age, Name = newView.Name };
// }
//}, null);
//Writable, Filter
writableFilter = SourceList.CreateWritableView(x => x);
WritableFilterPersonView = writableFilter.ToWritableNotifyCollectionChanged();
//WritableFilterPersonView = writableFilter.ToWritableNotifyCollectionChanged((Person newView, Person original, ref bool setValue) =>
//{
// if (setValue)
// {
// // default setValue == true is Set operation
// original.Name = newView.Name;
// original.Age = newView.Age;
// // You can modify setValue to false, it does not set original collection to new value.
// // For mutable reference types, when there is only a single,
// // bound View and to avoid recreating the View, setting false is effective.
// // Otherwise, keeping it true will set the value in the original collection as well,
// // and change notifications will be sent to lower-level Views(the delegate for View generation will also be called anew).
// setValue = false;
// return original;
// }
// else
// {
// // default setValue == false is Add operation
// return new Person { Age = newView.Age, Name = newView.Name };
// }
//});
AttachFilterCommand2.Subscribe(_ =>
{
notWritableFilter.AttachFilter(x => x.Age % 2 == 0);
});
ResetFilterCommand2.Subscribe(_ =>
{
notWritableFilter.ResetFilter();
});
AttachFilterCommand3.Subscribe(_ =>
{
writableFilter.AttachFilter(x => x.Age % 2 == 0);
});
ResetFilterCommand3.Subscribe(_ =>
{
writableFilter.ResetFilter();
});
}
}
public class Person
{
public int? Age { get; set; }
public string? Name { get; set; }
}
public class WpfDispatcherCollection(Dispatcher dispatcher) : ICollectionEventDispatcher
{

64
src/ObservableCollections/IObservableCollection.cs
View File

@ -57,7 +57,12 @@ namespace ObservableCollections
void SetViewAt(int index, TView view);
void SetToSourceCollection(int index, T value);
void AddToSourceCollection(T value);
void InsertIntoSourceCollection(int index, T value);
bool RemoveFromSourceCollection(T value);
void RemoveAtSourceCollection(int index);
void ClearSourceCollection();
IWritableSynchronizedViewList<TView> ToWritableViewList(WritableViewChangedEventHandler<T, TView> converter);
NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged();
NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(WritableViewChangedEventHandler<T, TView> converter);
NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher);
NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(WritableViewChangedEventHandler<T, TView> converter, ICollectionEventDispatcher? collectionEventDispatcher);
@ -99,8 +104,8 @@ namespace ObservableCollections
}
public abstract int Count { get; }
public bool IsReadOnly => false;
public bool IsFixedSize => false;
public virtual bool IsReadOnly { get; } = true;
public bool IsFixedSize => IsReadOnly;
public bool IsSynchronized => true;
public object SyncRoot => gate;
@ -112,9 +117,14 @@ namespace ObservableCollections
int IList.Add(object? value)
{
Add((TView)value!);
return -1; // itself does not add in this collection
return Count - 1;
}
public abstract void Insert(int index, TView item);
public abstract bool Remove(TView item);
public abstract void RemoveAt(int index);
public abstract void Clear();
public abstract bool Contains(TView item);
bool IList.Contains(object? value)
@ -149,17 +159,43 @@ namespace ObservableCollections
return value is TView || value == null && default(TView) == null;
}
void ICollection<TView>.Clear() => throw new NotSupportedException();
void IList.Clear() => throw new NotSupportedException();
void ICollection<TView>.Clear()
{
Clear();
}
void IList.Clear()
{
Clear();
}
void ICollection<TView>.CopyTo(TView[] array, int arrayIndex) => throw new NotSupportedException();
void ICollection.CopyTo(Array array, int index) => throw new NotSupportedException();
void IList<TView>.Insert(int index, TView item) => throw new NotSupportedException();
void IList.Insert(int index, object? value) => throw new NotSupportedException();
bool ICollection<TView>.Remove(TView item) => throw new NotSupportedException();
void IList.Remove(object? value) => throw new NotSupportedException();
void IList.RemoveAt(int index) => throw new NotSupportedException();
void IList<TView>.Insert(int index, TView item)
{
Insert(index, item);
}
void IList.Insert(int index, object? value)
{
Insert(index, (TView)value!);
}
bool ICollection<TView>.Remove(TView item)
{
return Remove(item!);
}
void IList.Remove(object? value)
{
Remove((TView)value!);
}
void IList.RemoveAt(int index)
{
RemoveAt(index);
}
void IList<TView>.RemoveAt(int index) => throw new NotSupportedException();
}
@ -176,22 +212,22 @@ namespace ObservableCollections
return new NonFilteredSynchronizedViewList<T, TView>(collection.CreateView(transform), isSupportRangeFeature: true, null, null);
}
public static INotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChanged<T>(this IObservableCollection<T> collection)
public static NotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChanged<T>(this IObservableCollection<T> collection)
{
return ToNotifyCollectionChanged(collection, null);
}
public static INotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChanged<T>(this IObservableCollection<T> collection, ICollectionEventDispatcher? collectionEventDispatcher)
public static NotifyCollectionChangedSynchronizedViewList<T> ToNotifyCollectionChanged<T>(this IObservableCollection<T> collection, ICollectionEventDispatcher? collectionEventDispatcher)
{
return ToNotifyCollectionChanged(collection, static x => x, collectionEventDispatcher);
}
public static INotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged<T, TView>(this IObservableCollection<T> collection, Func<T, TView> transform)
public static NotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged<T, TView>(this IObservableCollection<T> collection, Func<T, TView> transform)
{
return ToNotifyCollectionChanged(collection, transform, null!);
}
public static INotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged<T, TView>(this IObservableCollection<T> collection, Func<T, TView> transform, ICollectionEventDispatcher? collectionEventDispatcher)
public static NotifyCollectionChangedSynchronizedViewList<TView> ToNotifyCollectionChanged<T, TView>(this IObservableCollection<T> collection, Func<T, TView> transform, ICollectionEventDispatcher? collectionEventDispatcher)
{
// Optimized for non filtered
return new NonFilteredSynchronizedViewList<T, TView>(collection.CreateView(transform), isSupportRangeFeature: false, collectionEventDispatcher, null);

19
src/ObservableCollections/ObservableList.OptimizeView.cs
View File

@ -189,6 +189,25 @@ internal sealed class ObservableListSynchronizedViewList<T> : NotifyCollectionCh
{
parent.Add(item);
}
public override void Insert(int index, T item)
{
parent.Insert(index, item);
}
public override bool Remove(T item)
{
return parent.Remove(item);
}
public override void RemoveAt(int index)
{
parent.RemoveAt(index);
}
public override void Clear()
{
parent.Clear();
}
public override bool Contains(T item)
{

54
src/ObservableCollections/ObservableList.Views.cs
View File

@ -19,12 +19,12 @@ namespace ObservableCollections
return new View<TView>(this, transform);
}
public INotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged()
public NotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged()
{
return ToWritableNotifyCollectionChanged(null);
}
public INotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher)
public NotifyCollectionChangedSynchronizedViewList<T> ToWritableNotifyCollectionChanged(ICollectionEventDispatcher? collectionEventDispatcher)
{
return ToWritableNotifyCollectionChanged(
static x => x,
@ -36,12 +36,12 @@ namespace ObservableCollections
collectionEventDispatcher);
}
public INotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, WritableViewChangedEventHandler<T, TView>? converter)
public NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, WritableViewChangedEventHandler<T, TView>? converter)
{
return ToWritableNotifyCollectionChanged(transform, converter, null!);
}
public INotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, WritableViewChangedEventHandler<T, TView>? converter, ICollectionEventDispatcher? collectionEventDispatcher)
public NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged<TView>(Func<T, TView> transform, WritableViewChangedEventHandler<T, TView>? converter, ICollectionEventDispatcher? collectionEventDispatcher)
{
return new NonFilteredSynchronizedViewList<T, TView>(CreateView(transform), isSupportRangeFeature: false, collectionEventDispatcher, converter);
}
@ -367,12 +367,54 @@ namespace ObservableCollections
source.Add(value);
}
}
public void InsertIntoSourceCollection(int index, T value)
{
lock (SyncRoot)
{
source.Insert(index, value);
}
}
public bool RemoveFromSourceCollection(T value)
{
lock (SyncRoot)
{
return source.Remove(value);
}
}
public void RemoveAtSourceCollection(int index)
{
lock (SyncRoot)
{
source.RemoveAt(index);
}
}
public void ClearSourceCollection()
{
lock (SyncRoot)
{
source.Clear();
}
}
public IWritableSynchronizedViewList<TView> ToWritableViewList(WritableViewChangedEventHandler<T, TView> converter)
{
return new FiltableSynchronizedViewList<T, TView>(this, isSupportRangeFeature: true, converter: converter);
}
public NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged()
{
return new FiltableSynchronizedViewList<T, TView>(this,
isSupportRangeFeature: false,
converter: static (TView newView, T originalValue, ref bool setValue) =>
{
setValue = true;
return originalValue;
});
}
public NotifyCollectionChangedSynchronizedViewList<TView> ToWritableNotifyCollectionChanged(WritableViewChangedEventHandler<T, TView> converter)
{
return new FiltableSynchronizedViewList<T, TView>(this, isSupportRangeFeature: false, converter: converter);
@ -382,8 +424,8 @@ namespace ObservableCollections
{
return new FiltableSynchronizedViewList<T, TView>(this,
isSupportRangeFeature: false,
collectionEventDispatcher,
static (TView newView, T originalValue, ref bool setValue) =>
eventDispatcher: collectionEventDispatcher,
converter: static (TView newView, T originalValue, ref bool setValue) =>
{
setValue = true;
return originalValue;

186
src/ObservableCollections/SynchronizedViewList.cs
View File

@ -337,21 +337,22 @@ internal sealed class FiltableSynchronizedViewList<T, TView> : NotifyCollectionC
}
set
{
if (converter == null || parent is not IWritableSynchronizedView<T, TView> writableView)
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support set. If base type is ObservableList<T>, you can use ToWritableSynchronizedView and ToWritableNotifyCollectionChanged.");
throw new NotSupportedException("This CollectionView does not support Set. If base type is ObservableList<T>, you can use CreateWritableView and ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
var originalIndex = listView.GetAlternateIndex(index);
var (originalValue, _) = writableView.GetAt(originalIndex);
var (originalValue, _) = writableView!.GetAt(originalIndex);
// update view
writableView.SetViewAt(originalIndex, value);
listView[index] = value;
var setValue = true;
var newOriginal = converter(value, originalValue, ref setValue);
var newOriginal = converter!(value, originalValue, ref setValue);
if (setValue)
{
@ -372,6 +373,8 @@ internal sealed class FiltableSynchronizedViewList<T, TView> : NotifyCollectionC
}
}
public override bool IsReadOnly => converter == null || parent is not IWritableSynchronizedView<T, TView>;
public override IEnumerator<TView> GetEnumerator()
{
lock (gate)
@ -385,17 +388,91 @@ internal sealed class FiltableSynchronizedViewList<T, TView> : NotifyCollectionC
public override void Add(TView item)
{
if (converter == null || parent is not IWritableSynchronizedView<T, TView> writableView)
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Add. If base type is ObservableList<T>, you can use ToWritableSynchronizedView and ToWritableNotifyCollectionChanged.");
throw new NotSupportedException("This CollectionView does not support Add. If base type is ObservableList<T>, you can use CreateWritableView and ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
if (typeof(T) == typeof(TView) && item is T tItem)
{
writableView!.AddToSourceCollection(tItem);
return;
}
var setValue = false;
var newOriginal = converter(item, default!, ref setValue);
var newOriginal = converter!(item, default!, ref setValue);
// always add
writableView.AddToSourceCollection(newOriginal);
writableView!.AddToSourceCollection(newOriginal);
}
}
public override void Insert(int index, TView item)
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Insert. If base type is ObservableList<T>, you can use CreateWritableView and ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
if (typeof(T) == typeof(TView) && item is T tItem)
{
writableView!.InsertIntoSourceCollection(index, tItem);
return;
}
var setValue = false;
var newOriginal = converter!(item, default!, ref setValue);
writableView!.InsertIntoSourceCollection(index, newOriginal);
}
}
public override bool Remove(TView item)
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Remove. If base type is ObservableList<T>, you can use CreateWritableView and ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
if (typeof(T) == typeof(TView) && item is T tItem)
{
return writableView!.RemoveFromSourceCollection(tItem);
}
var setValue = false;
var newOriginal = converter!(item, default!, ref setValue);
// always add
return writableView!.RemoveFromSourceCollection(newOriginal);
}
}
public override void RemoveAt(int index)
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support RemoveAt. If base type is ObservableList<T>, you can use CreateWritableView and ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
writableView!.RemoveAtSourceCollection(index);
}
}
public override void Clear()
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Clear. If base type is ObservableList<T>, you can use CreateWritableView and ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
writableView!.ClearSourceCollection();
}
}
@ -762,20 +839,21 @@ internal sealed class NonFilteredSynchronizedViewList<T, TView> : NotifyCollecti
}
set
{
if (converter == null || parent is not IWritableSynchronizedView<T, TView> writableView)
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support set. If base type is ObservableList<T>, you can use ToWritableSynchronizedView and ToWritableNotifyCollectionChanged.");
throw new NotSupportedException("This CollectionView does not support set. If base type is ObservableList<T>, you can use ToWritableNotifyCollectionChanged.");
}
else
{
var (originalValue, _) = writableView.GetAt(index);
var writableView = parent as IWritableSynchronizedView<T, TView>;
var (originalValue, _) = writableView!.GetAt(index);
// update view
writableView.SetViewAt(index, value);
listView[index] = value;
var setValue = true;
var newOriginal = converter(value, originalValue, ref setValue);
var newOriginal = converter!(value, originalValue, ref setValue);
if (setValue)
{
@ -796,6 +874,8 @@ internal sealed class NonFilteredSynchronizedViewList<T, TView> : NotifyCollecti
}
}
public override bool IsReadOnly => converter == null || parent is not IWritableSynchronizedView<T, TView>;
public override IEnumerator<TView> GetEnumerator()
{
lock (gate)
@ -809,17 +889,91 @@ internal sealed class NonFilteredSynchronizedViewList<T, TView> : NotifyCollecti
public override void Add(TView item)
{
if (converter == null || parent is not IWritableSynchronizedView<T, TView> writableView)
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Add. If base type is ObservableList<T>, you can use ToWritableSynchronizedView and ToWritableNotifyCollectionChanged.");
throw new NotSupportedException("This CollectionView does not support Add. If base type is ObservableList<T>, you can use ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
if (typeof(T) == typeof(TView) && item is T tItem)
{
writableView!.AddToSourceCollection(tItem);
return;
}
var setValue = false;
var newOriginal = converter(item, default!, ref setValue);
var newOriginal = converter!(item, default!, ref setValue);
// always add
writableView.AddToSourceCollection(newOriginal);
writableView!.AddToSourceCollection(newOriginal);
}
}
public override void Insert(int index, TView item)
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Insert. If base type is ObservableList<T>, you can use ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
if (typeof(T) == typeof(TView) && item is T tItem)
{
writableView!.InsertIntoSourceCollection(index, tItem);
return;
}
var setValue = false;
var newOriginal = converter!(item, default!, ref setValue);
writableView!.InsertIntoSourceCollection(index, newOriginal);
}
}
public override bool Remove(TView item)
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Remove. If base type is ObservableList<T>, you can use ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
if (typeof(T) == typeof(TView) && item is T tItem)
{
return writableView!.RemoveFromSourceCollection(tItem);
}
var setValue = false;
var newOriginal = converter!(item, default!, ref setValue);
// always add
return writableView!.RemoveFromSourceCollection(newOriginal);
}
}
public override void RemoveAt(int index)
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support RemoveAt. If base type is ObservableList<T>, you can use ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
writableView!.RemoveAtSourceCollection(index);
}
}
public override void Clear()
{
if (IsReadOnly)
{
throw new NotSupportedException("This CollectionView does not support Clear. If base type is ObservableList<T>, you can use ToWritableNotifyCollectionChanged.");
}
else
{
var writableView = parent as IWritableSynchronizedView<T, TView>;
writableView!.ClearSourceCollection();
}
}