public static string GetLocatorPredicate(XElement element) { var locatorAttribute = element.Attributes(Namespaces.Xdt + "Locator").FirstOrDefault(); if (locatorAttribute == null) { return String.Empty; } else { var locator = Locator.Parse(locatorAttribute.Value); if (locator.Type == "Condition") { // use the user-defined value as an xpath predicate return "[" + locator.Arguments + "]"; } else if (locator.Type == "Match") { // convenience case of the Condition locator, build the xpath // predicate for the user by matching on all specified attributes var attributeNames = locator.Arguments.Split(',').Select(s => s.Trim()); var attributes = element.Attributes().Where(a => attributeNames.Contains(a.Name.LocalName)); return "[" + attributes.ToConcatenatedString(a => "@" + a.Name.LocalName + "='" + a.Value + "'", " and ") + "]"; } else { throw new NotImplementedException(String.Format("The Locator '{0}' is not supported", locator.Type)); } } }
public void ProcessElement(XElement element) { if (!IsEnabled) return; if (!element.HasAttributes) return; // Setter? Format "Value" attribute if "Property" atribute matches ThicknessAttributeNames if (element.Name == SetterName) { var propertyAttribute = element.Attributes("Property").FirstOrDefault(); if (propertyAttribute != null && ThicknessAttributeNames.Any(match => match.IsMatch(propertyAttribute.Value))) { var valueAttribute = element.Attributes("Value").FirstOrDefault(); if (valueAttribute != null) { FormatAttribute(valueAttribute); } } } // Not setter. Format value of all attributes where attribute name matches ThicknessAttributeNames else { foreach (var attribute in element.Attributes()) { var isMatchingAttribute = ThicknessAttributeNames.Any(match => match.IsMatch(attribute.Name)); if (isMatchingAttribute) { FormatAttribute(attribute); } } } }
MatchFactory GetRegexes(XElement element) { switch (element.Name.LocalName) { case "MatchHonorees": if (Presentation.MelaveMalka == null) return FixedRegexes(); return FixedRegexes(Presentation.MelaveMalka.Honorees.SelectMany(AdVerifier.GetNameRegexes)); case "MatchDonors": return ad => ad.Row.Pledges.SelectMany(p => AdVerifier.GetNameRegexes(p.Person)); case "Match": return FixedRegexes(new Regex(element.Attribute("Regex").Value)); case "MatchPerson": foreach (var field in element.Attributes()) if (!Person.Schema.Columns.Contains(field.Name.LocalName)) throw new ConfigurationException($"Unexpected attribute {field} in <MatchPerson>"); var fields = element.Attributes().ToDictionary( a => a.Name.LocalName, a => a.Value ); var people = Program.Table<Person>().Rows.Where(p => fields.All(f => f.Value.Equals(p[f.Key]))); if (people.Has(2)) throw new ConfigurationException($"Format rule {element} matches multiple people: {people.Join(", ", p => p.VeryFullName)}"); var person = people.FirstOrDefault(); if (person == null) throw new ConfigurationException($"Format rule {element} doesn't match anyone in the master directory."); return FixedRegexes(AdVerifier.GetNameRegexes(person)); case "Format": // Ignore this element. return FixedRegexes(); default: throw new ConfigurationException($"Unexpected <{element.Name}> element in <FormatRule>."); } }
private static bool BasicValueTypeAttributeCheckIsValid(XElement element, bool isCustomProperty, out string value) { Guard.AgainstNull(element, "element"); if (isCustomProperty) { if (element.Attributes().Count() != 2) { value = "Wrong number of attributes"; return false; } if (element.Attribute(SharedConstants.Name) == null) { value = "Custom property has no 'name' attribute"; return false; } } else { if (element.Attributes().Count() != 1) { value = "Wrong number of attributes"; return false; } } value = element.Attribute(SharedConstants.Val).Value; return true; }
public DslBuilder(XElement builderClassNode, XmlDocCommentReader commentReader, Type builderType) { input = builderClassNode.Value; syntaxStateClassname = builderClassNode.Attributes().Single(f => f.Name == "name").Value; outputNamespace = builderClassNode.Attributes().Single(f => f.Name == "namespace").Value; type = builderType; this.commentReader = commentReader; }
private static string ElementToLevelText(XElement el) { var blueText = el.Attributes().Any( a => a.Name == "Text") ? el.Attribute("Text").Value : string.Empty; var blueAmount = el.Attributes().Any(a => a.Name == "AMOUNT") ? el.Attribute("AMOUNT").Value : string.Empty; var blueType = el.Attributes().Any(a => a.Name == "TYPE") ? el.Attribute("TYPE").Value : string.Empty; return blueText +" : "+ blueAmount + " " + blueType; }
void SetMathVariant(XElement mathVariant) { string name = mathVariant.Attribute("name").Value; string weight = mathVariant.Attributes("weight").FirstOrDefault() != null ? mathVariant.Attribute("weight").Value : "normal"; string style = mathVariant.Attributes("style").FirstOrDefault() != null ? mathVariant.Attribute("style").Value : "normal"; MathVariant mv = new MathVariant(name, weight, style); mathVariant.Attribute("family").Value.Split(',').Select(x => x.Trim()).ToList().ForEach(x=> mv.AddFamily(x)); Variants.Add(name, mv); }
/// <summary> /// Updates an element from the datasource. /// </summary> /// <param name="table"></param> /// <param name="element"></param> public void UpdateElement(IList<XElement> table, XElement element) { XElement orderToUpdate = (from order in table where order.Attribute(element.Attributes().FirstOrDefault().Name).Value == element.Attributes().FirstOrDefault().Value select order).FirstOrDefault(); foreach (XElement el in orderToUpdate.Descendants()) { el.Value = element.Element(el.Name).Value; } }
/// <summary> /// Tests the Add methods on Container. /// </summary> /// <param name="context"></param> /// <returns></returns> //[Variation(Desc = "ContainerAdd")] public void ContainerAdd() { XElement element = new XElement("foo"); // Adding null does nothing. element.Add(null); Validate.Count(element.Nodes(), 0); // Add node, attrbute, string, some other value, and an IEnumerable. XComment comment = new XComment("this is a comment"); XComment comment2 = new XComment("this is a comment 2"); XComment comment3 = new XComment("this is a comment 3"); XAttribute attribute = new XAttribute("att", "att-value"); string str = "this is a string"; int other = 7; element.Add(comment); element.Add(attribute); element.Add(str); element.Add(other); element.Add(new XComment[] { comment2, comment3 }); Validate.EnumeratorDeepEquals( element.Nodes(), new XNode[] { comment, new XText(str + other), comment2, comment3 }); Validate.EnumeratorAttributes(element.Attributes(), new XAttribute[] { attribute }); element.RemoveAll(); Validate.Count(element.Nodes(), 0); // Now test params overload. element.Add(comment, attribute, str, other); Validate.EnumeratorDeepEquals( element.Nodes(), new XNode[] { comment, new XText(str + other) }); Validate.EnumeratorAttributes(element.Attributes(), new XAttribute[] { attribute }); // Not allowed to add a document as a child. XDocument document = new XDocument(); try { element.Add(document); Validate.ExpectedThrow(typeof(ArgumentException)); } catch (Exception ex) { Validate.Catch(ex, typeof(ArgumentException)); } }
public KevinBaconItem(XElement element) { _actorName = element.Attributes("name").First().Value + " (" + element.Elements("link").Count() + ")"; _description = element.Attributes("name").First().Value; var links = element.Elements("link").Select(linkElement => " to " + linkElement.Attributes("actor").First().Value + " in " + linkElement.Attributes("movie").First().Value); _description += "\r\n"; foreach (var link in links) { _description += "\r\n" + link; } _description += "\r\n"; }
private static dynamic CreateChildElement(XElement parent) { if (parent.Attributes().Count() == 0 && parent.Elements().Count() == 0) return null; IDictionary<string, object> child = new ExpandoObject(); parent.Attributes().ToList().ForEach(attr => { child.Add(attr.Name.LocalName, attr.Value); if (!child.ContainsKey("NodeName")) child.Add("NodeName", attr.Parent.Name.LocalName); }); parent.Elements().ToList().ForEach(childElement => { var grandChild = CreateChildElement(childElement); if (grandChild != null) { string nodeName = grandChild.NodeName; if (child.ContainsKey(nodeName) && child[nodeName].GetType() != typeof(List<dynamic>)) { var firstValue = child[nodeName]; child[nodeName] = new List<dynamic>(); ((dynamic)child[nodeName]).Add(firstValue); ((dynamic)child[nodeName]).Add(grandChild); } else if (child.ContainsKey(nodeName) && child[nodeName].GetType() == typeof(List<dynamic>)) { ((dynamic)child[nodeName]).Add(grandChild); } else { child.Add(childElement.Name.LocalName, CreateChildElement(childElement)); if (!child.ContainsKey("NodeName")) child.Add("NodeName", parent.Name.LocalName); } } else { child.Add(childElement.Name.LocalName, childElement.Value); if (!child.ContainsKey("NodeName")) child.Add("NodeName", parent.Name.LocalName); } }); return child; }
public PendingUpdate(XElement updateXml) { var rawVersion = updateXml .Attributes("NewVersion") .Select(a => a.Value) .FirstOrDefault(); NewVersion = new Version(rawVersion); var rawUpdateFileUri = updateXml .Attributes("UpdateFileUri") .Select(a => a.Value) .FirstOrDefault(); UpdateFileUri = new Uri(rawUpdateFileUri); var rawInfoFileUri = updateXml .Attributes("UpdateInfoUri") .Select(a => a.Value) .FirstOrDefault(); if (rawInfoFileUri != null) { UpdateInfoUri = new Uri(rawInfoFileUri); } var rawCategories = updateXml .Attributes("Categories") .Select(a => a.Value) .FirstOrDefault(); Categories = rawCategories == null ? new List<string>() : new List<string>(rawCategories.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)); InstallFileName = updateXml .Attributes("InstallFileName") .Select(a => a.Value) .FirstOrDefault(); var descriptionNode = updateXml .Elements("Description") .FirstOrDefault(); if (descriptionNode != null) { Description = descriptionNode.Value; } }
public IOperand CreateFieldRefOperand(XElement el) { if (el == null) { throw new ArgumentNullException("el"); } Guid? id = null; var idAttr = el.Attributes().FirstOrDefault(a => a.Name == Attributes.ID); if (idAttr != null) { try { id = new Guid(idAttr.Value); } catch { throw new CamlAnalysisException(string.Format("Value '{0}' is not correct for attribute '{1}'", idAttr.Value, Attributes.ID)); } } string name = null; var nameAttr = el.Attributes().FirstOrDefault(a => a.Name == Attributes.Name); if (nameAttr != null) { name = nameAttr.Value; } if (id != null && !string.IsNullOrEmpty(name)) { throw new CamlAnalysisException(string.Format("Only one from two attributes should be specified: {0} or {1}", Attributes.ID, Attributes.Name)); } if (id == null && string.IsNullOrEmpty(name)) { throw new CamlAnalysisException(string.Format("At least one from two attributes should be specified: {0} or {1}", Attributes.ID, Attributes.Name)); } var attributes = el.Attributes().Where( attr => { return (attr.Name != Attributes.ID && attr.Name != Attributes.Name && !string.IsNullOrEmpty(attr.Value)); }) .Select(attr => new KeyValuePair<string, string>(attr.Name.ToString(), attr.Value)) .ToList(); return (id != null ? new FieldRefOperand(id.Value, attributes) : new FieldRefOperand(name, attributes)); }
public BookModel ConvertXmlToBookModel(XElement book) { XElement publisher = book.Elements().Where(x => x.Name == "publisher").FirstOrDefault(); return new BookModel() { ISBN = book.Attributes().Where(x => x.Name == "isbn").FirstOrDefault().Value, ISBN13 = book.Attributes().Where(x => x.Name == "isbn13").FirstOrDefault().Value, Title = book.Elements().Where(x => x.Name == "title").FirstOrDefault().Value, Author = book.Elements().Where(x => x.Name == "author").FirstOrDefault().Value, Publisher = new Publisher() { Id = publisher.Attributes().Where(x => x.Name == "publisher_id").FirstOrDefault().Value, Name = publisher.Value } }; }
public static XElement MergeWith(this XElement source, XElement target, IDictionary<XName, Action<XElement, XElement>> nodeActions) { if (target == null) { return source; } // Merge the attributes foreach (var targetAttribute in target.Attributes()) { var sourceAttribute = source.Attribute(targetAttribute.Name); if (sourceAttribute == null) { source.Add(targetAttribute); } } // Go through the elements to be merged foreach (var targetChild in target.Elements()) { var sourceChild = FindElement(source, targetChild); if (sourceChild != null && !HasConflict(sourceChild, targetChild)) { // Other wise merge recursively sourceChild.MergeWith(targetChild, nodeActions); } else { Action<XElement, XElement> nodeAction; if (nodeActions != null && nodeActions.TryGetValue(targetChild.Name, out nodeAction)) { nodeAction(source, targetChild); } else { // If that element is null then add that node source.Add(targetChild); } } } return source; }
bool RewriteElement(XamlContext ctx, XElement parent, XElement elem) { var type = parent.Annotation<XamlType>(); var property = elem.Annotation<XamlProperty>(); if ((property == null || type == null) && elem.Name != key) return false; if (elem.Elements().Count() != 1 || elem.Attributes().Any(t => t.Name.Namespace != XNamespace.Xmlns)) return false; var value = elem.Elements().Single(); if (!CanInlineExt(ctx, value)) return false; var ext = InlineExtension(ctx, value); if (ext == null) return false; ctx.CancellationToken.ThrowIfCancellationRequested(); var extValue = ext.ToString(ctx, parent); var attrName = elem.Name; if (attrName != key) attrName = property.ToXName(ctx, parent, property.IsAttachedTo(type)); var attr = new XAttribute(attrName, extValue); parent.Add(attr); elem.Remove(); return true; }
private static XElement createOutputNode(XElement inputNode, XDocument input) { var outputNode = new XElement(inputNode.Name); setAttributesWithParentsNames(inputNode, input.Root, outputNode); outputNode.Add(inputNode.Attributes()); return outputNode; }
private void CompareAttributes(XElement actualElement, XElement expectedElement) { var actualAttributes = new List<XAttribute>(actualElement.Attributes()); var expectedAttributes = new List<XAttribute>(expectedElement.Attributes()); for (int i1 = actualAttributes.Count - 1; i1 >= 0; i1--) { for (int i2 = expectedAttributes.Count - 1; i2 >= 0; i2--) { if (actualAttributes[i1].Name == expectedAttributes[i2].Name) { if (actualAttributes[i1].Value != expectedAttributes[i2].Value) { var message = string.Format("Attribute '{0}' actual value '{1}' expected value '{2}'", actualAttributes[i1].LocalAttributeXPath(), actualAttributes[i1].Value, expectedAttributes[i2].Value); Notify(l => l.DifferentAttributes(message)); } actualAttributes.RemoveAt(i1); expectedAttributes.RemoveAt(i2); break; } } } foreach (var attribute in actualAttributes) { var message = string.Format("Attribute '{0}' is only in the actual tree", attribute.LocalAttributeXPath()); Notify(l => l.DifferentAttributes(message)); } foreach (var attribute in expectedAttributes) { var message = string.Format("Attribute '{0}' is only in the expected tree", attribute.LocalAttributeXPath()); Notify(l => l.DifferentAttributes(message)); } }
public static MPD LoadMPD(XElement element) { var ns = element.GetDefaultNamespace().NamespaceName; var result = new MPD(); result.Id = (string)element.Attribute("id"); result.Profiles = (string)element.Attribute("profiles"); result.Type = element.Attribute("type").GetEnum<Presentation>(); result.AvailabilityStartTime = element.Attribute("availabilityStartTime").GetNullableDateTime(); result.AvailabilityEndTime = element.Attribute("availabilityEndTime").GetNullableDateTime(); result.MediaPresentationDuration = element.Attribute("mediaPresentationDuration").GetNullableDuration(); result.MinimumUpdatePeriod = element.Attribute("minimumUpdatePeriod").GetNullableDuration(); result.MinBufferTime = element.Attribute("minBufferTime").GetNullableDuration(); result.TimeShiftBufferDepth = element.Attribute("timeShiftBufferDepth").GetNullableDuration(); result.SuggestedPresentationDelay = element.Attribute("suggestedPresentationDelay").GetNullableDuration(); result.MaxSegmentDuration = element.Attribute("maxSegmentDuration").GetNullableDuration(); result.MaxSubsegmentDuration = element.Attribute("maxSubsegmentDuration").GetNullableDuration(); result.AnyAttr.AddRange(element.Attributes()); result.ProgramInformation.AddRange(element.Elements(XName.Get("ProgramInformation", ns)).Select(LoadProgramInformation)); result.BaseURL.AddRange(element.Elements(XName.Get("BaseURL", ns)).Select(LoadBaseURL)); result.Location.AddRange(element.Elements(XName.Get("Location", ns)).Select(e => e.Value)); result.Period.AddRange(element.Elements(XName.Get("Period", ns)).Select(LoadPeriod)); result.Metrics.AddRange(element.Elements(XName.Get("Metrics", ns)).Select(LoadMetrics)); result.Any.AddRange(element.Elements()); return result; }
private void AddNode(TreeNodeCollection parentTreeNodes, XElement element) { StringBuilder sb = new StringBuilder(); string attrstring = string.Join(" ", element.Attributes().Select(a => a.Name + "=\"" + a.Value + "\"")); if (attrstring != string.Empty) { sb.Append(" " + attrstring); } string innertext = element.Value; if (innertext != string.Empty) { sb.Append(" Value=\"" + innertext + "\""); } TreeNode treenode = new TreeNode(); treenode.Text = element.Name.LocalName + sb.ToString(); parentTreeNodes.Add(treenode); foreach (XElement child in element.Descendants()) { AddNode(treenode.Nodes, child); } treenode.Expand(); }
private static bool HasIncludePath(XElement includeElement, string includePath) { XAttribute attr; attr = includeElement.Attributes(PathAttrName).Single(); return attr != null && string.Equals(attr.Value, includePath, StringComparison.OrdinalIgnoreCase); }
private IEnumerable<PlacementShapeLocation> AcceptPlace(XElement element) { // return attributes as part locations return element.Attributes().Select(attr => new PlacementShapeLocation { ShapeType = attr.Name.LocalName, Location = attr.Value }); }
private static InternalResult AreAttributesEqual(XElement xmlA, XElement xmlB) { var attributesB = xmlB.Attributes().Where(a => !a.IsNamespaceDeclaration).ToDictionary(a => a.Name); var attributesA = xmlA.Attributes().Where(a => !a.IsNamespaceDeclaration).ToList(); if (attributesA.Count != attributesB.Count) { return new InternalResult { FailObject = xmlA, ErrorMessage = "Element has different number of attributes" }; } foreach (var attributeA in attributesA) { XAttribute attributeB; if (attributesB.TryGetValue(attributeA.Name, out attributeB) && attributeA.Value == attributeB.Value) continue; return new InternalResult { FailObject = attributeA, ErrorMessage = "No matching attribute found." }; } return new InternalResult(); }
/// <summary> /// Uses XML to initialize the object. /// </summary> /// <param name="element">The element used for loading.</param> public override void LoadFromXml(XElement element) { //Attributes foreach (var attribute in element.Attributes()) { if (attribute.Name.LocalName.Equals("walkspeed", StringComparison.OrdinalIgnoreCase)) { float value; if (float.TryParse(attribute.Value, out value)) { WalkSpeed = value; } continue; } if (attribute.Name.LocalName.Equals("runspeed", StringComparison.OrdinalIgnoreCase)) { float value; if (float.TryParse(attribute.Value, out value)) { RunSpeed = value; } continue; } } }
/// <summary> /// v3 serialization /// </summary> /// <param name="e"></param> public TranscriptionPhrase(XElement e) { Elements = e.Attributes().ToDictionary(a => a.Name.ToString(), a => a.Value); Elements.Remove("b"); Elements.Remove("e"); Elements.Remove("f"); this._phonetics = (e.Attribute("f") ?? EmptyAttribute).Value; this._text = e.Value.Trim('\r', '\n'); if (e.Attribute("b") != null) { string val = e.Attribute("b").Value; int ms; if (int.TryParse(val, out ms)) { Begin = TimeSpan.FromMilliseconds(ms); } else Begin = XmlConvert.ToTimeSpan(val); } if (e.Attribute("e") != null) { string val = e.Attribute("e").Value; int ms; if (int.TryParse(val, out ms)) { End = TimeSpan.FromMilliseconds(ms); } else End = XmlConvert.ToTimeSpan(val); } }
/// <summary> /// Removes all namespaces from a XDocument /// </summary> /// <param name="e"></param> /// <returns></returns> /// <remarks>Borrowed from http://stackoverflow.com/a/7238007/41596</remarks> public static XElement RemoveAllNamespaces(XElement e) { return new XElement(e.Name.LocalName, (from n in e.Nodes() select ((n is XElement) ? RemoveAllNamespaces(n as XElement) : n)), (e.HasAttributes) ? (from a in e.Attributes() select a) : null); }
protected virtual SiteMapNode CreateNodeFromElement(XElement element, int currentLevel) { string str; NameValueCollection attributes = new NameValueCollection(); foreach (XAttribute attribute in element.Attributes()) { attributes.Add(attribute.Name.ToString(), attribute.Value); } try { if (element.Attribute("uri") != null) { str = element.Attribute("uri").Value; } else if (element.Attribute("pageId") != null) { str = element.Attribute("pageId").Value; } else if (element.Attribute("id") != null) { str = element.Attribute("id").Value; } else { str = ""; } } catch { LoggerService.Debug("exception while retrieving uri", LoggingCategory.General, new object[0]); str = ""; } return new TridionSiteMapNode(this, element.Attribute("id").Value, str, element.Attribute("url").Value, element.Attribute("title").Value, "", null, attributes, null, null) { Level = currentLevel }; }
private void GenerateCommandCallTree(XElement element, CommandCall parentCommandCall, Resource resource) { bool isCommandAssigned = false; foreach (XAttribute attribute in element.Attributes()) { string namespaceURI = attribute.Name.Namespace.NamespaceName; if (!attribute.IsNamespaceDeclaration && !String.IsNullOrEmpty(namespaceURI)) { string commandName = attribute.Name.LocalName; ICommand command = CreateCommand(namespaceURI, commandName); if (command != null) { Check.IsFalse(isCommandAssigned, "Multiple commands per element is currently not supported."); isCommandAssigned = true; String expression = attribute.Value; CommandCall commandCall = new CommandCall(command, new Element(element), expression, resource); parentCommandCall.AddChild(commandCall); parentCommandCall = commandCall; } } } foreach (XElement child in element.Elements()) { GenerateCommandCallTree(child, parentCommandCall, resource); } }
public static void Parse(dynamic parent, XElement node) { foreach (var a in node.Attributes()) AddProperty(parent, a.Name.ToString(), a.Value); if (node.HasElements) { IEnumerable<XElement> sorted = from XElement elt in node.Elements() orderby node.Elements(elt.Name.LocalName).Count() descending select elt; string elementName = string.Empty; List<dynamic> list = null; foreach (var element in sorted) { var item = new ExpandoObject(); Parse(item, element); if (element.Name.LocalName != elementName) { list = null; AddProperty(parent, elementName = element.Name.LocalName, item); } else if (list == null) AddProperty(parent, element.Name.LocalName, list = new List<dynamic>() { (parent as IDictionary<string, object>)[element.Name.LocalName], item }); else list.Add(item); } } else if (!string.IsNullOrWhiteSpace(node.Value)) AddProperty(parent, "TextValue", node.Value.Trim()); }
private static IEnumerable<XAttribute> NormalizeAttributes(XElement element, bool havePSVI) { return element.Attributes() .Where(a => !a.IsNamespaceDeclaration && a.Name != Xsi.schemaLocation && a.Name != Xsi.noNamespaceSchemaLocation) .OrderBy(a => a.Name.NamespaceName) .ThenBy(a => a.Name.LocalName) .Select( a => { if (havePSVI) { var dt = a.GetSchemaInfo().SchemaType.TypeCode; switch (dt) { case XmlTypeCode.Boolean: return new XAttribute(a.Name, (bool)a); case XmlTypeCode.DateTime: return new XAttribute(a.Name, (DateTime)a); case XmlTypeCode.Decimal: return new XAttribute(a.Name, (decimal)a); case XmlTypeCode.Double: return new XAttribute(a.Name, (double)a); case XmlTypeCode.Float: return new XAttribute(a.Name, (float)a); case XmlTypeCode.HexBinary: case XmlTypeCode.Language: return new XAttribute(a.Name, ((string)a).ToLower()); } } return a; } ); }
private static void RemoveSCCElementsAttributes(System.Xml.Linq.XElement el) { el.Elements().Where(x => x.Name.LocalName.StartsWith("Scc")).Remove(); el.Attributes().Where(x => x.Name.LocalName.StartsWith("Scc")).Remove(); foreach (var child in el.Elements()) { RemoveSCCElementsAttributes(child); } }
/// <summary> /// Maps an XML element to a settings dictionary. /// </summary> /// <param name="element">The XML element to be mapped.</param> /// <returns>The settings dictionary.</returns> public Models.SettingsDictionary Map(System.Xml.Linq.XElement element) { if (element == null) { return(new SettingsDictionary()); } return(new SettingsDictionary( element.Attributes() .ToDictionary(attr => XmlConvert.DecodeName(attr.Name.LocalName), attr => attr.Value))); }
//TODO: add a link for Trinity Configuration File Format Specification v1. /// <summary> /// Constructs a new configuration entry from an XML element. /// </summary> /// <param name="entry">The XML element.</param> public ConfigurationEntry(System.Xml.Linq.XElement entry) : this(entry.Name.LocalName) { foreach (var attribute in entry.Attributes()) { m_settings.Add(attribute.Name.LocalName, new ConfigurationSetting(attribute)); } foreach (var child in entry.Descendants()) { m_children.Add(new ConfigurationEntry(child)); } }
//Core recursion function private static System.Xml.Linq.XElement RemoveAllNamespaces(System.Xml.Linq.XElement xmlDocument) { if (xmlDocument.HasAttributes) { xmlDocument.RemoveAttributes(); } if (!xmlDocument.HasElements) { System.Xml.Linq.XElement xElement = new System.Xml.Linq.XElement(xmlDocument.Name.LocalName); xElement.Value = xmlDocument.Value; foreach (System.Xml.Linq.XAttribute attribute in xmlDocument.Attributes()) { xElement.Add(attribute); } return(xElement); } return(new System.Xml.Linq.XElement(xmlDocument.Name.LocalName, xmlDocument.Elements().Select(el => RemoveAllNamespaces(el)))); }
protected override void InnerInitializeProperties(System.Xml.Linq.XElement element) { this.FillProperty(m => m.TotalDeposit); this.FillProperty(m => m.Equity); this.FillProperty(m => m.AlertLevel); this.FillProperty(m => m.AlertTime); this.FillProperty(m => m.IsMultiCurrency); this.FillProperty(m => m.Code); this.FillProperty(m => m.CustomerName); this.FillProperty(m => m.CurrencyCode); this.FillProperty(m => m.Type); this.FillProperty(m => m.CreditAmount); this.FillProperty(m => m.Leverage); this.FillProperty(m => m.RateMarginD); this.FillProperty(m => m.RateMarginO); this.FillProperty(m => m.RateMarginLockD); this.FillProperty(m => m.RateMarginLockO); this.FillProperty(m => m.EstimateCloseCommission); this.FillProperty(m => m.EstimateCloseLevy); foreach (XAttribute attribute in element.Attributes()) { if (attribute.Name == "Necessary") { this._necessaries[0] = decimal.Parse(attribute.Value); } else if (attribute.Name == "MinEquityAvoidRiskLevel1") { this._necessaries[1] = decimal.Parse(attribute.Value); } else if (attribute.Name == "MinEquityAvoidRiskLevel2") { this._necessaries[2] = decimal.Parse(attribute.Value); } else if (attribute.Name == "MinEquityAvoidRiskLevel3") { this._necessaries[3] = decimal.Parse(attribute.Value); } } }
private void ShowData( System.Xml.Linq.XElement i_element ) { string nameText = i_element.Name.LocalName; string valueText = i_element.Value; string atrText = string.Empty; // アトリビュートがある場合。 if( i_element.HasAttributes ) { foreach( var attribute in i_element.Attributes() ) { atrText += string.Format( "\t\t{0}={1}\n", attribute.Name, attribute.Value ); } } Debug.LogFormat( "name:{0}\n\tvalue:{1}\n\tattribute:\n{2}", nameText, valueText, atrText ); // 子ノードも探そう。 foreach( var child in i_element.Elements() ) { ShowData( child ); } }
private void Transit(System.Xml.Linq.XElement expression) { if (expression == null) { return; } if (expression.Elements().Any()) { foreach (var element in expression.Elements()) { Transit(element); } } var attirbs = from attirb in expression.Attributes() where attirb.Value == typeof(DTO).FullName select attirb; foreach (var attrib in attirbs) { attrib.Value = typeof(Entity).FullName; //expression.ReplaceAttributes(new XAttribute("Name", typeof(Entity).FullName)); } }
public XElement(XElement source) { name = source.name; Add(source.Attributes()); Add(source.Nodes()); }
static bool ProcessXamlForDisplay(string sourceXaml, string sourceXamlFileNameAndPath, EnvDTE.Project currentProject, EnvDTE.Solution currentSolution, Dictionary <string, EnvDTE.Project> assemblyNameToProjectDictionary, ResourcesCache resourcesCache, out string outputXaml, out string errorsIfAny, out HashSet <string> warningsAndTips) { warningsAndTips = new HashSet <string>(); // Default output values: outputXaml = sourceXaml; errorsIfAny = ""; //--------------------------------------- // Remove the content of all the "HtmlPresenter" nodes, because the content may be not well formatted and may lead to a syntax error when parsing the XDocument: //--------------------------------------- sourceXaml = HtmlPresenterRemover.RemoveHtmlPresenterNodes(sourceXaml); //--------------------------------------- // Read the XDocument: //--------------------------------------- System.Xml.Linq.XDocument xdoc; try { xdoc = System.Xml.Linq.XDocument.Parse(sourceXaml); } catch (Exception ex) { errorsIfAny = ex.Message; return(false); } //--------------------------------------- // Remove the "x:Class" attribute if any: //--------------------------------------- if (xdoc.Root != null) { // Remove the "x:Class" attribute if any: XNamespace xNamespace = "http://schemas.microsoft.com/winfx/2006/xaml"; XAttribute classAttributeIfAny = xdoc.Root.Attribute(xNamespace + "Class"); if (classAttributeIfAny != null) { classAttributeIfAny.Remove(); } } //--------------------------------------- // Replace the root control with a UserControl (if it is not already one) and keep only the properties and attributes supported by the UserControl class: //--------------------------------------- ProcessNodeToMakeItCompatibleWithWpf.ReplaceRootWithUserControl(xdoc); //--------------------------------------- // Get the styles and other resources defined in App.xaml //--------------------------------------- IEnumerable <XElement> appDotXamlResources; string appDotXamlFullPath; if (resourcesCache.AppDotXamlResources != null) // This avoids reloading App.xaml at every refresh, to improve performance. { // Read from cache: appDotXamlResources = resourcesCache.AppDotXamlResources; appDotXamlFullPath = resourcesCache.AppDotXamlFullPath; } else { // Attempt to find App.xaml and read it: appDotXamlResources = ResolvingReferencedXamlResources.GetAppDotXamlResources(currentProject, currentSolution, out appDotXamlFullPath); resourcesCache.AppDotXamlResources = appDotXamlResources; resourcesCache.AppDotXamlFullPath = appDotXamlFullPath; } //--------------------------------------- // Resolve all the "Merged Dictionaries", and merge them so that there are no more references to other XAML files: //--------------------------------------- // Process the resources defined in App.xaml: if (appDotXamlResources != null) { try { foreach (XElement element in appDotXamlResources) { ResolvingReferencedXamlResources.ResolveAndMergeTheMergedDictionaries(element, appDotXamlFullPath, assemblyNameToProjectDictionary, new HashSet <string>(), resourcesCache); } } catch (Exception ex) { errorsIfAny = ex.Message; return(false); } } // Process the resources defined in the current file: try { ResolvingReferencedXamlResources.ResolveAndMergeTheMergedDictionaries(xdoc.Root, sourceXamlFileNameAndPath, assemblyNameToProjectDictionary, new HashSet <string>(), resourcesCache); } catch (Exception ex) { errorsIfAny = ex.Message; return(false); } //--------------------------------------- // Surround the document with a control in which we inject all the resources that we found in the end-user's "App.xaml" file: //--------------------------------------- if (appDotXamlResources != null && appDotXamlResources.Any()) { // Put those resouces in a control that will surround the xaml of the current page: var surroundingControlForResources = new XElement(DefaultXamlNamespace + "Border", xdoc.Root); surroundingControlForResources.Add(new XAttribute(XNamespace.Xmlns + "x", @"http://schemas.microsoft.com/winfx/2006/xaml")); // Note: This is required in case the XAML code contains the "x" prefix inside Markup Extensions (such as "{x:Null}"). It is not needed for the "x" prefix in elements and attributes (such as "x:Name"), because those are automatically imported when copying nodes, where as markup extensions are considered as simple strings by "Linq to XML". surroundingControlForResources.Add(new XAttribute("Tag", "AddedByDesignerToInjectAppDotXamlResources")); var resourcesContainer = new XElement(DefaultXamlNamespace + "Border.Resources"); surroundingControlForResources.AddFirst(resourcesContainer); resourcesContainer.Add(appDotXamlResources); // Replace the document with the one surrounded by the new control: xdoc = new XDocument(surroundingControlForResources); } #if Display_The_Processed_XAML // Uncomment to display the processed XAML: errorsIfAny = xdoc.Root.ToString(); outputXaml = xdoc.Root.ToString(); return(false); #endif //--------------------------------------- // Iterate through the document using a Stack<XElement> (pre-order traversal, no recursion) and process the nodes: //--------------------------------------- XElement root = xdoc.Root; Stack <System.Xml.Linq.XElement> stack = new Stack <System.Xml.Linq.XElement>(); stack.Push(root); while (stack.Count > 0) { System.Xml.Linq.XElement current = stack.Pop(); bool elementWasReplacedWithPlaceholder = false; // default value //--------------------------------------- // Process node to make it compatible with WPF (remove events such as PointerPressed, change "Page" to "UserControl", etc.): //--------------------------------------- ProcessNodeToMakeItCompatibleWithWpf.Process(current, ref warningsAndTips); //--------------------------------------- // Remove unknown nodes and attributes, and display "Cannot preview this element" instead: //--------------------------------------- // Verify that the node is not a property: if (!current.Name.LocalName.Contains(".")) { bool isKnownType = false; // Check to see if the element corresponds to a known type (only for elements that are supposed to be in the default namespace): Type type; if (current.Name.NamespaceName == DefaultXamlNamespace && TryGetType(current.Name, out type)) { isKnownType = true; // List all the event handlers of the type: List <string> eventHandlers = new List <string>(); foreach (EventInfo eventInfo in type.GetEvents()) { eventHandlers.Add(eventInfo.Name); } // Duplicate the list of attributes so that when we remove one, it doesn't affect the iteration: List <System.Xml.Linq.XAttribute> attributesListCopy = new List <System.Xml.Linq.XAttribute>(); foreach (System.Xml.Linq.XAttribute attr in current.Attributes()) { attributesListCopy.Add(attr); } // Remove event handlers: foreach (System.Xml.Linq.XAttribute attr in attributesListCopy) { // Check if the attribute is an event handler: //test+= " |||| " + attr.Name.LocalName + " " + attr.Name.NamespaceName + " " + (!attr.Name.LocalName.Contains(".")).ToString() + " " + eventHandlers.Contains(attr.Name.LocalName).ToString(); if (!attr.Name.LocalName.Contains(".") && eventHandlers.Contains(attr.Name.LocalName)) { // Remove the attrbute: attr.Remove(); } } } else if (current.Name.NamespaceName.EndsWith("assembly=mscorlib")) { isKnownType = true; } // If not known type, replace the element with a placeholder that says "Unable to display": if (!isKnownType) { // Create a border with inside a TextBlock that says "Unable to display": System.Xml.Linq.XElement msg = new System.Xml.Linq.XElement(DefaultXamlNamespace + "Border"); System.Xml.Linq.XElement msgTxt = new System.Xml.Linq.XElement(DefaultXamlNamespace + "TextBlock"); // Add the newly created stuff to the XAML: current.ReplaceWith(msg); msg.Add(msgTxt); // Set some attributes: msg.Add(new XAttribute("Background", "DarkRed")); msg.Add(new XAttribute("Opacity", "0.5")); msg.Add(new XAttribute("Tag", "AddedByDesignerAsPlaceholder")); msgTxt.Add(new XAttribute("Text", "Unable to preview this element")); msgTxt.Add(new XAttribute("TextWrapping", "Wrap")); msgTxt.Add(new XAttribute("TextAlignment", "Center")); msgTxt.Add(new XAttribute("HorizontalAlignment", "Stretch")); msgTxt.Add(new XAttribute("VerticalAlignment", "Center")); msgTxt.Add(new XAttribute("FontSize", "12")); msgTxt.Add(new XAttribute("Foreground", "#AAFFFFFF")); msgTxt.Add(new XAttribute("Tag", "AddedByDesignerForRendering")); // Give to that Border the same positioning information as the element that it replaces: MoveAttributeIfAny("Width", current, msg); MoveAttributeIfAny("Height", current, msg); MoveAttributeIfAny("HorizontalAlignment", current, msg); MoveAttributeIfAny("VerticalAlignment", current, msg); MoveAttributeIfAny("Margin", current, msg); MoveAttributeIfAny("Opacity", current, msg); MoveAttributeIfAny("MaxWidth", current, msg); MoveAttributeIfAny("MaxHeight", current, msg); MoveAttributeIfAny("MinWidth", current, msg); MoveAttributeIfAny("MinHeight", current, msg); MoveAttributeIfAny("Visibility", current, msg); MoveAttributeIfAny("Canvas.Left", current, msg); MoveAttributeIfAny("Canvas.Top", current, msg); MoveAttributeIfAny((XNamespace)"clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Toolkit" + "DockPanel.Dock", current, msg); MoveAttributeIfAny((XNamespace)"http://schemas.microsoft.com/winfx/2006/xaml" + "Name", current, msg); MoveAttributeIfAny((XNamespace)"http://schemas.microsoft.com/winfx/2006/xaml" + "Key", current, msg); // Remember that the element was replaced: elementWasReplacedWithPlaceholder = true; } } // Continue with the children of this element: if (!elementWasReplacedWithPlaceholder) { foreach (XElement element in current.Elements()) { stack.Push(element); } } } errorsIfAny = ""; //xdoc.ToString(); outputXaml = root.ToString(); return(true); }
public static IEnumerable <XAttribute> NormalizedAttributes(this XElement element) { return(element.Attributes().Where(a => !a.IsNamespaceDeclaration) .OrderBy(a => a.Name.NamespaceName) .ThenBy(a => a.Name.LocalName)); }
public static XAttribute GetAttribute(this XElement element, string name) { return(element.Attributes().FirstOrDefault(x => x.Name.LocalName.Equals(name, StringComparison.InvariantCultureIgnoreCase))); }