protected EntityDataSourceColumn(string displayName, EntityDataSourceColumn controllingColumn)
{
EntityDataSourceUtil.CheckArgumentNull(displayName, "displayName");
this.DisplayName = displayName;
this.ControllingColumn = controllingColumn;
}
internal override string GetEntitySqlValue()
{
// it.NavigationPropertyName
string result = EntityDataSourceUtil.EntitySqlElementAlias + "." + EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.navigationProperty.Name);
return(result);
}
private static void AddReferenceKeyColumns(List <EntityDataSourceColumn> columns, MetadataWorkspace ocWorkspace, EntitySet entitySet, EntityType entityType, Dictionary <EdmProperty, EntityDataSourcePropertyColumn> entityProperties)
{
foreach (AssociationSetEnd toEnd in GetReferenceEnds(entitySet, entityType, /*forKey*/ true))
{
ReferentialConstraint constraint;
bool isContained = EntityDataSourceUtil.IsContained(toEnd, out constraint);
// Create a group for the end columns
EntityType toType = EntityDataSourceUtil.GetEntityType(toEnd);
Type clrToType = EntityDataSourceUtil.GetClrType(ocWorkspace, toType);
EntityDataSourceReferenceGroup group = EntityDataSourceReferenceGroup.Create(clrToType, toEnd);
// Create a column for every key
foreach (EdmProperty keyMember in GetEntityType(toEnd).KeyMembers)
{
EntityDataSourceColumn controllingColumn = null;
if (isContained)
{
// if this key is 'contained' in the entity, make the referential constrained
// property the principal for the column
int ordinalInConstraint = constraint.FromProperties.IndexOf(keyMember);
// find corresponding member in the current (dependent) entity
EdmProperty correspondingProperty = constraint.ToProperties[ordinalInConstraint];
controllingColumn = entityProperties[correspondingProperty];
}
columns.Add(new EntityDataSourceReferenceKeyColumn(ocWorkspace, group, keyMember, controllingColumn));
}
}
}
private void SetEntityKeyProperties(
List <KeyValuePair <EntityDataSourceReferenceKeyColumn, object> > referenceList, bool overwriteSameValue)
{
EntityDataSourceUtil.CheckArgumentNull(referenceList, "referenceList");
var groups = referenceList.GroupBy(r => r.Key.Group);
foreach (var group in groups)
{
Dictionary <string, object> partialKeys = new Dictionary <string, object>();
foreach (KeyValuePair <EntityDataSourceReferenceKeyColumn, object> reference in group)
{
// convert the value as needed
EntityDataSourceReferenceKeyColumn column = reference.Key;
object keyValue = reference.Value;
if (null == keyValue)
{
partialKeys = null;
break;
}
partialKeys.Add(column.KeyMember.Name, keyValue);
}
// we only set the entitykey for once, although there might be more than one
// properties descriptor associated with the same entitykey
group.Key.SetKeyValues(this, partialKeys);
}
}
protected EntityDataSourceReferenceValueColumn(MetadataWorkspace ocWorkspace, NavigationProperty navigationProperty)
: base(EntityDataSourceUtil.CheckArgumentNull(navigationProperty, "navigationProperty").Name)
{
EntityDataSourceUtil.CheckArgumentNull(ocWorkspace, "ocWorkspace");
this.navigationProperty = navigationProperty;
}
internal static EntityDataSourceReferenceGroup Create(Type entityType, AssociationSetEnd end)
{
EntityDataSourceUtil.CheckArgumentNull(entityType, "entityType");
Type groupType = typeof(EntityDataSourceReferenceGroup <>).MakeGenericType(entityType);
return((EntityDataSourceReferenceGroup)Activator.CreateInstance(groupType, new object[] { end }));
}
internal EntityDataSourceWrapperPropertyDescriptor(EntityDataSourceWrapperCollection collection, EntityDataSourceColumn column)
: base(EntityDataSourceUtil.CheckArgumentNull(column, "column").DisplayName, new Attribute[] { })
{
EntityDataSourceUtil.CheckArgumentNull(collection, "collection");
_collection = collection;
_column = column;
}
internal static EntityDataSourceReferenceValueColumn Create(Type clrToType, MetadataWorkspace ocWorkspace, NavigationProperty navigationProperty)
{
EntityDataSourceUtil.CheckArgumentNull(clrToType, "clrToType");
Type columnType = typeof(EntityDataSourceReferenceValueColumn <>).MakeGenericType(clrToType);
EntityDataSourceReferenceValueColumn result = (EntityDataSourceReferenceValueColumn)Activator.CreateInstance(columnType, ocWorkspace, navigationProperty);
return(result);
}
Parameter _parameter; // Can be null, that's why this class doesn't subclass Parameter
internal WebControlParameterProxy(string propertyName, ParameterCollection parameterCollection, EntityDataSource entityDataSource)
{
Debug.Assert(null != entityDataSource);
Debug.Assert(!String.IsNullOrEmpty(propertyName));
_parameter = EntityDataSourceUtil.GetParameter(propertyName, parameterCollection);
_collection = parameterCollection;
_entityDataSource = entityDataSource;
VerifyUniqueType(_parameter);
}
private object Initialize(EntityDataSourceWrapper entity)
{
// get parent's value
object parentObjectValue = GetParentObjectValue(entity, true /* initialize */);
// construct type instance for this property
object propertyValue = EntityDataSourceUtil.InitializeType(this.ClrType);
// set property
this.propertyInfo.SetValue(parentObjectValue, propertyValue, new object[] { });
return(propertyValue);
}
internal EntityDataSourceWrapper(EntityDataSourceWrapperCollection collection, object trackedEntity)
{
EntityDataSourceUtil.CheckArgumentNull(collection, "collection");
EntityDataSourceUtil.CheckArgumentNull(trackedEntity, "trackedEntity");
this._collection = collection;
// retrieve state entry
if (!this._collection.Context.ObjectStateManager.TryGetObjectStateEntry(trackedEntity, out _stateEntry))
{
throw new ArgumentException(Strings.ComponentNotFromProperCollection, "trackedEntity");
}
}
private static void AddReferenceNavigationColumns(List <EntityDataSourceColumn> columns, MetadataWorkspace ocWorkspace, EntitySet entitySet, EntityType entityType)
{
foreach (AssociationSetEnd toEnd in GetReferenceEnds(entitySet, entityType, /*forKey*/ false))
{
// Check for a navigation property
NavigationProperty navigationProperty;
if (TryGetCorrespondingNavigationProperty(toEnd.CorrespondingAssociationEndMember, out navigationProperty))
{
Type clrToType = EntityDataSourceUtil.GetMemberClrType(ocWorkspace, navigationProperty);
EntityDataSourceReferenceValueColumn column = EntityDataSourceReferenceValueColumn.Create(clrToType, ocWorkspace, navigationProperty);
columns.Add(column);
}
}
}
private EntityDataSourceWrapper GetWrapper(object component)
{
// Validate that the component comes from the collection to which
// this descriptor is bound. Elements of the collection are
// non-null wrappers instances.
EntityDataSourceUtil.CheckArgumentNull(component, "component");
EntityDataSourceWrapper wrapper = component as EntityDataSourceWrapper;
if (null == wrapper || this._collection != wrapper.Collection)
{
throw new ArgumentException(Strings.ComponentNotFromProperCollection, "component");
}
return(wrapper);
}
internal EntityDataSourceMemberPath(MetadataWorkspace ocWorkspace, EntityDataSourceMemberPath parent, EdmProperty property, bool isLocallyInteresting)
{
EntityDataSourceUtil.CheckArgumentNull(ocWorkspace, "ocWorkspace");
EntityDataSourceUtil.CheckArgumentNull(property, "property");
this.property = property;
this.parent = parent;
this.isLocallyInteresting = isLocallyInteresting;
this.clrType = EntityDataSourceUtil.GetMemberClrType(ocWorkspace, property);
this.isKey = IsPropertyAKey(property);
// retrieve PropertyInfo (with respect to parent CLR type)
StructuralType parentType = property.DeclaringType;
Type parentClrType = EntityDataSourceUtil.GetClrType(ocWorkspace, parentType);
this.propertyInfo = EntityDataSourceUtil.GetPropertyInfo(parentClrType, this.property.Name);
}
internal override string GetEntitySqlValue()
{
// syntax: NAVIGATE(it, _association_type_name_, _target_role_name_)._key_member_
StringBuilder builder = new StringBuilder();
builder.Append("NAVIGATE(");
builder.Append(EntityDataSourceUtil.EntitySqlElementAlias);
builder.Append(", ");
builder.Append(EntityDataSourceUtil.CreateEntitySqlTypeIdentifier(this.Group.End.ParentAssociationSet.ElementType));
builder.Append(", ");
builder.Append(EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.Group.End.CorrespondingAssociationEndMember.Name));
builder.Append(").");
builder.Append(EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.keyMember.Name));
string result = builder.ToString();
return(result);
}
internal string GetEntitySqlValue()
{
// it.[member1].[member2]...
string prefix;
if (null != parent)
{
prefix = parent.GetEntitySqlValue();
}
else
{
prefix = EntityDataSourceUtil.EntitySqlElementAlias;
}
string eSql = prefix + "." + EntityDataSourceUtil.QuoteEntitySqlIdentifier(this.property.Name);
return(eSql);
}
/// <summary>
/// Verifies that the query's typeusage will not result in a polymorphic result.
/// If the query would be restricted "is of only" using entityTypeFilter, then
/// this check assumes the result will not be polymorphic.
///
/// This method is only called if the user specifies EntitySetName and updates are enabled.
///
/// Does nothing for RowTypes.
/// </summary>
/// <param name="typeUsage">The TypeUsage from the query</param>
/// <param name="itemCollection"></param>
/// <returns></returns>
internal static void CheckNonPolymorphicTypeUsage(EntityType entityType,
ItemCollection ocItemCollection,
string entityTypeFilter)
{
CheckArgumentNull <ItemCollection>(ocItemCollection, "ocItemCollection");
if (String.IsNullOrEmpty(entityTypeFilter))
{
List <EdmType> types = new List <EdmType>(EntityDataSourceUtil.GetTypeAndSubtypesOf(entityType, ocItemCollection, /*includeAbstractTypes*/ true));
if (entityType.BaseType != null ||
types.Count() > 1 || entityType.Abstract)
{
throw new InvalidOperationException(Strings.EntityDataSourceUtil_EntityQueryCannotReturnPolymorphicTypes);
}
}
return;
}
internal EntityDataSourceWrapperCollection(ObjectContext context, EntitySet entitySet, EntityType restrictedEntityType)
{
EntityDataSourceUtil.CheckArgumentNull(context, "context");
EntityDataSourceUtil.CheckArgumentNull(entitySet, "entitySet");
_context = context;
_wrapperList = new List <EntityDataSourceWrapper>();
// get handles on the relevant workspaces
MetadataWorkspace csWorkspace = ((EntityConnection)context.Connection).GetMetadataWorkspace();
MetadataWorkspace ocWorkspace = context.MetadataWorkspace;
// if no restricted type is given, we assume the entity set element type is exposed
EntityType entityType = restrictedEntityType ?? entitySet.ElementType;
_clrEntityType = EntityDataSourceUtil.GetClrType(ocWorkspace, entityType);
// if no restricted type is given and the set is polymorphic, make the collection readonly
if (null == restrictedEntityType &&
1 < EntityDataSourceUtil.GetTypeAndSubtypesOf(entityType, csWorkspace.GetItemCollection(DataSpace.CSpace), true).Count())
{
_isReadOnly = true;
}
// gather the properties
ReadOnlyCollection <EntityDataSourceColumn> columns = EntityDataSourceUtil.GetNamedColumns(csWorkspace, ocWorkspace, entitySet, entityType);
List <PropertyDescriptor> visiblePropertyDescriptors = new List <PropertyDescriptor>(columns.Count);
List <EntityDataSourceWrapperPropertyDescriptor> propertyDescriptors = new List <EntityDataSourceWrapperPropertyDescriptor>(columns.Count);
foreach (EntityDataSourceColumn column in columns)
{
var descriptor = new EntityDataSourceWrapperPropertyDescriptor(this, column);
propertyDescriptors.Add(descriptor);
// if the descriptor does not have a dependent, it is exposed to the user
if (!descriptor.Column.IsHidden)
{
visiblePropertyDescriptors.Add(descriptor);
}
}
_visiblePropertyDescriptors = new PropertyDescriptorCollection(visiblePropertyDescriptors.ToArray(), true);
AllPropertyDescriptors = propertyDescriptors.AsReadOnly();
}
internal EntityDataSourceReferenceKeyColumn(MetadataWorkspace workspace, EntityDataSourceReferenceGroup group, EdmProperty keyMember, EntityDataSourceColumn dependent)
: base(CreateDisplayName(group, keyMember), dependent)
{
EntityDataSourceUtil.CheckArgumentNull(group, "group");
EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");
Debug.Assert(EntityDataSourceUtil.IsScalar(keyMember.TypeUsage.EdmType), "Expected primitive or enum type for key members.");
this.group = group;
this.keyMember = keyMember;
this.clrType = EntityDataSourceUtil.GetMemberClrType(workspace, keyMember);
// if the association end is optional (0..1), make sure the CLR type
// is also nullable
if (this.group.End.CorrespondingAssociationEndMember.RelationshipMultiplicity == RelationshipMultiplicity.ZeroOrOne)
{
this.clrType = EntityDataSourceUtil.MakeNullable(clrType);
this.isNullable = true;
}
}
/// <summary>
/// Get the Clr type for the primitive enum or complex type member. The member must not be null.
/// </summary>
internal static Type GetMemberClrType(MetadataWorkspace ocWorkspace, EdmMember member)
{
EntityDataSourceUtil.CheckArgumentNull(member, "member");
EdmType memberType = member.TypeUsage.EdmType;
Debug.Assert(EntityDataSourceUtil.IsScalar(memberType) ||
memberType.BuiltInTypeKind == BuiltInTypeKind.ComplexType ||
memberType.BuiltInTypeKind == BuiltInTypeKind.EntityType, "member type must be primitive, enum, entity or complex type");
Type clrType;
if (EntityDataSourceUtil.IsScalar(memberType))
{
clrType = memberType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType ?
((PrimitiveType)memberType).ClrEquivalentType :
GetClrType(ocWorkspace, (EnumType)memberType);
if (!NullCanBeAssignedTo(clrType))
{
Facet facet;
if (member.TypeUsage.Facets.TryGetValue("Nullable", true, out facet))
{
if ((bool)facet.Value)
{
clrType = MakeNullable(clrType);
}
}
}
}
else
{
Debug.Assert(
memberType.BuiltInTypeKind == BuiltInTypeKind.EntityType || memberType.BuiltInTypeKind == BuiltInTypeKind.ComplexType,
"Complex or Entity type expected");
clrType = GetClrType(ocWorkspace, (StructuralType)memberType);
}
return(clrType);
}
private void AppendOrderByKey(StringBuilder orderByClauseBuilder, string expression, string errorText, TypeUsage tu)
{
if (!String.IsNullOrEmpty(expression))
{
string[] statements = expression.Split(',');
string spacer = String.Empty;
foreach (string statement in statements)
{
bool isAscending = true;
string columnName = ParseStatement(statement.Trim(), out isAscending);
if (String.IsNullOrEmpty(columnName))
{
throw new ArgumentException(Strings.EntityDataSourceView_EmptyPropertyName);
}
if (EntityDataSourceUtil.PropertyIsOnEntity(columnName, _wrapperCollection, null, tu))
{
orderByClauseBuilder.Append(spacer);
orderByClauseBuilder.Append(EntityDataSourceUtil.GetEntitySqlValueForColumnName(columnName, _wrapperCollection));
}
else // pass the sort expression through verbatim.
{
if (!columnName.StartsWith("it.", StringComparison.OrdinalIgnoreCase))
{
columnName = "it." + columnName;
}
orderByClauseBuilder.Append(spacer + columnName);
}
if (!isAscending)
{
orderByClauseBuilder.Append(c_esqlDescendingTail);
}
spacer = ",";
}
}
}
private static string GenerateDefaultOrderByFromTypeUsage(TypeUsage tu)
{
StringBuilder orderByBuilder = new StringBuilder();
ReadOnlyMetadataCollection <EdmProperty> propertyCollection;
List <string> keyMemberNames = null;
EntityType entityType = tu.EdmType as EntityType;
if (null != entityType)
{
ReadOnlyMetadataCollection <EdmMember> keyMembers;
keyMembers = entityType.KeyMembers;
keyMemberNames = new List <string>(entityType.KeyMembers.Count);
propertyCollection = entityType.Properties;
foreach (EdmMember edmMember in keyMembers)
{
keyMemberNames.Add(edmMember.Name);
}
}
else
{
return(String.Empty);
}
foreach (EdmProperty property in propertyCollection)
{
if (keyMemberNames.Contains(property.Name) && EntityDataSourceUtil.IsScalar(property.TypeUsage.EdmType))
{
if (0 < orderByBuilder.Length)
{
orderByBuilder.Append(", ");
}
orderByBuilder.Append(EntityDataSourceUtil.EntitySqlElementAlias);
orderByBuilder.Append(".");
orderByBuilder.Append(EntityDataSourceUtil.QuoteEntitySqlIdentifier(property.Name));
}
}
return(orderByBuilder.ToString());
}
private static string CreateDisplayName(EntityDataSourceReferenceGroup group, EdmProperty keyMember)
{
EntityDataSourceUtil.CheckArgumentNull(group, "group");
EntityDataSourceUtil.CheckArgumentNull(keyMember, "keyMember");
NavigationProperty navigationProperty;
string result;
if (EntityDataSourceUtil.TryGetCorrespondingNavigationProperty(group.End.CorrespondingAssociationEndMember, out navigationProperty))
{
result = navigationProperty.Name + "." + keyMember.Name;
}
else
{
// if there is no Navigation property, use the TargetTole and KeyMember name
// TargetRole.KeyMember
result = group.End.Name + "." + keyMember.Name;
}
return(result);
}
/// <summary>
/// Use this method to set the properties on the wrapped entity
/// </summary>
/// <param name="propertiesFromViewState"></param>
/// <param name="wrapper"></param>
/// <param name="overwriteSameValue"></param>
internal void SetAllProperties(Dictionary <string, object> propertiesFromViewState, bool overwriteSameValue,
ref Dictionary <string, Exception> propertySettingExceptionsCaught)
{
// We aggregate the reference descriptors rather than setting them directly
// to account for compound keys (we need all components of the key to create
// an EntityKey that can be set on the EntityReference)
var referenceList = new List <KeyValuePair <EntityDataSourceReferenceKeyColumn, object> >();
foreach (EntityDataSourceWrapperPropertyDescriptor descriptor in _collection.AllPropertyDescriptors)
{
// figure out which display name to match for this descriptor
string displayName = descriptor.Column.DisplayName;
// if we have a controlling column, use its display name instead
if (descriptor.Column.ControllingColumn != null)
{
displayName = descriptor.Column.ControllingColumn.DisplayName;
}
object value;
if (propertiesFromViewState.TryGetValue(displayName, out value))
{
// get all changed ReferencePropertyDescriptor from ViewState
EntityDataSourceReferenceKeyColumn referenceColumn = descriptor.Column as EntityDataSourceReferenceKeyColumn;
// convert the value as needed
object adjustedValue = EntityDataSourceUtil.ConvertType(value, descriptor.PropertyType, descriptor.DisplayName);
if (null != referenceColumn)
{
referenceList.Add(new KeyValuePair <EntityDataSourceReferenceKeyColumn, object>(
referenceColumn, adjustedValue));
continue;
}
if (overwriteSameValue || adjustedValue != descriptor.GetValue(this))
{
if (EntityDataSourceUtil.NullCanBeAssignedTo(descriptor.PropertyType) || null != adjustedValue)
{
try
{
descriptor.SetValue(this, adjustedValue);
}
catch (Exception e)
{
// The property descriptor uses reflection to set the property. Therefore, the inner exception contains the actual message.
Exception exceptionToThrow = e;
if (e.InnerException != null)
{
exceptionToThrow = e.InnerException;
}
if (null == propertySettingExceptionsCaught)
{
propertySettingExceptionsCaught = new Dictionary <string, Exception>();
}
propertySettingExceptionsCaught.Add(descriptor.DisplayName, exceptionToThrow);
}
}
}
}
}
// aggregate setting for EntityKey
SetEntityKeyProperties(referenceList, overwriteSameValue);
}
internal static string GetQualifiedEntitySetName(EntitySet entitySet)
{
EntityDataSourceUtil.CheckArgumentNull(entitySet, "entitySet");
// ContainerName.EntitySetName
return(entitySet.EntityContainer.Name + "." + entitySet.Name);
}
protected EntityDataSourceReferenceGroup(AssociationSetEnd end)
{
EntityDataSourceUtil.CheckArgumentNull(end, "end");
this.end = end;
}
internal EntityDataSourcePropertyColumn(EntityDataSourceMemberPath memberPath)
: base(EntityDataSourceUtil.CheckArgumentNull(memberPath, "memberPath").GetDescription())
{
this.memberPath = memberPath;
}
