예제 #1
0
        /// <summary>
        /// глубокое сравнение контентов с учетом циклов
        /// </summary>
        /// <param name="other"></param>
        /// <param name="visitedContents">родительские контенты, Key текущего, Value - other</param>
        /// <returns></returns>
        internal bool RecursiveEquals(Content other, ReferenceDictionary <Content, Content> visitedContents)
        {
            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            if (visitedContents.ContainsKey(this))
            {
                return(ReferenceEquals(visitedContents[this], other));
            }

            visitedContents.Add(this, other);

            return(ContentId == other.ContentId &&
                   IsReadOnly == other.IsReadOnly &&
                   LoadAllPlainFields == other.LoadAllPlainFields &&
                   PublishingMode == other.PublishingMode &&
                   Fields.Count == other.Fields.Count &&
                   Fields.All(x => other.Fields
                              .Any(y => y.FieldId == x.FieldId && x.RecursiveEquals(y, visitedContents))));
        }
예제 #2
0
        public override bool TryThisParseXml(XmlElement elem)
        {
            if (!base.TryThisParseXml(elem))
            {
                return(false);
            }

            if (!elem.HasChildNodes)
            {
                return(true);
            }

            var tempIdList = new List <XrefIdentifier>();

            foreach (var cnode in elem.ChildNodes)
            {
                var cElem = cnode as XmlElement;
                if (cElem == null)
                {
                    continue;
                }

                if (string.Equals(cElem.Name, X_REF, StringComparison.OrdinalIgnoreCase))
                {
                    if (!cElem.HasChildNodes)
                    {
                        throw new RahRowRagee($"The '{X_REF}' node must have at least one child " +
                                              "element to be a valid cross reference");
                    }

                    foreach (var xRefIdNode in cElem.ChildNodes)
                    {
                        var xRefIdElem = xRefIdNode as XmlElement;

                        var idValue = xRefIdElem?.InnerText;
                        if (string.IsNullOrWhiteSpace(idValue))
                        {
                            continue;
                        }

                        var dataFileXrefNode = _dataFile.SelectSingleNode($"//{_nodeName}[@ID='{idValue}']");

                        var dataFileXrefElem = dataFileXrefNode as XmlElement;

                        var xmlDocId = new XmlDocXrefIdentifier(_nodeName);
                        if (xmlDocId.TryThisParseXml(dataFileXrefElem))
                        {
                            tempIdList.Add(xmlDocId);
                        }
                    }

                    continue;
                }

                var nameAttr  = cElem.Attributes[NAME];
                var valueAttr = cElem.Attributes[VALUE];

                if (nameAttr == null || valueAttr == null)
                {
                    continue;
                }
                if (string.IsNullOrWhiteSpace(nameAttr.Value) || string.IsNullOrWhiteSpace(valueAttr.Value))
                {
                    continue;
                }

                ReferenceDictionary.Add(nameAttr.Value, valueAttr.Value);
            }

            XrefIds = new XmlDocIdentifier[tempIdList.Count];
            Array.Copy(tempIdList.ToArray(), XrefIds, XrefIds.Length);

            return(XrefIds.Length > 0);
        }