public static SynchronizationContextCollection <TResult> ToSyncedSynchronizationContextCollection <TSource, TResult>(
this ISynchronizableNotifyChangedCollection <TSource> source,
Func <TSource, TResult> converter,
SynchronizationContext context)
{
lock (source.Synchronizer.LockObject)
{
var result = new SynchronizationContextCollection <TResult>(source.Select(converter), context);
var collectionChangedListener = SynchronizableNotifyChangedCollectionHelper.CreateSynchronizableCollectionChangedEventListener(source, result,
converter);
result.Synchronizer.EventListeners.Add(collectionChangedListener);
return(result);
}
}
public static SortedObservableCollection <TSource, TKey> ToSyncedSortedObservableCollection <TSource, TKey>(
this ISynchronizableNotifyChangedCollection <TSource> source,
Func <TSource, TKey> keySelector,
IComparer <TKey> comparer = null,
bool isDescending = false)
{
var isDisposableType = typeof(IDisposable).GetTypeInfo().IsAssignableFrom(typeof(TSource).GetTypeInfo());
lock (source.Synchronizer.LockObject)
{
var result = new SortedObservableCollection <TSource, TKey>(keySelector, comparer, isDescending);
foreach (var item in source)
{
result.Add(item);
}
var collectionChangedListener = SynchronizableNotifyChangedCollectionHelper.CreateSynchronizableCollectionChangedEventListener(source, result,
_ => _,
removeAction: e =>
{
var removeSourceItem = (TSource)e.OldItems[0];
result.RemoveAt(result.IndexOf(removeSourceItem));
if (isDisposableType)
{
((IDisposable)removeSourceItem).Dispose();
}
},
moveAction: e => { },
replaceAction: e =>
{
var removeSourceItem = (TSource)e.OldItems[0];
result.RemoveAt(result.IndexOf(removeSourceItem));
result.Add((TSource)e.NewItems[0]);
if (isDisposableType)
{
((IDisposable)removeSourceItem).Dispose();
}
}
);
result.Synchronizer.EventListeners.Add(collectionChangedListener);
return(result);
}
}
public static ObservableSynchronizedCollection <TResult> ToSyncedObservableSynchronizedCollection <TSource, TResult>(
this ISynchronizableNotifyChangedCollection <TSource> source,
Func <TSource, TResult> converter)
{
lock (source.Synchronizer.LockObject)
{
var result = new ObservableSynchronizedCollection <TResult>();
foreach (var item in source)
{
result.Add(converter(item));
}
var collectionChangedListener =
SynchronizableNotifyChangedCollectionHelper.CreateSynchronizableCollectionChangedEventListener(
source, result,
converter);
result.Synchronizer.EventListeners.Add(collectionChangedListener);
return(result);
}
}
public ReadOnlyNotifyChangedCollection(ISynchronizableNotifyChangedCollection <T> collection)
: base(collection)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
EventListeners = new MultipleDisposable();
_isDisposableType = typeof(IDisposable).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo());
lock (collection.Synchronizer.LockObject)
{
SourceCollection = collection;
EventListeners.Add(new PropertyChangedWeakEventListener(SourceCollection, (sender, e) => OnPropertyChanged(e)));
EventListeners.Add(new CollectionChangedWeakEventListener(SourceCollection, (sender, e) => OnCollectionChanged(e)));
}
}
public static ObservableSynchronizedCollection <T> ToSyncedObservableSynchronizedCollection <T>(
this ISynchronizableNotifyChangedCollection <T> source) => ToSyncedObservableSynchronizedCollection(source, _ => _);
public static SynchronizationContextCollection <T> ToSyncedSynchronizationContextCollection <T>(
this ISynchronizableNotifyChangedCollection <T> source,
SynchronizationContext context) => ToSyncedSynchronizationContextCollection(source, _ => _, context);
public static ReadOnlyNotifyChangedCollection <T> ToSyncedReadOnlyNotifyChangedCollection <T>(
this ISynchronizableNotifyChangedCollection <T> source) => new ReadOnlyNotifyChangedCollection <T>(source);
public static CollectionChangedWeakEventListener CreateSynchronizableCollectionChangedEventListener
<TSource, TResult>(
ISynchronizableNotifyChangedCollection <TSource> source,
ISynchronizableNotifyChangedCollection <TResult> target,
Func <TSource, TResult> converter,
Action <NotifyCollectionChangedEventArgs> addAction = null,
Action <NotifyCollectionChangedEventArgs> moveAction = null,
Action <NotifyCollectionChangedEventArgs> removeAction = null,
Action <NotifyCollectionChangedEventArgs> replaceAction = null,
Action <NotifyCollectionChangedEventArgs> resetAction = null)
{
var isDisposableType = typeof(IDisposable).GetTypeInfo().IsAssignableFrom(typeof(TResult).GetTypeInfo());
var collectionChangedListener = new CollectionChangedWeakEventListener(source);
collectionChangedListener.RegisterHandler((sender, e) =>
{
switch (e.Action)
{
case NotifyCollectionChangedAction.Add:
if (addAction != null)
{
addAction(e);
break;
}
var vm = converter((TSource)e.NewItems[0]);
target.Insert(e.NewStartingIndex, vm);
break;
case NotifyCollectionChangedAction.Move:
if (moveAction != null)
{
moveAction(e);
break;
}
target.Move(e.OldStartingIndex, e.NewStartingIndex);
break;
case NotifyCollectionChangedAction.Remove:
if (removeAction != null)
{
removeAction(e);
break;
}
if (isDisposableType)
{
((IDisposable)target[e.OldStartingIndex]).Dispose();
}
target.RemoveAt(e.OldStartingIndex);
break;
case NotifyCollectionChangedAction.Replace:
if (replaceAction != null)
{
replaceAction(e);
break;
}
if (isDisposableType)
{
((IDisposable)target[e.NewStartingIndex]).Dispose();
}
var replaceVm = converter((TSource)e.NewItems[0]);
target[e.NewStartingIndex] = replaceVm;
break;
case NotifyCollectionChangedAction.Reset:
if (resetAction != null)
{
resetAction(e);
break;
}
if (isDisposableType)
{
foreach (var result in target)
{
var item = (IDisposable)result;
item.Dispose();
}
}
target.Clear();
break;
default:
throw new ArgumentException();
}
});
return(collectionChangedListener);
}
