/// <include file='doc\XmlParserContext.uex' path='docs/doc[@for="XmlParserContext.XmlParserContext3"]/*' /> public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, String docTypeName, String pubId, String sysId, String internalSubset, String baseURI, String xmlLang, XmlSpace xmlSpace, Encoding enc) { if (nsMgr != null) { if (nt == null) { _nt = nsMgr.NameTable; } else { if ( (object)nt != (object) nsMgr.NameTable ) { throw new XmlException(Res.Xml_NotSameNametable); } _nt = nt; } } else { _nt = nt; } _nsMgr = nsMgr; _docTypeName = (null == docTypeName ? String.Empty : docTypeName); _pubId = (null == pubId ? String.Empty : pubId); _sysId = (null == sysId ? String.Empty : sysId); _internalSubset = (null == internalSubset ? String.Empty : internalSubset); _baseURI = (null == baseURI ? String.Empty : baseURI); _xmlLang = (null == xmlLang ? String.Empty : xmlLang); _xmlSpace = xmlSpace; _encoding = enc; }
public void from(XmlNode node, XmlNamespaceManager xnm, string prefix, string subfix) { Type type = this.GetType(); FieldInfo[] fields = type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public); foreach (FieldInfo field in fields) { string query = prefix +ObjectUtil.GetSimpleName(field) + subfix; try { string value = null; XmlNode tempNode; if (xnm != null) { tempNode = node.SelectSingleNode(query, xnm); } else { tempNode = node.SelectSingleNode(query); } if (tempNode == null) { field.SetValue(this,XML_NULL); continue; } value = tempNode.InnerText; field.SetValue(this, value); } catch (Exception ex) { } } }
public Feed(IXPathNavigable navigable) { navigator = navigable.CreateNavigator(); manager = new XmlNamespaceManager(navigator.NameTable); manager.AddNamespace("f", "http://hl7.org/fhir"); manager.AddNamespace("atom", "http://www.w3.org/2005/Atom"); }
/// <summary> /// Parses source file names from a project file. /// </summary> /// <param name="projectFile">Project file name.</param> /// <returns>A list of source code filenames</returns> public virtual ReadOnlyCollection<string> Parse(string projectFile) { if (projectFile == null) { throw new ArgumentNullException("projectFile"); } string projectPath = Path.GetDirectoryName(projectFile); List<string> sourceFiles = new List<string>(); XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(projectFile); XmlNamespaceManager namespaceManager = new XmlNamespaceManager(xmlDocument.NameTable); namespaceManager.AddNamespace("ns", "http://schemas.microsoft.com/developer/msbuild/2003"); XmlNodeList nodes = xmlDocument.SelectNodes("//ns:Compile", namespaceManager); foreach (XmlNode node in nodes) { XmlAttribute includeAttribute = node.Attributes["Include"]; if (includeAttribute != null) { if (node.SelectSingleNode("ns:Link", namespaceManager) == null) { string fileName = includeAttribute.Value; string sourceFilePath = Path.Combine(projectPath, fileName); sourceFiles.Add(sourceFilePath); } } } return sourceFiles.AsReadOnly(); }
protected void TelemetryInitializerInstall(string sourceDocument, params string[] telemetryInitializerTypes) { string resourceName = "Microsoft.ApplicationInsights.Resources.ApplicationInsights.config.install.xdt"; Stream stream = typeof(ModuleTransformTests).Assembly.GetManifestResourceStream(resourceName); using (StreamReader reader = new StreamReader(stream)) { string transform = reader.ReadToEnd(); XmlTransformation transformation = new XmlTransformation(transform, false, null); XmlDocument targetDocument = new XmlDocument(); targetDocument.LoadXml(sourceDocument); transformation.Apply(targetDocument); XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable()); manager.AddNamespace("ai", AppInsightsNamespace); int moduleIndex = 0; foreach (XPathNavigator module in targetDocument.CreateNavigator().Select("/ai:ApplicationInsights/ai:TelemetryInitializers/ai:Add/@Type", manager)) { string contextInitializerType = telemetryInitializerTypes[moduleIndex++]; Assert.Equal(module.Value, contextInitializerType); } Assert.Equal(moduleIndex, telemetryInitializerTypes.Length); } }
public override bool Execute() { try { var document = new XmlDocument(); document.Load(this.XmlFileName); var navigator = document.CreateNavigator(); var nsResolver = new XmlNamespaceManager(navigator.NameTable); if (!string.IsNullOrEmpty(this.Prefix) && !string.IsNullOrEmpty(this.Namespace)) { nsResolver.AddNamespace(this.Prefix, this.Namespace); } var expr = XPathExpression.Compile(this.XPath, nsResolver); var iterator = navigator.Select(expr); while (iterator.MoveNext()) { iterator.Current.DeleteSelf(); } using (var writer = new XmlTextWriter(this.XmlFileName, Encoding.UTF8)) { writer.Formatting = Formatting.Indented; document.Save(writer); writer.Close(); } } catch (Exception exception) { base.Log.LogErrorFromException(exception); return false; } base.Log.LogMessage("Updated file '{0}'", new object[] { this.XmlFileName }); return true; }
public static PrintTicket ModifyPrintTicket(PrintTicket ticket, string featureName, string newValue) { if (ticket == null) { throw new ArgumentNullException("ticket"); } var xmlDoc = new XmlDocument(); xmlDoc.Load(ticket.GetXmlStream()); var manager = new XmlNamespaceManager(xmlDoc.NameTable); manager.AddNamespace(xmlDoc.DocumentElement.Prefix, xmlDoc.DocumentElement.NamespaceURI); var xpath = string.Format("//psf:Feature[contains(@name, 'InputBin')]/psf:Option", featureName); var node = xmlDoc.SelectSingleNode(xpath, manager); if (node != null) { node.Attributes["name"].Value = newValue; } var printTicketStream = new MemoryStream(); xmlDoc.Save(printTicketStream); printTicketStream.Position = 0; var modifiedPrintTicket = new PrintTicket(printTicketStream); return modifiedPrintTicket; }
public static TestResults InterpretTestResults(XmlDocument doc) { TestResults results = new TestResults(); XmlNamespaceManager nsm = new XmlNamespaceManager(doc.NameTable); nsm.AddNamespace("n", "http://microsoft.com/schemas/VisualStudio/TeamTest/2010"); results.Outcome = doc.SelectSingleNode("n:TestRun/n:ResultSummary", nsm).Attributes["outcome"].Value; results.CountExecuted = int.Parse(doc.SelectSingleNode("n:TestRun/n:ResultSummary/n:Counters", nsm).Attributes["executed"].Value); results.CountPassed = int.Parse(doc.SelectSingleNode("n:TestRun/n:ResultSummary/n:Counters", nsm).Attributes["passed"].Value); results.CountFailed = int.Parse(doc.SelectSingleNode("n:TestRun/n:ResultSummary/n:Counters", nsm).Attributes["failed"].Value); XmlNodeList testresults = doc.SelectNodes("n:TestRun/n:Results/n:UnitTestResult[@outcome='Failed']", nsm); string names = string.Empty; foreach (XmlNode testresult in testresults) { string message = testresult.Attributes["testName"].Value; XmlNode xmlErrorInfoNode = testresult.SelectSingleNode("n:Output/n:ErrorInfo/n:Message", nsm); if (xmlErrorInfoNode != null) { message += ": " + xmlErrorInfoNode.InnerText; results.ResultCode = ExitCode.Failure; } results.FailingTests.Add(message); } return results; }
public void QueryAndNamespace() { try { var output = ""; var path = Server.MapPath("~/App_Data/bookstore.xml"); XPathDocument document = new XPathDocument(path); XPathNavigator navigator = document.CreateNavigator(); XPathExpression query = navigator.Compile("/bookstore:bookstore/bookstore:book"); XmlNamespaceManager manager = new XmlNamespaceManager(navigator.NameTable); manager.AddNamespace("bookstore", "urn:newbooks-schema"); query.SetContext(manager); XPathNodeIterator nodes = navigator.Select(query); while (nodes.MoveNext()) { output += nodes.Current.OuterXml; } Textarea4.InnerHtml = output; } catch (Exception ex) { Textarea4.InnerHtml = ex.Message; } }
public bool CancelAppointment(HackExchangeContext context, CalendarItem appointment) { var url = context.Endpoint; var request = new HttpRequestMessage(HttpMethod.Post, url); var postBodyTemplate = LoadXml("CancelAppointment"); var postBody = string.Format(postBodyTemplate, appointment.Id, appointment.ChangeKey); request.Content = new StringContent(postBody, Encoding.UTF8, "text/xml"); var clientHandler = new HttpClientHandler() { Credentials = context.Credentials }; using (var client = new HttpClient(clientHandler)) { var response = client.SendAsync(request).Result; var responseBody = response.Content.ReadAsStringAsync().Result; var doc = new XPathDocument(new StringReader(responseBody)); var nav = doc.CreateNavigator(); var nsManager = new XmlNamespaceManager(nav.NameTable); nsManager.AddNamespace("m", "http://schemas.microsoft.com/exchange/services/2006/messages"); nsManager.AddNamespace("t", "http://schemas.microsoft.com/exchange/services/2006/types"); var responseClass = EvaluateXPath(nav, nsManager, "//m:DeleteItemResponseMessage/@ResponseClass"); return responseClass == "Success"; } }
public void Initialize(XmlDocument basedata, XmlNamespaceManager namespaces, RDFTriple rdftriple) { BaseData = basedata; Namespaces = namespaces; RDFTriple = rdftriple; UploadInfoToORCID1.Initialize(basedata, namespaces, rdftriple); }
public string GetValue(XElement element, XmlNamespaceManager nsm) { XPathContext context = new XPathContext((NameTable)nsm.NameTable); XPathNavigator navigator = element.CreateNavigator(); object result = null; foreach (var ns in nsm.GetNamespacesInScope(XmlNamespaceScope.All)) context.AddNamespace(ns.Key, ns.Value); context.Arguments.AddParam(XPathContext.ParameterNames.CurrentNode, string.Empty, navigator.Select(".")); result = navigator.Evaluate(this.RawValue, context); if (result is string) return (string)result; else if (result is XPathNodeIterator) { var iterator = ((XPathNodeIterator)result); var current = (XPathNavigator)((IEnumerable)iterator).Cast<object>().First(); return current.Value; } else if (result is XAttribute) return ((XAttribute)result).Value; else if (result is XElement) return ((XElement)result).Value; return string.Empty; }
static void Main( string[] args ) { if ( args.Length != 1 ) { return; } string fileName = args[ 0 ]; StringBuilder fileContent = new StringBuilder( System.IO.File.ReadAllText( fileName ) ); XmlDocument xdoc = new XmlDocument(); xdoc.LoadXml( fileContent.ToString() ); System.Xml.XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager( xdoc.NameTable ); xmlnsManager.AddNamespace( "gpx", "http://www.topografix.com/GPX/1/0" ); XmlNodeList timeNodes = xdoc.SelectNodes( "//gpx:time", xmlnsManager ); foreach ( XmlNode timeNode in timeNodes ) { string[] split1 = timeNode.InnerText.Split( 'T' ); string[] splitDays = split1[ 0 ].Split( '-' ); string[] splitHours = split1[ 1 ].Replace( "Z", "" ).Split( ':' ); fileContent.Replace( timeNode.InnerText, new DateTime( int.Parse( splitDays[ 0 ] ), int.Parse( splitDays[ 1 ] ), int.Parse( splitDays[ 2 ] ), int.Parse( splitHours[ 0 ] ), int.Parse( splitHours[ 1 ] ), int.Parse( splitHours[ 2 ] ) ).ToUniversalTime().ToString( "s" ) + "Z" ); } System.IO.File.WriteAllText( fileName.Replace( ".gpx", "-fix.gpx" ), fileContent.ToString() ); }
SelectRequiredSingleNode ( XmlNode node, String xPath, XmlNamespaceManager xmlNamespaceManager ) { Debug.Assert(node != null); Debug.Assert( !String.IsNullOrEmpty(xPath) ); XmlNode oSelectedNode; if ( !TrySelectSingleNode(node, xPath, xmlNamespaceManager, out oSelectedNode) ) { throw new XmlException( String.Format( "An XML node with the name \"{0}\" is missing a required" + " descendent node. The XPath is \"{1}\"." , node.Name, xPath ) ); } return (oSelectedNode); }
public override bool IsMine(List<string> lines, string fileName) { var sb = new StringBuilder(); lines.ForEach(line => sb.AppendLine(line)); string xmlAsString = sb.ToString().Trim(); if (xmlAsString.Contains("xmlns:tts=\"http://www.w3.org/2006/04")) return false; if (xmlAsString.Contains("http://www.w3.org/") && xmlAsString.Contains("/ttaf1")) { var xml = new XmlDocument(); try { xml.LoadXml(xmlAsString); var nsmgr = new XmlNamespaceManager(xml.NameTable); nsmgr.AddNamespace("ttaf1", xml.DocumentElement.NamespaceURI); XmlNode div = xml.DocumentElement.SelectSingleNode("//ttaf1:body", nsmgr).SelectSingleNode("ttaf1:div", nsmgr); if (div == null) div = xml.DocumentElement.SelectSingleNode("//ttaf1:body", nsmgr).FirstChild; int numberOfParagraphs = div.ChildNodes.Count; return numberOfParagraphs > 0; } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); return false; } } return false; }
/// <summary> /// Initialisiert eine Verwaltung. /// </summary> /// <param name="path">Der volle Pfad zur Projektdatei.</param> protected ProjectTypeHandler( FileInfo path = null ) { // Remember FilePath = path; // Attach to the table Namespaces = new XmlNamespaceManager( Document.NameTable ); // Create the default name space Namespaces.AddNamespace( "msbuild", "http://schemas.microsoft.com/developer/msbuild/2003" ); // None if (path == null) { // Fake name AssemblyName = Guid.NewGuid().ToString( "N" ).ToUpper(); // Done return; } // Load Document.Load( FilePath.FullName ); // Read the name of the target var assemblyName = Document.SelectSingleNode( TargetNamePath, Namespaces ); if (assemblyName != null) AssemblyName = assemblyName.InnerText; // Validate if (string.IsNullOrEmpty( AssemblyName )) AssemblyName = Path.GetFileNameWithoutExtension( path.FullName ); }
private void CreateReport(IDictionary idc, string rptStyle) { var sp1 = new SpreadsheetClass(); var doc = new XmlDocument(); doc.LoadXml(rptStyle); var xn = new XmlNamespaceManager(doc.NameTable); xn.AddNamespace("ss", "urn:schemas-microsoft-com:office:spreadsheet"); var nodes = doc.SelectNodes("//ss:Data", xn); //根据key替换数据 foreach (XmlNode node in nodes) { var tmpValue = node.InnerText.Trim(); if (tmpValue.Length > 2 && tmpValue.Substring(0, 1) == "♂") { string val = tmpValue.Substring(1); node.InnerText = idc.Contains(val) ? idc[val].ToString() : string.Empty; rptStyle = rptStyle.Replace(tmpValue, node.InnerText); } } //sp1.XMLData = style; sp1.XMLData = doc.OuterXml; //dvShow.InnerHtml = sp1.HTMLData; sp1.XMLData = sp1.XMLData.ToString().Replace("<ss:Table", "<ss:Table ss:id=\"CX\""); Response.Write(sp1.HTMLData); }
public MainMenu(XmlDocument pagedata, List<ModuleParams> moduleparams, XmlNamespaceManager pagenamespaces) : base(pagedata, moduleparams, pagenamespaces) { menulist = new System.Text.StringBuilder(); sm = new SessionManagement(); ActiveNetworkRelationshipTypes.ClassURI = ""; }
public XmlValidationRule(IXmlDocumentProvider docProvider, XmlNode node, XmlNamespaceManager nsmgr) { if (node.Attributes["name"] != null) Name = node.Attributes["name"].Value; if (node.Attributes["file"] != null) File = node.Attributes["file"].Value; if (!string.IsNullOrEmpty(File)) { try { XmlDocument doc = docProvider.Load(File); if (doc != null) { List<ITest> tests = new List<ITest>(); string prefix = nsmgr.LookupPrefix("http://icalvalid.wikidot.com/validation"); foreach (XmlNode passNode in doc.SelectNodes("/" + prefix + ":rule/" + prefix + ":pass", nsmgr)) tests.Add(new XmlCalendarTest(passNode, nsmgr)); foreach (XmlNode failNode in doc.SelectNodes("/" + prefix + ":rule/" + prefix + ":fail", nsmgr)) tests.Add(new XmlCalendarTest(failNode, nsmgr)); Tests = tests.ToArray(); } else throw new ValidationRuleLoadException("The file could not be found at the following path: '" + File + "'.", this); } catch (ValidationRuleLoadException) { throw; } catch { throw new ValidationRuleLoadException(this); } } }
public static CT_Border Parse(XmlNode node, XmlNamespaceManager namespaceManager) { if (node == null) return null; CT_Border ctObj = new CT_Border(); ctObj.diagonalUp = XmlHelper.ReadBool(node.Attributes["diagonalUp"]); ctObj.diagonalDown = XmlHelper.ReadBool(node.Attributes["diagonalDown"]); ctObj.outline = XmlHelper.ReadBool(node.Attributes["outline"]); foreach (XmlNode childNode in node.ChildNodes) { if (childNode.LocalName == "left") ctObj.left = CT_BorderPr.Parse(childNode, namespaceManager); else if (childNode.LocalName == "right") ctObj.right = CT_BorderPr.Parse(childNode, namespaceManager); else if (childNode.LocalName == "top") ctObj.top = CT_BorderPr.Parse(childNode, namespaceManager); else if (childNode.LocalName == "bottom") ctObj.bottom = CT_BorderPr.Parse(childNode, namespaceManager); else if (childNode.LocalName == "diagonal") ctObj.diagonal = CT_BorderPr.Parse(childNode, namespaceManager); else if (childNode.LocalName == "vertical") ctObj.vertical = CT_BorderPr.Parse(childNode, namespaceManager); else if (childNode.LocalName == "horizontal") ctObj.horizontal = CT_BorderPr.Parse(childNode, namespaceManager); } return ctObj; }
public ResinConf(String file) { _xPathDoc = new XPathDocument(file); _docNavigator = _xPathDoc.CreateNavigator(); _xmlnsMgr = new XmlNamespaceManager(_docNavigator.NameTable); _xmlnsMgr.AddNamespace("caucho", "http://caucho.com/ns/resin"); }
/// <summary> /// Copys the same nodes under a parent node from one document to a second /// </summary> /// <param name="oDocDonor">Xml Doc to copy the nodes from</param> /// <param name="oDocReceiver">Xml Doc to copy the nodes to</param> /// <param name="xPath">Generic namespaces are automatically applied. use ns: as namespace for each node.</param> /// <returns></returns> private static int CopyNodes(XmlDocument oDocReceiver, XmlDocument oDocDonor, string xPath) { var namespaceManagerReceiver = new XmlNamespaceManager(oDocReceiver.NameTable); namespaceManagerReceiver.AddNamespace("ns", oDocReceiver.DocumentElement.NamespaceURI); var namespaceManagerDonor = new XmlNamespaceManager(oDocDonor.NameTable); namespaceManagerDonor.AddNamespace("ns", oDocDonor.DocumentElement.NamespaceURI); var testDefinitionNode = oDocDonor.SelectSingleNode(xPath, namespaceManagerDonor); if (testDefinitionNode == null) { throw new InvalidDataException("Donor document misses node for xpath " + xPath); } var testDefinitionNodeReceiver = oDocReceiver.SelectSingleNode(xPath, namespaceManagerReceiver); if (testDefinitionNodeReceiver == null) { throw new InvalidDataException("Receiver document misses node for xpath " + xPath); } int copied = 0; foreach (XmlNode node in testDefinitionNode.ChildNodes) { XmlNode newChildNode = oDocReceiver.ImportNode(node, true); testDefinitionNodeReceiver.AppendChild(newChildNode); copied++; } return copied; }
/// <include file='doc\XmlParserContext.uex' path='docs/doc[@for="XmlParserContext.XmlParserContext1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public XmlParserContext(XmlNameTable nt, XmlNamespaceManager nsMgr, String docTypeName, String pubId, String sysId, String internalSubset, String baseURI, String xmlLang, XmlSpace xmlSpace) : this(nt, nsMgr, docTypeName, pubId, sysId, internalSubset, baseURI, xmlLang, xmlSpace, null) { // Intentionally Empty }
public TestEnvironment() { _palasoFileNames = Directory.GetFiles(GlobalWritingSystemRepositoryMigrator.PalasoLdmlPathPre0); _flexFileNames = Directory.GetFiles(GlobalWritingSystemRepositoryMigrator.FlexLdmlPathPre0); NamespaceManager = new XmlNamespaceManager(new NameTable()); NamespaceManager.AddNamespace("palaso", "urn://palaso.org/ldmlExtensions/v1"); }
public bool Load(XPathNavigator source, XmlNamespaceManager manager) { //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ ResourceName = source.LocalName; Namespace = source.NamespaceURI; string value; Key = source.TryGetAttribute("key", Framework.Common.SData.Namespace, out value) ? value : null; Uri = source.TryGetAttribute("uri", Framework.Common.SData.Namespace, out value) && !string.IsNullOrEmpty(value) ? new Uri(value) : null; Uuid = source.TryGetAttribute("uuid", Framework.Common.SData.Namespace, out value) && !string.IsNullOrEmpty(value) ? new Guid(value) : (Guid?) null; Descriptor = source.TryGetAttribute("descriptor", Framework.Common.SData.Namespace, out value) ? value : null; Lookup = source.TryGetAttribute("lookup", Framework.Common.SData.Namespace, out value) ? value : null; IsDeleted = source.TryGetAttribute("isDeleted", Framework.Common.SData.Namespace, out value) && !string.IsNullOrEmpty(value) ? XmlConvert.ToBoolean(value) : (bool?) null; return source.SelectChildren(XPathNodeType.Element) .Cast<XPathNavigator>() .GroupBy(item => item.LocalName) .All(group => LoadItem(group.Key, group, manager)); }
public static bool IsProject40(string projectXml) { bool result = false; double targetFrameworkVersion; XmlDocument projectDocument = new XmlDocument(); projectDocument.LoadXml(projectXml); XmlNamespaceManager namespaceManager = new XmlNamespaceManager(projectDocument.NameTable); namespaceManager.AddNamespace("msbd", projectDocument.DocumentElement.NamespaceURI); XmlNodeList nodes = projectDocument.SelectNodes("//msbd:PropertyGroup//msbd:TargetFrameworkVersion", namespaceManager); Debug.Assert(nodes != null, "TargetFrameworkVersion node not foud (null)."); Debug.Assert(nodes.Count > 0, "TargetFrameworkVersion node not foud (count = 0)."); // Parse <TargetFrameworkVersion>v4.0<TargetFrameworkVersion/> if(double.TryParse(nodes[0].InnerText.Remove(0, 1), out targetFrameworkVersion) && targetFrameworkVersion >= 4) { result = true; } return result; }
private static void PatchSystemFolder_Add(string typeName, params string[] additionalContentTypeNames) { var ct = ContentType.GetByName(typeName); var xml = new XmlDocument(); var nsmgr = new XmlNamespaceManager(xml.NameTable); nsmgr.AddNamespace("x", ContentType.ContentDefinitionXmlNamespace); xml.Load(ct.Binary.GetStream()); var list = new List<string>(); var element = (XmlElement)xml.DocumentElement.SelectSingleNode("x:AllowedChildTypes", nsmgr); if (element == null) { var fieldsElement = (XmlElement)xml.DocumentElement.SelectSingleNode("x:Fields", nsmgr); //if (fieldsElement == null) //{ //} element = xml.CreateElement("", "AllowedChildTypes", ContentType.ContentDefinitionXmlNamespace); xml.DocumentElement.InsertBefore(element, fieldsElement); } else { list.AddRange(element.InnerXml.Split(" \t\r\n,;".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries).Select(x=>x.Trim())); } if (additionalContentTypeNames != null && additionalContentTypeNames.Length > 0) list.AddRange(additionalContentTypeNames); element.InnerText = string.Join(" ", list); ContentTypeInstaller.InstallContentType(xml.OuterXml); }
/// <summary> /// Evaluates the given expression and returns the typed result. /// </summary> public static object Evaluate(string expression, XPathNavigator source, XmlNamespaceManager context, params XPathVariable[] variables) { XPathExpression expr = GetCompiledExpression(expression, source); expr.SetContext(PrepareContext(source, context, null, variables)); return source.Evaluate(expr); }
/// <summary> /// Evaluates the given expression and returns the typed result. /// </summary> public static object Evaluate(string expression, XPathNavigator source, XmlNamespaceManager context) { XPathExpression expr = GetCompiledExpression(expression, source); expr.SetContext(context); return source.Evaluate(expr); }
public async Task<List<Link>> GetReutersTechRss() { var list = new List<Link>(); var data = await fetchUrl("http://feeds.reuters.com/reuters/technologyNews?format=xml"); if (data != null) { var xmlDoc = new XmlDocument(); xmlDoc.LoadXml(data); var ns = new XmlNamespaceManager(xmlDoc.NameTable); ns.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); ns.AddNamespace("taxo", "http://purl.org/rss/1.0/modules/taxonomy/"); ns.AddNamespace("dc", "http://purl.org/dc/elements/1.1/"); ns.AddNamespace("itunes", "http://www.itunes.com/dtds/podcast-1.0.dtd"); ns.AddNamespace("feedburner", "http://rssnamespace.org/feedburner/ext/1.0"); XmlNodeList urlList; urlList = xmlDoc.SelectNodes("//item", ns); foreach(XmlNode node in urlList) { var myNode = node; list.Add(new Link() { Title = node["title"].InnerText, Url = node["link"].InnerText, Description = node["description"].InnerText }); } } return list; }
/// <summary> /// Write this document's schema mappings from the given XML document /// </summary> /// <param name="node">The node.</param> /// <param name="mgr">The namespace manager.</param> protected override void ReadSchemaMappings(System.Xml.XmlNode node, System.Xml.XmlNamespaceManager mgr) { foreach (XmlNode map in node.ChildNodes) { if (map.Name != "SchemaMapping") //NOXLATE { continue; } var prv = map.Attributes["provider"]; //NOXLATE if (prv == null) { throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedAttribute, "provider")); } var sn = map.Attributes["name"]; if (sn == null) { throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedAttribute, "name")); } foreach (XmlNode clsMap in map.ChildNodes) { if (clsMap.Name != "complexType") //NOXLATE { continue; } var cn = clsMap.Attributes["name"]; //NOXLATE if (cn == null) { throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedAttribute, "name")); } var rdf = clsMap.FirstChild; if (rdf == null || rdf.Name != "RasterDefinition") { throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedElement, "RasterDefinition")); } RasterWmsItem item = new RasterWmsItem(); item.SchemaName = sn.Value; item.ReadXml(rdf, mgr); this.AddRasterItem(item); } } }
List <PointLatLng> GetRoutePoints(string url) { List <PointLatLng> points = null; try { string route = GetContentUsingHttp(url); if (!string.IsNullOrEmpty(route)) { XmlDocument xmldoc = new XmlDocument(); xmldoc.LoadXml(route); System.Xml.XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(xmldoc.NameTable); xmlnsManager.AddNamespace("sm", "http://earth.google.com/kml/2.0"); ///Folder/Placemark/LineString/coordinates var coordNode = xmldoc.SelectSingleNode("/sm:kml/sm:Document/sm:Folder/sm:Placemark/sm:LineString/sm:coordinates", xmlnsManager); string[] coordinates = coordNode.InnerText.Split('\n'); if (coordinates.Length > 0) { points = new List <PointLatLng>(); foreach (string coordinate in coordinates) { if (coordinate != string.Empty) { string[] XY = coordinate.Split(','); if (XY.Length == 2) { double lat = double.Parse(XY[1], CultureInfo.InvariantCulture); double lng = double.Parse(XY[0], CultureInfo.InvariantCulture); points.Add(new PointLatLng(lat, lng)); } } } } } } catch (Exception ex) { Debug.WriteLine("GetRoutePoints: " + ex); } return(points); }
/// <summary> /// Constructs a schema from the contents of an XML specification. /// </summary> /// <param name="fileContents">The contents of a file that specifies the schema in XML.</param> public DataModelSchema(string fileContents) { // Initialize the object this.itemList = new List <ObjectSchema>(); this.relationList = new SortedList <string, RelationSchema>(); this.tableList = new SortedList <string, TableSchema>(); // Compile the schema to resolve all the types and qualified names. XmlSchemaSet xmlSchemaSet = new XmlSchemaSet(); XmlTextReader xmlTextReader = new XmlTextReader(new StringReader(fileContents)); XmlSchema primarySchema = XmlSchema.Read(xmlTextReader, new ValidationEventHandler(ValidationCallback)); xmlSchemaSet.Add(primarySchema); xmlSchemaSet.Compile(); // The namespace Teraque.DataModelGenerator is used to create qualified names from the XPath specifications. These are most useful in // following the key schemas back to the relevant table schemas. this.xmlNamespaceManager = new XmlNamespaceManager(new NameTable()); foreach (XmlSchema xmlSchema in xmlSchemaSet.Schemas()) { foreach (XmlQualifiedName xmlQualifiedName in xmlSchema.Namespaces.ToArray()) { this.xmlNamespaceManager.AddNamespace(xmlQualifiedName.Name, xmlQualifiedName.Namespace); } } // Initialize the data structures from primary schema in the set. foreach (XmlSchema xmlSchema in xmlSchemaSet.Schemas(primarySchema.TargetNamespace)) { this.name = xmlSchema.Id; this.targetNamespace = xmlSchema.TargetNamespace; this.version = Convert.ToDecimal(xmlSchema.Version); foreach (XmlSchemaObject xmlSchemaObject in xmlSchema.Items) { if (xmlSchemaObject is XmlSchemaAnnotation) { this.itemList.Add(new AnnotationSchema(this, xmlSchemaObject as XmlSchemaAnnotation)); } } } // The schema is parsed in two passes. The first evaluates the tables, keys and unique constraints. The second // evaluates the foreign keys and associates them with the parent and child tables. FirstPass(xmlSchemaSet); SecondPass(xmlSchemaSet); }
private int FillFilesFromResult(XmlDocument oResult, ref List <OracleUCMFile> files) { int searchRow = -1; try { int startRow, endRow, totalRows; // Setup Namespace manager System.Xml.XmlNamespaceManager oNSMgr = new System.Xml.XmlNamespaceManager(oResult.NameTable); //Add the namespaces used in Fusion Opportunity to the XmlNamespaceManager. oNSMgr.AddNamespace("env", "http://schemas.xmlsoap.org/soap/envelope/"); oNSMgr.AddNamespace("ns2", "http://www.oracle.com/UCM"); startRow = GetIntFromNode(oResult.SelectSingleNode("//ns2:Field[@name='StartRow']", oNSMgr)); endRow = GetIntFromNode(oResult.SelectSingleNode("//ns2:Field[@name='EndRow']", oNSMgr)); totalRows = GetIntFromNode(oResult.SelectSingleNode("//ns2:Field[@name='TotalRows']", oNSMgr)); if (endRow < totalRows) { searchRow = endRow + 1; } System.Xml.XmlNode oResp = oResult.SelectSingleNode("//ns2:ResultSet[@name='SearchResults']", oNSMgr); if (oResp != null) { foreach (XmlNode xnRow in oResp.ChildNodes) { OracleUCMFile tfile = new OracleUCMFile(); tfile.dID = GetIntFromNode(xnRow.SelectSingleNode("./ns2:Field[@name='dID']", oNSMgr)); tfile.dCreateDate = GetDateFromNode(xnRow.SelectSingleNode("./ns2:Field[@name='dCreateDate']", oNSMgr)); tfile.dDocTitle = xnRow.SelectSingleNode("./ns2:Field[@name='dDocTitle']", oNSMgr).InnerText; tfile.dDocType = xnRow.SelectSingleNode("./ns2:Field[@name='dDocType']", oNSMgr).InnerText; tfile.dOriginalName = xnRow.SelectSingleNode("./ns2:Field[@name='dOriginalName']", oNSMgr).InnerText; tfile.VaultFileSize = GetIntFromNode(xnRow.SelectSingleNode("./ns2:Field[@name='VaultFileSize']", oNSMgr)); tfile.dFormat = xnRow.SelectSingleNode("./ns2:Field[@name='dFormat']", oNSMgr).InnerText; files.Add(tfile); } } } catch (Exception ex) { searchRow = -1; LastErrorMessage = String.Format("Exception during FillFilesFromResult: {0}", ex.Message); } return(searchRow); }
/// <summary> /// Set the current element's content from the current XML node /// </summary> /// <param name="node"></param> /// <param name="mgr"></param> public void ReadXml(System.Xml.XmlNode node, System.Xml.XmlNamespaceManager mgr) { if (!node.Name.Equals("xs:schema")) //NOXLATE { throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedElement, "xs:schema")); } //Description var docNode = node.SelectSingleNode("xs:annotation/xs:documentation", mgr); //NOXLATE if (docNode != null) { this.Description = docNode.InnerText; } var tns = node.Attributes["targetNamespace"]; if (tns == null) { throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedAttribute, "targetNamespace")); } int lidx = tns.Value.LastIndexOf("/") + 1; //NOXLATE this.Name = tns.Value.Substring(lidx); //TODO: Description //Now handle classes if (node.ChildNodes.Count > 0) { XmlNodeList clsNodes = node.SelectNodes("xs:complexType", mgr); //NOXLATE foreach (XmlNode clsNode in clsNodes) { var nn = clsNode.Attributes["name"]; //NOXLATE if (nn == null) { throw new Exception(string.Format(Strings.ErrorBadDocumentExpectedAttribute, "name")); //NOXLATE } string name = Utility.DecodeFDOName(nn.Value.Substring(0, nn.Value.Length - "Type".Length)); //NOXLATE ClassDefinition cls = new ClassDefinition(name, string.Empty); //TODO: Description ((IFdoSerializable)cls).ReadXml(clsNode, mgr); this.AddClass(cls); } } }
public static System.Xml.XmlNamespaceManager GenericNamespace(XmlNameTable NameTable) { try { System.Xml.XmlNamespaceManager tmp = new System.Xml.XmlNamespaceManager(NameTable); tmp.AddNamespace("message", message); tmp.AddNamespace("common", common); tmp.AddNamespace("generic", generic); tmp.AddNamespace("xsi", xsi); tmp.AddNamespace("schemaLocation", schemaLocation); return(tmp); } catch (Exception ex) { throw new Exception("Error, [Common.CommonNameSpace.GenericNamespace] " + ex.Message); } }
private async void LoadResources(string version) { resources = null; var themeResourcesXaml = File.ReadAllText((await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Resources/{version}/themeresources.xaml"))).Path); var genericXaml = File.ReadAllText((await Windows.Storage.StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Resources/{version}/generic.xaml"))).Path); var themeresources = Windows.UI.Xaml.Markup.XamlReader.Load(themeResourcesXaml) as ResourceDictionary; var generic = Windows.UI.Xaml.Markup.XamlReader.Load(genericXaml) as ResourceDictionary; var themes = themeresources.ThemeDictionaries.ToArray(); var dics = themeresources.MergedDictionaries.ToArray(); var byType = themeresources.GroupBy(g => g.Value.GetType()).ToArray(); List <DataModel> items = new List <DataModel>(); XmlDocument doc = new XmlDocument(); doc.LoadXml(themeResourcesXaml); System.Xml.XmlNamespaceManager manager = new System.Xml.XmlNamespaceManager(new NameTable()); manager.AddNamespace("d", "http://schemas.microsoft.com/winfx/2006/xaml/presentation"); manager.AddNamespace("x", "http://schemas.microsoft.com/winfx/2006/xaml"); var root = doc.DocumentElement; List <ResourceDictionaryModel> themeModels = new List <ResourceDictionaryModel>(); foreach (var theme in themeresources.ThemeDictionaries) { var themeModel = new ResourceDictionaryModel { Key = theme.Key as string }; var themeName = theme.Key; XmlNode nodeList = root.SelectSingleNode($"/d:ResourceDictionary/d:ResourceDictionary.ThemeDictionaries/d:ResourceDictionary[@x:Key='{themeName}']", manager); var value = theme.Value as ResourceDictionary; var themeByType = value.GroupBy(g => g.Value.GetType()).ToArray(); themeModel.Resources = value.Select(t => new DataModel(t, nodeList.ChildNodes.OfType <XmlNode>().Where(node => node.Attributes["x:Key"].Value == t.Key as string).FirstOrDefault())).OrderBy(t => t.Key).ToList(); themeModels.Add(themeModel); } Themes.SelectedIndex = -1; resources = themeresources.Select(t => new DataModel(t, root.ChildNodes.OfType <XmlNode>().Where(node => node.Attributes["x:Key"]?.Value == t.Key as string).FirstOrDefault())).OrderBy(t => t.Key).ToList(); Themes.ItemsSource = themeModels; if (themeModels.Count > 0) { Themes.SelectedIndex = 0; } else { UpdateDataView(); } }
public static System.Xml.XmlNamespaceManager RegistryNamespace(XmlNameTable NameTable) { try { System.Xml.XmlNamespaceManager tmp = new System.Xml.XmlNamespaceManager(NameTable); tmp.AddNamespace("message", message); tmp.AddNamespace("common", common); tmp.AddNamespace("registry", registry); tmp.AddNamespace("structure", structure); tmp.AddNamespace("xsi", xsi); tmp.AddNamespace("schemaLocation", schemaLocation); return(tmp); } catch (Exception ex) { throw new Exception("Error, [Common.CommonNameSpace.RegistryNamespace] " + ex.Message); } }
/// <summary> /// 对 本结点(xNode) 的 Namespace 注册 /// </summary> /// <param name="xNode">含有或继承有命名空间的结点</param> /// <param name="xNameSpaceManager">命名空间管理器</param> /// <returns>返回该 Namespace 的 prefix</returns> public static string AutoPrefix(System.Xml.XmlNode xNode, System.Xml.XmlNamespaceManager xNameSpaceManager) { string xPrefix; if (xNode.NamespaceURI == string.Empty) { return(string.Empty); } else { xPrefix = xNameSpaceManager.LookupPrefix(xNode.NamespaceURI); if (xPrefix == null || xPrefix == string.Empty) { xPrefix = "x" + xNode.GetHashCode().ToString(); xNameSpaceManager.AddNamespace(xPrefix, xNode.NamespaceURI); } return(xPrefix + (xPrefix.Length > 0 ? ":" : "")); } }
/// <summary> /// Get a vaule from complet xml document /// </summary> /// <param name="doc">Loaded xml document</param> /// <param name="nodeName">Path of node</param> /// <param name="xmlnsManager">namespace manager</param> /// <returns>value of path</returns> public static string GetFromXML(XmlDocument doc, string nodeName, System.Xml.XmlNamespaceManager xmlnsManager = null, bool text = true) { string temp = string.Empty; XmlNode node = null; if (xmlnsManager != null) { node = doc.SelectSingleNode(nodeName, xmlnsManager); } else { node = doc.SelectSingleNode(nodeName); } if (node != null) { temp = text ? node.InnerText : node.InnerXml; } return(HTMLAgilityUtils.removeNRT(temp)); }
private void SendNotify(string sid, string url) { try { HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url); webRequest.Method = "NOTIFY"; webRequest.ContentType = "text/xml; charset=\"utf-8\""; webRequest.Headers.Add("NT", "upnp:event"); webRequest.Headers.Add("NTS", "upnp:propchange"); webRequest.Headers.Add("SID", "uuid:" + sid); webRequest.Headers.Add("SEQ", String.Format("{0}", ++subseq)); var doc = new XmlDocument(); doc.LoadXml(Properties.Resources.notify); System.Xml.XmlNamespaceManager nsmgr = new System.Xml.XmlNamespaceManager(doc.NameTable); nsmgr.AddNamespace("e", "urn:schemas-upnp-org:event-1-0"); var xProperty = doc.SelectSingleNode("//e:property", nsmgr); var xElement = doc.CreateElement("SystemUpdateID"); xElement.InnerText = systemID.ToString(); xProperty.AppendChild(xElement); byte[] requestBytes = new System.Text.UTF8Encoding().GetBytes(doc.OuterXml); using (var reqstream = webRequest.GetRequestStream()) { reqstream.Write(requestBytes, 0, requestBytes.Length); } using (var res = webRequest.GetResponse()) { } } catch (System.Net.WebException e) { //subscribers.Remove(sid); Error(string.Format("SendNotify failed {0} {1}", sid, url), e); } catch (Exception exn) { Error("SendNotify failed" + exn.Message, exn); } }
private string ReadXMLValue( System.Xml.XmlNode node, string path, System.Xml.XmlNamespaceManager nsm) { System.Xml.XmlNode node2 = node.SelectSingleNode(path, nsm); if (node2 == null) { return(null); } else { if (node2 is System.Xml.XmlElement) { return(((System.Xml.XmlElement)node2).InnerText); } else { return(node2.Value); } } }
public static MapInfoDocument Parse(XDocument xmldoc, System.Xml.XmlNamespaceManager NameSpaceManager) { MapInfoDocument doc = new MapInfoDocument(); doc.map = new CT_MapInfo(); doc.map.Map = new System.Collections.Generic.List <CT_Map>(); foreach (XElement mapNode in xmldoc.XPathSelectElements("d:MapInfo/d:Map", NameSpaceManager)) { CT_Map ctMap = new CT_Map(); ctMap.ID = XmlHelper.ReadUInt(mapNode.GetAttributeNode("ID")); ctMap.Name = XmlHelper.ReadString(mapNode.GetAttributeNode("Name")); ctMap.RootElement = XmlHelper.ReadString(mapNode.GetAttributeNode("RootElement")); ctMap.SchemaID = XmlHelper.ReadString(mapNode.GetAttributeNode("SchemaID")); ctMap.ShowImportExportValidationErrors = XmlHelper.ReadBool(mapNode.GetAttributeNode("ShowImportExportValidationErrors")); ctMap.PreserveFormat = XmlHelper.ReadBool(mapNode.GetAttributeNode("PreserveFormat")); ctMap.PreserveSortAFLayout = XmlHelper.ReadBool(mapNode.GetAttributeNode("PreserveSortAFLayout")); ctMap.Append = XmlHelper.ReadBool(mapNode.GetAttributeNode("Append")); ctMap.AutoFit = XmlHelper.ReadBool(mapNode.GetAttributeNode("AutoFit")); doc.map.Map.Add(ctMap); } doc.map.Schema = new System.Collections.Generic.List <CT_Schema>(); foreach (XElement schemaNode in xmldoc.XPathSelectElements("d:MapInfo/d:Schema", NameSpaceManager)) { CT_Schema ctSchema = new CT_Schema(); ctSchema.ID = schemaNode.AttributeValue("ID"); if (schemaNode.Attribute("Namespace") != null) { ctSchema.Namespace = schemaNode.AttributeValue("Namespace"); } if (schemaNode.Attribute("SchemaRef") != null) { ctSchema.Namespace = schemaNode.AttributeValue("SchemaRef"); } ctSchema.InnerXml = schemaNode.InnerXml(); doc.map.Schema.Add(ctSchema); } return(doc); }
protected virtual XmlNamespaceManager GetNamespaceManager(IPDFComponent owner) { System.Xml.NameTable nt = new System.Xml.NameTable(); System.Xml.XmlNamespaceManager mgr = new System.Xml.XmlNamespaceManager(nt); IPDFRemoteComponent parsed = this.GetParsedParent(owner); IDictionary <string, string> parsedNamespaces = null; //add the namespaces of the last parsed document so we can infer any declarations if (null != parsed) { parsedNamespaces = parsed.GetDeclaredNamespaces(); if (null != parsedNamespaces) { foreach (string prefix in parsedNamespaces.Keys) { mgr.AddNamespace(prefix, parsedNamespaces[prefix]); } } } return(mgr); }
/// <summary> /// Load the SSAS namespaces into a XmlNameSpaceManager. These are used for XPath /// queries into a SSAS file /// </summary> /// <param name="document">XML Document to load namespaces for</param> /// <returns>XmlNamespaceManager loaded with SSAS namespaces</returns> private static XmlNamespaceManager LoadSsasNamespaces(XmlDocument document) { XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(document.NameTable); //xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlnsManager.AddNamespace("xsd", "http://www.w3.org/2001/XMLSchema"); //xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlnsManager.AddNamespace("xsi", "http://www.w3.org/2001/XMLSchema-instance"); //xmlns:ddl2="http://schemas.microsoft.com/analysisservices/2003/engine/2" xmlnsManager.AddNamespace("ddl2", "http://schemas.microsoft.com/analysisservices/2003/engine/2"); //xmlns:ddl2_2="http://schemas.microsoft.com/analysisservices/2003/engine/2/2" xmlnsManager.AddNamespace("ddl2_2", "http://schemas.microsoft.com/analysisservices/2003/engine/2/2"); //xmlns:ddl100_100="http://schemas.microsoft.com/analysisservices/2008/engine/100/100" xmlnsManager.AddNamespace("ddl100_100", "http://schemas.microsoft.com/analysisservices/2008/engine/100/100"); //xmlns:dwd="http://schemas.microsoft.com/DataWarehouse/Designer/1.0" xmlnsManager.AddNamespace("dwd", "http://schemas.microsoft.com/DataWarehouse/Designer/1.0"); //xmlns="http://schemas.microsoft.com/analysisservices/2003/engine" xmlnsManager.AddNamespace("AS", "http://schemas.microsoft.com/analysisservices/2003/engine"); xmlnsManager.AddNamespace("msprop", "urn:schemas-microsoft-com:xml-msprop"); xmlnsManager.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema"); xmlnsManager.AddNamespace("msdata", "urn:schemas-microsoft-com:xml-msdata"); return(xmlnsManager); }
DirectionsStatusCode GetDirectionsUrl(string url, out GDirections direction) { DirectionsStatusCode ret = DirectionsStatusCode.UNKNOWN_ERROR; direction = null; try { string route = GMaps.Instance.UseRouteCache ? Cache.Instance.GetContent(url, CacheType.DirectionsCache) : string.Empty; if (string.IsNullOrEmpty(route)) { route = GetContentUsingHttp(url); if (!string.IsNullOrEmpty(route)) { if (GMaps.Instance.UseRouteCache) { Cache.Instance.SaveContent(url, CacheType.DirectionsCache, route); } } } #region -- gpx response -- //<?xml version="1.0" encoding="UTF-8"?> //<gpx creator="" version="1.1" xmlns="http://www.topografix.com/GPX/1/1" // xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" // xsi:schemaLocation="http://www.topografix.com/GPX/1/1 gpx.xsd "> // <extensions> // <distance>293</distance> // <time>34</time> // <start>Perckhoevelaan</start> // <end>Goudenregenlaan</end> // </extensions> // <wpt lat="51.17702" lon="4.39630" /> // <wpt lat="51.17656" lon="4.39655" /> // <wpt lat="51.17639" lon="4.39670" /> // <wpt lat="51.17612" lon="4.39696" /> // <wpt lat="51.17640" lon="4.39767" /> // <wpt lat="51.17668" lon="4.39828" /> // <wpt lat="51.17628" lon="4.39874" /> // <wpt lat="51.17618" lon="4.39888" /> // <rte> // <rtept lat="51.17702" lon="4.39630"> // <desc>Head south on Perckhoevelaan, 0.1 km</desc> // <extensions> // <distance>111</distance> // <time>13</time> // <offset>0</offset> // <distance-text>0.1 km</distance-text> // <direction>S</direction> // <azimuth>160.6</azimuth> // </extensions> // </rtept> // <rtept lat="51.17612" lon="4.39696"> // <desc>Turn left at Laarstraat, 0.1 km</desc> // <extensions> // <distance>112</distance> // <time>13</time> // <offset>3</offset> // <distance-text>0.1 km</distance-text> // <direction>NE</direction> // <azimuth>58.1</azimuth> // <turn>TL</turn> // <turn-angle>269.0</turn-angle> // </extensions> // </rtept> // <rtept lat="51.17668" lon="4.39828"> // <desc>Turn right at Goudenregenlaan, 70 m</desc> // <extensions> // <distance>70</distance> // <time>8</time> // <offset>5</offset> // <distance-text>70 m</distance-text> // <direction>SE</direction> // <azimuth>143.4</azimuth> // <turn>TR</turn> // <turn-angle>89.8</turn-angle> // </extensions> // </rtept> // </rte> //</gpx> #endregion if (!string.IsNullOrEmpty(route)) { XmlDocument xmldoc = new XmlDocument(); xmldoc.LoadXml(route); System.Xml.XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(xmldoc.NameTable); xmlnsManager.AddNamespace("sm", "http://www.topografix.com/GPX/1/1"); XmlNodeList wpts = xmldoc.SelectNodes("/sm:gpx/sm:wpt", xmlnsManager); if (wpts != null && wpts.Count > 0) { ret = DirectionsStatusCode.OK; direction = new GDirections(); direction.Route = new List <PointLatLng>(); foreach (XmlNode w in wpts) { double lat = double.Parse(w.Attributes["lat"].InnerText, CultureInfo.InvariantCulture); double lng = double.Parse(w.Attributes["lon"].InnerText, CultureInfo.InvariantCulture); direction.Route.Add(new PointLatLng(lat, lng)); } if (direction.Route.Count > 0) { direction.StartLocation = direction.Route[0]; direction.EndLocation = direction.Route[direction.Route.Count - 1]; } XmlNode n = xmldoc.SelectSingleNode("/sm:gpx/sm:metadata/sm:copyright/sm:license", xmlnsManager); if (n != null) { direction.Copyrights = n.InnerText; } n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:distance", xmlnsManager); if (n != null) { direction.Distance = n.InnerText + "m"; } n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:time", xmlnsManager); if (n != null) { direction.Duration = n.InnerText + "s"; } n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:start", xmlnsManager); if (n != null) { direction.StartAddress = n.InnerText; } n = xmldoc.SelectSingleNode("/sm:gpx/sm:extensions/sm:end", xmlnsManager); if (n != null) { direction.EndAddress = n.InnerText; } wpts = xmldoc.SelectNodes("/sm:gpx/sm:rte/sm:rtept", xmlnsManager); if (wpts != null && wpts.Count > 0) { direction.Steps = new List <GDirectionStep>(); foreach (XmlNode w in wpts) { GDirectionStep step = new GDirectionStep(); double lat = double.Parse(w.Attributes["lat"].InnerText, CultureInfo.InvariantCulture); double lng = double.Parse(w.Attributes["lon"].InnerText, CultureInfo.InvariantCulture); step.StartLocation = new PointLatLng(lat, lng); XmlNode nn = w.SelectSingleNode("sm:desc", xmlnsManager); if (nn != null) { step.HtmlInstructions = nn.InnerText; } nn = w.SelectSingleNode("sm:extensions/sm:distance-text", xmlnsManager); if (nn != null) { step.Distance = nn.InnerText; } nn = w.SelectSingleNode("sm:extensions/sm:time", xmlnsManager); if (nn != null) { step.Duration = nn.InnerText + "s"; } direction.Steps.Add(step); } } } } } catch (Exception ex) { ret = DirectionsStatusCode.ExceptionInCode; direction = null; Debug.WriteLine("GetDirectionsUrl: " + ex); } return(ret); }