public virtual async Task ApplyCollectionChangeAsync(ICollectionChange <ContentType, ContentType> contentContentChange)
{
applyCollectionChange(contentContentChange, out var appliedBundle);
var eventSequence = new AsyncEventSequence();
var args = new CollectionChangeAppliedEventArgs <ItemType, ContentType>(appliedBundle, eventSequence);
OnCollectionChangeApplied(args);
await eventSequence.FinishDependenciesAsync();
}
public virtual async Task ApplyCollectionChangeAsync(ICollectionChange <ItemType, ContentType> itemContentChange)
{
BeginWork();
try {
applyCollectionChange(itemContentChange, out var appliedBundle);
var eventSequence = new AsyncEventSequence();
var args = new CollectionChangeAppliedEventArgs <ItemType, ContentType>(appliedBundle, eventSequence);
OnCollectionChangeApplied(args);
await eventSequence.FinishDependenciesAsync();
} finally {
EndWork();
}
}
public async Task RelayCollectionChangeAsync(ICollectionChangeBundle <ContentType, OriginContentType> originBundle)
{
var convertedApplyingBundle = createApplyingCollectionChangeConversionBundle(originBundle);
synchronizer.ApplyCollectionChangeBundle(convertedApplyingBundle);
var convertedAppliedBundle = synchronizer.GetAppliedCollectionChangeBundle(convertedApplyingBundle);
var convertedChangeAppliedEventSequence = new AsyncEventSequence();
var convertedChangeAppliedArgs = new CollectionChangeAppliedEventArgs <ItemType, ContentType>(convertedAppliedBundle, convertedChangeAppliedEventSequence);
synchronizer.OnCollectionChangeApplied(convertedChangeAppliedArgs);
await convertedChangeAppliedEventSequence.FinishDependenciesAsync();
var conversionBundles = new ConversionCollectionChangeBundles(convertedAppliedBundle, originBundle);
var changeConversionAppliedEventSequence = new AsyncEventSequence();
var changeConversionAppliedArgs = CollectionChangeConversionAppliedEventArgs <ItemType, ContentType, OriginContentType> .CreateAsynchronous(conversionBundles, changeConversionAppliedEventSequence);
OnCollectionChangeConversionApplied(changeConversionAppliedArgs);
await convertedChangeAppliedEventSequence.FinishDependenciesAsync();
}
private void NotifiableCollectionContainer_CollectionChanged(object sender, CollectionChangeAppliedEventArgs <ItemType, ContentType> args)
{
var change = args.ItemItemChange;
var oldItemItemItems = change.OldItems ??
throw new ArgumentException("The old item-item-items were not given that can be processed as collection change");
var newItemItemItems = change.NewItems ??
throw new ArgumentException("The new item-item-items were not given that can be processed as collection change");
switch (change.Action)
{
case NotifyCollectionChangedAction.Remove:
foreach (var item in oldItemItemItems)
{
detachWantParentsHandler(item);
}
break;
case NotifyCollectionChangedAction.Add:
foreach (var item in newItemItemItems)
{
attachWantParentsHandler(item);
}
break;
case NotifyCollectionChangedAction.Reset:
foreach (var oldItem in oldItemItemItems)
{
detachWantParentsHandler(oldItem);
}
foreach (var newItem in newItemItemItems)
{
attachWantParentsHandler(newItem);
}
break;
}
}
private async void NotifiableCollectionContainer_CollectionChangeAppliedAsync(object sender, CollectionChangeAppliedEventArgs <ItemType, ContentType> args)
{
var change = args.ItemContentChange;
var tcs = args.AsyncEventSequence.RegisterDependency();
try {
foreach (var oldItemUpdateContainer in getOldItemUpdateContainerIterator(change))
{
await oldItemUpdateContainer.Target.ApplyContentUpdateByAsync(oldItemUpdateContainer.Update);
}
tcs.SetResult();
} catch (Exception error) {
tcs.SetException(error);
}
}
protected void OnCollectionChangeApplied(CollectionChangeAppliedEventArgs <ItemType, ContentType> args) => CollectionChangeApplied?.Invoke(this, args);
