/// <summary>Initialize and start tracking an DataServiceCollection</summary>
/// <param name="context">The context</param>
/// <param name="items">Collection to initialize with</param>
/// <param name="entitySet">The entity set of the elements in the collection.</param>
/// <param name="entityChanged">delegate that needs to be called when an entity changes.</param>
/// <param name="collectionChanged">delegate that needs to be called when an entity collection is changed.</param>
private void StartTracking(
DataServiceContext context,
IEnumerable <T> items,
String entitySet,
Func <EntityChangedParams, bool> entityChanged,
Func <EntityCollectionChangedParams, bool> collectionChanged)
{
Debug.Assert(context != null, "Must have a valid context to initialize.");
Debug.Assert(this.observer == null, "Must have no observer which implies Initialize should only be called once.");
context.UsingDataServiceCollection = true;
// Verify that T corresponds to an entity type.
// Validate here before any items are added to the collection because if this fails we want to prevent the collection from being populated.
if (!BindingEntityInfo.IsEntityType(typeof(T), context.Model))
{
throw new ArgumentException(Strings.DataBinding_DataServiceCollectionArgumentMustHaveEntityType(typeof(T)));
}
// Set up the observer first because we want the collection to know it's supposed to be tracked while the items are being loaded.
// Items being added to the collection are not added to the binding graph until later when StartTracking is called on the observer.
this.observer = new BindingObserver(context, entityChanged, collectionChanged);
// Add everything from the input collection.
if (items != null)
{
try
{
this.InternalLoadCollection(items);
}
catch
{
// If any failures occur, reset the observer since we couldn't successfully start tracking
this.observer = null;
throw;
}
}
this.observer.StartTracking(this, entitySet);
this.rootCollection = true;
}
/// <summary>
/// Get the entity set name for the target entity object.
/// </summary>
/// <param name="target">An entity object.</param>
/// <param name="targetEntitySet">The 'currently known' entity set name for the target object.</param>
/// <param name="model">The client model.</param>
/// <returns>The entity set name for the target object.</returns>
/// <remarks>
/// Allow user code to provide the entity set name. If user code does not provide the entity set name, then
/// this method will get the entity set name from the value of the EntitySetAttribute.
/// The 'currently known' entity set name for top level collections can be provided through OEC constructor
/// </remarks>
internal static string GetEntitySet(
object target,
string targetEntitySet,
ClientEdmModel model)
{
Debug.Assert(target != null, "Argument 'target' cannot be null.");
Debug.Assert(BindingEntityInfo.IsEntityType(target.GetType(), model), "Argument 'target' must be an entity type.");
// Here's the rules in order of priority for resolving entity set name
// 1. EntitySet name passed in the constructor or extension methods of DataServiceCollection
// 2. EntitySet name specified in the EntitySet attribute by the code gen. {Remember this attribute is
// not generated in case of MEST)
if (!String.IsNullOrEmpty(targetEntitySet))
{
return(targetEntitySet);
}
else
{
// If there is not a 'currently known' entity set name to validate against, then there must be
// EntitySet attribute on the entity type
return(BindingEntityInfo.GetEntitySetAttribute(target.GetType(), model));
}
}
/// <summary>Obtain binding info corresponding to a given type</summary>
/// <param name="entityType">Type for which to obtain information</param>
/// <param name="model">The client model.</param>
/// <returns>Info about the <paramref name="entityType"/></returns>
private static BindingEntityInfoPerType GetBindingEntityInfoFor(Type entityType, ClientEdmModel model)
{
BindingEntityInfoPerType bindingEntityInfo;
metadataCacheLock.EnterReadLock();
try
{
if (bindingEntityInfos.TryGetValue(entityType, out bindingEntityInfo))
{
return(bindingEntityInfo);
}
}
finally
{
metadataCacheLock.ExitReadLock();
}
bindingEntityInfo = new BindingEntityInfoPerType();
// Try to get the entity set name from the EntitySetAttribute attributes. In order to make the
// inheritance work, we need to look at the attributes declared in the base types also.
// EntitySetAttribute does not allow multiples, so there can be at most 1 instance on the type.
EntitySetAttribute entitySetAttribute = (EntitySetAttribute)entityType.GetCustomAttributes(typeof(EntitySetAttribute), true).SingleOrDefault();
// There must be exactly one (unambiguous) EntitySetAttribute attribute.
bindingEntityInfo.EntitySet = entitySetAttribute != null ? entitySetAttribute.EntitySet : null;
bindingEntityInfo.ClientType = model.GetClientTypeAnnotation(model.GetOrCreateEdmType(entityType));
foreach (ClientPropertyAnnotation p in bindingEntityInfo.ClientType.Properties())
{
BindingPropertyInfo bpi = null;
Type propertyType = p.PropertyType;
if (p.IsStreamLinkProperty)
{
// DataServiceStreamLink is not mutable externally
// It implements INPC to notify controls about our updates
// We should ignore its events since we are the only one updating it.
continue;
}
else if (p.IsPrimitiveOrEnumOrComplexCollection)
{
Debug.Assert(!BindingEntityInfo.IsDataServiceCollection(propertyType, model), "DataServiceCollection cannot be the type that backs collections of primitives or complex types.");
bpi = new BindingPropertyInfo {
PropertyKind = BindingPropertyKind.BindingPropertyKindPrimitiveOrComplexCollection
};
}
else if (p.IsEntityCollection)
{
if (BindingEntityInfo.IsDataServiceCollection(propertyType, model))
{
bpi = new BindingPropertyInfo {
PropertyKind = BindingPropertyKind.BindingPropertyKindDataServiceCollection
};
}
}
else if (BindingEntityInfo.IsEntityType(propertyType, model))
{
bpi = new BindingPropertyInfo {
PropertyKind = BindingPropertyKind.BindingPropertyKindEntity
};
}
else if (BindingEntityInfo.CanBeComplexType(propertyType))
{
// Add complex types and nothing else.
Debug.Assert(!p.IsKnownType, "Known types do not implement INotifyPropertyChanged.");
bpi = new BindingPropertyInfo {
PropertyKind = BindingPropertyKind.BindingPropertyKindComplex
};
}
if (bpi != null)
{
bpi.PropertyInfo = p;
// For entity types, all of the above types of properties are interesting.
// For complex types, only observe collections and complex type properties.
if (bindingEntityInfo.ClientType.IsEntityType ||
bpi.PropertyKind == BindingPropertyKind.BindingPropertyKindComplex ||
bpi.PropertyKind == BindingPropertyKind.BindingPropertyKindPrimitiveOrComplexCollection)
{
bindingEntityInfo.ObservableProperties.Add(bpi);
}
}
}
metadataCacheLock.EnterWriteLock();
try
{
if (!bindingEntityInfos.ContainsKey(entityType))
{
bindingEntityInfos[entityType] = bindingEntityInfo;
}
}
finally
{
metadataCacheLock.ExitWriteLock();
}
return(bindingEntityInfo);
}