public void Can_get_and_set_ends_via_wrapper_properties() { var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace) { SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)), TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace)) }; var associationSet = new AssociationSet("A", associationType); Assert.Null(associationSet.SourceSet); Assert.Null(associationSet.TargetSet); var sourceEntitySet = new EntitySet(); associationSet.SourceSet = sourceEntitySet; var targetEntitySet = new EntitySet(); associationSet.TargetSet = targetEntitySet; Assert.Same(sourceEntitySet, associationSet.SourceSet); Assert.Same(targetEntitySet, associationSet.TargetSet); }
/// <summary> /// Initialize Metadata for an AssociationSet /// </summary> internal AssociationSetMetadata(Set<EntitySet> affectedTables, AssociationSet associationSet, MetadataWorkspace workspace) { // If there is only 1 table, there can be no ambiguity about the "destination" of a relationship, so such // sets are not typically required. var isRequired = 1 < affectedTables.Count; // determine the ends of the relationship var ends = associationSet.AssociationSetEnds; // find collocated entities foreach (var table in affectedTables) { // Find extents influencing the table var influencingExtents = MetadataHelper.GetInfluencingEntitySetsForTable(table, workspace); foreach (var influencingExtent in influencingExtents) { foreach (var end in ends) { // If the extent is an end of the relationship and we haven't already added it to the // required set... if (end.EntitySet.EdmEquals(influencingExtent)) { if (isRequired) { AddEnd(ref RequiredEnds, end.CorrespondingAssociationEndMember); } else if (null == RequiredEnds || !RequiredEnds.Contains(end.CorrespondingAssociationEndMember)) { AddEnd(ref OptionalEnds, end.CorrespondingAssociationEndMember); } } } } } // fix Required and Optional sets FixSet(ref RequiredEnds); FixSet(ref OptionalEnds); // for associations with referential constraints, the principal end is always interesting // since its key values may take precedence over the key values of the dependent end foreach (var constraint in associationSet.ElementType.ReferentialConstraints) { // FromRole is the principal end in the referential constraint var principalEnd = (AssociationEndMember)constraint.FromRole; if (!RequiredEnds.Contains(principalEnd) && !OptionalEnds.Contains(principalEnd)) { AddEnd(ref IncludedValueEnds, principalEnd); } } FixSet(ref IncludedValueEnds); }
protected virtual void Visit(AssociationSet associationSet) { Visit(associationSet.ElementType); Visit(associationSet.EntityContainer); foreach (var end in associationSet.AssociationSetEnds) { Visit(end); } }
public void Can_get_association_set() { var entitySet = new EntitySet(); var associationSet = new AssociationSet("AS", new AssociationType()); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet); Assert.Same(associationSet, associationSetMapping.AssociationSet); }
public void Can_get_association_set() { var entitySet = new EntitySet(); var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet); Assert.Same(associationSet, associationSetMapping.AssociationSet); }
public void Can_get_table() { var entityType = new EntityType("E", "N", DataSpace.CSpace); var entitySet = new EntitySet("ES", null, null, null, entityType); var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet); Assert.Same(entityType, associationSetMapping.Table); }
public void Can_get_table() { var entityType = new EntityType(); var entitySet = new EntitySet("ES", null, null, null, entityType); var associationSet = new AssociationSet("AS", new AssociationType()); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet); Assert.Same(entityType, associationSetMapping.Table); }
internal StorageAssociationSetModificationFunctionMapping( AssociationSet associationSet, StorageModificationFunctionMapping deleteFunctionMapping, StorageModificationFunctionMapping insertFunctionMapping) { Contract.Requires(associationSet != null); AssociationSet = associationSet; DeleteFunctionMapping = deleteFunctionMapping; InsertFunctionMapping = insertFunctionMapping; }
public void Cannot_create_with_null_argument() { var associationType = new AssociationType("AT", "N", false, DataSpace.CSpace); var associationSet = new AssociationSet("AS", associationType); Assert.Equal( "members", Assert.Throws<ArgumentNullException>( () => new ModificationFunctionMemberPath( null, associationSet)).ParamName); }
/// <summary> /// Initalizes a new AssociationSetModificationFunctionMapping instance. /// </summary> /// <param name="associationSet">An association set.</param> /// <param name="deleteFunctionMapping">A delete function mapping.</param> /// <param name="insertFunctionMapping">An insert function mapping.</param> public AssociationSetModificationFunctionMapping( AssociationSet associationSet, ModificationFunctionMapping deleteFunctionMapping, ModificationFunctionMapping insertFunctionMapping) { Check.NotNull(associationSet, "associationSet"); _associationSet = associationSet; _deleteFunctionMapping = deleteFunctionMapping; _insertFunctionMapping = insertFunctionMapping; }
internal StorageAssociationSetModificationFunctionMapping( AssociationSet associationSet, StorageModificationFunctionMapping deleteFunctionMapping, StorageModificationFunctionMapping insertFunctionMapping) { DebugCheck.NotNull(associationSet); AssociationSet = associationSet; DeleteFunctionMapping = deleteFunctionMapping; InsertFunctionMapping = insertFunctionMapping; }
/// <summary> /// Initializes a new AssociationSetMapping instance. /// </summary> /// <param name="associationSet">The association set to be mapped.</param> /// <param name="storeEntitySet">The store entity set to be mapped.</param> /// <param name="containerMapping">The parent container mapping.</param> public AssociationSetMapping(AssociationSet associationSet, EntitySet storeEntitySet, EntityContainerMapping containerMapping) : base(containerMapping) { Check.NotNull(associationSet, "associationSet"); Check.NotNull(storeEntitySet, "storeEntitySet"); _associationSet = associationSet; _associationTypeMapping = new AssociationTypeMapping(associationSet.ElementType, this); _associationTypeMapping.MappingFragment = new MappingFragment(storeEntitySet, _associationTypeMapping, false); }
// <summary> // A name derived from a *:* association will be: FK_[Association Name]_[End Name]. Note that we are // getting the association name for *one* of the SSDL associations that are inferred from a CSDL *:* // association. The 'principalEnd' corresponds to the end of the *:* association that will become // the principal end in the 1:* association (where the * end is the newly-constructed entity corresponding // to the link table) // </summary> internal static string GetStorageAssociationSetNameFromManyToMany(AssociationSet associationSet, AssociationEndMember principalEnd) { Debug.Assert(associationSet != null, "AssociationSet should not be null"); Debug.Assert(principalEnd != null, "The principal end cannot be null"); var associationSetName = String.Empty; if (associationSet != null && principalEnd != null) { associationSetName = String.Format( CultureInfo.CurrentCulture, Resources.CodeViewManyToManyAssocName, associationSet.Name, principalEnd.Name); } return associationSetName; }
internal StorageModificationFunctionMemberPath(IEnumerable<EdmMember> members, AssociationSet associationSetNavigation) { Contract.Requires(members != null); Members = new ReadOnlyCollection<EdmMember>(new List<EdmMember>(members)); if (null != associationSetNavigation) { Debug.Assert(2 == Members.Count, "Association bindings must always consist of the end and the key"); // find the association set end AssociationSetEnd = associationSetNavigation.AssociationSetEnds[Members[1].Name]; } }
public void Can_remove_set_from_container() { var entityContainer = new EntityContainer("C", DataSpace.CSpace); var associationSet = new AssociationSet("A", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)); entityContainer.AddEntitySetBase(associationSet); Assert.Equal(1, entityContainer.AssociationSets.Count); entityContainer.RemoveEntitySetBase(associationSet); Assert.Empty(entityContainer.AssociationSets); Assert.Null(associationSet.EntityContainer); }
public override void VisitEdmAssociationSet(AssociationSet item) { _schemaWriter.WriteAssociationSetElementHeader(item); base.VisitEdmAssociationSet(item); if (item.SourceSet != null) { _schemaWriter.WriteAssociationSetEndElement(item.SourceSet, item.ElementType.SourceEnd.Name); } if (item.TargetSet != null) { _schemaWriter.WriteAssociationSetEndElement(item.TargetSet, item.ElementType.TargetEnd.Name); } _schemaWriter.WriteEndElement(); }
/// <summary> /// Initializes a new ModificationFunctionMemberPath instance. /// </summary> /// <param name="members">Gets the members in the path from the leaf (the member being bound) /// to the root of the structure.</param> /// <param name="associationSet">Gets the association set to which we are navigating /// via this member. If the value is null, this is not a navigation member path.</param> public ModificationFunctionMemberPath(IEnumerable<EdmMember> members, AssociationSet associationSet) { Check.NotNull(members, "members"); _members = new ReadOnlyCollection<EdmMember>(new List<EdmMember>(members)); if (null != associationSet) { Debug.Assert(2 == Members.Count, "Association bindings must always consist of the end and the key"); // find the association set end _associationSetEnd = associationSet.AssociationSetEnds[Members[1].Name]; } }
public void Create_should_return_only_fk_associations() { var filter = new ViewgenContext.OneToOneFkAssociationsForEntitiesFilter(); var associationType1 = new AssociationType("A1", EdmConstants.TransientNamespace, true, DataSpace.CSpace); var entityType = new EntityType("E", "N", DataSpace.CSpace); associationType1.AddMember( new AssociationEndMember("S", entityType) { RelationshipMultiplicity = RelationshipMultiplicity.One }); associationType1.AddMember( new AssociationEndMember("T", entityType) { RelationshipMultiplicity = RelationshipMultiplicity.One }); associationType1.SetReadOnly(); var associationSet1 = new AssociationSet("AS1", associationType1); var associationType2 = new AssociationType("A2", EdmConstants.TransientNamespace, false, DataSpace.CSpace); associationType2.AddMember( new AssociationEndMember("S", entityType) { RelationshipMultiplicity = RelationshipMultiplicity.One }); associationType2.AddMember( new AssociationEndMember("T", entityType) { RelationshipMultiplicity = RelationshipMultiplicity.One }); associationType2.SetReadOnly(); var associationSet2 = new AssociationSet("AS2", associationType2); var query = filter.Filter( new[] { entityType }, new[] { associationSet1, associationSet2 }); Assert.Same(associationSet1, query.Single()); }
internal StorageAssociationSetMapping(AssociationSet extent, EntitySet entitySet) : base(extent, null) { DebugCheck.NotNull(entitySet); var associationTypeMapping = new StorageAssociationTypeMapping(extent.ElementType, this); var mappingFragment = new StorageMappingFragment(entitySet, associationTypeMapping, false); associationTypeMapping.AddFragment(mappingFragment); AddTypeMapping(associationTypeMapping); }
private void AppendDropForeignKeys(AssociationSet associationSet) { var constraint = associationSet.ElementType.ReferentialConstraints.Single(); var principalEnd = associationSet.AssociationSetEnds[constraint.FromRole.Name]; var dependentEnd = associationSet.AssociationSetEnds[constraint.ToRole.Name]; AppendObjectExistenceCheck(QuoteIdentifier(GetSchemaName(dependentEnd.EntitySet)) + "." + QuoteIdentifier(associationSet.Name), "F"); AppendNewLine(); AppendSql("alter table "); AppendTableName(dependentEnd.EntitySet); AppendSql(" drop constraint "); AppendIdentifier(associationSet.Name); AppendSql(";"); AppendNewLine(); }
public void Can_get_and_set_store_entity_set() { var entitySet1 = new EntitySet(); var associationSet = new AssociationSet("AS", new AssociationType()); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet1); Assert.Same(entitySet1, associationSetMapping.StoreEntitySet); var entitySet2 = new EntitySet(); associationSetMapping.StoreEntitySet = entitySet2; Assert.Same(entitySet2, associationSetMapping.StoreEntitySet); }
public void Can_get_and_set_store_entity_set() { var entitySet1 = new EntitySet(); var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet1); Assert.Same(entitySet1, associationSetMapping.StoreEntitySet); var entitySet2 = new EntitySet(); associationSetMapping.StoreEntitySet = entitySet2; Assert.Same(entitySet2, associationSetMapping.StoreEntitySet); }
public ForeignKeyBuilder(EdmModel database, string name) { Check.NotNull(database, "database"); _database = database; _associationType = new AssociationType( name, EdmModelExtensions.DefaultStoreNamespace, true, DataSpace.SSpace); _associationSet = new AssociationSet(_associationType.Name, _associationType); }
internal WithRelationship( AssociationSet associationSet, AssociationEndMember fromEnd, EntityType fromEndEntityType, AssociationEndMember toEnd, EntityType toEndEntityType, IEnumerable<MemberPath> toEndEntityKeyMemberPaths) { m_associationSet = associationSet; m_fromEnd = fromEnd; m_fromEndEntityType = fromEndEntityType; m_toEnd = toEnd; m_toEndEntityType = toEndEntityType; m_toEndEntitySet = MetadataHelper.GetEntitySetAtEnd(associationSet, toEnd); m_toEndEntityKeyMemberPaths = toEndEntityKeyMemberPaths; }
public void SetReadOnly_is_called_on_child_mapping_items() { var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); var associationSet = new AssociationSet("AS", associationType); var associationSetMapping = new AssociationSetMapping( associationSet, new EntityContainerMapping(new EntityContainer("C", DataSpace.CSpace))); var associationTypeMapping = new AssociationTypeMapping(associationSetMapping); var fragment = new MappingFragment(new EntitySet(), associationTypeMapping, false); associationTypeMapping.MappingFragment = fragment; Assert.False(fragment.IsReadOnly); associationTypeMapping.SetReadOnly(); Assert.True(fragment.IsReadOnly); }
public void Can_initialize_with_entity_set() { var entitySet = new EntitySet(); var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)); var associationSetMapping = new AssociationSetMapping(associationSet, entitySet); var associationTypeMapping = associationSetMapping.TypeMappings.Single(); Assert.NotNull(associationTypeMapping); Assert.Same(associationSet.ElementType, associationTypeMapping.Types.Single()); Assert.Same(associationSetMapping, associationTypeMapping.SetMapping); var mappingFragment = associationTypeMapping.MappingFragments.Single(); Assert.Same(entitySet, mappingFragment.TableSet); }
public void Can_initialize_with_entity_set() { var entitySet = new EntitySet(); var associationSet = new AssociationSet("AS", new AssociationType()); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet); var associationTypeMapping = associationSetMapping.TypeMappings.Single(); Assert.NotNull(associationTypeMapping); Assert.Same(associationSet.ElementType, associationTypeMapping.Types.Single()); Assert.Same(associationSetMapping, associationTypeMapping.SetMapping); var mappingFragment = associationTypeMapping.MappingFragments.Single(); Assert.Same(entitySet, mappingFragment.TableSet); }
// effects: Creates a foreign key constraint of the form: // <i_childTable, i_childColumns> --> <i_parentTable, i_childColumns> // i_fkeySet is the name of the constraint internal ForeignConstraint( AssociationSet i_fkeySet, EntitySet i_parentTable, EntitySet i_childTable, ReadOnlyMetadataCollection<EdmProperty> i_parentColumns, ReadOnlyMetadataCollection<EdmProperty> i_childColumns) { m_fKeySet = i_fkeySet; m_parentTable = i_parentTable; m_childTable = i_childTable; m_childColumns = new List<MemberPath>(); // Create parent and child paths using the table names foreach (var property in i_childColumns) { var path = new MemberPath(m_childTable, property); m_childColumns.Add(path); } m_parentColumns = new List<MemberPath>(); foreach (var property in i_parentColumns) { var path = new MemberPath(m_parentTable, property); m_parentColumns.Add(path); } }
public void Can_get_association_ends_from_association_set() { var sourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); var targetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace)); var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); associationType.AddKeyMember(targetEnd); associationType.AddKeyMember(sourceEnd); var associationSet = new AssociationSet("A", associationType); Assert.Null(associationSet.SourceEnd); Assert.Null(associationSet.TargetEnd); associationSet.AddAssociationSetEnd(new AssociationSetEnd(new EntitySet(), associationSet, sourceEnd)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(new EntitySet(), associationSet, targetEnd)); Assert.Same(sourceEnd, associationSet.SourceEnd); Assert.Same(targetEnd, associationSet.TargetEnd); }
public void Can_get_and_set_source__and_target_end_mappings() { var entitySet1 = new EntitySet(); var associationSet = new AssociationSet("AS", new AssociationType()); var associationSetMapping = new StorageAssociationSetMapping(associationSet, entitySet1); Assert.Null(associationSetMapping.SourceEndMapping); Assert.Null(associationSetMapping.TargetEndMapping); var sourceEndMapping = new StorageEndPropertyMapping(new EdmProperty("P")); associationSetMapping.SourceEndMapping = sourceEndMapping; Assert.Same(sourceEndMapping, associationSetMapping.SourceEndMapping); var targetEndMapping = new StorageEndPropertyMapping(new EdmProperty("P")); associationSetMapping.TargetEndMapping = targetEndMapping; Assert.Same(targetEndMapping, associationSetMapping.TargetEndMapping); }
/// <summary> /// Creates a read-only AssociationSet instance from the specified parameters. /// </summary> /// <param name="name">The name of the association set.</param> /// <param name="type">The association type of the elements in the association set.</param> /// <param name="sourceSet">The entity set for the source association set end.</param> /// <param name="targetSet">The entity set for the target association set end.</param> /// <param name="metadataProperties">Metadata properties to be associated with the instance.</param> /// <returns>The newly created AssociationSet instance.</returns> /// <exception cref="T:System.ArgumentException">The specified name is null or empty.</exception> /// <exception cref="T:System.ArgumentNullException">The specified association type is null.</exception> /// <exception cref="T:System.ArgumentException"> /// The entity type of one of the ends of the specified /// association type does not match the entity type of the corresponding entity set end. /// </exception> public static AssociationSet Create( string name, AssociationType type, EntitySet sourceSet, EntitySet targetSet, IEnumerable <MetadataProperty> metadataProperties) { Check.NotEmpty(name, nameof(name)); Check.NotNull <AssociationType>(type, nameof(type)); if (!AssociationSet.CheckEntitySetAgainstEndMember(sourceSet, type.SourceEnd) || !AssociationSet.CheckEntitySetAgainstEndMember(targetSet, type.TargetEnd)) { throw new ArgumentException(Strings.AssociationSet_EndEntityTypeMismatch); } AssociationSet associationSet = new AssociationSet(name, type); if (sourceSet != null) { associationSet.SourceSet = sourceSet; } if (targetSet != null) { associationSet.TargetSet = targetSet; } if (metadataProperties != null) { associationSet.AddMetadataProperties(metadataProperties.ToList <MetadataProperty>()); } associationSet.SetReadOnly(); return(associationSet); }
public void Create_checks_each_EntitySet_parameter_against_corresponding_AssociationEndMember() { var source = new EntityType("Source", "Namespace", DataSpace.CSpace); var target = new EntityType("Target", "Namespace", DataSpace.CSpace); var other = new EntityType("Other", "Namespace", DataSpace.CSpace); var sourceSet = new EntitySet("SourceSet", "Schema", "Table", "Query", source); var targetSet = new EntitySet("TargetSet", "Schema", "Table", "Query", target); var otherSet = new EntitySet("OtherSet", "Schema", "Table", "Query", other); var sourceEnd = new AssociationEndMember("SourceEnd", source); var targetEnd = new AssociationEndMember("TargetEnd", target); var associationTypeWithNonNullEndMembers = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, sourceEnd, targetEnd, null, null); var associationTypeWithNullEndMembers = AssociationType.Create( "AssociationType", "Namespace", true, DataSpace.CSpace, null, // sourceEnd null, // targetEnd null, null); Assert.NotNull( AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, sourceSet, targetSet, null)); Assert.NotNull( AssociationSet.Create( "AssociationSet", associationTypeWithNullEndMembers, null, // sourceSet null, // targetSet null)); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, otherSet, targetSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, sourceSet, otherSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, null, // sourceSet targetSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNonNullEndMembers, sourceSet, null, // targetSet null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNullEndMembers, null, // sourceSet targetSet, null)).Message); Assert.Equal( Resources.Strings.AssociationSet_EndEntityTypeMismatch, Assert.Throws <ArgumentException>( () => AssociationSet.Create( "AssociationSet", associationTypeWithNullEndMembers, sourceSet, null, // targetSet null)).Message); }
public void WriteAssociationSetMapping_should_write_modification_function_mapping() { var fixture = new Fixture(); var entityType = new EntityType("E", "N", DataSpace.CSpace); var entitySet = new EntitySet("ES", "S", null, null, entityType); new EntityContainer("EC", DataSpace.SSpace).AddEntitySetBase(entitySet); var associationSet = new AssociationSet("AS", new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace)); var associationEndMember1 = new AssociationEndMember("Source", new EntityType("E", "N", DataSpace.CSpace)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember1)); var associationEndMember2 = new AssociationEndMember("Target", new EntityType("E", "N", DataSpace.CSpace)); associationSet.AddAssociationSetEnd(new AssociationSetEnd(entitySet, associationSet, associationEndMember2)); var storageModificationFunctionMapping = new ModificationFunctionMapping( associationSet, associationSet.ElementType, new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()), new[] { new ModificationFunctionParameterBinding( new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.In), new ModificationFunctionMemberPath( new EdmMember[] { new EdmProperty("K"), associationEndMember1 }, associationSet), true), new ModificationFunctionParameterBinding( new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.In), new ModificationFunctionMemberPath( new EdmMember[] { new EdmProperty("K"), associationEndMember2 }, associationSet), false) }, null, null); var associationSetMapping = new AssociationSetMapping( associationSet, entitySet) { SourceEndMapping = new EndPropertyMapping { AssociationEnd = associationEndMember1 }, TargetEndMapping = new EndPropertyMapping { AssociationEnd = associationEndMember2 }, ModificationFunctionMapping = new AssociationSetModificationFunctionMapping( associationSet, storageModificationFunctionMapping, storageModificationFunctionMapping) }; fixture.Writer.WriteAssociationSetMappingElement(associationSetMapping); Assert.Equal( @"<AssociationSetMapping Name=""AS"" TypeName="".A"" StoreEntitySet=""E""> <EndProperty Name=""Source"" /> <EndProperty Name=""Target"" /> <ModificationFunctionMapping> <InsertFunction FunctionName=""N.F""> <EndProperty Name=""Source""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Current"" /> </EndProperty> <EndProperty Name=""Target""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Original"" /> </EndProperty> </InsertFunction> <DeleteFunction FunctionName=""N.F""> <EndProperty Name=""Source""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Current"" /> </EndProperty> <EndProperty Name=""Target""> <ScalarProperty Name=""K"" ParameterName=""P"" Version=""Original"" /> </EndProperty> </DeleteFunction> </ModificationFunctionMapping> </AssociationSetMapping>", fixture.ToString()); }
// <summary> // Initializes a new instance of AssocationSetEnd // </summary> // <param name="entitySet"> Entity set that this end refers to </param> // <param name="parentSet"> The association set which this belongs to </param> // <param name="endMember"> The end member of the association set which this is an instance of </param> // <exception cref="System.ArgumentNullException">Thrown if either the role,entitySet, parentSet or endMember arguments are null</exception> internal AssociationSetEnd(EntitySet entitySet, AssociationSet parentSet, AssociationEndMember endMember) { _entitySet = Check.NotNull(entitySet, "entitySet"); _parentSet = Check.NotNull(parentSet, "parentSet"); _endMember = Check.NotNull(endMember, "endMember"); }