public override void ElementDeleted(ElementDeletedEventArgs e) { DataContractBaseCanBeContainedOnContracts link = e.ModelElement as DataContractBaseCanBeContainedOnContracts; Debug.Assert(link != null, "link != null"); DataContractBase sourceDataContractBase = link.DataContractBase; Contract targetContractElement = link.Contract; if (targetContractElement is DataContract) { DataContract dataContractElement = targetContractElement as DataContract; RemoveDataElement( dataContractElement.Store, dataContractElement.DataMembers, GetDataElement(dataContractElement.DataMembers, link.Id)); } else if (targetContractElement is FaultContract) { FaultContract faultContractElement = targetContractElement as FaultContract; RemoveDataElement( faultContractElement.Store, faultContractElement.DataMembers, GetDataElement(faultContractElement.DataMembers, link.Id)); } base.ElementDeleted(e); }
public override void ElementAdded(ElementAddedEventArgs e) { FaultContract faultContract = e.ModelElement as FaultContract; DataContractModel root = faultContract.DataContractModel; if (root != null && root.ImplementationTechnology != null) { ExtensionProviderHelper.AttachObjectExtender(faultContract, root.ImplementationTechnology); } }
public void TestInitialize() { serviceProvider = new MockMappingServiceProvider(); attributes = new NameValueCollection(); attributes.Add("elementNameProperty", "Name"); #region Data Contract dcStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(DataContractDslDomainModel)); dcDomainModel = dcStore.GetDomainModel<DataContractDslDomainModel>(); dcTransaction = dcStore.TransactionManager.BeginTransaction(); dcModel = (DataContractModel)dcDomainModel.CreateElement(new Partition(dcStore), typeof(DataContractModel), null); dcModel.ProjectMappingTable = projectMappingTableName; fc = dcStore.ElementFactory.CreateElement(FaultContract.DomainClassId) as FaultContract; fc.Name = faultContractName; dcModel.Contracts.Add(fc); #endregion #region Service Contract scStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel)); scDomainModel = scStore.GetDomainModel<ServiceContractDslDomainModel>(); scTransaction = scStore.TransactionManager.BeginTransaction(); scModel = (ServiceContractModel)scDomainModel.CreateElement(new Partition(scStore), typeof(ServiceContractModel), null); scModel.ProjectMappingTable = projectMappingTableName; operation = scStore.ElementFactory.CreateElement(Operation.DomainClassId) as Operation; operation.Name = operationName; //Create the moniker //mel://[DSLNAMESPACE]\[MODELELEMENTTYPE]\[MODELELEMENT.GUID]@[PROJECT]\[MODELFILE] string requestMoniker = string.Format(@"mel://{0}\{1}\{2}@{3}\{4}", fc.GetType().Namespace, fc.GetType().Name, fc.Id.ToString(), dataContractModelProjectName, dataContractModelFileName); dcfault = scStore.ElementFactory.CreateElement(DataContractFault.DomainClassId) as DataContractFault; dcfault.Name = dcfaultName; dcfault.Type = new MockModelBusReference(fc); operation.Faults.Add(dcfault); scModel.Operations.Add(operation); #endregion }
protected ModelElement ResolveFaultElement(string instanceNamespace) { using (Transaction transaction = DataContractStore.TransactionManager.BeginTransaction()) { FaultContract fc = new FaultContract(DataContractStore); fc.DataContractModel = new DataContractModel(DataContractStore); fc.DataContractModel.ProjectMappingTable = "WCF"; fc.Name = instanceNamespace; WCFFaultContract extender = new WCFFaultContract(); fc.ObjectExtender = extender; extender.ModelElement = fc; transaction.Commit(); return fc; } }
public static DslModeling::LinkedElementCollection<DataMember> GetDataMembers(FaultContract element) { return GetRoleCollection<DslModeling::LinkedElementCollection<DataMember>, DataMember>(element, FaultContractDomainRoleId); }
public static void SetFaultContract(DataMember element, FaultContract newFaultContract) { DslModeling::DomainRoleInfo.SetLinkedElement(element, DataMemberDomainRoleId, newFaultContract); }
/// <summary> /// Constructor /// Creates a FaultContractHasDataMembers link in the same Partition as the given FaultContract /// </summary> /// <param name="source">FaultContract to use as the source of the relationship.</param> /// <param name="target">DataMember to use as the target of the relationship.</param> public FaultContractHasDataMembers(FaultContract source, DataMember target) : base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(FaultContractHasDataMembers.FaultContractDomainRoleId, source), new DslModeling::RoleAssignment(FaultContractHasDataMembers.DataMemberDomainRoleId, target)}, null) { }
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, FaultContract element, global::System.Xml.XmlWriter writer) { // FaultContractHasDataMembers global::System.Collections.ObjectModel.ReadOnlyCollection<FaultContractHasDataMembers> allFaultContractHasDataMembersInstances = FaultContractHasDataMembers.GetLinksToDataMembers(element); if (!serializationContext.Result.Failed && allFaultContractHasDataMembersInstances.Count > 0) { writer.WriteStartElement("dataMembers"); global::System.Type typeofFaultContractHasDataMembers = typeof(FaultContractHasDataMembers); foreach (FaultContractHasDataMembers eachFaultContractHasDataMembersInstance in allFaultContractHasDataMembersInstances) { if (serializationContext.Result.Failed) break; if (eachFaultContractHasDataMembersInstance.GetType() != typeofFaultContractHasDataMembers) { // Derived relationships will be serialized in full-form. DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachFaultContractHasDataMembersInstance.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachFaultContractHasDataMembersInstance.GetDomainClass().Name + "!"); derivedRelSerializer.Write(serializationContext, eachFaultContractHasDataMembersInstance, writer); } else { // No need to serialize the relationship itself, just serialize the role-player directly. DslModeling::ModelElement targetElement = eachFaultContractHasDataMembersInstance.DataMember; DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!"); targetSerializer.Write(serializationContext, targetElement, writer); } } writer.WriteEndElement(); } }
/// <summary> /// Reads all instances of relationship FaultContractHasDataMembers. /// </summary> /// <remarks> /// The caller will position the reader at the open tag of the first XML element inside the relationship tag, so it can be /// either the first instance, or a bogus tag. This method will deserialize all instances and ignore all bogus tags. When the /// method returns, the reader will be positioned at the end tag of the relationship (or EOF if somehow that happens). /// </remarks> /// <param name="serializationContext">Serialization context.</param> /// <param name="element">In-memory FaultContract instance that will get the deserialized data.</param> /// <param name="reader">XmlReader to read serialized data from.</param> private static void ReadFaultContractHasDataMembersInstances(DslModeling::SerializationContext serializationContext, FaultContract element, global::System.Xml.XmlReader reader) { while (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element) { DslModeling::DomainClassXmlSerializer newDataMemberOfFaultContractHasDataMembersSerializer = serializationContext.Directory.GetSerializer(DataMember.DomainClassId); global::System.Diagnostics.Debug.Assert(newDataMemberOfFaultContractHasDataMembersSerializer != null, "Cannot find serializer for DataMember!"); DataMember newDataMemberOfFaultContractHasDataMembers = newDataMemberOfFaultContractHasDataMembersSerializer.TryCreateInstance(serializationContext, reader, element.Partition) as DataMember; if (newDataMemberOfFaultContractHasDataMembers != null) { element.DataMembers.Add(newDataMemberOfFaultContractHasDataMembers); DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newDataMemberOfFaultContractHasDataMembers.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newDataMemberOfFaultContractHasDataMembers.GetDomainClass().Name + "!"); targetSerializer.Read(serializationContext, newDataMemberOfFaultContractHasDataMembers, reader); } else { global::System.Type typeofFaultContractHasDataMembers = typeof(FaultContractHasDataMembers); DslModeling::DomainRelationshipXmlSerializer newFaultContractHasDataMembersSerializer = serializationContext.Directory.GetSerializer(FaultContractHasDataMembers.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer; global::System.Diagnostics.Debug.Assert(newFaultContractHasDataMembersSerializer != null, "Cannot find serializer for FaultContractHasDataMembers!"); FaultContractHasDataMembers newFaultContractHasDataMembers = newFaultContractHasDataMembersSerializer.TryCreateInstance (serializationContext, reader, element.Partition) as FaultContractHasDataMembers; if (newFaultContractHasDataMembers != null) { if (newFaultContractHasDataMembers.GetType() == typeofFaultContractHasDataMembers) { // The relationship should be serialized in short-form. DataContractDslSerializationBehaviorSerializationMessages.ExpectingShortFormRelationship(serializationContext, reader, typeof(FaultContractHasDataMembers)); } DslModeling::DomainRoleInfo.SetRolePlayer (newFaultContractHasDataMembers, FaultContractHasDataMembers.FaultContractDomainRoleId, element); DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newFaultContractHasDataMembers.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newFaultContractHasDataMembers.GetDomainClass().Name + "!"); targetSerializer.Read(serializationContext, newFaultContractHasDataMembers, reader); } else { // Unknown element, skip DslModeling::SerializationUtilities.Skip(reader); } } } }
/// <summary> /// This method deserializes all child model elements. /// </summary> /// <remarks> /// The caller will position the reader at the open tag of the first child XML element to deserialized. /// This method will read as many child elements as it can. It returns under three circumstances: /// 1) When an unknown child XML element is encountered. In this case, this method will position the reader at the /// open tag of the unknown element. This implies that if the first child XML element is unknown, this method /// should return immediately and do nothing. /// 2) When all child XML elemnets are read. In this case, the reader will be positioned at the end tag of the parent element. /// 3) EOF. /// </remarks> /// <param name="serializationContext">Serialization context.</param> /// <param name="reader">XmlReader to read serialized data from.</param> /// <param name="element">In-memory FaultContract instance that will get the deserialized data.</param> private static void ReadChildElements(DslModeling::SerializationContext serializationContext, FaultContract element, global::System.Xml.XmlReader reader) { if (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element) { if (string.Compare(reader.LocalName, "dataMembers", global::System.StringComparison.CurrentCulture) == 0) { if (reader.IsEmptyElement) { // No instance of this relationship, just skip DslModeling::SerializationUtilities.Skip(reader); } else { DslModeling::SerializationUtilities.SkipToFirstChild(reader); // Skip the open tag of <dataMembers> ReadFaultContractHasDataMembersInstances(serializationContext, element, reader); DslModeling::SerializationUtilities.Skip(reader); // Skip the close tag of </dataMembers> } } } }