/// <summary>Loads the collection from another collection.</summary> /// <param name="items">Collection whose elements will be loaded into the DataServiceCollection.</param> /// <remarks> /// When tracking is enabled, the behavior of Load would be to attach all those entities that are not already tracked by the context /// associated with the collection. The operation will go deep into the input entities so that all related /// entities are attached to the context if not already present. All entities in <paramref name="items"/> /// will be tracked after Load is done. /// Load method checks for duplication. The collection will ignore any duplicated items been loaded. /// For large amount of items, consider DataServiceContext.LoadProperty instead. /// </remarks> public void Load(IEnumerable <T> items) { DataServiceCollection <T> .ValidateIteratorParameter(items); if (this.trackingOnLoad) { // This throws if no context can be obtained, no need to check here DataServiceContext context = DataServiceCollection <T> .GetContextFromItems(items); this.trackingOnLoad = false; this.StartTracking(context, items, this.entitySetName, this.entityChangedCallback, this.collectionChangedCallback); } else { this.StartLoading(); try { this.InternalLoadCollection(items); } finally { this.FinishLoading(); } } }
public DataServiceCollection(DataServiceContext context, IEnumerable <T> items, TrackingMode trackingMode, string entitySetName, Func <EntityChangedParams, bool> entityChangedCallback, Func <EntityCollectionChangedParams, bool> collectionChangedCallback) { if (trackingMode == TrackingMode.AutoChangeTracking) { if (context == null) { if (items == null) { this.trackingOnLoad = true; this.entitySetName = entitySetName; this.entityChangedCallback = entityChangedCallback; this.collectionChangedCallback = collectionChangedCallback; } else { context = DataServiceCollection <T> .GetContextFromItems(items); } } if (!this.trackingOnLoad) { if (items != null) { DataServiceCollection <T> .ValidateIteratorParameter(items); } this.StartTracking(context, items, entitySetName, entityChangedCallback, collectionChangedCallback); } } else if (items != null) { this.Load(items); } }
internal bool LookupParent <T>(DataServiceCollection <T> collection, out object parentEntity, out string parentProperty) { string sourceEntitySet; string targetEntitySet; this.bindingGraph.GetEntityCollectionInfo(collection, out parentEntity, out parentProperty, out sourceEntitySet, out targetEntitySet); return(parentEntity != null); }
internal static void VerifyObserverNotPresent <T>(object oec, string sourceProperty, Type sourceType) { DataServiceCollection <T> services = oec as DataServiceCollection <T>; if (services.Observer != null) { throw new InvalidOperationException(Strings.DataBinding_CollectionPropertySetterValueHasObserver(sourceProperty, sourceType)); } }
internal static void VerifyObserverNotPresent <T>(object oec, string sourceProperty, Type sourceType) { Debug.Assert(BindingEntityInfo.IsDataServiceCollection(oec.GetType()), "Must be an DataServiceCollection."); DataServiceCollection <T> typedCollection = oec as DataServiceCollection <T>; if (typedCollection.Observer != null) { throw new InvalidOperationException(Strings.DataBinding_CollectionPropertySetterValueHasObserver(sourceProperty, sourceType)); } }
internal void StartTracking <T>(DataServiceCollection <T> collection, string collectionEntitySet) { try { this.AttachBehavior = true; this.bindingGraph.AddDataServiceCollection(null, null, collection, collectionEntitySet); } finally { this.AttachBehavior = false; } }
internal static DataServiceCollection <T> RestoreState( CollectionState state, DataServiceContext context, Dictionary <Guid, EntityDescriptor> idToEntityDescriptor) { var items = new List <T>(state.DescriptorIds.Count); foreach (Guid id in state.DescriptorIds) { EntityDescriptor entityDescriptor = idToEntityDescriptor[id]; items.Add((T)entityDescriptor.Entity); } DataServiceCollection <T> collection = new DataServiceCollection <T>( context, items, TrackingMode.AutoChangeTracking, state.EntitySetName, null, null); collection.rootCollection = state.RootCollection; return(collection); }
/// <summary>Creates a new DataServiceCollection.</summary> /// <param name="context"><see cref="DataServiceContext"/> associated with the new collection.</param> /// <param name="items">Enumeration of items to initialize the new DataServiceCollection with.</param> /// <param name="trackingMode">The tracking mode for the new collection.</param> /// <param name="entitySetName">The name of the entity set the elements in the collection belong to.</param> /// <param name="entityChangedCallback">Delegate that gets called when an entity changes.</param> /// <param name="collectionChangedCallback">Delegate that gets called when an entity collection changes.</param> public DataServiceCollection( DataServiceContext context, IEnumerable <T> items, TrackingMode trackingMode, string entitySetName, Func <EntityChangedParams, bool> entityChangedCallback, Func <EntityCollectionChangedParams, bool> collectionChangedCallback) { if (trackingMode == TrackingMode.AutoChangeTracking) { if (context == null) { if (items == null) { // Enable tracking on first Load/LoadAsync call, when we can obtain a context this.trackingOnLoad = true; // Save off these for when we enable tracking later this.entitySetName = entitySetName; this.entityChangedCallback = entityChangedCallback; this.collectionChangedCallback = collectionChangedCallback; } else { // This throws if no context can be obtained, no need to check here context = DataServiceCollection <T> .GetContextFromItems(items); } } if (!this.trackingOnLoad) { if (items != null) { DataServiceCollection <T> .ValidateIteratorParameter(items); } this.StartTracking(context, items, entitySetName, entityChangedCallback, collectionChangedCallback); } } else if (items != null) { this.Load(items); } }
internal void StartTracking <T>(DataServiceCollection <T> collection, string collectionEntitySet) { Debug.Assert(collection != null, "Only constructed collections are tracked."); if (!BindingEntityInfo.IsEntityType(typeof(T))) { throw new ArgumentException(Strings.DataBinding_DataServiceCollectionArgumentMustHaveEntityType(typeof(T))); } try { this.AttachBehavior = true; this.bindingGraph.AddCollection(null, null, collection, collectionEntitySet); } finally { this.AttachBehavior = false; } }
/// <summary>Start tracking the specified DataServiceCollection.</summary> /// <typeparam name="T">An entity type.</typeparam> /// <param name="collection">An DataServiceCollection.</param> /// <param name="collectionEntitySet">The entity set of the elements in <paramref name="collection"/>.</param> internal void StartTracking <T>(DataServiceCollection <T> collection, string collectionEntitySet) { Debug.Assert(collection != null, "Only constructed collections are tracked."); // Verify that T corresponds to an entity type. if (!BindingEntityInfo.IsEntityType(typeof(T))) { throw new ArgumentException(Strings.DataBinding_DataServiceCollectionArgumentMustHaveEntityType(typeof(T))); } try { this.AttachBehavior = true; // Recursively traverse the entire object graph under the root collection. this.bindingGraph.AddCollection(null, null, collection, collectionEntitySet); } finally { this.AttachBehavior = false; } }
private void SetObserver <T>(ICollection collection) { DataServiceCollection <T> oec = collection as DataServiceCollection <T>; oec.Observer = this.observer; }