private static XDocument CreateModel(Version targetSchemaVersion) { const string edmxTemplate = @"<!-- edmx --> <edmx:Edmx Version=""{0}"" xmlns:edmx=""{1}""> <edmx:Runtime> <edmx:StorageModels> <Schema xmlns=""{2}"" /> </edmx:StorageModels> <edmx:ConceptualModels> <Schema xmlns=""{3}"" /> </edmx:ConceptualModels> <!-- C-S mapping content --> <edmx:Mappings> <Mapping xmlns=""{4}"" /> </edmx:Mappings> </edmx:Runtime> </edmx:Edmx>"; return (XDocument.Parse( string.Format( edmxTemplate, targetSchemaVersion.ToString(2), SchemaManager.GetEDMXNamespaceName(targetSchemaVersion), SchemaManager.GetCSDLNamespaceName(targetSchemaVersion), SchemaManager.GetSSDLNamespaceName(targetSchemaVersion), SchemaManager.GetMSLNamespaceName(targetSchemaVersion)))); }
private static XmlDocument CreateSourceEdmx(Version schemaVersion) { const string template = "<Edmx xmlns=\"{0}\">" + " <Runtime>" + " <StorageModels>" + " <Schema xmlns=\"{1}\" />" + " </StorageModels>" + " <ConceptualModels>" + " <Schema xmlns=\"{2}\" />" + " </ConceptualModels>" + " <Mappings>" + " <Mapping xmlns=\"{3}\" />" + " </Mappings>" + " </Runtime>" + " <Designer/>" + "</Edmx>"; var edmx = new XmlDocument(); edmx.LoadXml( string.Format( template, SchemaManager.GetEDMXNamespaceName(schemaVersion), SchemaManager.GetSSDLNamespaceName(schemaVersion), SchemaManager.GetCSDLNamespaceName(schemaVersion), SchemaManager.GetMSLNamespaceName(schemaVersion))); return(edmx); }
private static LegacyMetadata.EdmItemCollection GetLegacyEdmItemCollection(Version version) { const string csdlTemplate = @"<Schema xmlns=""{0}"" Namespace=""dummy"">" + @" <EntityContainer Name=""DummyContainer""/>" + @"</Schema>"; LegacyMetadata.EdmItemCollection itemCollection; if (!LegacyEdmItemCollections.TryGetValue(version, out itemCollection)) { var csdl = string.Format(CultureInfo.InvariantCulture, csdlTemplate, SchemaManager.GetCSDLNamespaceName(version)); using (var stringReader = new StringReader(csdl)) { using (var reader = XmlReader.Create(stringReader)) { itemCollection = new LegacyMetadata.EdmItemCollection(new[] { reader }); LegacyEdmItemCollections[version] = itemCollection; } } } return(itemCollection); }
/// <summary> /// this will always return the preceding sibling that appears before the first sibling with a different namespace. /// </summary> /// <param name="parent"></param> /// <returns></returns> private static XElement GetLastSiblingOfMyNamespace(EFElement parent) { string expectedNamespace; if (ModelHelper.GetBaseModelRoot(parent).IsCSDL) { expectedNamespace = SchemaManager.GetCSDLNamespaceName(parent.Artifact.SchemaVersion); } else { expectedNamespace = SchemaManager.GetSSDLNamespaceName(parent.Artifact.SchemaVersion); } var c = parent.XContainer; XElement predecesor = null; foreach (var e in c.Elements()) { if (e.Name.NamespaceName.Equals(expectedNamespace, StringComparison.OrdinalIgnoreCase)) { predecesor = e; } else { break; } } return(predecesor); }
internal virtual void DetermineIfArtifactIsVersionSafe() { // make sure that the XML namespace of the EDMX, Csdl, ssdl & msl nodes match the expected XML namespaces for the schema version _isVersionSafe = GetRootNamespace() == SchemaManager.GetEDMXNamespaceName(SchemaVersion) && CompareNamespaces(ConceptualModel, SchemaManager.GetCSDLNamespaceName(SchemaVersion)) && CompareNamespaces(StorageModel, SchemaManager.GetSSDLNamespaceName(SchemaVersion)) && CompareNamespaces(MappingModel, SchemaManager.GetMSLNamespaceName(SchemaVersion)); }
private static EntityDesignArtifact SetupArtifact( Version edmxVersion, Version storeModelVersion, Version conceptualModelVersion, Version mappingModelVersion) { var modelManager = new Mock <ModelManager>(null, null).Object; var modelProvider = new Mock <XmlModelProvider>().Object; var mockEntityDesignArtifact = new Mock <EntityDesignArtifact>(modelManager, new Uri("urn:dummy"), modelProvider) { CallBase = true }; var mockConceptualModel = new Mock <ConceptualEntityModel>( mockEntityDesignArtifact.Object, new XElement(XName.Get("Schema", SchemaManager.GetCSDLNamespaceName(conceptualModelVersion)))); mockConceptualModel .Setup(m => m.XNamespace) .Returns(SchemaManager.GetCSDLNamespaceName(conceptualModelVersion)); mockEntityDesignArtifact .Setup(m => m.ConceptualModel) .Returns(mockConceptualModel.Object); var mockStoreModel = new Mock <StorageEntityModel>( mockEntityDesignArtifact.Object, new XElement(XName.Get("Schema", SchemaManager.GetSSDLNamespaceName(storeModelVersion)))); mockStoreModel .Setup(m => m.XNamespace) .Returns(SchemaManager.GetSSDLNamespaceName(storeModelVersion)); mockEntityDesignArtifact .Setup(m => m.StorageModel) .Returns(mockStoreModel.Object); var mockMappingModel = new Mock <MappingModel>( mockEntityDesignArtifact.Object, new XElement(XName.Get("Mapping", SchemaManager.GetMSLNamespaceName(mappingModelVersion)))); mockMappingModel .Setup(m => m.XNamespace) .Returns(SchemaManager.GetMSLNamespaceName(mappingModelVersion)); mockEntityDesignArtifact .Setup(m => m.MappingModel) .Returns(mockMappingModel.Object); mockEntityDesignArtifact .Setup(a => a.XDocument) .Returns( new XDocument( new XElement(XName.Get("Edmx", SchemaManager.GetEDMXNamespaceName(edmxVersion))))); return(mockEntityDesignArtifact.Object); }
protected override void DoParse(ICollection <XName> unprocessedElements) { // Ensure to parse all enum types before ConceptualProperty/ComplexConceptualProperty are parsed. // This is done so that we have enough information to decide which property to create. var csdlNamespaceName = SchemaManager.GetCSDLNamespaceName(Artifact.SchemaVersion); foreach (var element in XElement.Elements(XName.Get(EnumType.ElementName, csdlNamespaceName))) { var enumType = new EnumType(this, element); _enumTypes.Add(enumType); enumType.Parse(unprocessedElements); } base.DoParse(unprocessedElements); }
internal NamespaceConverterHandler(Version sourceSchemaVersion, Version targetSchemaVersion) { var template = String.Format( CultureInfo.InvariantCulture, XsltTemplate, SchemaManager.GetEDMXNamespaceName(sourceSchemaVersion), SchemaManager.GetEDMXNamespaceName(targetSchemaVersion), SchemaManager.GetCSDLNamespaceName(sourceSchemaVersion), SchemaManager.GetCSDLNamespaceName(targetSchemaVersion), SchemaManager.GetSSDLNamespaceName(sourceSchemaVersion), SchemaManager.GetSSDLNamespaceName(targetSchemaVersion), SchemaManager.GetMSLNamespaceName(sourceSchemaVersion), SchemaManager.GetMSLNamespaceName(targetSchemaVersion)); _xsltTransform = new XslCompiledTransform(); using (var reader = XmlReader.Create(new StringReader(template))) { _xsltTransform.Load(reader); } }
public void UpdateConceptualModel_updates_csdl() { var edmx = XDocument.Parse(EdmxTemplate); new EdmxHelper(edmx) .UpdateConceptualModels(new EdmModel(DataSpace.CSpace), "modelNamespace"); var conceptualModelsElements = edmx.Descendants(EdmxV3Namespace + "ConceptualModels").Single(); Assert.Equal(1, conceptualModelsElements.Elements().Count()); Assert.Equal( XName.Get("Schema", SchemaManager.GetCSDLNamespaceName(EntityFrameworkVersion.Version3)), conceptualModelsElements.Elements().Single().Name); Assert.Equal("modelNamespace", (string)conceptualModelsElements.Elements().Single().Attribute("Namespace")); }
public void DetermineIfArtifactIsVersionSafe_sets_IsVersionSafe_to_false_if_versions_dont_match() { var mockDte = new MockDTE( ".NETFramework, Version=v4.5.1", Constants.vsMiscFilesProjectUniqueName); var modelManager = new Mock <ModelManager>(null, null).Object; var modelProvider = new Mock <XmlModelProvider>().Object; var mockVsArtifact = new Mock <VSArtifact>(modelManager, new Uri("urn:dummy"), modelProvider) { CallBase = true }; mockVsArtifact.Protected().Setup <IServiceProvider>("ServiceProvider").Returns(mockDte.ServiceProvider); mockVsArtifact.Protected().Setup <Project>("GetProject").Returns(mockDte.Project); mockVsArtifact.Setup(a => a.XDocument).Returns( new XDocument( new XElement( XName.Get( "Edmx", SchemaManager.GetEDMXNamespaceName(EntityFrameworkVersion.Version3))))); var mockConceptualModel = new Mock <ConceptualEntityModel>( mockVsArtifact.Object, new XElement(XName.Get("Schema", SchemaManager.GetCSDLNamespaceName(EntityFrameworkVersion.Version2)))); mockConceptualModel .Setup(m => m.XNamespace) .Returns(SchemaManager.GetCSDLNamespaceName(EntityFrameworkVersion.Version2)); mockVsArtifact .Setup(m => m.ConceptualModel) .Returns(mockConceptualModel.Object); var artifact = mockVsArtifact.Object; artifact.DetermineIfArtifactIsVersionSafe(); Assert.False(artifact.IsVersionSafe); }
private static EntityType CreateEntityType <T>() where T : EntityType { XNamespace ns = typeof(T) == typeof(ConceptualEntityType) ? SchemaManager.GetCSDLNamespaceName(EntityFrameworkVersion.Version3) : SchemaManager.GetSSDLNamespaceName(EntityFrameworkVersion.Version3); var mockModelProvider = new Mock <XmlModelProvider>(); var mockModelManager = new Mock <ModelManager>(new Mock <IEFArtifactFactory>().Object, new Mock <IEFArtifactSetFactory>().Object); mockModelManager.Setup(m => m.GetRootNamespace(It.IsAny <EFObject>())).Returns(ns); var mockValidator = new Mock <AttributeContentValidator>(null); mockModelManager.Setup(m => m.GetAttributeContentValidator(It.IsAny <EFArtifact>())) .Returns(mockValidator.Object); var mockArtifact = new Mock <EntityDesignArtifact>(mockModelManager.Object, new Uri("http://tempuri"), mockModelProvider.Object); var mockArtifactSet = new Mock <EFArtifactSet>(mockArtifact.Object) { CallBase = true }; mockArtifact.Setup(m => m.SchemaVersion).Returns(EntityFrameworkVersion.Version3); mockArtifact.Setup(m => m.ArtifactSet).Returns(mockArtifactSet.Object); mockModelManager.Setup(m => m.GetArtifactSet(It.IsAny <Uri>())).Returns(mockArtifactSet.Object); var mockEntity = new Mock <T>(null, new XElement(ns + "EntityType")) { CallBase = true }; mockEntity.Setup(e => e.Parent).Returns(mockArtifact.Object); mockEntity.Setup(e => e.Artifact).Returns(mockArtifact.Object); return(mockEntity.Object); }
public void ToLegacyMetadataWorkspace_creates_equivalent_legacy_MetadataWorkspace_for_all_versions() { const string ssdlTemplate = @"<Schema Namespace=""NorthwindEF5Model.Store"" Provider=""System.Data.SqlClient"" ProviderManifestToken=""2008"" Alias=""Self"" xmlns=""{0}"" xmlns:store=""http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator"">" + @" <EntityType Name=""Customers"">" + @" <Key>" + @" <PropertyRef Name=""CustomerID"" />" + @" </Key>" + @" <Property Name=""CustomerID"" Type=""nchar"" MaxLength=""5"" Nullable=""false"" />" + @" <Property Name=""CompanyName"" Type=""nvarchar"" MaxLength=""40"" Nullable=""false"" />" + @" </EntityType>" + @" <EntityContainer Name=""Container"" />" + @"</Schema>"; const string csdlTemplate = @"<Schema xmlns=""{0}"" Namespace=""dummy"">" + @" <EntityContainer Name=""DummyContainer""/>" + @"</Schema>"; const string mslTemplate = @"<Mapping Space=""C-S"" xmlns=""{0}"">" + @" <EntityContainerMapping StorageEntityContainer=""Container"" CdmEntityContainer=""DummyContainer"" />" + @"</Mapping>"; foreach (var version in EntityFrameworkVersion.GetAllVersions()) { var storeItemCollection = Utils.CreateStoreItemCollection( string.Format( ssdlTemplate, SchemaManager.GetSSDLNamespaceName(version))); var edmItemCollection = new EdmItemCollection( new[] { XmlReader.Create( new StringReader( string.Format( csdlTemplate, SchemaManager.GetCSDLNamespaceName(version)))) }); var mappingItemCollection = new StorageMappingItemCollection( edmItemCollection, storeItemCollection, new[] { XmlReader.Create( new StringReader( string.Format( mslTemplate, SchemaManager.GetMSLNamespaceName(version)))) }); var workspace = new MetadataWorkspace( () => edmItemCollection, () => storeItemCollection, () => mappingItemCollection); var legacyWorkspace = workspace.ToLegacyMetadataWorkspace(); Assert.NotNull(legacyWorkspace); var legacyStoreItemCollection = legacyWorkspace.GetItemCollection(LegacyMetadata.DataSpace.SSpace); Assert.Equal( storeItemCollection.GetItems <GlobalItem>().Count, legacyStoreItemCollection.GetItems <LegacyMetadata.GlobalItem>().Count); Assert.NotNull( legacyStoreItemCollection.GetItem <LegacyMetadata.EntityType>("NorthwindEF5Model.Store.Customers")); var legacyEdmItemCollection = (LegacyMetadata.EdmItemCollection)legacyWorkspace.GetItemCollection(LegacyMetadata.DataSpace.CSpace); Assert.NotNull(legacyEdmItemCollection); Assert.Equal(version, EntityFrameworkVersion.DoubleToVersion(legacyEdmItemCollection.EdmVersion)); Assert.NotNull(legacyWorkspace.GetItemCollection(LegacyMetadata.DataSpace.CSSpace)); } }
public static void AddSchemaSpecificReplacements(IDictionary <string, string> replacementsDictionary, Version schemaVersion) { Debug.Assert(replacementsDictionary != null, "replacementsDictionary is null."); Debug.Assert(schemaVersion != null, "schemaVersion is null."); Debug.Assert(!replacementsDictionary.ContainsKey("$edmxversion$"), "replacementsDictionary contains key '$edmxversion$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$edmxnamespacename$"), "replacementsDictionary contains key '$edmxnamespacename$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$ssdlnamespacename$"), "replacementsDictionary contains key '$ssdlnamespacename$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$csdlnamespacename$"), "replacementsDictionary contains key '$csdlnamespacename$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$msdlnamespacename$"), "replacementsDictionary contains key '$msdlnamespacename$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$essgnamespacename$"), "replacementsDictionary contains key '$essgnamespacename$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$cgnamespacename$"), "replacementsDictionary contains key '$cgnamespacename$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$annotationnamespace$"), "replacementsDictionary contains key '$annotationnamespace$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$lazyloadingattribute$"), "replacementsDictionary contains key '$lazyloadingattribute$'"); Debug.Assert( !replacementsDictionary.ContainsKey("$useStrongSpatialTypesAttribute$"), "replacementsDictionary contains key '$useStrongSpatialTypesAttribute$'"); // Set the namespace names (EDMX, CodeGen, ESSG, CSDL, MSDL, and SSDL) replacementsDictionary.Add("$edmxversion$", schemaVersion.ToString(2)); // only print Major.Minor version information replacementsDictionary.Add("$edmxnamespacename$", SchemaManager.GetEDMXNamespaceName(schemaVersion)); replacementsDictionary.Add("$ssdlnamespacename$", SchemaManager.GetSSDLNamespaceName(schemaVersion)); replacementsDictionary.Add("$csdlnamespacename$", SchemaManager.GetCSDLNamespaceName(schemaVersion)); replacementsDictionary.Add("$msdlnamespacename$", SchemaManager.GetMSLNamespaceName(schemaVersion)); replacementsDictionary.Add( "$essgnamespacename$", SchemaManager.GetEntityStoreSchemaGeneratorNamespaceName()); replacementsDictionary.Add( "$cgnamespacename$", SchemaManager.GetCodeGenerationNamespaceName()); if (EdmFeatureManager.GetLazyLoadingFeatureState(schemaVersion).IsEnabled() || EdmFeatureManager.GetUseStrongSpatialTypesFeatureState(schemaVersion).IsEnabled()) { replacementsDictionary.Add( "$annotationnamespace$", string.Format( CultureInfo.InvariantCulture, "xmlns:annotation=\"{0}\"", SchemaManager.GetAnnotationNamespaceName())); } else { replacementsDictionary.Add("$annotationnamespace$", string.Empty); } if (EdmFeatureManager.GetLazyLoadingFeatureState(schemaVersion).IsEnabled()) { replacementsDictionary.Add("$lazyloadingattribute$", "annotation:LazyLoadingEnabled=\"true\""); } else { replacementsDictionary.Add("$lazyloadingattribute$", string.Empty); } // set UseStrongSpatialTypes to false as runtime will throw exception if true (as of V3 - to be updated in later version of runtime) if (EdmFeatureManager.GetUseStrongSpatialTypesFeatureState(schemaVersion).IsEnabled()) { replacementsDictionary.Add( "$useStrongSpatialTypesAttribute$", "annotation:UseStrongSpatialTypes=\"false\""); } else { replacementsDictionary.Add("$useStrongSpatialTypesAttribute$", string.Empty); } }
protected override void InvokeInternal(CommandProcessorContext cpc) { Debug.Assert( PrincipalEnd != null && DependentEnd != null, "InvokeInternal is called when PrincipalEnd or DependentEnd is null."); if (PrincipalEnd == null || DependentEnd == null) { throw new InvalidOperationException("InvokeInternal is called when PrincipalEnd or DependentEnd is null."); } var association = PrincipalEnd.Parent as Association; Debug.Assert( association != null && association == DependentEnd.Parent, "Association parent for both ends must agree and be not null"); var principalProps = PrincipalProperties.ToList(); var dependentProps = DependentProperties.ToList(); Debug.Assert(principalProps.Count == dependentProps.Count, "Number of principal and dependent properties must agree"); Debug.Assert(principalProps.Count > 0, "Number of properties must be positive"); var referentialConstraint = new ReferentialConstraint(association, null); association.ReferentialConstraint = referentialConstraint; XmlModelHelper.NormalizeAndResolve(referentialConstraint); var principalRole = new ReferentialConstraintRole(referentialConstraint, null); var dependentRole = new ReferentialConstraintRole(referentialConstraint, null); var service = cpc.EditingContext.GetEFArtifactService(); // we can't pass the type of referential constraint role ("Principal" or "Dependent") // in the constructor because XElement gets created in base constructor // before we have a chance to set any properties if (association.EntityModel.IsCSDL) { var csdlNamespaceName = SchemaManager.GetCSDLNamespaceName(service.Artifact.SchemaVersion); principalRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNamePrincipal, csdlNamespaceName); dependentRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNameDependent, csdlNamespaceName); } else { var ssdlNamespaceName = SchemaManager.GetSSDLNamespaceName(service.Artifact.SchemaVersion); principalRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNamePrincipal, ssdlNamespaceName); dependentRole.XElement.Name = XName.Get(ReferentialConstraint.ElementNameDependent, ssdlNamespaceName); } principalRole.Role.SetRefName(PrincipalEnd); dependentRole.Role.SetRefName(DependentEnd); referentialConstraint.Principal = principalRole; referentialConstraint.Dependent = dependentRole; XmlModelHelper.NormalizeAndResolve(principalRole); XmlModelHelper.NormalizeAndResolve(dependentRole); for (var i = 0; i < principalProps.Count; i++) { principalRole.AddPropertyRef(principalProps[i]); dependentRole.AddPropertyRef(dependentProps[i]); } Debug.Assert( principalProps.Count == 0 || (principalRole.PropertyRefs.First().Name.Target != null && dependentRole.PropertyRefs.First().Name.Target != null), "Unresolved property references"); _createdRefConstraint = referentialConstraint; }
/// <summary> /// Move Property's XElement before the specified position. /// If position parameter is null, the property XElement will be moved to the last position. /// </summary> internal void MoveTo(InsertPropertyPosition position) { Debug.Assert( PreviousSiblingInPropertyXElementOrder != null || NextSiblingInPropertyXElementOrder != null, "Why do we need to move the property if it is the only property?"); Debug.Assert(position != null, "InsertPropertyPosition parameter is null."); if (position != null) { // Check if the InsertPropertyPosition's InsertAt is not null. Debug.Assert(position.InsertAtProperty != null, "Why InsertPropertyPosition's InsertAt is null?"); if (position.InsertAtProperty != null) { // Instead of re-parenting the property's XElement, we are going to clone the XElement, insert the clone and delete the old XElement. // This is a workaround for an XML editor bug where re-parenting an element causes asserts. // First create the new XElement. var tempDoc = XDocument.Parse(XElement.ToString(SaveOptions.None), LoadOptions.None); var newPropertyXElement = tempDoc.Root; newPropertyXElement.Remove(); // Remove known namespaces from the element since the namespaces are already set in the parent node. // This is workaround because XDocument automatically appends the default namespace in the property XElement. foreach (var a in newPropertyXElement.Attributes()) { if (a.IsNamespaceDeclaration && (a.Value == SchemaManager.GetCSDLNamespaceName(Artifact.SchemaVersion) || a.Value == SchemaManager.GetSSDLNamespaceName(Artifact.SchemaVersion) || a.Value == SchemaManager.GetAnnotationNamespaceName())) { a.Remove(); } } var toBeDeleteElement = XElement; // format the XML we just parsed so that the XElement will have the same indenting. Utils.FormatXML(newPropertyXElement, GetIndentLevel()); // Call method that will insert the XElement to the specified location. InsertPosition = position; AddXElementToParent(newPropertyXElement); // Re-establish the links between EFElement and XElement. SetXObject(newPropertyXElement); Debug.Assert( XElement == newPropertyXElement, "Unexpected XElement value. Expected:" + newPropertyXElement + " , Actual:" + XElement); ModelItemAnnotation.SetModelItem(newPropertyXElement, this); Debug.Assert( ModelItemAnnotation.GetModelItem(newPropertyXElement) == this, "The new XElement should contain annotation to the model property."); // Delete both old XElement and the preceding whitespace. // Preceding whitespace is preferred over trailing whitespace because we don't want to remove the last property's trailing white-space since // it has different indent level than the rest (see EFElement's EnsureFirstNodeWhitespaceSeparation method). var preceedingNewLine = toBeDeleteElement.PreviousNode as XText; while (preceedingNewLine != null && String.IsNullOrWhiteSpace(preceedingNewLine.Value)) { var toBeDeletedWhiteSpace = preceedingNewLine; preceedingNewLine = preceedingNewLine.PreviousNode as XText; toBeDeletedWhiteSpace.Remove(); } toBeDeleteElement.Remove(); #if DEBUG // Assert if the property is not moved to the correct location. if (position.InsertBefore) { Debug.Assert( position.InsertAtProperty == NextSiblingInPropertyXElementOrder, "Expected next sibling property: " + position.InsertAtProperty.DisplayName + " , Actual next sibling:" + NextSiblingInPropertyXElementOrder.DisplayName); } else { Debug.Assert( position.InsertAtProperty == PreviousSiblingInPropertyXElementOrder, "Expected previous sibling property: " + position.InsertAtProperty.DisplayName + " , Actual previous sibling:" + PreviousSiblingInPropertyXElementOrder.DisplayName); } #endif } } }