WriteTo() public method

public WriteTo ( XmlWriter w ) : void
w XmlWriter
return void
示例#1
1
        //ArrayList openElements = new ArrayList();
        public void SerializeXml(IList<StarSystem> starSystems)
        {
            MemoryStream memXmlStream = new MemoryStream();
            XmlSerializer serializer = new XmlSerializer(starSystems.GetType(), null, new Type[] { typeof(Planet), typeof(StarSystem) }, new XmlRootAttribute("Stars"), null, null);

            serializer.Serialize(memXmlStream, starSystems);

            XmlDocument xmlDoc = new XmlDocument();

            memXmlStream.Seek(0, SeekOrigin.Begin);
            xmlDoc.Load(memXmlStream);

            XmlProcessingInstruction newPI;
            String PItext = string.Format("type='text/xsl' href='{0}'", "system.xslt");
            newPI = xmlDoc.CreateProcessingInstruction("xml-stylesheet", PItext);

            xmlDoc.InsertAfter(newPI, xmlDoc.FirstChild);

            // Now write the document

            // out to the final output stream

            XmlTextWriter wr = new XmlTextWriter("system.xml", System.Text.Encoding.ASCII);
            wr.Formatting = Formatting.Indented;
            wr.IndentChar = '\t';
            wr.Indentation = 1;

            XmlWriterSettings settings = new XmlWriterSettings();
            XmlWriter writer = XmlWriter.Create(wr, settings);

            xmlDoc.WriteTo(writer);
            writer.Flush();
            //Console.Write(xmlDoc.InnerXml);
        }
示例#2
1
        /// <summary>
        /// Define o valor de uma configuração
        /// </summary>
        /// <param name="file">Caminho do arquivo (ex: c:\program.exe.config)</param>
        /// <param name="key">Nome da configuração</param>
        /// <param name="value">Valor a ser salvo</param>
        /// <returns></returns>
        public static bool SetValue(string file, string key, string value)
        {
            var fileDocument = new XmlDocument();
            fileDocument.Load(file);
            var nodes = fileDocument.GetElementsByTagName(AddElementName);

            if (nodes.Count == 0)
            {
                return false;
            }

            for (var i = 0; i < nodes.Count; i++)
            {
                var node = nodes.Item(i);
                if (node == null || node.Attributes == null || node.Attributes.GetNamedItem(KeyPropertyName) == null)
                    continue;
                
                if (node.Attributes.GetNamedItem(KeyPropertyName).Value == key)
                {
                    node.Attributes.GetNamedItem(ValuePropertyName).Value = value;
                }
            }

            var writer = new XmlTextWriter(file, null) { Formatting = Formatting.Indented };
            fileDocument.WriteTo(writer);
            writer.Flush();
            writer.Close();
            return true;
        }
示例#3
0
		public static int Main (string [] args)
		{
			if (args.Length == 0)
				return 1;

			AbiMode = false;

			AssemblyCollection acoll = new AssemblyCollection ();

			foreach (string arg in args) {
				if (arg == "--abi")
					AbiMode = true;
				else
					acoll.Add (arg);
			}

			XmlDocument doc = new XmlDocument ();
			acoll.Document = doc;
			acoll.DoOutput ();

			var writer = new WellFormedXmlWriter (new XmlTextWriter (Console.Out) { Formatting = Formatting.Indented });
			XmlNode decl = doc.CreateXmlDeclaration ("1.0", "utf-8", null);
			doc.InsertBefore (decl, doc.DocumentElement);
			doc.WriteTo (writer);
			return 0;
		}
示例#4
0
        private static void UpdateProjectFile(ParsedArgs pa)
        {
            //load the project file
            var template = new System.Xml.XmlDocument();

            template.Load(pa.TemplateFile);

            //update it

            RemoveTargets(template);
            AddTargets(template, pa.TargetsDirectory);

            UpdateReferencePaths(template);

            //write it back to disk

            var output = new System.Xml.XmlDocument();

            foreach (var node in template.ChildNodes.Cast <XmlNode>().Where(w => w.NodeType != XmlNodeType.XmlDeclaration))
            {
                var importNode = output.ImportNode(node, true);
                output.AppendChild(importNode);
            }

            using (var xWriter = XmlWriter.Create(pa.TemplateFile, new XmlWriterSettings()
            {
                Indent = true, IndentChars = " "
            }))
            {
                output.WriteTo(xWriter);
            }
        }
        /// <summary>
        /// Transform: read from an input stream and write to an output stream.
        /// </summary>
        public void Transform(Stream inputStream, Stream outputStream)
        {
            var document = new XmlDocument();
            document.PreserveWhitespace = true;
            document.Load(inputStream);

            foreach (XmlNode node in document.SelectNodes("/root/data/value"))
            {
                var child = node.FirstChild;
                if (child != null && child.NodeType == XmlNodeType.Text)
                {
                    var original = child.Value;
                    var args = new TransformStringEventArgs { Value = original };
                    OnTransformString(args);

                    if (args.Value != original)
                    {
                        child.Value = args.Value;
                    }
                }
            }

            using (var xmlWriter = XmlWriter.Create(outputStream))
            {
                document.WriteTo(xmlWriter);
            }
        }
        private string GetXmlDocumentAsString(XmlDocument xml)
        {
            var xmlString = string.Empty;

            using (var stream = new MemoryStream())
            {
                using (var streamWriter = new StreamWriter(stream))
                {
                    var xmlWriterSettings = new XmlWriterSettings();
                    xmlWriterSettings.Encoding = Encoding.UTF8;
                    xmlWriterSettings.Indent = true;

                    using (var xmlWriter = XmlWriter.Create(streamWriter, xmlWriterSettings))
                    {
                        xml.WriteTo(xmlWriter);
                        xmlWriter.Flush();
                        xmlWriter.Close();
                    }

                    using (var streamReader = new StreamReader(stream))
                    {
                        stream.Position = 0;
                        xmlString = streamReader.ReadToEnd();
                        streamReader.Close();
                    }
                }
            }

            return xmlString;
        }
示例#7
0
文件: Xml.cs 项目: ziyan/reactivity
 /// <summary>
 /// Converts a XmlDocument to string
 /// </summary>
 /// <param name="doc">XmlDocument to be converted</param>
 /// <returns>string with the xml content</returns>
 public static string Write(XmlDocument doc)
 {
     StringWriter sw = new StringWriter();
     XmlWriter xw = new XmlTextWriter(sw);
     doc.WriteTo(xw);
     return sw.ToString();
 }
 public ActionResult Create(string webConfigXml, string transformXml)
 {
     try
     {
         var transformation = new XmlTransformation(transformXml, false, null);
         var document = new XmlDocument();
         document.LoadXml(webConfigXml);
         var success = transformation.Apply(document);
         if (success)
         {
             var stringBuilder = new StringBuilder();
             var xmlWriterSettings = new XmlWriterSettings();
             xmlWriterSettings.Indent = true;
             xmlWriterSettings.IndentChars = "    ";
             using (var xmlTextWriter =
                 XmlTextWriter.Create(stringBuilder, xmlWriterSettings))
             {
                 document.WriteTo(xmlTextWriter);
             }
             return Content(stringBuilder.ToString(), "text/xml");
         }
         else
         {
             return ErrorXml("Transformation failed for unkown reason");
         }
     }
     catch (XmlTransformationException xmlTransformationException)
     {
         return ErrorXml(xmlTransformationException.Message);
     }
     catch (XmlException xmlException)
     {
         return ErrorXml(xmlException.Message);
     }
 }
        public string CreateXml(XmlDocument doc, string cookie, int page, int count)
        {
            if (doc.DocumentElement == null)
                throw new ArgumentNullException("DocumentElement");

            XmlAttributeCollection attrs = doc.DocumentElement.Attributes;

            if (cookie != null)
            {
                XmlAttribute pagingAttr = doc.CreateAttribute("paging-cookie");
                pagingAttr.Value = cookie;
                attrs.Append(pagingAttr);
            }

            XmlAttribute pageAttr = doc.CreateAttribute("page");
            pageAttr.Value = System.Convert.ToString(page);
            attrs.Append(pageAttr);

            XmlAttribute countAttr = doc.CreateAttribute("count");
            countAttr.Value = System.Convert.ToString(count);
            attrs.Append(countAttr);

            StringBuilder sb = new StringBuilder(1024);
            StringWriter stringWriter = new StringWriter(sb);

            XmlTextWriter writer = new XmlTextWriter(stringWriter);
            doc.WriteTo(writer);
            writer.Close();

            return sb.ToString();
        }
示例#10
0
        /// <summary>
        /// Converts the given XML string into a more readable format.
        /// </summary>
        internal static string PrettyPrintXml(string xml)
        {
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.OmitXmlDeclaration = true;
            settings.ConformanceLevel = ConformanceLevel.Fragment;
            settings.NewLineHandling = NewLineHandling.Replace;
            settings.NewLineChars = "\r\n";
            settings.Indent = true;
            settings.IndentChars = "\t";
            settings.NewLineOnAttributes = true;

            XmlDocument doc = new XmlDocument();
            try
            {
                doc.LoadXml(xml);
            }
            catch (Exception e)
            {
                throw new Exception("Invalid XML: " + xml, e);
            }

            var sb = new StringBuilder();
            using (var writer = XmlTextWriter.Create(sb, settings))
                doc.WriteTo(writer);

            return sb.ToString();
        }
        protected override string GetInnerResponse()
        {
            XmlDocument doc = new XmlDocument();
            XmlElement musicFoldersElem = doc.CreateElement("musicFolders");

            List<string> musicFolders = this.GetExampleFolderNames();
            for (int i=1;i<=musicFolders.Count;i++)
            {
                XmlElement folder = doc.CreateElement("musicFolder");
                XmlAttribute idAttr = doc.CreateAttribute("id");
                XmlAttribute nameAttr = doc.CreateAttribute("name");
                idAttr.Value = i.ToString();
                nameAttr.Value = musicFolders[i-1];
                folder.Attributes.Append(idAttr);
                folder.Attributes.Append(nameAttr);
                musicFoldersElem.AppendChild(folder);
            }

            doc.AppendChild(musicFoldersElem);

            StringWriter sw = new StringWriter();
            XmlTextWriter xtw = new XmlTextWriter(sw);

            doc.WriteTo(xtw);

            return sw.ToString();
        }
示例#12
0
        public static string PrettyPrint(XmlDocument xml)
        {
            var result = "";

            if (xml == null)
                return result;

            using (var ms = new MemoryStream())
            {
                var writer = new XmlTextWriter(ms, Encoding.Unicode);
                writer.Formatting = Formatting.Indented;

                xml.WriteTo(writer);

                writer.Flush();
                ms.Flush();

                ms.Position = 0;

                var reader = new StreamReader(ms);
                result = reader.ReadToEnd();

                writer.Close();
                reader.Close();

            }

            return result;
        }
        public override void Save(object value, string sectionName, string fileName)
        {
            XmlNode xmlNode = this.Serialize(value);
            XmlDocument document = new XmlDocument();
            document.AppendChild(document.ImportNode(xmlNode,true));

            // Encrypt xml
            EncryptXml enc = new EncryptXml(document);
            enc.AddKeyNameMapping("db", ReadServerEncryptionKey());

            XmlNodeList list = document.SelectNodes("//Password");

            foreach ( XmlNode n in list )
            {
                XmlElement el = (XmlElement)n;
                EncryptedData data = enc.Encrypt(el, "db");
                enc.ReplaceElement(el, data);
            }

            XmlTextWriter writer = new XmlTextWriter(fileName, null);
            writer.Formatting = Formatting.Indented;
            document.WriteTo(writer);
            writer.Flush();
            writer.Close();
        }
示例#14
0
        private void Init(string url)
        {
            XmlDocument xml = new XmlDocument();
            xml.Load(url);

            StringWriter xmlString = new StringWriter();
            xml.WriteTo(new XmlTextWriter(xmlString));
            m_DeviceXml = xmlString.ToString();

            // Set up namespace manager for XPath   
            XmlNamespaceManager ns = new XmlNamespaceManager(xml.NameTable);   
            ns.AddNamespace("n",xml.ChildNodes[1].NamespaceURI);

            m_BaseUrl          = xml.SelectSingleNode("n:root/n:URLBase",ns).InnerText;
            m_DeviceType       = xml.SelectSingleNode("n:root/n:device/n:deviceType",ns).InnerText;
            m_FriendlyName     = xml.SelectSingleNode("n:root/n:device/n:friendlyName",ns).InnerText;
            m_Manufacturer     = xml.SelectSingleNode("n:root/n:device/n:manufacturer",ns).InnerText;
            m_ManufacturerUrl  = xml.SelectSingleNode("n:root/n:device/n:manufacturerURL",ns).InnerText;
            m_ModelDescription = xml.SelectSingleNode("n:root/n:device/n:modelDescription",ns).InnerText;
            m_ModelName        = xml.SelectSingleNode("n:root/n:device/n:modelName",ns).InnerText;
            m_ModelNumber      = xml.SelectSingleNode("n:root/n:device/n:modelNumber",ns).InnerText;
            m_ModelUrl         = xml.SelectSingleNode("n:root/n:device/n:modelURL",ns).InnerText;
            m_SerialNumber     = xml.SelectSingleNode("n:root/n:device/n:serialNumber",ns).InnerText;
            m_UDN              = xml.SelectSingleNode("n:root/n:device/n:UDN",ns).InnerText;
            m_PresentationUrl  = xml.SelectSingleNode("n:root/n:device/n:presentationURL",ns).InnerText;
        }
示例#15
0
        public override void SignFile(String xmlFilePath, object xmlDigitalSignature)
        {
            XmlElement XmlDigitalSignature = (XmlElement)xmlDigitalSignature;
            XmlDocument Document = new XmlDocument();
            Document.PreserveWhitespace = true;
            XmlTextReader XmlFile = new XmlTextReader(xmlFilePath);
            Document.Load(XmlFile);
            XmlFile.Close();
            // Append the element to the XML document.
            Document.DocumentElement.AppendChild(Document.ImportNode(XmlDigitalSignature, true));

            if (Document.FirstChild is XmlDeclaration)
            {
                Document.RemoveChild(Document.FirstChild);
            }

            // Save the signed XML document to a file specified
            // using the passed string.
            using (XmlTextWriter textwriter = new XmlTextWriter(xmlFilePath, new UTF8Encoding(false)))
            {
                textwriter.WriteStartDocument();
                Document.WriteTo(textwriter);
                textwriter.Close();
            }
        }
        /// <summary>
        ///     Converts entries in a XML document.
        /// </summary>
        /// <param name="entries">The entries.</param>
        /// <returns>The XML document that represents the entries.</returns>
        public string Convert(IEnumerable<string> entries)
        {
            var doc = new XmlDocument();
            var xmlDeclaration = doc.CreateXmlDeclaration("1.0", "utf-8", null);
            var root = doc.DocumentElement;
            doc.InsertBefore(xmlDeclaration, root);

            var rootElement = doc.CreateElement("directory");
            foreach (var entry in entries)
            {
                var element = doc.CreateElement("entry");
                var textNode = doc.CreateTextNode(entry);
                element.AppendChild(textNode);
                rootElement.AppendChild(element);
            }

            doc.AppendChild(rootElement);

            using (var stringWriter = new StringWriter(CultureInfo.InvariantCulture))
            using (var xmlTextWriter = XmlWriter.Create(stringWriter))
            {
                doc.WriteTo(xmlTextWriter);
                xmlTextWriter.Flush();
                return stringWriter.GetStringBuilder().ToString();
            }
        }
        /// <summary>
        /// Creates the FetchXML Query.
        /// </summary>
        /// <param name="xml">The FetchXMLQuery.</param>
        /// <param name="cookie">The paging cookie.</param>
        /// <param name="page">The page number.</param>
        /// <param name="count">The records per page count.</param>
        /// <returns>Formatted FechXML Query</returns>
        protected string CreateXml(string xml, string cookie, int page, int count)
        {
            StringReader stringReader = new StringReader(xml);
            XmlTextReader reader = new XmlTextReader(stringReader);

            // Load document
            XmlDocument doc = new XmlDocument();
            doc.Load(reader);

            XmlAttributeCollection attrs = doc.DocumentElement.Attributes;

            if (cookie != null)
            {
                XmlAttribute pagingAttr = doc.CreateAttribute("paging-cookie");
                pagingAttr.Value = cookie;
                attrs.Append(pagingAttr);
            }

            XmlAttribute pageAttr = doc.CreateAttribute("page");
            pageAttr.Value = System.Convert.ToString(page);
            attrs.Append(pageAttr);

            XmlAttribute countAttr = doc.CreateAttribute("count");
            countAttr.Value = System.Convert.ToString(count);
            attrs.Append(countAttr);

            StringBuilder sb = new StringBuilder(1024);
            StringWriter stringWriter = new StringWriter(sb);

            XmlTextWriter writer = new XmlTextWriter(stringWriter);
            doc.WriteTo(writer);
            writer.Close();

            return sb.ToString();
        }
示例#18
0
        private void IntroduceErrorToMessage(ref Message message)
        {
            XmlDocument doc = new XmlDocument();
            doc.Load(message.GetReaderAtBodyContents());

            XmlNamespaceManager nsManager = new XmlNamespaceManager(doc.NameTable);
            nsManager.AddNamespace("tempuri", "http://tempuri.org/");
            XmlElement xNode = doc.SelectSingleNode("//tempuri:x", nsManager) as XmlElement;
            XmlText xValue = xNode.FirstChild as XmlText;
            xValue.Value = (double.Parse(xValue.Value, CultureInfo.InvariantCulture) + 1).ToString(CultureInfo.InvariantCulture);

            MemoryStream ms = new MemoryStream();
            XmlWriterSettings writerSettings = new XmlWriterSettings
            {
                CloseOutput = false,
                OmitXmlDeclaration = true,
                Encoding = Encoding.UTF8,
            };

            XmlWriter writer = XmlWriter.Create(ms, writerSettings);
            doc.WriteTo(writer);
            writer.Close();
            ms.Position = 0;
            XmlReader reader = XmlReader.Create(ms);

            Message newMessage = Message.CreateMessage(message.Version, null, reader);
            newMessage.Headers.CopyHeadersFrom(message);
            newMessage.Properties.CopyProperties(message.Properties);
            message.Close();
            message = newMessage;
        }
        // This function generates the XML request body
        // for the FolderSync request.
        protected override void GenerateXMLPayload()
        {
            // If WBXML was explicitly set, use that
            if (WbxmlBytes != null)
                return;

            // Otherwise, use the properties to build the XML and then WBXML encode it
            XmlDocument folderSyncXML = new XmlDocument();

            XmlDeclaration xmlDeclaration = folderSyncXML.CreateXmlDeclaration("1.0", "utf-8", null);
            folderSyncXML.InsertBefore(xmlDeclaration, null);

            XmlNode folderSyncNode = folderSyncXML.CreateElement(Xmlns.folderHierarchyXmlns, "FolderSync", Namespaces.folderHierarchyNamespace);
            folderSyncNode.Prefix = Xmlns.folderHierarchyXmlns;
            folderSyncXML.AppendChild(folderSyncNode);

            if (syncKey == "")
                syncKey = "0";

            XmlNode syncKeyNode = folderSyncXML.CreateElement(Xmlns.folderHierarchyXmlns, "SyncKey", Namespaces.folderHierarchyNamespace);
            syncKeyNode.Prefix = Xmlns.folderHierarchyXmlns;
            syncKeyNode.InnerText = syncKey;
            folderSyncNode.AppendChild(syncKeyNode);

            StringWriter sw = new StringWriter();
            XmlTextWriter xmlw = new XmlTextWriter(sw);
            xmlw.Formatting = Formatting.Indented;
            folderSyncXML.WriteTo(xmlw);
            xmlw.Flush();

            XmlString = sw.ToString();
        }
        // Accumulation format is now called Victory.
        private static void Upgrades0210()
        {
            var xml = new XmlDocument();
            if (Config.Settings.SeparateEventFiles)
            {
                var targetPath = Path.Combine(Program.BasePath, "Tournaments");
                if (!Directory.Exists(targetPath)) Directory.CreateDirectory(targetPath);
                var files = new List<string>(Directory.GetFiles(targetPath, "*.tournament.dat",
                    SearchOption.TopDirectoryOnly));
                files.AddRange(Directory.GetFiles(targetPath, "*.league.dat",
                    SearchOption.TopDirectoryOnly));
                foreach (string filename in files)
                {
                    xml.Load(filename);
                    var oldNodes = xml.SelectNodes("//Events/Tournaments/Tournament/Format[. = 'Accumulation']");
                    if (oldNodes != null)
                        foreach (XmlNode oldNode in oldNodes)
                            oldNode.InnerText = "Victory";
                    oldNodes = xml.SelectNodes("//Events/Leagues/League/Format[. = 'Accumulation']");
                    if (oldNodes != null)
                        foreach (XmlNode oldNode in oldNodes)
                            oldNode.InnerText = "Victory";

                    var writer = new XmlTextWriter(new FileStream(filename, FileMode.Create), null)
                        {
                            Formatting = Formatting.Indented,
                            Indentation = 1,
                            IndentChar = '\t'
                        };

                    xml.WriteTo(writer);
                    writer.Flush();
                    writer.Close();
                }
            }
            else if (File.Exists(Path.Combine(Program.BasePath, "Events.dat")))
            {
                xml.Load(Path.Combine(Program.BasePath, "Events.dat"));
                var oldNodes = xml.SelectNodes("//Events/Tournaments/Tournament/Format[. = 'Accumulation']");
                if (oldNodes != null)
                    foreach (XmlNode oldNode in oldNodes)
                        oldNode.InnerText = "Victory";
                oldNodes = xml.SelectNodes("//Events/Leagues/League/Format[. = 'Accumulation']");
                if (oldNodes != null)
                    foreach (XmlNode oldNode in oldNodes)
                        oldNode.InnerText = "Victory";

                var writer = new XmlTextWriter(new FileStream(Path.Combine(Program.BasePath,
                                                                           "Events.dat"), FileMode.Create), null)
                {
                    Formatting = Formatting.Indented,
                    Indentation = 1,
                    IndentChar = '\t'
                };

                xml.WriteTo(writer);
                writer.Flush();
                writer.Close();
            }
        }
示例#21
0
        public static void Read()
        {
            XmlDocument xmlDocument = new XmlDocument();
            XmlElement rootElement = xmlDocument.CreateElement("sales");

            IEnumerable<SalesReportByVendor> sales;
            string nativeSQLQuery =
                    "SELECT v.VendorName, s.Date, SUM(s.Sum) as [Sum] " +
                    "FROM Sales AS s INNER JOIN Products AS p ON s.ProductID = p.ID " +
                    "INNER JOIN Vendors AS v ON p.VendorID = v.ID " +
                    "GROUP BY v.VendorName, s.Date";

            sales = db.Database.SqlQuery<SalesReportByVendor>(nativeSQLQuery);
            foreach (SalesReportByVendor sale in sales)
            {
                XmlElement saleElement = xmlDocument.CreateElement("sale");
                saleElement.SetAttribute("vendor", sale.VendorName);

                XmlElement summaryElement = xmlDocument.CreateElement("summary");
                summaryElement.SetAttribute("date", sale.Date.ToString("dd-MMM-yyyy", CultureInfo.GetCultureInfo("en-US")));
                summaryElement.SetAttribute("total-sum", sale.Sum.ToString("0.00", CultureInfo.GetCultureInfo("en-US")));
                saleElement.AppendChild(summaryElement);
                rootElement.AppendChild(saleElement);
            }
            xmlDocument.AppendChild(rootElement);

            XmlWriter xmlReportFile = GenerateXMLFile(XMLReportFileName);
            xmlReportFile.WriteStartDocument();
            using (xmlReportFile)
            {
                xmlDocument.WriteTo(xmlReportFile);
            }
            Console.WriteLine(xmlDocument.DocumentElement.OuterXml);
        }
示例#22
0
文件: Program.cs 项目: Kalyan00/proj
		static int Main(string[] args)
		{
			if (args.Length < 1)
				return ExitErr("args.Length < 1");
			if(!File.Exists(args[0]))
				return ExitErr("File '" + args[0] + "' not Exists");
			XmlDocument xDoc = new XmlDocument();
			try
			{
				xDoc.Load(args[0]);
			}
			catch(Exception ex)
			{
				return ExitErr(ex.ToString());
			}

			foreach (XmlNode chNode in xDoc.ChildNodes)
				SortAttribs(chNode);

			foreach (XmlNode chNode in xDoc.ChildNodes)
				SortChildNodes(chNode);

			StringBuilder sb = new StringBuilder();
			using (var xw = XmlWriter.Create(sb, new XmlWriterSettings
			{
				//Encoding = Encoding.UTF8,
				Indent = true,
			}))
				xDoc.WriteTo(xw);

			Console.Out.Write(sb.ToString());
			
			return 0;
		}
示例#23
0
        static void Main(string[] args)
        {
            XmlDocument doc = new XmlDocument();
            XmlNode booksnode = doc.AppendChild(doc.CreateElement("Books"));
            XmlNode booknode = booksnode.AppendChild(doc.CreateElement("Book"));
            //booksnode.RemoveChild(booknode);
            XmlAttribute bookname = booknode.Attributes.Append(doc.CreateAttribute("Name"));
            bookname.Value = "test";

            XmlWriter writer = XmlWriter.Create("booklist.xml");
            doc.WriteTo(writer);
            writer.Close();

            XslCompiledTransform transform = new XslCompiledTransform(true);
            transform.Load("template.xsl");
            transform.Transform("testdata.xml", "testdata.html");

            string[] data = { "a", "b", "c" };
            List<string> strings = new List<string>(data);
            string temp = string.Empty;

            foreach (string s in strings)
            {
                temp += s;
            }

            MessageBox.Show(temp);

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
示例#24
0
文件: KML.cs 项目: TNOCS/csTouch
 public static void CreateKmlFile(string fileName, IEnumerable<Location> locations)
 {
     try
     {
         var doc = new XmlDocument();
         var xdoc = new XDocument(
                           new XDeclaration("1.0", Encoding.UTF8.HeaderName, String.Empty),
                           new XElement(Kmlns + "kml",
                           new XElement(Kmlns + "Document",
                           new XElement(Kmlns + "name", "None"),
                           new XElement(Kmlns + "Style",
                           new XAttribute("id", "defaultStyle"),
                           new XElement(Kmlns + "LineStyle", new XElement(Kmlns + "color", "ffffffff"), new XElement(Kmlns + "colorMode", "normal"), new XElement(Kmlns + "width", 1)),
                           new XElement(Kmlns + "PolyStyle", new XElement(Kmlns + "color", "880000ff"), new XElement(Kmlns + "colorMode", "normal"), new XElement(Kmlns + "fill", 1), new XElement(Kmlns + "outline", 1))),
                           BuildGeographicPolylineType("FoV", locations))));
         doc.LoadXml(xdoc.Root.ToString());
         using (var writer = XmlWriter.Create(fileName))
         {
             doc.WriteTo(writer);
         }
     }
     catch (Exception)
     {
         Console.WriteLine("Could not create KML file!!!!");
     }
 }
示例#25
0
		public static void WriteGzip(XmlDocument theDoc, Stream theStream)
		{
			MemoryStream ms = new MemoryStream();
			XmlWriterSettings xmlSettings = new XmlWriterSettings();

			xmlSettings.Encoding = Encoding.UTF8;
			xmlSettings.ConformanceLevel = ConformanceLevel.Document;
			xmlSettings.Indent = false;
			xmlSettings.NewLineOnAttributes = false;
			xmlSettings.CheckCharacters = true;
			xmlSettings.IndentChars = "";

			XmlWriter tw = XmlWriter.Create(ms, xmlSettings);

			theDoc.WriteTo(tw);
			tw.Flush();
			tw.Close();

			byte[] buffer = ms.GetBuffer();

			GZipStream compressedzipStream = new GZipStream(theStream, CompressionMode.Compress, true);
			compressedzipStream.Write(buffer, 0, buffer.Length);
			// Close the stream.
			compressedzipStream.Flush();
			compressedzipStream.Close();

			// Force a flush
			theStream.Flush();
		}
示例#26
0
        public bool Write(Database database, StreamWriter stream, bool encrypt = true)
        {
            // Clear the last error
            this.ErrorString = string.Empty;

            XmlDocument document = new XmlDocument();
            this.Append(document, document, database);

            StringWriter sw = new StringWriter();
            XmlTextWriter xw = new XmlTextWriter(sw);
            xw.Formatting = Formatting.Indented;
            xw.Indentation = 4;
            document.WriteTo(xw);
            string fileDataString = sw.ToString();

            if (encrypt)
            {
                DatabaseCrypto.CryptoStatus status;
                fileDataString = DatabaseCrypto.Encrypt(fileDataString, database.Password, database.Compression, out status);
                if (status != DatabaseCrypto.CryptoStatus.NoError)
                {
                    this.ErrorString = DatabaseCrypto.StatusMessage(status);
                    return false;
                }
            }

            stream.Write(fileDataString);
            return true;
        }
示例#27
0
        private string FixResource(string path)
        {
            XmlDocument doc = new XmlDocument();
            doc.Load(path);
            Regex rxName = new Regex(@".*\.(.*)\.DisplayName$");

            foreach (XmlNode node in doc.SelectNodes("//root/data/value"))
            {
                if (String.IsNullOrEmpty(node.InnerText) || node.InnerText == "Sage.Platform.Orm.Entities.OrmFieldProperty")
                {
                    String name = ((XmlElement)node.ParentNode).GetAttribute("name");
                    Match m = rxName.Match(name);
                    if (m.Success)
                    {
                        node.InnerText = m.Groups[1].Value;
                    }
                }
            }
            using (StringWriter buf = new StringWriter())
            {
                XmlWriterSettings settings = new XmlWriterSettings { Indent = true };
                using (XmlWriter w = XmlWriter.Create(buf, settings))
                {
                    doc.WriteTo(w);
                }
                return buf.GetStringBuilder().ToString();
            }
        }
		public int Generate(XmlDocument sourceDocument, Stream output)
		{
			var source = new CircularStream();
			XmlWriter w = new XmlTextWriter(source, Encoding.Default);
			sourceDocument.WriteTo(w);

			return Generate(source, output);
		}
示例#29
0
        private void SavePrefs()
        {
            XmlTextWriter writer = new XmlTextWriter(location, System.Text.Encoding.UTF8);

            writer.Formatting = Formatting.Indented;
            document.WriteTo(writer);
            writer.Flush();
            writer.Close();
        }
示例#30
0
        private static string ConvertXmlDocumentToString(XmlDocument xmlDocument)
        {
            StringWriter stringWriter = new StringWriter();
            XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter);;

            xmlDocument.WriteTo(xmlTextWriter);

            return stringWriter.ToString();
        }
        public static String xmlToString(XmlDocument xml)
        {
            StringWriter sw = new StringWriter();
            XmlTextWriter tx = new XmlTextWriter(sw);
            xml.WriteTo(tx);

            string str = sw.ToString();
            return str;
        }
示例#32
0
文件: Helper.cs 项目: barbarossia/DIS
 /// <summary>
 /// Convert a XmlDocument To String
 /// </summary>
 /// <param name="xDoc"></param>
 /// <returns></returns>
 public static string XmlToString(XmlDocument xDoc)
 {
     using (StringWriter sw = new StringWriter())
     {
         XmlTextWriter tx = new XmlTextWriter(sw);
         xDoc.WriteTo(tx);
         return sw.ToString();
     }
 }
示例#33
0
        private string OutputResource(FhirXmlSerializer serializer, Resource item)
        {
            string newJson = serializer.SerializeToString(item);
            var    doc     = new System.Xml.XmlDocument();

            doc.LoadXml(newJson);
            var sr = new System.IO.StringWriter();
            var xw = new XmlTextWriter(sr);

            xw.Formatting  = Formatting.Indented;
            xw.IndentChar  = '\t';
            xw.Indentation = 1;
            doc.WriteTo(xw);
            return(sr.ToString());
        }
        public string createXMLFromCustomList(List <List <KeyValuePair <string, string> > > myList, int AddressListId)
        {
            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
            //create nodes
            System.Xml.XmlElement root = doc.CreateElement("addressList");


            System.Xml.XmlElement addressListName = doc.CreateElement("addressListName");
            _addressListName         = Guid.NewGuid().ToString("N");
            addressListName.InnerXml = _addressListName;

            root.AppendChild(addressListName);

            System.Xml.XmlElement addressMappingId = doc.CreateElement("addressMappingId");
            addressMappingId.InnerXml = AddressListId.ToString();

            root.AppendChild(addressMappingId);

            System.Xml.XmlElement addresses = doc.CreateElement("addresses");
            root.AppendChild(addresses);
            System.Xml.XmlElement address = null;
            foreach (List <KeyValuePair <string, string> > a in myList)
            {
                foreach (KeyValuePair <string, string> aa in a)
                {
                    address = doc.CreateElement("address");
                    System.Xml.XmlElement i = doc.CreateElement(aa.Key);
                    i.InnerXml = aa.Value;
                    address.AppendChild(i);
                }
                addresses.AppendChild(address);
            }

            doc.AppendChild(root);
            string xmlString = null;

            using (StringWriter stringWriter = new StringWriter())
            {
                using (XmlWriter xmlTextWriter = XmlWriter.Create(stringWriter))
                {
                    doc.WriteTo(xmlTextWriter);
                    xmlTextWriter.Flush();

                    xmlString = stringWriter.GetStringBuilder().ToString();
                }
            }
            return(xmlString);
        }
示例#35
0
    /// <summary>
    /// Get the XML string version of the currently loaded wiring documents.
    /// </summary>
    /// <returns>The XML string version of the currently loaded wiring documents.</returns>
    public string ConvertToXMLString()
    {
        System.Xml.XmlDocument doc =
            this.SaveDocument();

        using (var stringWriter = new System.IO.StringWriter())
        {
            System.Xml.XmlWriterSettings xmlWriteSettings = new System.Xml.XmlWriterSettings();
            xmlWriteSettings.OmitXmlDeclaration  = true;
            xmlWriteSettings.Indent              = true;
            xmlWriteSettings.NewLineOnAttributes = false;

            using (var xmlTextWriter = System.Xml.XmlWriter.Create(stringWriter, xmlWriteSettings))
            {
                doc.WriteTo(xmlTextWriter);
                xmlTextWriter.Flush();
                string stringval = stringWriter.GetStringBuilder().ToString();

                return(stringval);
            }
        }
    }
        public string createXMLFromAddressList()
        {
            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
            //create nodes
            System.Xml.XmlElement root = doc.CreateElement("addressList");


            System.Xml.XmlElement addressListName = doc.CreateElement("addressListName");
            _addressListName         = Guid.NewGuid().ToString("N");
            addressListName.InnerXml = _addressListName;

            root.AppendChild(addressListName);

            System.Xml.XmlElement addressMappingId = doc.CreateElement("addressMappingId");
            addressMappingId.InnerXml = "2";
            root.AppendChild(addressMappingId);

            System.Xml.XmlElement addresses = doc.CreateElement("addresses");
            root.AppendChild(addresses);

            foreach (addressItem a in addressList)
            {
                System.Xml.XmlElement address = doc.CreateElement("address");
                System.Xml.XmlElement fname   = doc.CreateElement("First_name");
                fname.InnerXml = a._First_name;
                address.AppendChild(fname);
                System.Xml.XmlElement lname = doc.CreateElement("Last_name");
                lname.InnerXml = a._Last_name;
                address.AppendChild(lname);
                System.Xml.XmlElement Organization = doc.CreateElement("Organization");
                Organization.InnerXml = a._Organization;
                address.AppendChild(Organization);
                System.Xml.XmlElement Address1 = doc.CreateElement("Address1");
                Address1.InnerXml = a._Address1;
                address.AppendChild(Address1);
                System.Xml.XmlElement Address2 = doc.CreateElement("Address2");
                Address2.InnerXml = a._Address2;
                address.AppendChild(Address2);
                System.Xml.XmlElement Address3 = doc.CreateElement("Address3");
                Address3.InnerXml = a._Address3;
                address.AppendChild(Address3);
                System.Xml.XmlElement City = doc.CreateElement("City");
                City.InnerXml = a._City;
                address.AppendChild(City);
                System.Xml.XmlElement State = doc.CreateElement("State");
                State.InnerXml = a._State;
                address.AppendChild(State);
                System.Xml.XmlElement zip = doc.CreateElement("zip");
                zip.InnerXml = a._Zip;
                address.AppendChild(zip);
                System.Xml.XmlElement country = doc.CreateElement("Country_non-US");
                country.InnerXml = a._Country_nonUS;
                address.AppendChild(country);
                addresses.AppendChild(address);
            }

            doc.AppendChild(root);
            string xmlString = null;

            using (StringWriter stringWriter = new StringWriter())
            {
                using (XmlWriter xmlTextWriter = XmlWriter.Create(stringWriter))
                {
                    doc.WriteTo(xmlTextWriter);
                    xmlTextWriter.Flush();

                    xmlString = stringWriter.GetStringBuilder().ToString();
                }
            }
            return(xmlString);
        }
        public string createXMLBatchPost()
        {
            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
            doc.AppendChild(doc.CreateXmlDeclaration("1.0", "utf-8", null));
            //create nodes
            System.Xml.XmlElement root = doc.CreateElement("batch");

            //"    <username>" & username & "</username>" &
            //"    <password>" & password & "</password>" &
            //"    <filename>" & fileName & "</filename>" &
            //"    <appSignature>MyTest App</appSignature>" &
            System.Xml.XmlElement attr = doc.CreateElement("username");
            attr.InnerXml = this._username;
            root.AppendChild(attr);

            attr          = doc.CreateElement("password");
            attr.InnerXml = this._password;
            root.AppendChild(attr);

            attr          = doc.CreateElement("filename");
            attr.InnerXml = this.pdf;
            root.AppendChild(attr);


            attr          = doc.CreateElement("appSignature");
            attr.InnerXml = ".NET SDK API";
            root.AppendChild(attr);
            foreach (batchJob b in jobList)
            {
                dynamic job = doc.CreateElement("job");

                attr          = doc.CreateElement("startingPage");
                attr.InnerXml = b.startingPage.ToString();
                job.AppendChild(attr);

                attr          = doc.CreateElement("endingPage");
                attr.InnerXml = b.endingPage.ToString();
                job.AppendChild(attr);

                dynamic printProductIOptions = doc.CreateElement("printProductionOptions");
                job.AppendChild(printProductIOptions);
                //<documentClass>Letter 8.5 x 11</documentClass>" &
                //"            <layout>Address on First Page</layout>" &
                //"            <productionTime>Next Day</productionTime>" &
                //"            <envelope>#10 Double Window</envelope>" &
                //"            <color>Full Color</color>" &
                //"            <paperType>White 24#</paperType>" &
                //"            <printOption>Printing One side</printOption>" &
                //"            <mailClass>First Class</mailClass>" &
                attr          = doc.CreateElement("documentClass");
                attr.InnerXml = b.documentClass;
                printProductIOptions.AppendChild(attr);

                attr          = doc.CreateElement("layout");
                attr.InnerXml = b.layout;
                printProductIOptions.AppendChild(attr);

                attr          = doc.CreateElement("productionTime");
                attr.InnerXml = b.productionTime;
                printProductIOptions.AppendChild(attr);
                attr          = doc.CreateElement("envelope");
                attr.InnerXml = b.envelope;
                printProductIOptions.AppendChild(attr);
                attr          = doc.CreateElement("color");
                attr.InnerXml = b.color;
                printProductIOptions.AppendChild(attr);

                attr          = doc.CreateElement("paperType");
                attr.InnerXml = b.paperType;
                printProductIOptions.AppendChild(attr);
                attr          = doc.CreateElement("printOption");
                attr.InnerXml = b.printOption;
                printProductIOptions.AppendChild(attr);
                attr          = doc.CreateElement("mailClass");
                attr.InnerXml = b.mailClass;
                printProductIOptions.AppendChild(attr);

                XmlElement addressList = doc.CreateElement("recipients");
                job.AppendChild(addressList);
                foreach (addressItem ai in b.addressList)
                {
                    XmlElement address = doc.CreateElement("address");
                    addressList.AppendChild(address);
                    attr = doc.CreateElement("name");
                    if ((ai._First_name.Length > 0 & ai._Last_name.Length > 0))
                    {
                        attr.InnerText = ai._Last_name + ", " + ai._First_name;
                    }
                    else
                    {
                        attr.InnerText = (ai._First_name + " " + ai._Last_name).Trim();
                    }
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("organization");
                    attr.InnerText = ai._Organization.Trim();
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("address1");
                    attr.InnerText = ai._Address1.Trim();
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("address2");
                    attr.InnerText = ai._Address2.Trim();
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("address3");
                    attr.InnerText = "";
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("city");
                    attr.InnerText = ai._City.Trim();
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("state");
                    attr.InnerText = ai._State.Trim();
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("postalCode");
                    attr.InnerText = ai._Zip.Trim();;
                    address.AppendChild(attr);

                    attr           = doc.CreateElement("country");
                    attr.InnerText = (ai._Country_nonUS).Trim();;
                    address.AppendChild(attr);
                }
                root.AppendChild(job);
            }

            doc.AppendChild(root);

            //doc.Declaration = New XDeclaration("1.0", "utf-8", Nothing)
            string xmlString = null;

            using (StringWriter stringWriter = new StringWriter())
            {
                using (XmlWriter xmlTextWriter = XmlWriter.Create(stringWriter))
                {
                    doc.WriteTo(xmlTextWriter);
                    xmlTextWriter.Flush();

                    xmlString = stringWriter.GetStringBuilder().ToString();
                }
            }



            return(xmlString);
        }
示例#38
0
        public Validation.SchematronOutput.schematronoutput Validate(Stream xmlstream, Stream schematronstream)
        {
            ///////////////////////////////
            // Transform original Schemtron
            ///////////////////////////////
            string path = AppDomain.CurrentDomain.BaseDirectory;

            Uri schematronxsl = new Uri(@"file:\\" + path + @"\xsl_2.0\iso_svrl_for_xslt2.xsl");

            Stream schematrontransform = new Validation.XSLTransform().Transform(schematronstream, schematronxsl);

            ///////////////////////////////
            // Apply Schemtron xslt
            ///////////////////////////////
            Stream results = new Validation.XSLTransform().Transform(xmlstream, schematrontransform);

            results.Position = 0;

            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
            doc.Load(results);

            var nodes = doc.ChildNodes[1].ChildNodes;

            System.Xml.XmlNode activepattern = null;
            System.Xml.XmlNode firedrule     = null;
            System.Xml.XmlNode failedassert  = null;

            List <System.Xml.XmlNode> nodesclone = new List <System.Xml.XmlNode>();

            foreach (System.Xml.XmlNode node in nodes)
            {
                nodesclone.Add(node);
            }

            foreach (System.Xml.XmlNode node in nodesclone)
            {
                if (node.Name == "svrl:active-pattern")
                {
                    activepattern = node;
                }

                if (node.Name == "svrl:fired-rule")
                {
                    firedrule = node;
                    activepattern.AppendChild(firedrule);
                }
                if (node.Name == "svrl:failed-assert")
                {
                    failedassert = node;
                    firedrule.AppendChild(failedassert);
                }
            }
            //System.IO.StreamReader rd2 = new System.IO.StreamReader(results);
            //string xsltSchematronResult = rd2.ReadToEnd();
            //xsltSchematronResult = xsltSchematronResult.Replace("schematron-output", "schematronoutput");
            MemoryStream ms = new MemoryStream();

            System.Xml.XmlWriter w = System.Xml.XmlWriter.Create(ms);

            ms.Position = 0;
            doc.WriteTo(w);
            w.Flush();

            return(Serialization.DerializeXML <Validation.SchematronOutput.schematronoutput>(ms));
        }