/// <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);
}
}
/// <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);
}
}
