public override DbExpression Visit(DbRelationshipNavigationExpression expression)
{
EntityUtil.CheckArgumentNull(expression, "expression");
DbExpression result = expression;
RelationshipEndMember newFrom;
RelationshipEndMember newTo;
VisitRelationshipEnds(expression.NavigateFrom, expression.NavigateTo, out newFrom, out newTo);
DbExpression newNavSource = this.VisitExpression(expression.NavigationSource);
if (!object.ReferenceEquals(expression.NavigateFrom, newFrom) ||
!object.ReferenceEquals(expression.NavigateTo, newTo) ||
!object.ReferenceEquals(expression.NavigationSource, newNavSource))
{
result = CqtBuilder.Navigate(newNavSource, newFrom, newTo);
}
NotifyIfChanged(expression, result);
return(result);
}
public override DbExpression Visit(DbSkipExpression expression)
{
EntityUtil.CheckArgumentNull(expression, "expression");
DbExpression result = expression;
DbExpressionBinding newInput = this.VisitExpressionBindingEnterScope(expression.Input);
IList <DbSortClause> newSortOrder = this.VisitSortOrder(expression.SortOrder);
this.ExitScope();
DbExpression newCount = this.VisitExpression(expression.Count);
if (!object.ReferenceEquals(expression.Input, newInput) ||
!object.ReferenceEquals(expression.SortOrder, newSortOrder) ||
!object.ReferenceEquals(expression.Count, newCount))
{
result = CqtBuilder.Skip(newInput, newSortOrder, newCount);
}
NotifyIfChanged(expression, result);
return(result);
}
public override DbExpression Visit(DbRefExpression expression)
{
EntityUtil.CheckArgumentNull(expression, "expression");
DbExpression result = expression;
EntityType targetType = (EntityType)TypeHelpers.GetEdmType <RefType>(expression.ResultType).ElementType;
DbExpression newArgument = this.VisitExpression(expression.Argument);
EntityType newType = (EntityType)this.VisitType(targetType);
EntitySet newSet = (EntitySet)this.VisitEntitySet(expression.EntitySet);
if (!object.ReferenceEquals(expression.Argument, newArgument) ||
!object.ReferenceEquals(targetType, newType) ||
!object.ReferenceEquals(expression.EntitySet, newSet))
{
result = CqtBuilder.RefFromKey(newSet, newArgument, newType);
}
NotifyIfChanged(expression, result);
return(result);
}
public override DbExpression Visit(DbPropertyExpression expression)
{
EntityUtil.CheckArgumentNull(expression, "expression");
DbExpression result = expression;
DbExpression newInstance = this.VisitExpression(expression.Instance);
if (!object.ReferenceEquals(expression.Instance, newInstance))
{
if (Helper.IsRelationshipEndMember(expression.Property))
{
RelationshipEndMember endMember;
if (!TryGetMember(newInstance, expression.Property.Name, out endMember))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_EndNotFound(expression.Property.Name, TypeHelpers.GetFullName(newInstance.ResultType.EdmType)));
}
result = DbExpressionBuilder.Property(newInstance, endMember);
}
else if (Helper.IsNavigationProperty(expression.Property))
{
NavigationProperty navProp;
if (!TryGetMember(newInstance, expression.Property.Name, out navProp))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_NavPropertyNotFound(expression.Property.Name, TypeHelpers.GetFullName(newInstance.ResultType.EdmType)));
}
result = DbExpressionBuilder.Property(newInstance, navProp);
}
else
{
EdmProperty prop;
if (!TryGetMember(newInstance, expression.Property.Name, out prop))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Copier_PropertyNotFound(expression.Property.Name, TypeHelpers.GetFullName(newInstance.ResultType.EdmType)));
}
result = DbExpressionBuilder.Property(newInstance, prop);
}
}
return(result);
}
internal FunctionImportReturnTypeEntityTypeColumnsRenameBuilder(
Dictionary <EntityType, Collection <FunctionImportReturnTypePropertyMapping> > isOfTypeEntityTypeColumnsRenameMapping,
Dictionary <EntityType, Collection <FunctionImportReturnTypePropertyMapping> > entityTypeColumnsRenameMapping)
{
EntityUtil.CheckArgumentNull(isOfTypeEntityTypeColumnsRenameMapping, "isOfTypeEntityTypeColumnsRenameMapping");
EntityUtil.CheckArgumentNull(entityTypeColumnsRenameMapping, "entityTypeColumnsRenameMapping");
this.ColumnRenameMapping = new Dictionary <string, FunctionImportReturnTypeStructuralTypeColumnRenameMapping>();
// Assign the columns renameMapping to the result dictionary.
foreach (EntityType entityType in isOfTypeEntityTypeColumnsRenameMapping.Keys)
{
this.SetStructuralTypeColumnsRename(
entityType, isOfTypeEntityTypeColumnsRenameMapping[entityType], true /*isTypeOf*/);
}
foreach (EntityType entityType in entityTypeColumnsRenameMapping.Keys)
{
this.SetStructuralTypeColumnsRename(
entityType, entityTypeColumnsRenameMapping[entityType], false /*isTypeOf*/);
}
}
/// <summary>
/// Propagation rule (F = filter node, S = input to filter, I(x) = rows inserted
/// into x, D(x) = rows deleted from x, Sigma_p = filter predicate)
///
/// F = Sigma_p S
/// D(F) = Sigma_p D(S)
/// I(F) = Sigma_p I(S)
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public override ChangeNode Visit(DbFilterExpression node)
{
EntityUtil.CheckArgumentNull(node, "node");
// Initialize an empty change node for this filter node.
ChangeNode result = BuildChangeNode(node);
// Retrieve result of propagating changes to the input of the filter.
ChangeNode input = Visit(node.Input.Expression);
// Implement insert propagation rule I(F) = Sigma_p I(S)
result.Inserted.AddRange(Evaluator.Filter(node.Predicate, input.Inserted, this));
// Implement delete propagation rule D(F) = Sigma_p D(S
result.Deleted.AddRange(Evaluator.Filter(node.Predicate, input.Deleted, this));
// The placeholder for a filter node is identical to that of the input, which has an
// identical shape (type).
result.Placeholder = input.Placeholder;
return(result);
}
/// <summary>
/// Add a relationship to be tracked by the validator.
/// </summary>
/// <param name="associationSet">Relationship set to which the given record belongs.</param>
/// <param name="record">Relationship record. Must conform to the type of the relationship set.</param>
/// <param name="stateEntry">State entry for the relationship being tracked</param>
internal void RegisterAssociation(AssociationSet associationSet, IExtendedDataRecord record, IEntityStateEntry stateEntry)
{
EntityUtil.CheckArgumentNull(associationSet, "relationshipSet");
EntityUtil.CheckArgumentNull(record, "record");
EntityUtil.CheckArgumentNull(stateEntry, "stateEntry");
Debug.Assert(associationSet.ElementType.Equals(record.DataRecordInfo.RecordType.EdmType));
// retrieve the ends of the relationship
Dictionary <string, EntityKey> endNameToKeyMap = new Dictionary <string, EntityKey>(
StringComparer.Ordinal);
foreach (FieldMetadata field in record.DataRecordInfo.FieldMetadata)
{
string endName = field.FieldType.Name;
EntityKey entityKey = (EntityKey)record.GetValue(field.Ordinal);
endNameToKeyMap.Add(endName, entityKey);
}
// register each unidirectional relationship subpart in the relationship instance
var ends = associationSet.AssociationSetEnds;
foreach (var fromEnd in ends)
{
foreach (var toEnd in ends)
{
// end to itself does not describe an interesting relationship subpart
if (object.ReferenceEquals(toEnd.CorrespondingAssociationEndMember, fromEnd.CorrespondingAssociationEndMember))
{
continue;
}
EntityKey toEntityKey = endNameToKeyMap[toEnd.CorrespondingAssociationEndMember.Name];
DirectionalRelationship relationship = new DirectionalRelationship(toEntityKey, fromEnd.CorrespondingAssociationEndMember,
toEnd.CorrespondingAssociationEndMember, associationSet, stateEntry);
AddExistingRelationship(relationship);
}
}
}
/// <summary>
/// Evaluates an 'or' expression given results of evaluating its children.
/// </summary>
/// <param name="predicate">'Or' predicate</param>
/// <returns>True if either child predicate is satisfied; false otherwise.</returns>
public override PropagatorResult Visit(DbOrExpression predicate)
{
EntityUtil.CheckArgumentNull(predicate, "predicate");
PropagatorResult left = Visit(predicate.Left);
PropagatorResult right = Visit(predicate.Right);
bool? leftResult = ConvertResultToBool(left);
bool? rightResult = ConvertResultToBool(right);
bool? result;
// Optimization: if either argument is true, preserved and known, return a
// result that is true, preserved and known.
if ((leftResult.HasValue && leftResult.Value && PreservedAndKnown(left)) ||
(rightResult.HasValue && rightResult.Value && PreservedAndKnown(right)))
{
return(CreatePerservedAndKnownResult(true));
}
result = EntityUtil.ThreeValuedOr(leftResult, rightResult);
return(ConvertBoolToResult(result, left, right));
}
// --------------
// Public Methods
// --------------
#region Add
/// <summary>
/// This method adds the specified parameter object to the collection. If
/// the parameter object already exists in the collection, an exception is
/// thrown.
/// </summary>
/// <param name="parameter">
/// The parameter object to add to the collection.
/// </param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// If the value of the parameter argument is null.
/// </exception>
/// <exception cref="ArgumentException">
/// If the parameter argument already exists in the collection. This
/// behavior differs from that of most collections which allow duplicate
/// entries.
/// </exception>
/// <exception cref="ArgumentException">
/// If another parameter with the same name as the parameter argument
/// already exists in the collection. Note that the lookup is case-
/// insensitive. This behavior differs from that of most collections,
/// and is more like that of a Dictionary.
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// If the type of the specified parameter is invalid.
/// </exception>
public void Add(ObjectParameter parameter)
{
EntityUtil.CheckArgumentNull(parameter, "parameter");
CheckUnlocked();
if (this.Contains(parameter))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectParameterCollection_ParameterAlreadyExists(parameter.Name), "parameter");
}
if (this.Contains(parameter.Name))
{
throw EntityUtil.Argument(System.Data.Entity.Strings.ObjectParameterCollection_DuplicateParameterName(parameter.Name), "parameter");
}
if (!parameter.ValidateParameterType(this._perspective))
{
throw EntityUtil.ArgumentOutOfRange(System.Data.Entity.Strings.ObjectParameter_InvalidParameterType(parameter.ParameterType.FullName), "parameter");
}
this._parameters.Add(parameter);
this._cacheKey = null;
}
/// <summary>
/// Creates a record for an extent containing default values. Assumes the extent is either
/// a relationship set or an entity set.
/// </summary>
/// <remarks>
/// Each scalar value appearing in the record is a <see cref="DbConstantExpression" />. A placeholder is created by recursively
/// building a record, so an entity record type will return a new record (<see cref="DbNewInstanceExpression" />)
/// consisting of some recursively built record for each column in the type.
/// </remarks>
/// <param name="extent">Extent</param>
/// <param name="parent">Command tree used to generate portions of the record</param>
/// <returns>A default record for the </returns>
internal static PropagatorResult CreatePlaceholder(EntitySetBase extent, UpdateTranslator parent)
{
EntityUtil.CheckArgumentNull(extent, "extent");
ExtentPlaceholderCreator creator = new ExtentPlaceholderCreator(parent);
AssociationSet associationSet = extent as AssociationSet;
if (null != associationSet)
{
return(creator.CreateAssociationSetPlaceholder(associationSet));
}
EntitySet entitySet = extent as EntitySet;
if (null != entitySet)
{
return(creator.CreateEntitySetPlaceholder(entitySet));
}
throw EntityUtil.NotSupported(System.Data.Entity.Strings.Update_UnsupportedExtentType(
extent.Name, extent.GetType().Name));
}
/// <summary>
/// Constructs a new DbFunctionCommandTree that uses the specified metadata workspace, data space and function metadata
/// </summary>
/// <param name="metadata">The metadata workspace that the command tree should use.</param>
/// <param name="dataSpace">The logical 'space' that metadata in the expressions used in this command tree must belong to.</param>
/// <param name="edmFunction"></param>
/// <param name="resultType"></param>
/// <param name="parameters"></param>
/// <exception cref="ArgumentNullException"><paramref name="metadata"/>, <paramref name="dataSpace"/> or <paramref name="edmFunction"/> is null</exception>
/// <exception cref="ArgumentException"><paramref name="dataSpace"/> does not represent a valid data space or
/// <paramref name="edmFunction">is a composable function</paramref></exception>
/*CQT_PUBLIC_API(*/ internal /*)*/ DbFunctionCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, EdmFunction edmFunction, TypeUsage resultType, IEnumerable <KeyValuePair <string, TypeUsage> > parameters)
: base(metadata, dataSpace)
{
EntityUtil.CheckArgumentNull(edmFunction, "edmFunction");
_edmFunction = edmFunction;
_resultType = resultType;
List <string> paramNames = new List <string>();
List <TypeUsage> paramTypes = new List <TypeUsage>();
if (parameters != null)
{
foreach (KeyValuePair <string, TypeUsage> paramInfo in parameters)
{
paramNames.Add(paramInfo.Key);
paramTypes.Add(paramInfo.Value);
}
}
_parameterNames = paramNames.AsReadOnly();
_parameterTypes = paramTypes.AsReadOnly();
}
public override bool TryResolveType(Type dataContractType, Type declaredType, DataContractResolver knownTypeResolver, out System.Xml.XmlDictionaryString typeName, out System.Xml.XmlDictionaryString typeNamespace)
{
EntityUtil.CheckArgumentNull(dataContractType, "dataContractType");
EntityUtil.CheckArgumentNull(declaredType, "declaredType");
EntityUtil.CheckArgumentNull(knownTypeResolver, "knownTypeResolver");
Type nonProxyType = ObjectContext.GetObjectType(dataContractType);
if (nonProxyType != dataContractType)
{
// Type was a proxy type, so map the name to the non-proxy name
XmlQualifiedName qualifiedName = _exporter.GetSchemaTypeName(nonProxyType);
XmlDictionary dictionary = new XmlDictionary(2);
typeName = new XmlDictionaryString(dictionary, qualifiedName.Name, 0);
typeNamespace = new XmlDictionaryString(dictionary, qualifiedName.Namespace, 1);
return(true);
}
else
{
// Type was not a proxy type, so do the default
return(knownTypeResolver.TryResolveType(dataContractType, declaredType, null, out typeName, out typeNamespace));
}
}
/// <summary>
/// Determines whether the argument being evaluated has a given type (declared in the IsOfOnly predicate).
/// </summary>
/// <param name="predicate">IsOfOnly predicate.</param>
/// <returns>True if the row being evaluated is of the requested type; false otherwise.</returns>
public override PropagatorResult Visit(DbIsOfExpression predicate)
{
EntityUtil.CheckArgumentNull(predicate, "predicate");
if (DbExpressionKind.IsOfOnly != predicate.ExpressionKind)
{
throw ConstructNotSupportedException(predicate);
}
PropagatorResult childResult = Visit(predicate.Argument);
bool result;
if (childResult.IsNull)
{
// Null value expressions are typed, but the semantics of null are slightly different.
result = false;
}
else
{
result = childResult.StructuralType.EdmEquals(predicate.OfType.EdmType);
}
return(ConvertBoolToResult(result, childResult));
}
public override object GetValue(object item)
{
EntityUtil.CheckArgumentNull(item, "item");
if (!_itemType.IsAssignableFrom(item.GetType()))
{
throw EntityUtil.IncompatibleArgument();
}
object propertyValue;
DbDataRecord dbDataRecord = item as DbDataRecord;
if (dbDataRecord != null)
{
propertyValue = (dbDataRecord.GetValue(dbDataRecord.GetOrdinal(_property.Name)));
}
else
{
propertyValue = LightweightCodeGenerator.GetValue(_property, item);
}
return(propertyValue);
}
/// <summary>
/// Removes a parameter from the builder
/// </summary>
/// <param name="keyword">The keyword specifying the name of the parameter to remove</param>
/// <returns>True if the parameter is removed</returns>
public override bool Remove(string keyword)
{
EntityUtil.CheckArgumentNull(keyword, "keyword");
// Convert the given object into a string
if (string.Compare(keyword, MetadataParameterName, StringComparison.OrdinalIgnoreCase) == 0)
{
this._metadataLocations = null;
}
else if (string.Compare(keyword, ProviderConnectionStringParameterName, StringComparison.OrdinalIgnoreCase) == 0)
{
this._storeProviderConnectionString = null;
}
else if (string.Compare(keyword, NameParameterName, StringComparison.OrdinalIgnoreCase) == 0)
{
this._namedConnectionName = null;
}
else if (string.Compare(keyword, ProviderParameterName, StringComparison.OrdinalIgnoreCase) == 0)
{
this._providerName = null;
}
return(base.Remove(keyword));
}
[ResourceConsumption(ResourceScope.Machine)] //For MetadataArtifactLoader.CreateCompositeFromFilePaths method call but we do not create the file paths in this method
public StoreItemCollection(params string[] filePaths)
: base(DataSpace.SSpace)
{
EntityUtil.CheckArgumentNull(filePaths, "filePaths");
IEnumerable <string> enumerableFilePaths = filePaths;
EntityUtil.CheckArgumentEmpty(ref enumerableFilePaths, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths");
// Wrap the file paths in instances of the MetadataArtifactLoader class, which provides
// an abstraction and a uniform interface over a diverse set of metadata artifacts.
//
MetadataArtifactLoader composite = null;
List <XmlReader> readers = null;
try
{
composite = MetadataArtifactLoader.CreateCompositeFromFilePaths(enumerableFilePaths, XmlConstants.SSpaceSchemaExtension);
readers = composite.CreateReaders(DataSpace.SSpace);
IEnumerable <XmlReader> ieReaders = readers.AsEnumerable();
EntityUtil.CheckArgumentEmpty(ref ieReaders, Strings.StoreItemCollectionMustHaveOneArtifact, "filePaths");
this.Init(readers,
composite.GetPaths(DataSpace.SSpace), true,
out _providerManifest,
out _providerFactory,
out _providerManifestToken,
out _cachedCTypeFunction);
}
finally
{
if (readers != null)
{
Helper.DisposeXmlReaders(readers);
}
}
}
private IList <EdmSchemaError> Init(IEnumerable <XmlReader> xmlReaders,
IEnumerable <string> filePaths, bool throwOnError,
out DbProviderManifest providerManifest,
out DbProviderFactory providerFactory,
out string providerManifestToken,
out Memoizer <EdmFunction, EdmFunction> cachedCTypeFunction)
{
EntityUtil.CheckArgumentNull(xmlReaders, "xmlReaders");
// 'filePaths' can be null
cachedCTypeFunction = new Memoizer <EdmFunction, EdmFunction>(ConvertFunctionSignatureToCType, null);
Loader loader = new Loader(xmlReaders, filePaths, throwOnError);
providerFactory = loader.ProviderFactory;
providerManifest = loader.ProviderManifest;
providerManifestToken = loader.ProviderManifestToken;
// load the items into the colleciton
if (!loader.HasNonWarningErrors)
{
LoadProviderManifest(loader.ProviderManifest, true /* check for system namespace */);
List <EdmSchemaError> errorList = EdmItemCollection.LoadItems(_providerManifest, loader.Schemas, this);
foreach (var error in errorList)
{
loader.Errors.Add(error);
}
if (throwOnError && errorList.Count != 0)
{
loader.ThrowOnNonWarningErrors();
}
}
return(loader.Errors);
}
internal ExtractorMetadata(EntitySetBase entitySetBase, StructuralType type, UpdateTranslator translator)
{
EntityUtil.CheckArgumentNull(entitySetBase, "entitySetBase");
m_type = EntityUtil.CheckArgumentNull(type, "type");
m_translator = EntityUtil.CheckArgumentNull(translator, "translator");
EntityType entityType = null;
Set <EdmMember> keyMembers;
Set <EdmMember> foreignKeyMembers;
switch (type.BuiltInTypeKind)
{
case BuiltInTypeKind.RowType:
// for row types (which are actually association end key records in disguise), all members
// are keys
keyMembers = new Set <EdmMember>(((RowType)type).Properties).MakeReadOnly();
foreignKeyMembers = Set <EdmMember> .Empty;
break;
case BuiltInTypeKind.EntityType:
entityType = (EntityType)type;
keyMembers = new Set <EdmMember>(entityType.KeyMembers).MakeReadOnly();
foreignKeyMembers = new Set <EdmMember>(((EntitySet)entitySetBase).ForeignKeyDependents
.SelectMany(fk => fk.Item2.ToProperties)).MakeReadOnly();
break;
default:
keyMembers = Set <EdmMember> .Empty;
foreignKeyMembers = Set <EdmMember> .Empty;
break;
}
IBaseList <EdmMember> members = TypeHelpers.GetAllStructuralMembers(type);
m_memberMap = new MemberInformation[members.Count];
// for each member, cache expensive to compute metadata information
for (int ordinal = 0; ordinal < members.Count; ordinal++)
{
EdmMember member = members[ordinal];
// figure out flags for this member
PropagatorFlags flags = PropagatorFlags.NoFlags;
int? entityKeyOrdinal = default(int?);
if (keyMembers.Contains(member))
{
flags |= PropagatorFlags.Key;
if (null != entityType)
{
entityKeyOrdinal = entityType.KeyMembers.IndexOf(member);
}
}
if (foreignKeyMembers.Contains(member))
{
flags |= PropagatorFlags.ForeignKey;
}
if (MetadataHelper.GetConcurrencyMode(member) == ConcurrencyMode.Fixed)
{
flags |= PropagatorFlags.ConcurrencyValue;
}
// figure out whether this member is mapped to any server generated
// columns in the store
bool isServerGenerated = m_translator.ViewLoader.IsServerGen(entitySetBase, m_translator.MetadataWorkspace, member);
// figure out whether member nullability is used as a condition in mapping
bool isNullConditionMember = m_translator.ViewLoader.IsNullConditionMember(entitySetBase, m_translator.MetadataWorkspace, member);
// add information about this member
m_memberMap[ordinal] = new MemberInformation(ordinal, entityKeyOrdinal, flags, member, isServerGenerated, isNullConditionMember);
}
}
private DbExpression Process(DbExpression expression)
{
EntityUtil.CheckArgumentNull(expression, "expression");
expression = this.VisitExpression(expression);
return(expression);
}
internal static Func <DbExpression, DbExpression> Create(params PatternMatchRule[] rules)
{
EntityUtil.CheckArgumentNull(rules, "rules");
return(new PatternMatchRuleProcessor(new System.Collections.ObjectModel.ReadOnlyCollection <PatternMatchRule>(rules)).Process);
}
// effects: Adds a key constraint to this
internal void Add(TKeyConstraint constraint)
{
EntityUtil.CheckArgumentNull(constraint, "constraint");
m_keyConstraints.Add(constraint);
}
internal void AddEntry(Record record)
{
EntityUtil.CheckArgumentNull(record, "record");
m_log.Add(record);
}
/// <summary>
/// Add an entity to be tracked by the validator. Requires that the input describes an entity.
/// </summary>
/// <param name="stateEntry">State entry for the entity being tracked.</param>
internal void RegisterEntity(IEntityStateEntry stateEntry)
{
EntityUtil.CheckArgumentNull(stateEntry, "stateEntry");
if (EntityState.Added == stateEntry.State || EntityState.Deleted == stateEntry.State)
{
// We only track added and deleted entities because modifications to entities do not affect
// cardinality constraints. Relationships are based on end keys, and it is not
// possible to modify key values.
Debug.Assert(null != (object)stateEntry.EntityKey, "entity state entry must have an entity key");
EntityKey entityKey = EntityUtil.CheckArgumentNull(stateEntry.EntityKey, "stateEntry.EntityKey");
EntitySet entitySet = (EntitySet)stateEntry.EntitySet;
EntityType entityType = EntityState.Added == stateEntry.State ?
GetEntityType(stateEntry.CurrentValues) :
GetEntityType(stateEntry.OriginalValues);
// figure out relationship set ends that are associated with this entity set
foreach (AssociationSet associationSet in GetReferencingAssocationSets(entitySet))
{
// describe unidirectional relationships in which the added entity is the "destination"
var ends = associationSet.AssociationSetEnds;
foreach (var fromEnd in ends)
{
foreach (var toEnd in ends)
{
// end to itself does not describe an interesting relationship subpart
if (object.ReferenceEquals(toEnd.CorrespondingAssociationEndMember,
fromEnd.CorrespondingAssociationEndMember))
{
continue;
}
// skip ends that don't target the current entity set
if (!toEnd.EntitySet.EdmEquals(entitySet))
{
continue;
}
// skip ends that aren't required
if (0 == MetadataHelper.GetLowerBoundOfMultiplicity(
fromEnd.CorrespondingAssociationEndMember.RelationshipMultiplicity))
{
continue;
}
// skip ends that don't target the current entity type
if (!MetadataHelper.GetEntityTypeForEnd(toEnd.CorrespondingAssociationEndMember)
.IsAssignableFrom(entityType))
{
continue;
}
// register the relationship so that we know it's required
DirectionalRelationship relationship = new DirectionalRelationship(entityKey, fromEnd.CorrespondingAssociationEndMember,
toEnd.CorrespondingAssociationEndMember, associationSet, stateEntry);
m_impliedRelationships.Add(relationship, stateEntry);
}
}
}
}
}
public int GetHashCode(ProjectedSlot key)
{
EntityUtil.CheckArgumentNull(key, "key");
return(key.GetHash());
}
/// <summary>
/// Removes an entity from the EntityCollection. If the owner is
/// attached to a context, Remove marks the relationship for deletion and if
/// the relationship is composition also marks the entity for deletion.
/// </summary>
/// <param name="entity">
/// Entity instance to remove from the EntityCollection
/// </param>
/// <returns>Returns true if the entity was successfully removed, false if the entity was not part of the RelatedEnd.</returns>
public bool Remove(TEntity entity)
{
EntityUtil.CheckArgumentNull(entity, "entity");
DeferredLoad();
return(RemoveInternal(entity));
}
/// <summary>
///
/// </summary>
public void Add(TEntity entity)
{
EntityUtil.CheckArgumentNull(entity, "entity");
Add(EntityWrapperFactory.WrapEntityUsingContext(entity, ObjectContext));
}
internal static IBindingList CreateViewForQuery <TElement>(TypeUsage elementEdmTypeUsage, IEnumerable <TElement> queryResults, ObjectContext objectContext, bool forceReadOnly, EntitySet singleEntitySet)
{
EntityUtil.CheckArgumentNull(queryResults, "queryResults");
EntityUtil.CheckArgumentNull(objectContext, "objectContext");
Type clrElementType = null;
TypeUsage ospaceElementTypeUsage = GetOSpaceTypeUsage(elementEdmTypeUsage, objectContext);
// Map the O-Space EDM type to a CLR type.
// If the mapping is unsuccessful, fallback to TElement type.
if (ospaceElementTypeUsage == null)
{
clrElementType = typeof(TElement);
}
{
clrElementType = GetClrType <TElement>(ospaceElementTypeUsage.EdmType);
}
IBindingList objectView;
object eventDataSource = objectContext.ObjectStateManager;
// If the clrElementType matches the declared TElement type, optimize the construction of the ObjectView
// by avoiding a reflection-based instantiation.
if (clrElementType == typeof(TElement))
{
ObjectViewQueryResultData <TElement> viewData = new ObjectViewQueryResultData <TElement>((IEnumerable)queryResults, objectContext, forceReadOnly, singleEntitySet);
objectView = new ObjectView <TElement>(viewData, eventDataSource);
}
else if (clrElementType == null)
{
ObjectViewQueryResultData <DbDataRecord> viewData = new ObjectViewQueryResultData <DbDataRecord>((IEnumerable)queryResults, objectContext, true, null);
objectView = new DataRecordObjectView(viewData, eventDataSource, (RowType)ospaceElementTypeUsage.EdmType, typeof(TElement));
}
else
{
if (!typeof(TElement).IsAssignableFrom(clrElementType))
{
throw EntityUtil.ValueInvalidCast(clrElementType, typeof(TElement));
}
// Use reflection to create an instance of the generic ObjectView and ObjectViewQueryResultData classes,
// using clrElementType as the value of TElement generic type parameter for both classes.
Type objectViewDataType = genericObjectViewQueryResultDataType.MakeGenericType(clrElementType);
ConstructorInfo viewDataConstructor = objectViewDataType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic,
null,
new Type[] { typeof(IEnumerable), typeof(ObjectContext), typeof(bool), typeof(EntitySet) },
null);
Debug.Assert(viewDataConstructor != null, "ObjectViewQueryResultData constructor not found. Please ensure constructor signature is correct.");
// Create ObjectViewQueryResultData instance
object viewData = viewDataConstructor.Invoke(new object[] { queryResults, objectContext, forceReadOnly, singleEntitySet });
// Create ObjectView instance
objectView = CreateObjectView(clrElementType, objectViewDataType, viewData, eventDataSource);
}
return(objectView);
}
public CompensatingCollection(IEnumerable <TElement> source)
{
_source = EntityUtil.CheckArgumentNull(source, "source");
_expression = Expression.Constant(source);
}
/// <summary>
/// Attaches an entity to the EntityReference. The given
/// entity is not assumed to be the complete set of related entities.
///
/// Owner and all entities passed in must be in Unchanged or Modified state.
/// Deleted elements are allowed only when the state manager is already tracking the relationship
/// instance.
/// </summary>
/// <param name="entity">The entity to attach to the EntityCollection</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="entity"/> is null.</exception>
/// <exception cref="InvalidOperationException">Thrown when the entity cannot be related via the current relationship end.</exception>
public void Attach(TEntity entity)
{
CheckOwnerNull();
EntityUtil.CheckArgumentNull(entity, "entity");
Attach(new IEntityWrapper[] { EntityWrapperFactory.WrapEntityUsingContext(entity, ObjectContext) }, false);
}
internal ForeignKeyValueComparer(IEqualityComparer<CompositeKey> baseComparer)
{
_baseComparer = EntityUtil.CheckArgumentNull(baseComparer, "baseComparer");
}