private void ApplyItemsToCollection(MaterializerEntry entry, ClientPropertyAnnotation property, IEnumerable items, Uri nextLink, ProjectionPlan continuationPlan)
{
Func <LinkDescriptor, bool> predicate = null;
object instance = entry.ShouldUpdateFromPayload ? GetOrCreateCollectionProperty(entry.ResolvedObject, property, null) : null;
ClientEdmModel model = ClientEdmModel.GetModel(base.ResponseInfo.MaxProtocolVersion);
ClientTypeAnnotation clientTypeAnnotation = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(property.EntityCollectionItemType));
foreach (object obj3 in items)
{
if (!clientTypeAnnotation.ElementType.IsAssignableFrom(obj3.GetType()))
{
throw new InvalidOperationException(System.Data.Services.Client.Strings.AtomMaterializer_EntryIntoCollectionMismatch(obj3.GetType().FullName, clientTypeAnnotation.ElementType.FullName));
}
if (entry.ShouldUpdateFromPayload)
{
property.SetValue(instance, obj3, property.PropertyName, true);
this.log.AddedLink(entry, property.PropertyName, obj3);
}
}
if (entry.ShouldUpdateFromPayload)
{
this.FoundNextLinkForCollection(instance as IEnumerable, nextLink, continuationPlan);
}
else
{
this.FoundNextLinkForUnmodifiedCollection(property.GetValue(entry.ResolvedObject) as IEnumerable);
}
if ((this.mergeOption == MergeOption.OverwriteChanges) || (this.mergeOption == MergeOption.PreserveChanges))
{
if (predicate == null)
{
predicate = delegate(LinkDescriptor x) {
if (MergeOption.OverwriteChanges != this.mergeOption)
{
return(EntityStates.Added != x.State);
}
return(true);
};
}
foreach (object obj4 in (from x in base.ResponseInfo.EntityTracker.GetLinks(entry.ResolvedObject, property.PropertyName).Where <LinkDescriptor>(predicate) select x.Target).Except <object>(EnumerateAsElementType <object>(items)))
{
if (instance != null)
{
property.RemoveValue(instance, obj4);
}
this.log.RemovedLink(entry, property.PropertyName, obj4);
}
}
}
/// <summary>
/// Applies the values of the <paramref name="items"/> enumeration to the
/// <paramref name="property"/> of the specified <paramref name="entry"/>.
/// </summary>
/// <param name="entry">Entry with collection to be modified.</param>
/// <param name="property">Collection property on the entry.</param>
/// <param name="items">Values to apply onto the collection.</param>
/// <param name="nextLink">Next link for collection continuation.</param>
/// <param name="continuationPlan">Projection plan for collection continuation.</param>
/// <param name="isContinuation">Whether this is a continuation request.</param>
internal void ApplyItemsToCollection(
MaterializerEntry entry,
ClientPropertyAnnotation property,
IEnumerable items,
Uri nextLink,
ProjectionPlan continuationPlan,
bool isContinuation)
{
Debug.Assert(entry.Entry != null || entry.ForLoadProperty, "ODataResource should be non-null except for LoadProperty");
Debug.Assert(property != null, "property != null");
Debug.Assert(items != null, "items != null");
IEnumerable <object> itemsEnumerable = ODataEntityMaterializer.EnumerateAsElementType <object>(items);
// Populate the collection property with items collection.
object collection = this.PopulateCollectionProperty(entry, property, itemsEnumerable, nextLink, continuationPlan);
// Get collection of all non-linked elements in collection and remove them except for the ones that were obtained from the response.
if (this.EntityTrackingAdapter.MergeOption == MergeOption.OverwriteChanges ||
this.EntityTrackingAdapter.MergeOption == MergeOption.PreserveChanges)
{
var linkedItemsInCollection =
this.EntityTrackingAdapter
.EntityTracker
.GetLinks(entry.ResolvedObject, property.PropertyName)
.Select(l => new { l.Target, l.IsModified });
if (collection != null && !property.IsDictionary)
{
var nonLinkedNonReceivedItemsInCollection = ODataEntityMaterializer.EnumerateAsElementType <object>((IEnumerable)collection)
.Except(linkedItemsInCollection.Select(i => i.Target))
.Except(itemsEnumerable).ToArray();
// Since no link exists, we just remove the item from the collection
foreach (var item in nonLinkedNonReceivedItemsInCollection)
{
property.RemoveValue(collection, item);
}
}
// When the first time a property or collection is being loaded, we remove all items other than the ones that we receive.
if (!isContinuation)
{
IEnumerable <object> itemsToRemove;
if (this.EntityTrackingAdapter.MergeOption == MergeOption.OverwriteChanges)
{
itemsToRemove = linkedItemsInCollection.Select(i => i.Target);
}
else
{
Debug.Assert(
this.EntityTrackingAdapter.MergeOption == MergeOption.PreserveChanges,
"this.EntityTrackingAdapter.MergeOption == MergeOption.PreserveChanges");
itemsToRemove = linkedItemsInCollection
.Where(i => !i.IsModified)
.Select(i => i.Target);
}
itemsToRemove = itemsToRemove.Except(itemsEnumerable);
foreach (var item in itemsToRemove)
{
if (collection != null)
{
property.RemoveValue(collection, item);
}
this.EntityTrackingAdapter.MaterializationLog.RemovedLink(entry, property.PropertyName, item);
}
}
}
}
