private void expandNamespace_namespace(TreeNodeCollection outNodes, TreeNode outInstanceMethods, string strSection, string strNamespace, XmlReader reader) { bool bContinue = reader.ReadToDescendant("namespace"); while (bContinue) { if (reader.GetAttribute("name") == strNamespace) { expandNamespace_function(outNodes, outInstanceMethods, strSection, strNamespace, reader.ReadSubtree()); reader.Close(); return; } bContinue = ReadToNextSibling(reader, "namespace"); } reader.Close(); }
private XmlDocument ReadXMLDocument() { System.Xml.XmlDocument Doc = new System.Xml.XmlDocument(); MemoryStream Buffer = default(MemoryStream); System.Xml.XmlReader XMLReader = default(System.Xml.XmlReader); byte B = 0; Buffer = new MemoryStream(); do { B = pReader.ReadByte(); if (B == 0) { break; } Buffer.WriteByte(B); }while (true); Buffer.Flush(); Buffer.Seek(0, SeekOrigin.Begin); XMLReader = System.Xml.XmlReader.Create(Buffer, pXMLSettings); Doc.Load(XMLReader); XMLReader.Close(); return(Doc); }
public bool Load(string FileName) { if (!File.Exists(FileName)) return false; if ((new FileInfo(FileName).Length) == 0) { File.Delete(FileName); return false; } F = XmlReader.Create(FileName); try { F.MoveToContent(); } catch (Exception) { F.Close(); File.Delete(FileName); return false; } return true; }
void ReadResults(XmlReader reader) { CodeCoverageModule currentModule = null; CodeCoverageMethod currentMethod = null; string currentClassName = String.Empty; while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: if (reader.Name == "Type") { currentModule = AddModule(reader); currentClassName = reader.GetAttribute("name"); } else if ((reader.Name == "Method") && (currentModule != null)) { currentMethod = AddMethod(currentModule, currentClassName, reader); } else if ((reader.Name == "pt") && (currentMethod != null)) { AddSequencePoint(currentMethod, reader); } else if (reader.Name == "File") { AddFileName(reader); } else if (reader.Name == "Assembly") { AddAssembly(reader); } break; } } reader.Close(); }
/// <summary> /// Executes an XMLA command on the tabular model for the connection. /// </summary> /// <param name="server"></param> /// <param name="commandStatement"></param> /// <returns>XmlNodeList containing results of the command execution.</returns> public static XmlNodeList ExecuteXmlaCommand(Microsoft.AnalysisServices.Core.Server server, string catalog, string commandStatement, ref bool foundFault) { XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined); WriteSoapEnvelopeWithCommandStatement(xmlWriter, server.SessionID, catalog, commandStatement); System.Xml.XmlReader xmlReader = server.EndXmlaRequest(); xmlReader.MoveToContent(); string fullEnvelopeResponseFromServer = xmlReader.ReadOuterXml(); xmlReader.Close(); XmlDocument documentResponse = new XmlDocument(); documentResponse.LoadXml(fullEnvelopeResponseFromServer); XmlNamespaceManager nsmgr = new XmlNamespaceManager(documentResponse.NameTable); nsmgr.AddNamespace("myns1", "urn:schemas-microsoft-com:xml-analysis"); nsmgr.AddNamespace("myns2", "urn:schemas-microsoft-com:xml-analysis:rowset"); XmlNodeList rows = documentResponse.SelectNodes("//myns1:ExecuteResponse/myns1:return/myns2:root/myns2:row", nsmgr); if (rows.Count == 0 && documentResponse.GetElementsByTagName("faultcode").Count > 0) { foundFault = true; } return(rows); }
XDocument settings; //xml settings document #endregion Fields #region Constructors public DataHandler() { //instantiate lists history = new History(); bookmarks = new Bookmarks(); //set path to user.home path = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\settings.xml"; //Read xml from user home, if no document exist, skip try { reader = XmlTextReader.Create(@path); settings = XDocument.Load(reader); //create objects and lists from xml loadBookmarks(); loadHistory(); loadHomePage(); reader.Close(); } catch (FileNotFoundException) { //skip this step } }
void ReadResults(XmlReader reader) { CodeCoverageModule currentModule = null; CodeCoverageMethod currentMethod = null; string currentClassName = String.Empty; while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: if (reader.Name == "Type") { currentModule = AddModule(reader); currentClassName = reader.GetAttribute("name"); } else if ((reader.Name == "Method") && (currentModule != null) && (!reader.IsEmptyElement)) { currentMethod = AddMethod(currentModule, currentClassName, reader); } else if ((reader.Name == "pt") && (currentMethod != null)) { AddSequencePoint(currentMethod, reader); } else if (reader.Name == "File") { AddFileName(reader); } else if (reader.Name == "Assembly") { AddAssembly(reader); } break; case XmlNodeType.EndElement: if (currentMethod != null && reader.Name == "Method" && currentMethod.SequencePoints.Count == 0) { // Remove method that has no sequence points. currentModule.Methods.Remove(currentMethod); } break; } } reader.Close(); RemoveModulesWithNoMethods(); }
public string Task1() { reader = XmlReader.Create(FILE_NAME); decimal in_v = 0; decimal out_v = 0; while (reader.Read()) { if (reader.IsStartElement()) { switch (reader.Name) { case IN_V: if(reader.Read()) in_v += Convert.ToDecimal(reader.Value.Trim()); break; case OUT_V: if (reader.Read()) out_v += Convert.ToDecimal(reader.Value.Trim()); break; } } } reader.Close(); return IN_V + in_v.ToString() + "\n" + OUT_V + out_v.ToString(); }
private void updateLastPost() { reader = XmlReader.Create(URL); SyndicationFeed feed = SyndicationFeed.Load(reader); reader.Close(); lastPost = feed.Items.First(); }
public ApiResponse <T> ReadXml <T>(string fileName) { var response = new ApiResponse <T>(); string fileSysName = fileName; FileStream fs = null; System.Xml.XmlReader reader = null; //--------------------------------------------------------------------- try { fs = new FileStream(fileSysName, FileMode.Open, FileAccess.Read, FileShare.Read); reader = XmlReader.Create(fs); var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); //todo use DI for serializer var obj = serializer.Deserialize(reader); response.Data = (T)obj; } catch (Exception e) { response.Status.SetError(-1, "Xml error reading/deserializing file: " + fileSysName, e); } finally { reader?.Close(); fs?.Close(); } return(response); }
static XmlDocument ParseTextAssetToXMLDocument(TextAsset textasset) { XmlDocument xmlDoc = new XmlDocument(); //because of annoying feature of Unity, that the way to read UTF-8 XML, we need to skip BOM(byte order mark) //but for XML without UTF-8 character, we MUST NOT skip first character. //so, we firstly not skip BOM, try to load XML, if it fail, then try skip BOM to parse again. bool parseOK = false; //1. not SKIP first character try { xmlDoc.LoadXml(textasset.text); parseOK = true; return(xmlDoc); } catch (System.Exception exc) { Debug.Log("It seems we need to skip BOM at XML:" + textasset.name + "\n" + exc.StackTrace); parseOK = false; } //if 1. fail, skip BOM, and parse again. if (parseOK == false) { System.IO.StringReader stringReader = new System.IO.StringReader(textasset.text); stringReader.Read(); // skip BOM System.Xml.XmlReader reader = System.Xml.XmlReader.Create(stringReader); xmlDoc.Load(reader); reader.Close(); stringReader.Close(); } return(xmlDoc); }
private void expandNamespace_function(TreeNodeCollection outNodes, string strSection, string strNamespace, XmlReader reader) { bool bContinue = reader.ReadToDescendant("function"); while (bContinue) { NodeDocPythonFunction node = newnode(strSection, strNamespace, reader.GetAttribute("name")); outNodes.Add(node); bool bInstance = reader.GetAttribute("instance") == "true"; node.bIsInstanceMethod = bInstance; string strSyntax = reader.GetAttribute("fullsyntax"); if (strSyntax != null && strSyntax != "") node.strFullSyntax = strSyntax; node.strDocumentation = getFunctionDocAndExample(reader.ReadSubtree()); //assumes doc before example if (this.emphasizeStaticness()) { if (!bInstance) { //change visible node text to emphasize static-ness node.Text = node.strNamespacename + "." + node.strFunctionname; } } bContinue = ReadToNextSibling(reader, "function"); } reader.Close(); }
internal Disc (XmlReader reader) { reader.Read (); int.TryParse (reader ["sectors"], out sectors); id = reader ["id"]; reader.Close (); }
private void expandNamespace_function(TreeNodeCollection outNodes, TreeNode outInstanceMethods, string strSection, string strNamespace, XmlReader reader) { bool bContinue = reader.ReadToDescendant("function"); while (bContinue) { // if (reader.GetAttribute("args") != null) MessageBox.Show("instance?"); NodeDocLnzFunction node = new NodeDocLnzFunction(strSection, strNamespace, reader.GetAttribute("name")); bool bInstance = reader.GetAttribute("instance") == "true"; node.bIsInstanceMethod = bInstance; string strArgs = reader.GetAttribute("args"); if (strArgs != null && strArgs != "") node.strArguments = strArgs; string strReturns = reader.GetAttribute("returns"); if (strReturns != null && strReturns != "") node.strReturns = strReturns; node.strDocumentationAndExample = getFunctionDocAndExample(reader.ReadSubtree()); //assumes doc before example if (bInstance) { //MessageBox.Show("instance found"); outInstanceMethods.Nodes.Add(node); } else outNodes.Add(node); bContinue = ReadToNextSibling(reader, "function"); } reader.Close(); }
/// <summary> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { // Need a specific parser IParser subparser = null; IFeed ret = null; string localRootName = reader.LocalName.ToLower().Trim(); if (localRootName == "rss" || localRootName == "rdf") { subparser = new RssFeedParser(); } else if (localRootName == "feed") { subparser = new AtomFeedParser(); } if (subparser != null) { using (XmlReader subreader = reader.ReadSubtree()) { ret = (IFeed)subparser.Parse <T>(subreader); } } else { throw new Exception(string.Format("Unknown feed type '{0}'.", reader.Name)); } reader.Close(); return((T)ret); }
private static void ReadXmlSerializable(DataTable dt, XmlReader xr) { XmlSerializer serializer = new XmlSerializer(dt.GetType()); IXmlSerializable idt = dt; idt.ReadXml(xr); xr.Close(); }
private string ReadOuterXml(XmlReader forReader) { try { forReader.MoveToContent(); return forReader.ReadOuterXml(); } finally { forReader.Close(); } }
/// <summary> /// Serializes an object instance to a file. /// </summary> /// <param name="instance">the object instance to serialize</param> /// <param name="resultBuffer">The result buffer.</param> /// <param name="throwExceptions">if set to <c>true</c> [throw exceptions].</param> /// <returns></returns> /// <summary> /// Serializes an object to an XML string. Unlike the other SerializeObject overloads /// this methods *returns a string* rather than a bool result! /// </summary> /// <param name="instance"></param> /// <param name="throwExceptions">Determines if a failure throws or returns null</param> /// <returns> /// null on error otherwise the Xml String. /// </returns> /// <remarks> /// If null is passed in null is also returned so you might want /// to check for null before calling this method. /// </remarks> /// <summary> /// Deserializes an object from file and returns a reference. /// </summary> /// <param name="fileName">name of the file to serialize to</param> /// <param name="objectType">The Type of the object. Use typeof(yourobject class)</param> /// <param name="binarySerialization">determines whether we use Xml or Binary serialization</param> /// <returns>Instance of the deserialized object or null. Must be cast to your object type</returns> /// <summary> /// Deserializes an object from file and returns a reference. /// </summary> /// <param name="fileName">name of the file to serialize to</param> /// <param name="objectType">The Type of the object. Use typeof(yourobject class)</param> /// <param name="binarySerialization">determines whether we use Xml or Binary serialization</param> /// <param name="throwExceptions">determines whether failure will throw rather than return null on failure</param> /// <returns>Instance of the deserialized object or null. Must be cast to your object type</returns> /// <summary> /// Deserialize an object from an XmlReader object. /// </summary> /// <param name="reader"></param> /// <param name="objectType"></param> /// <returns></returns> public static object DeSerializeObject(XmlReader reader, Type objectType) { var serializer = new XmlSerializer(objectType); var instance = serializer.Deserialize(reader); reader.Close(); return instance; }
/// <exclude /> public void Compile(XmlReader reader, IFormChannelIdentifier channel, Dictionary<string, object> bindingObjects, bool withDebug, string customControlIdPrefix, Dictionary<string, List<ClientValidationRule>> bindingsValidationRules) { XDocument doc = XDocument.Load(reader); reader.Close(); Compile(doc, channel, bindingObjects, withDebug, customControlIdPrefix, bindingsValidationRules); }
protected override void DeserializePropertyElement(XmlReader reader) { if (reader.Name.ToLower () == "optional") { optional = true; reader.Close (); } else { base.DeserializePropertyElement (reader); } }
/// <summary> /// Deserialize an object from an XmlReader object. /// </summary> /// <param name="reader"></param> /// <param name="ObjectType"></param> /// <returns></returns> public static object DeSerializeObject(System.Xml.XmlReader reader, Type ObjectType) { XmlSerializer serializer = new XmlSerializer(ObjectType); object Instance = serializer.Deserialize(reader); reader.Close(); return(Instance); }
public override void Close() { if (!Settings.KeepOpen) { if (reader != null) { reader.Close(); } } }
private void ProcessDataReader(XmlReader reader) { ResultsListBox.Items.Clear(); while (reader.Read()) { ResultsListBox.Items.Add(reader.ReadOuterXml()); //MessageBox.Show(reader.ReadOuterXml()); } reader.Close(); }
/// <summary> /// Parse the data from specified Uri into a document. /// </summary> /// <param name="document">The document instance to store the gained data in.</param> /// <param name="xmlTextReader">XmlTextReader instance</param> protected virtual void Parse(OpmlDocument document, System.Xml.XmlReader xmlTextReader) { try { System.Diagnostics.Debug.Assert(xmlTextReader != null); // xmlTextReader.MoveToContent(); if (xmlTextReader.Name != "opml") { throw new FormatException(xmlTextReader.BaseURI + " is no valid Opml File"); } // read the stream forward while not end of file int currentDepth = -1; System.Collections.Hashtable nodeLevels = new System.Collections.Hashtable(); // while (!xmlTextReader.EOF) { // process head if (xmlTextReader.Name == "head" && xmlTextReader.NodeType == XmlNodeType.Element) { document.Head = new OpmlHead(xmlTextReader); } // process outline and child outlines else if (xmlTextReader.Name == "outline" && xmlTextReader.NodeType == XmlNodeType.Element) { currentDepth = xmlTextReader.Depth; // OpmlOutline o = OnCreateOutline(xmlTextReader); if (currentDepth == 2) { document.Body.Items.Add(o); // new node nodeLevels.Clear(); } else { ((OpmlOutline)nodeLevels[xmlTextReader.Depth - 1]).Items.Add(o); } nodeLevels[xmlTextReader.Depth] = o; } else { xmlTextReader.Read(); xmlTextReader.MoveToContent(); } } } finally { if (xmlTextReader != null) { xmlTextReader.Close(); } } }
/// <summary> /// 反序列化Xml /// </summary> /// <typeparam name="T"></typeparam> /// <param name="targetFile"></param> /// <returns></returns> public T XmlFileDeserialize <T>(string targetFile) { System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); StringBuilder sb = new StringBuilder(); System.Xml.XmlReader reader = System.Xml.XmlReader.Create(targetFile); object deobj = serializer.Deserialize(reader); reader.Close(); return((T)deobj); }
protected override void DeserializePropertyElement(XmlReader reader) { if (reader.Name.ToLower () == "optional") { IsOptional = true; reader.Close (); } else if (reader.Name.ToLower () == "sendeventsattribute") { SendsEvents = reader.ReadString ().Trim () == "yes"; } else { base.DeserializePropertyElement (reader); } }
protected string getFunctionDocAndExample(XmlReader reader) { //assumes doc is before example. Otherwise, could miss an example. string strRes = ""; bool bFound = reader.ReadToDescendant("doc"); if (bFound) strRes += (unencodeXml(reader.ReadString())); bFound = reader.ReadToNextSibling("example"); if (bFound) strRes += ("\r\n\r\nExample:\r\n" + unencodeXml(reader.ReadString())); reader.Close(); return strRes; }
public static List <T> DeserializeParams <T>(XDocument doc) { System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(List <T>)); System.Xml.XmlReader reader = doc.CreateReader(); List <T> result = (List <T>)serializer.Deserialize(reader); reader.Close(); return(result); }
/// <summary> /// 反序列化xml /// </summary> /// <typeparam name="t"></typeparam> /// <param name="targetfile"></param> /// <returns></returns> public T XmlDeserialize <T>(string xml) { System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); System.IO.MemoryStream stream = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(xml)); System.Xml.XmlReader reader = System.Xml.XmlReader.Create(stream); object deobj = serializer.Deserialize(reader); reader.Close(); stream.Close(); return((T)deobj); }
protected XDocument ExecuteDVMQuery(Server server, string query) { System.Xml.XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined); WriteDVMEnvelope(xmlWriter, query); System.Xml.XmlReader xmlReader = server.EndXmlaRequest(); xmlReader.MoveToContent(); XDocument doc = XDocument.Load(xmlReader); xmlReader.Close(); return(doc); }
public ISMStream(Stream stream) { ISMElement ismElement = null; try { xmlReader = XmlReader.Create(stream); // crude parser while (xmlReader.Read()) { if (xmlReader.NodeType != XmlNodeType.Element) { continue; } if (xmlReader.Name == "audio" || xmlReader.Name == "video") { // ismElement MUST be null at this point if (ismElement != null) throw new Exception("ISMFile: time scale param not found"); ismElement = new ISMElement(); if (xmlReader.Name == "audio") { ismElement.FragmentType = FragmentType.Audio; } else if (xmlReader.Name == "video") { ismElement.FragmentType = FragmentType.Video; } ismElement.Source = xmlReader.GetAttribute("src"); ismElement.Bitrate = long.Parse(xmlReader.GetAttribute("systemBitrate")); } else if (xmlReader.Name == "param") { string paramName = xmlReader.GetAttribute("name"); string attributeValue = xmlReader.GetAttribute("value"); if (paramName == "trackID") { ismElement.TrackID = int.Parse(attributeValue); } else if (paramName == "timeScale") { ismElement.TimeScale = uint.Parse(attributeValue); ismElements.Add(ismElement); ismElement = null; } } } } catch { throw; } finally { if (xmlReader != null) { xmlReader.Close(); } } }
private XPathDocument CreateAndCacheDocument(XmlReader r) { string uri = r.BaseURI; XPathDocument doc = new XPathDocument(r, XmlSpace.Preserve); r.Close(); lock (_cache) { if (!_cache.ContainsKey(uri)) _cache.Add(uri, new WeakReference(doc)); } return doc; }
internal Event(XmlReader reader) { reader.Read (); date = reader ["date"]; country = reader ["country"]; catalog_number = reader ["catalog-number"]; barcode = reader ["barcode"]; format = Utils.StringToEnum<ReleaseFormat> (reader ["format"]); if (reader.ReadToDescendant ("label")) { label = new Label (reader.ReadSubtree ()); reader.Read (); // FIXME this is a workaround for Mono bug 334752 } reader.Close (); }
private static bool EsCFDIXmlValido(List <String> PathsXSD, System.IO.StringReader XMLPath, out List <string> Errores) { try { // 0- Initialize variables... _IsValid = true; Resultado = new List <string>(); // 1- Read XML file content Reader = new System.Xml.XmlTextReader(XMLPath); // 3- Create a new instance of XmlSchema object System.Xml.Schema.XmlSchema Schema = new System.Xml.Schema.XmlSchema(); System.Xml.XmlReaderSettings ReaderSettings = new System.Xml.XmlReaderSettings(); // 2- Read Schema file content foreach (String XSD in PathsXSD) { StreamReader SR = new StreamReader(XSD); Schema = System.Xml.Schema.XmlSchema.Read(SR, new System.Xml.Schema.ValidationEventHandler(ReaderSettings_ValidationEventHandler)); ReaderSettings.ValidationType = System.Xml.ValidationType.Schema; ReaderSettings.Schemas.Add(Schema); } // 8- Add your ValidationEventHandler address to // XmlReaderSettings ValidationEventHandler ReaderSettings.ValidationEventHandler += new System.Xml.Schema.ValidationEventHandler(ReaderSettings_ValidationEventHandler); // 9- Create a new instance of XmlReader object System.Xml.XmlReader objXmlReader = System.Xml.XmlReader.Create(Reader, ReaderSettings); // 10- Read XML content in a loop while (objXmlReader.Read()) { // empty loop } // Se cierra el validador objXmlReader.Close(); Errores = Resultado; return(_IsValid); } catch (Exception ex) { Errores = new List <string>(); Errores.Add("Error de validacion del XML Error:" + ex.ToString()); return(true); } }
private void btnConvert_Click(object sender, EventArgs e) { scale = float.Parse(txtScale.Text, NumberFormatInfo); worldsize = float.Parse(txtWorldSize.Text, NumberFormatInfo); x = float.Parse(txtX.Text, NumberFormatInfo); z = float.Parse(txtZ.Text, NumberFormatInfo); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.IndentChars = " "; Log("Creating nodes.xml"); writer = XmlWriter.Create("nodes.xml", settings); // write writer.WriteStartDocument(); writer.WriteStartElement("nodes"); writer.WriteAttributeString("count", "0"); // process grass Log("Reading " + txtGrassFilename.Text); reader = XmlReader.Create(txtGrassFilename.Text); int grassnodes = ConvertGrass(reader, writer); reader.Close(); Log("Exported " + grassnodes + " grassnodes."); // process trees Log("Reading " + txtTreeFilename.Text); reader = XmlReader.Create(txtTreeFilename.Text); int treenodes = ConvertTrees(reader, writer); reader.Close(); Log("Exported " + treenodes + " treenodes."); // end writer.WriteEndElement(); writer.WriteEndDocument(); writer.Close(); int sum = grassnodes + treenodes; Log("Sum: " + sum.ToString() + " nodes."); // replace count Log("Replacing count in nodes.xml"); string s = System.IO.File.ReadAllText("nodes.xml"); System.IO.File.WriteAllText("nodes.xml", s.Replace("count=\"0\"", "count=\"" + sum + "\"")); Log("Export finished."); }
public static T ExecuteXmlCommand <T>(SqlCommand sqlCommand, DataLocationEnum dataLocation) { string connectionString = GetSqlConnectionString(dataLocation); using (SqlConnection cn = new SqlConnection(connectionString)) { cn.Open(); sqlCommand.Connection = cn; System.Xml.XmlReader xmlReader = sqlCommand.ExecuteXmlReader(); T item = YellowstonePathology.Business.Domain.Persistence.SerializationHelper.DeserializeItem <T>(xmlReader); xmlReader.Close(); return(item); } }
//public static string HostAddress //{ // get // { // foreach (IPAddress address in Dns.GetHostAddresses (Dns.GetHostName ())) { // if (address.AddressFamily == AddressFamily.InterNetwork) { // return address; // } // } // } //} public static Version DeserializeSpecVersion(XmlReader reader) { try { // We assume the elements appear in this order reader.ReadToFollowing ("major"); reader.Read (); var major = reader.ReadContentAsInt (); reader.ReadToFollowing ("minor"); reader.Read (); var minor = reader.ReadContentAsInt (); return new Version (major, minor); } catch (Exception e) { throw new UpnpDeserializationException ("There was a problem deserializing a spec version.", e); } finally { reader.Close (); } }
private XPathDocument CreateAndCacheDocument(XmlReader r) { string uri = r.BaseURI; XPathDocument doc = new XPathDocument(r, XmlSpace.Preserve); r.Close(); //Can't cache documents with empty base URI if (!string.IsNullOrEmpty(uri)) { lock (_cache) { if (!_cache.ContainsKey(uri)) _cache.Add(uri, new WeakReference(doc)); } } return doc; }
/// <summary> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { IOpmlFeed ret = new OpmlFeed(); bool readContent = false; while (readContent || reader.Read()) { readContent = false; if (reader.NodeType == XmlNodeType.Element) { readContent = true; switch (reader.Name) { case "head": using (XmlReader subReader = reader.ReadSubtree()) { ret.Head = ConvertToIOpmlHead(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "body": using (XmlReader subReader = reader.ReadSubtree()) { ret.Body = ConvertToIOpmlBody(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; default: UnhandledElement(ret, reader); break; } } } reader.Close(); return((T)ret); }
/// <summary> /// Releases the unmanaged resources used by the ComponentLibrary and optionally releases the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> private void Dispose(bool disposing) { if (!this._disposed) { if (disposing) { _xmlReader.Close(); _input.Close(); if (_ownsInputStream) { _input.Dispose(); } } _disposed = true; } }
//RETORNA TABELA NO FORMATO DE STRING XML public string ReturnStrXml() { string strXml = ""; try { DateTime datStart = DateTime.Now; if (this._XmlCmd == null) { SetConn(); GenericCLX.CS.Util objUtil = new GenericCLX.CS.Util(); //objUtil.GetConfig(""); _XmlCmd = new SqlXmlCommand(objUtil.ConnectionStringXML()); _XmlCmd.OutputEncoding = "ISO-8859-1"; _XmlCmd.RootTag = "ROOT"; } _XmlCmd.CommandText = this._Sql; System.Xml.XmlReader objXr = _XmlCmd.ExecuteXmlReader(); XmlDocument objXd = new XmlDocument(); objXd.Load(objXr); strXml = objXd.OuterXml; objXd = null; objXr.Close(); objXr = null; if (this._CloseConn) { _XmlCmd = null; } this._TimeQuery = Functions.DateDiff(datStart.ToLocalTime().ToString()); } catch (Exception e) { if (TreatedError(e.Message)) { this.ReturnStrXml(); } } return(strXml); }
private static XDocument StartAndEndXmlaRequest(Server server, string query) { // Step 1: start the XML/A request. System.Xml.XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined); // Step 2: write the XML/A request. WriteSoapEnvelope(xmlWriter, query); // Step 3: end the XML/A request and get the System.Xml.XmlReader for parsing the result from server. System.Xml.XmlReader xmlReader = server.EndXmlaRequest(); // Step 4: read/parse the XML/A response from server. xmlReader.MoveToContent(); XDocument doc = XDocument.Load(xmlReader); // Step 5: close the System.Xml.XmlReader, to release the connection for future use. xmlReader.Close(); return(doc); }
public static List <T> DeserializeParamsListOf <T>(string xmlFilename) { List <T> result; XDocument xdoc = XDocument.Load(xmlFilename); try { System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(List <T>)); System.Xml.XmlReader reader = xdoc.CreateReader(); result = (List <T>)serializer.Deserialize(reader); reader.Close(); } finally { } return(result); }
public void post(Subreddit subreddit) { reader = XmlReader.Create(URL); SyndicationFeed feed = SyndicationFeed.Load(reader); reader.Close(); foreach (SyndicationItem item in feed.Items) { if(item.Title.Text == lastPost.Title.Text) { break; } else { try { postItem(item, subreddit); } catch (Exception) { } } } }
protected XDocument WriteDiscoverSchemaQuery(Server server, string type) { System.Xml.XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined); xmlWriter.WriteStartElement("Envelope", "http://schemas.xmlsoap.org/soap/envelope/"); xmlWriter.WriteStartElement("Body"); xmlWriter.WriteStartElement("Discover", "urn:schemas-microsoft-com:xml-analysis"); xmlWriter.WriteElementString("RequestType", type); xmlWriter.WriteStartElement("Restrictions"); xmlWriter.WriteEndElement(); // </Restrictions> xmlWriter.WriteStartElement("Properties"); xmlWriter.WriteEndElement(); // </Properties> xmlWriter.WriteEndElement(); // </Discover> xmlWriter.WriteEndElement(); // </Body> xmlWriter.WriteEndElement(); // </Envelope> System.Xml.XmlReader xmlReader = server.EndXmlaRequest(); xmlReader.MoveToContent(); XDocument doc = XDocument.Load(xmlReader); xmlReader.Close(); return(doc); }
//The Sum operation operates on the WCF Message object directly public Message Sum(Message request) { int sum = 0; string text = ""; //The body of the message contains a list of numbers which will be read directly using an XmlReader System.Xml.XmlReader body = request.GetReaderAtBodyContents(); while (body.Read()) { text = body.ReadString().Trim(); if (text.Length > 0) { sum += Convert.ToInt32(text, CultureInfo.InvariantCulture); } } body.Close(); Message response = Message.CreateMessage(request.Version, "http://Microsoft.Samples.XmlReader/ICalculator/SumResponse", sum); return(response); }
public static Manifest Create(XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } var configurationNode = new Manifest(); // no attributes on the root node; just process child elements while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case ArgumentsElementName: ReadArgumentsElement(reader.ReadSubtree(), configurationNode.DefaultArguments); break; case OutputElementName: configurationNode.Outputs.Add(ReadOutputElement(reader.ReadSubtree())); break; case RenameElementName: ReadRenameElement(reader.ReadSubtree(), configurationNode.RenameIdentifiers); break; case NoRenameElementName: ReadNoRenameElement(reader.ReadSubtree(), configurationNode.NoRenameIdentifiers); break; } } } reader.Close(); return configurationNode; }
/// <summary> /// Pretty prints XML document using XmlWriter's formatting functionality. /// </summary> /// <param name="reader">Source XML reader</param> /// <param name="options">Parsed command line options</param> public static void PrettyPrint(XmlReader reader, NXsltOptions options) { XmlWriterSettings writerSettings = new XmlWriterSettings(); writerSettings.Indent = true; writerSettings.NewLineOnAttributes = true; writerSettings.Encoding = new UTF8Encoding(false); XmlWriter writer; if (options.OutFile != null) { //Pretty print to a file writer = XmlWriter.Create(options.OutFile, writerSettings); } else { //Pretty print to the console writer = XmlWriter.Create(Console.Out, writerSettings); } while (reader.ReadState != ReadState.EndOfFile) { writer.WriteNode(reader, false); } writer.Close(); reader.Close(); }
public async Task <HttpResponseMessage> PostRawBufferManual() { string connStr = ""; string loc = ""; try { string request = await Request.Content.ReadAsStringAsync(); var addin = Globals.ThisAddIn; var app = addin.Application; var wb = app.ActiveWorkbook; loc = wb.FullName; //@"D:\Data\Presentations\Drop Your DAX\demos\02 DAX filter similar.xlsx"; // parse request looking for workbook name in Workstation ID // we are using the Workstation ID property to tunnel the location property through // from the UI to the PowerPivot engine. The Location property does not appear to get // serialized through into the XMLA request so we "hijack" the Workstation ID var wsid = ParseRequestForWorkstationID(request); if (!string.IsNullOrEmpty(wsid)) { Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "Resetting Location based on WorkstationID to: " + loc); loc = wsid; } connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location=\"{0}\"", loc); //connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location={0}", loc); // 2010 conn str //connStr = string.Format("Provider=MSOLAP.5;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Cell Error Mode=TextValue;Location={0}", loc); //connStr = string.Format("Provider=MSOLAP;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Location={0};", loc); Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "About to Load AmoWrapper"); AmoWrapper.AmoType amoType = AmoWrapper.AmoType.AnalysisServices; if (float.Parse(app.Version, CultureInfo.InvariantCulture) >= EXCEL_2013) { amoType = AmoWrapper.AmoType.Excel; Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "Loading Microsoft.Excel.Amo"); } else { Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "defaulting to Microsoft.AnalysisServices"); } var svr = new AmoWrapper.AmoServer(amoType); svr.Connect(connStr); // STEP 1: send the request to server. Log.Verbose("{class} {method} request: {request}", "XmlaController", "PostRawBufferManual", request); System.IO.TextReader streamWithXmlaRequest = new StringReader(request); System.Xml.XmlReader xmlaResponseFromServer = null; // will be used to parse the XML/A response from server string fullEnvelopeResponseFromServer = ""; try { //xmlaResponseFromServer = svr.SendXmlaRequest( XmlaRequestType.Undefined, streamWithXmlaRequest); xmlaResponseFromServer = svr.SendXmlaRequest(streamWithXmlaRequest); // STEP 2: read/parse the XML/A response from server. xmlaResponseFromServer.MoveToContent(); fullEnvelopeResponseFromServer = xmlaResponseFromServer.ReadOuterXml(); } catch (Exception ex) { Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex); //result = new HttpResponseMessage(HttpStatusCode.InternalServerError); //result.Content = new StringContent(String.Format("An unexpected error occurred (sending XMLA request): \n{0}", ex.Message)); } finally { streamWithXmlaRequest.Close(); } HttpResponseMessage result; try { result = new HttpResponseMessage(HttpStatusCode.OK); result.Content = new StringContent(fullEnvelopeResponseFromServer); result.Content.Headers.ContentType = new MediaTypeHeaderValue("text/xml"); result.Headers.TransferEncodingChunked = true; } catch (Exception ex) { Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex); result = new HttpResponseMessage(HttpStatusCode.InternalServerError); result.Content = new StringContent(String.Format("An unexpected error occurred (reading XMLA response): \n{0}", ex.Message)); } finally { // STEP 3: close the System.Xml.XmlReader, to release the connection for future use. if (xmlaResponseFromServer != null) { xmlaResponseFromServer.Close(); } } return(result); } catch (Exception ex) { Log.Error("ERROR Connecting: {class} {method} loc: '{loc}' conn:'{connStr}' ex: {exception}", "XmlaController", "PostRawBufferManual", loc, connStr, ex); var expResult = new HttpResponseMessage(HttpStatusCode.InternalServerError); expResult.Content = new StringContent(String.Format("An unexpected error occurred: \n{0}", ex.Message)); return(expResult); } }
/// <summary> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { IAtomFeed ret = (IAtomFeed) new AtomFeed(); reader.Read(); bool readContent = false; while (readContent || reader.Read()) { readContent = false; if (reader.NodeType == XmlNodeType.Element) { readContent = true; switch (reader.Name) { case "id": ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString(), reader.BaseURI); break; case "title": ret.Title = reader.ReadElementContentAsString(); break; case "updated": ret.LastUpdated = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString()); break; case "generator": using (XmlReader subReader = reader.ReadSubtree()) { ret.Generator = ConvertToIAtomGenerator(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "author": using (XmlReader subReader = reader.ReadSubtree()) { ret.Authors.Add(ConvertToIAtomPerson(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "link": using (XmlReader subReader = reader.ReadSubtree()) { ret.Links.Add(ConvertToIAtomLink(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "category": using (XmlReader subReader = reader.ReadSubtree()) { ret.Categories.Add(ConvertToIAtomCategory(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "entry": using (XmlReader subReader = reader.ReadSubtree()) { ret.Items.Add(ParseItem(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "contributor": using (XmlReader subReader = reader.ReadSubtree()) { ret.Contributors.Add(ConvertToIAtomPerson(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "logo": ret.Logo = reader.ReadElementContentAsString(); break; case "icon": ret.Icon = reader.ReadElementContentAsString(); break; case "rights": using (XmlReader subReader = reader.ReadSubtree()) { ret.Rights = ConvertToIAtomText(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "subtitle": using (XmlReader subReader = reader.ReadSubtree()) { ret.Subtitle = ConvertToIAtomText(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; default: UnhandledElement(ret, reader); break; } } } reader.Close(); return((T)ret); }
// Closes the stream, changes the ReadState to Closed, and sets all the properties back to zero. public override void Close() { _coreReader.Close(); _cacheState = CachingReaderState.ReaderClosed; }
/// <summary> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { IRssFeed ret = (IRssFeed) new RssFeed(); reader.Read(); // RDF versions of RSS don't have version tags. //double version = double.Parse(reader.GetAttribute("version")); reader.ReadToDescendant("channel"); bool readContent = false; while (readContent || reader.Read()) { readContent = false; if (reader.NodeType == XmlNodeType.Element) { readContent = true; switch (reader.Name) { case "title": ret.Title = reader.ReadElementContentAsString(); break; case "link": ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString()); break; case "description": ret.Description = reader.ReadElementContentAsString(); break; case "language": ret.Culture = CachedPropertiesProvider.ConvertToCultureInfo(reader.ReadElementContentAsString()); break; case "copyright": ret.Copyright = reader.ReadElementContentAsString(); break; case "managingEditor": ret.ManagingEditor = reader.ReadElementContentAsString(); break; case "webMaster": ret.WebMaster = reader.ReadElementContentAsString(); break; case "pubDate": ret.PublicationDate = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString()); break; case "lastBuildDate": ret.LastChanged = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString()); break; case "category": using (XmlReader subReader = reader.ReadSubtree()) { ret.Category = ConvertToIRssCategory(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "generator": ret.Generator = reader.ReadElementContentAsString(); break; case "docs": ret.Doc = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString()); break; case "cloud": using (XmlReader subReader = reader.ReadSubtree()) { ret.Cloud = ConvertToIRssCloud(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "ttl": ret.TimeToLive = CachedPropertiesProvider.ConvertToInt(reader.ReadElementContentAsString()); break; case "image": using (XmlReader subReader = reader.ReadSubtree()) { ret.Image = ConvertToIRssImage(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; /*case "rating": * break;*/ case "textInput": using (XmlReader subReader = reader.ReadSubtree()) { ret.TextInput = ConvertToIRssTextInput(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "skipHours": using (XmlReader subReader = reader.ReadSubtree()) { ret.SkipHours = ConvertToSkipHourList(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "skipDays": using (XmlReader subReader = reader.ReadSubtree()) { ret.SkipDays = ConvertToDayOfWeekList(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "item": using (XmlReader itemReader = reader.ReadSubtree()) { ret.Items.Add(ParseItem(itemReader)); } if (reader.IsEmptyElement) { readContent = false; } break; default: UnhandledElement(ret, reader); break; } } } reader.Close(); return((T)ret); }
/* public static void SaveTemplates () { if (!Directory.Exists (TemplatePath)) Directory.CreateDirectory (TemplatePath); foreach (string templateFile in Directory.GetFiles (TemplatePath, "*.xml")) { File.Delete (templateFile); } foreach (CodeTemplate template in templates) { if (string.IsNullOrEmpty (template.Shortcut)) { LoggingService.LogError ("CodeTemplateService: Can't save unnamed template " + template); continue; } SaveTemplate (template, Path.Combine (TemplatePath, template.Shortcut + ".template.xml")); } }*/ static List<CodeTemplate> LoadTemplates (XmlReader reader) { List<CodeTemplate> result = new List<CodeTemplate> (); try { while (reader.Read ()) { if (reader.IsStartElement ()) { switch (reader.LocalName) { case Node: string fileVersion = reader.GetAttribute (VersionAttribute); if (fileVersion != Version) return null; break; case CodeTemplate.Node: result.Add (CodeTemplate.Read (reader)); break; } } } } catch (Exception e) { LoggingService.LogError ("CodeTemplateService: Exception while loading template.", e); return null; } finally { reader.Close (); } return result; }
int RecurseWorkUnit(AssetType in_type, System.IO.FileInfo in_workUnit, string in_currentPathInProj, string in_currentPhysicalPath, LinkedList <AkWwiseProjectData.PathElement> in_pathAndIcons, string in_parentPhysicalPath = "") { m_WwuToProcess.Remove(in_workUnit.FullName); System.Xml.XmlReader reader = null; int wwuIndex = -1; try { //Progress bar stuff string msg = "Parsing Work Unit " + in_workUnit.Name; EditorUtility.DisplayProgressBar(s_progTitle, msg, (float)m_currentWwuCnt / (float)m_totWwuCnt); m_currentWwuCnt++; in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name)); in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name), AkWwiseProjectData.WwiseObjectType.WORKUNIT)); string WwuPhysicalPath = System.IO.Path.Combine(in_currentPhysicalPath, in_workUnit.Name); AkWwiseProjectData.WorkUnit wwu = null; ReplaceWwuEntry(WwuPhysicalPath, in_type, out wwu, out wwuIndex); wwu.ParentPhysicalPath = in_parentPhysicalPath; wwu.PhysicalPath = WwuPhysicalPath; wwu.Guid = ""; wwu.SetLastTime(System.IO.File.GetLastWriteTime(in_workUnit.FullName)); reader = System.Xml.XmlReader.Create(in_workUnit.FullName); reader.MoveToContent(); reader.Read(); while (!reader.EOF && reader.ReadState == System.Xml.ReadState.Interactive) { if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("WorkUnit")) { if (wwu.Guid.Equals("")) { wwu.Guid = reader.GetAttribute("ID"); } string persistMode = reader.GetAttribute("PersistMode"); if (persistMode == "Reference") { // ReadFrom advances the reader var matchedElement = System.Xml.Linq.XNode.ReadFrom(reader) as System.Xml.Linq.XElement; string newWorkUnitPath = System.IO.Path.Combine(in_workUnit.Directory.FullName, matchedElement.Attribute("Name").Value + ".wwu"); var newWorkUnit = new System.IO.FileInfo(newWorkUnitPath); // Parse the referenced Work Unit if (m_WwuToProcess.Contains(newWorkUnit.FullName)) { RecurseWorkUnit(in_type, newWorkUnit, in_currentPathInProj, in_currentPhysicalPath, in_pathAndIcons, WwuPhysicalPath); } } else { // If the persist mode is "Standalone" or "Nested", it means the current XML tag // is the one corresponding to the current file. We can ignore it and advance the reader reader.Read(); } } else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("AuxBus")) { in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name")); in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.AUXBUS)); bool isEmpty = reader.IsEmptyElement; AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex); if (isEmpty) { in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar)); in_pathAndIcons.RemoveLast(); } } // Busses and folders act the same for the Hierarchy: simply add them to the path else if (reader.NodeType == System.Xml.XmlNodeType.Element && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus"))) { //check if node has children if (!reader.IsEmptyElement) { // Add the folder/bus to the path in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name")); if (reader.Name.Equals("Folder")) { in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.FOLDER)); } else if (reader.Name.Equals("Bus")) { in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.BUS)); } } // Advance the reader reader.Read(); } else if (reader.NodeType == System.Xml.XmlNodeType.EndElement && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus") || reader.Name.Equals("AuxBus"))) { // Remove the folder/bus from the path in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar)); in_pathAndIcons.RemoveLast(); // Advance the reader reader.Read(); } else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals(in_type.XmlElementName)) { // Add the element to the list AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex); } else { reader.Read(); } } // Sort the newly populated Wwu alphabetically SortWwu(in_type.RootDirectoryName, wwuIndex); } catch (System.Exception e) { Debug.LogError(e.ToString()); wwuIndex = -1; } if (reader != null) { reader.Close(); } in_pathAndIcons.RemoveLast(); return(wwuIndex); }
public bool ProcessMessage(MessagePackage message) { try { string xmlString = message.GetMessageXml(); string schemaFile = _param.GetFullPath(_config.SchemaFileName); try { _param.Log.Write(LogType.Debug, "Start Validate Meta File"); XmlReaderSettings rs = new XmlReaderSettings(); try { rs.ValidationType = ValidationType.Schema; rs.Schemas.Add(null, schemaFile); rs.ValidationEventHandler += new System.Xml.Schema.ValidationEventHandler(RS_ValidationEventHandler); } catch (Exception ex) { _param.Log.Write(LogType.Debug, "Load schema file error" + ex.Message); _isValid = false; return(false); } finally { } System.Xml.XmlReader xr = XmlReader.Create(new StringReader(xmlString), rs); try { while (xr.Read() && _isValid) { _param.Log.Write(LogType.Debug, "Read XML Information: " + xr.Value); } } catch (Exception ex) { _param.Log.Write(LogType.Error, "System gets error while reading XML, " + ex.Message); _isValid = false; } finally { xr.Close(); } } catch (Exception ex) { _param.Log.Write(LogType.Error, "System gets error while validateing XML, " + ex.Message); _isValid = false; } finally { } return(_isValid); } catch (Exception e) { WriteLog(e); return(false); } }
public override void Close() { CheckAsync(); _coreReader.Close(); }
private void BriefAction(XmlReader reader, ServiceAction action) { reader.Read (); foreach (Argument argument in action.Arguments.Values) { argument.Value = argument.RelatedStateVariable.DefaultValue; } while (Helper.ReadToNextElement (reader)) { if (!action.Arguments.ContainsKey (reader.Name)) { throw UpnpControlException.InvalidArgs (); } Argument argument = action.Arguments[reader.Name]; if (argument.RelatedStateVariable.DataType.IsEnum) { try { argument.Value = Enum.Parse (argument.RelatedStateVariable.DataType, reader.ReadString ()); } catch { throw UpnpControlException.ArgumentValueOutOfRange (); } } else { try { argument.Value = Convert.ChangeType (reader.ReadString (), argument.RelatedStateVariable.DataType); } catch { throw UpnpControlException.InvalidArgs (); } // TODO handle min, max, and step } } reader.Close (); }
// Closes the input stream ot TextReader, changes the ReadState to Closed and sets all properties to zero/string.Empty public override void Close() { _coreReader.Close(); _parsingFunction = ParsingFunction.ReaderClosed; }
/// <summary> /// Parses a highlighting definition. /// </summary> /// <param name="highlighter">The highlighting strategy, which is set.</param> /// <param name="syntaxMode">The syntax highlighting mode.</param> /// <param name="xmlReader">The XML reader.</param> /// <returns></returns> private static DefaultHighlightingStrategy Parse(DefaultHighlightingStrategy highlighter, SyntaxMode syntaxMode, XmlReader xmlReader) { if (syntaxMode == null) throw new ArgumentNullException("syntaxMode"); if (xmlReader == null) throw new ArgumentNullException("xmlReader"); try { List<ValidationEventArgs> errors = null; XmlReaderSettings settings = new XmlReaderSettings(); Stream shemaStream = typeof(HighlightingDefinitionParser).Assembly.GetManifestResourceStream("DigitalRune.Windows.TextEditor.Resources.Mode.xsd"); settings.Schemas.Add("", new XmlTextReader(shemaStream)); settings.Schemas.ValidationEventHandler += delegate(object sender, ValidationEventArgs args) { if (errors == null) { errors = new List<ValidationEventArgs>(); } errors.Add(args); }; settings.ValidationType = ValidationType.Schema; XmlReader validatingReader = XmlReader.Create(xmlReader, settings); XmlDocument doc = new XmlDocument(); doc.Load(validatingReader); if (highlighter == null) highlighter = new DefaultHighlightingStrategy(doc.DocumentElement.Attributes["name"].InnerText); if (doc.DocumentElement.HasAttribute("extends")) { KeyValuePair<SyntaxMode, ISyntaxModeFileProvider> entry = HighlightingManager.Manager.FindHighlighterEntry(doc.DocumentElement.GetAttribute("extends")); if (entry.Key == null) { throw new HighlightingDefinitionInvalidException("Cannot find referenced highlighting source " + doc.DocumentElement.GetAttribute("extends")); } else { highlighter = Parse(highlighter, entry.Key, entry.Value.GetSyntaxModeFile(entry.Key)); if (highlighter == null) return null; } } if (doc.DocumentElement.HasAttribute("extensions")) { highlighter.Extensions = doc.DocumentElement.GetAttribute("extensions").Split(new char[] { ';', '|' }); } XmlElement environment = doc.DocumentElement["Environment"]; if (environment != null) { foreach (XmlNode node in environment.ChildNodes) { if (node is XmlElement) { XmlElement el = (XmlElement) node; if (el.Name == "Custom") highlighter.SetColorFor(el.GetAttribute("name"), el.HasAttribute("bgcolor") ? new HighlightBackground(el) : new HighlightColor(el)); else highlighter.SetColorFor(el.Name, el.HasAttribute("bgcolor") ? new HighlightBackground(el) : new HighlightColor(el)); } } } // parse properties if (doc.DocumentElement["Properties"] != null) foreach (XmlElement propertyElement in doc.DocumentElement["Properties"].ChildNodes) highlighter.Properties[propertyElement.Attributes["name"].InnerText] = propertyElement.Attributes["value"].InnerText; if (doc.DocumentElement["Digits"] != null) highlighter.DigitColor = new HighlightColor(doc.DocumentElement["Digits"]); XmlNodeList nodes = doc.DocumentElement.GetElementsByTagName("RuleSet"); foreach (XmlElement element in nodes) highlighter.AddRuleSet(new HighlightRuleSet(element)); xmlReader.Close(); if (errors != null) { StringBuilder msg = new StringBuilder(); foreach (ValidationEventArgs args in errors) { msg.AppendLine(args.Message); } throw new HighlightingDefinitionInvalidException(msg.ToString()); } else { return highlighter; } } catch (Exception e) { throw new HighlightingDefinitionInvalidException("Could not load mode definition file '" + syntaxMode.FileName + "'.\n", e); } }
public override void Close() { reader.Close(); }