public XmlRenderer(System.Windows.Size size)
 {
     Size = size;
     m_stream = new MemoryStream();
     m_writer = new XmlTextWriter(m_stream, Encoding.UTF8);
     m_writer.Formatting = Formatting.Indented;
 }
Exemple #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;
        }
Exemple #3
1
        private bool SaveRegister(string RegisterKey)
        {
            try
            {
                
                Encryption enc = new Encryption();
                FileStream fs = new FileStream("reqlkd.dll", FileMode.Create);
                XmlTextWriter w = new XmlTextWriter(fs, Encoding.UTF8);

                // Khởi động tài liệu.
                w.WriteStartDocument();
                w.WriteStartElement("QLCV");

                // Ghi một product.
                w.WriteStartElement("Register");
                w.WriteAttributeString("GuiNumber", enc.EncryptData(sGuiID));
                w.WriteAttributeString("Serialnumber", enc.EncryptData(sSerial));
                w.WriteAttributeString("KeyRegister", enc.EncryptData(RegisterKey, sSerial + sGuiID));
                w.WriteEndElement();

                // Kết thúc tài liệu.
                w.WriteEndElement();
                w.WriteEndDocument();
                w.Flush();
                w.Close();
                fs.Close();
                return true;
            }
            catch (Exception ex)
            {

                return false;
            }
        }
Exemple #4
1
        static void Main(string[] args)
        {
            string textFile = "../../PersonData.txt";
            string xmlFile = "../../Person.xml";

            using (XmlTextWriter xmlWriter = new XmlTextWriter(xmlFile, Encoding.GetEncoding("utf-8")))
            {
                xmlWriter.Formatting = Formatting.Indented;
                xmlWriter.IndentChar = '\t';
                xmlWriter.Indentation = 1;

                xmlWriter.WriteStartDocument();
                xmlWriter.WriteStartElement("person");
                xmlWriter.WriteAttributeString("id", "1");

                using (StreamReader fileReader = new StreamReader(textFile))
                {
                    string name = fileReader.ReadLine();
                    xmlWriter.WriteElementString("name", name);
                    string address = fileReader.ReadLine();
                    xmlWriter.WriteElementString("address", address);
                    string phone = fileReader.ReadLine();
                    xmlWriter.WriteElementString("phone", phone);
                }

                xmlWriter.WriteEndElement();
                xmlWriter.WriteEndDocument();
            }
        }
        private static void WriteXMLDocument(List<List<Review>> allResults)
        {
            string fileName = "../../reviews-search-results.xml";
            Encoding encoding = Encoding.GetEncoding("UTF-8");


            using (XmlTextWriter writer = new XmlTextWriter(fileName, encoding))
            {
                writer.Formatting = Formatting.Indented;
                writer.IndentChar = '\t';
                writer.Indentation = 1;

                writer.WriteStartDocument();

                writer.WriteStartElement("search-results");

                foreach (var results in allResults)
                {
                    writer.WriteStartElement("result-set");
                    var orderedResult = (from e in results
                                         orderby e.DateOfCreation
                                         select e).ToList();

                    WriteBookInXML(orderedResult, writer);
                    writer.WriteEndElement();
                }
                writer.WriteEndDocument();
            }
        }
        public void updateCartFile(List<CartObject> newCartObj)
        {
            bool found = false;

            string cartFile = "C:\\Users\\Kiran\\Desktop\\cart.xml";

            if (!File.Exists(cartFile))
            {
                XmlTextWriter xWriter = new XmlTextWriter(cartFile, Encoding.UTF8);
                xWriter.Formatting = Formatting.Indented;
                xWriter.WriteStartElement("carts");
                xWriter.WriteStartElement("cart");
                xWriter.WriteAttributeString("emailId", Session["emailId"].ToString());
                xWriter.Close();
            }

            XmlDocument doc = new XmlDocument();
            doc.Load(cartFile);
            foreach (CartObject cartItem in newCartObj)
            {
                foreach (XmlNode xNode in doc.SelectNodes("carts"))
                {
                    XmlNode cartNode = xNode.SelectSingleNode("cart");
                    if (cartNode.Attributes["emailId"].InnerText == Session["emailId"].ToString())
                    {
                        found = true;
                        XmlNode bookNode = doc.CreateElement("book");
                        XmlNode nameNode = doc.CreateElement("name");
                        nameNode.InnerText = cartItem.itemName;
                        XmlNode priceNode = doc.CreateElement("price");
                        priceNode.InnerText = cartItem.itemPrice.ToString();
                        XmlNode quantityNode = doc.CreateElement("quantity");
                        quantityNode.InnerText = "1";
                        bookNode.AppendChild(nameNode);
                        bookNode.AppendChild(priceNode);
                        bookNode.AppendChild(quantityNode);
                        cartNode.AppendChild(bookNode);
                    }
                }
                if(!found)
                  {
                        XmlNode cartNode = doc.CreateElement("cart");
                        cartNode.Attributes["emailId"].InnerText = Session["emailId"].ToString();
                        XmlNode bookNode = doc.CreateElement("book");
                        XmlNode nameNode = doc.CreateElement("name");
                        nameNode.InnerText = cartItem.itemName;
                        XmlNode priceNode = doc.CreateElement("price");
                        priceNode.InnerText = cartItem.itemPrice.ToString();
                        XmlNode quantityNode = doc.CreateElement("quantity");
                        quantityNode.InnerText = "1";
                        bookNode.AppendChild(nameNode);
                        bookNode.AppendChild(priceNode);
                        bookNode.AppendChild(quantityNode);
                        cartNode.AppendChild(bookNode);
                        doc.DocumentElement.AppendChild(cartNode);

                  }
                }
            doc.Save(cartFile);
        }
        public static string Serialize(IEnumerable<MicroDataEntry> entries)
        {
            StringBuilder sb = new StringBuilder(3000);
            using (StringWriter sw = new StringWriter(sb))
            {
                using (XmlTextWriter xw = new XmlTextWriter(sw))
                {
                    xw.WriteStartElement("microData");

                    foreach (MicroDataEntry microDataEntry in entries)
                    {
                        xw.WriteStartElement("entry");

                        if (microDataEntry.ContentType.HasValue)
                        {
                            xw.WriteAttributeString("contentType", microDataEntry.ContentType.Value.ToString());
                        }

                        xw.WriteAttributeString("entryType", microDataEntry.Type.ToString());
                        xw.WriteAttributeString("selector", microDataEntry.Selector);
                        xw.WriteAttributeString("value", microDataEntry.Value);

                        xw.WriteEndElement();
                    }

                    xw.WriteEndElement();
                }
            }

            return sb.ToString();
        }
Exemple #8
1
        private void CreateConfig()
        {
            this.ConfigFileLocation = Path.Combine(this.ThemeDirectory, "Theme.config");

            using (var xml = new XmlTextWriter(this.ConfigFileLocation, Encoding.UTF8))
            {
                xml.WriteStartDocument(true);
                xml.Formatting = Formatting.Indented;
                xml.Indentation = 4;

                xml.WriteStartElement("configuration");
                xml.WriteStartElement("appSettings");

                this.AddKey(xml, "ThemeName", this.Info.ThemeName);
                this.AddKey(xml, "Author", this.Info.Author);
                this.AddKey(xml, "AuthorUrl", this.Info.AuthorUrl);
                this.AddKey(xml, "AuthorEmail", this.Info.AuthorEmail);
                this.AddKey(xml, "ConvertedBy", this.Info.ConvertedBy);
                this.AddKey(xml, "ReleasedOn", this.Info.ReleasedOn);
                this.AddKey(xml, "Version", this.Info.Version);
                this.AddKey(xml, "Category", this.Info.Category);
                this.AddKey(xml, "Responsive", this.Info.Responsive ? "Yes" : "No");
                this.AddKey(xml, "Framework", this.Info.Framework);
                this.AddKey(xml, "Tags", string.Join(",", this.Info.Tags));
                this.AddKey(xml, "HomepageLayout", this.Info.HomepageLayout);
                this.AddKey(xml, "DefaultLayout", this.Info.DefaultLayout);

                xml.WriteEndElement(); //appSettings
                xml.WriteEndElement(); //configuration
                xml.Close();
            }
        }
Exemple #9
1
 // XmlWriterSample1/form.cs
 private void button1_Click(object sender, System.EventArgs e)
 {
     // change to match you path structure
     string fileName="booknew.xml";
     //create the XmlTextWriter
     XmlTextWriter tw=new XmlTextWriter(fileName,null);
     //set the formatting to indented
     tw.Formatting=Formatting.Indented;
     tw.WriteStartDocument();
     //Start creating elements and attributes
     tw.WriteStartElement("book");
     tw.WriteAttributeString("genre","Mystery");
     tw.WriteAttributeString("publicationdate","2001");
     tw.WriteAttributeString("ISBN","123456789");
     tw.WriteElementString("title","Case of the Missing Cookie");
     tw.WriteStartElement("author");
     tw.WriteElementString("name","Cookie Monster");
     tw.WriteEndElement();
     tw.WriteElementString("price","9.99");
     tw.WriteEndElement();
     tw.WriteEndDocument();
     //clean up
     tw.Flush();
     tw.Close();
 }
        public static void Save(VProject vProject, XmlTextWriter xml)
        {
            Debug.Assert(vProject.ProjectDescriptor != null);
            Debug.Assert(vProject.ProjectDescriptor.Code != null);
            Debug.Assert(vProject.Items != null);

            xml.WriteStartElement("Code");
            xml.WriteValue(vProject.ProjectDescriptor.Code);
            xml.WriteEndElement();

            xml.WriteStartElement("ProjectItems");
            foreach (var item in vProject.Items)
            {
                xml.WriteStartElement("ProjectItem");

                xml.WriteStartElement("DisplayName");
                xml.WriteValue(item.DisplayName);
                xml.WriteEndElement();

                xml.WriteStartElement("Code");
                xml.WriteValue(item.Descriptor.Code);
                xml.WriteEndElement();

                xml.WriteEndElement();
            }
            xml.WriteEndElement();
        }
 /// <summary>
 /// Renders the object as KML, and calls upon any children to do the same
 /// </summary>
 /// <param name="kml"></param>
 public override void ToKML(XmlTextWriter kml)
 {
     string coord = Longitude.ToString() + "," + Latitude.ToString();
     if (!Altitude.Equals(Single.NaN))
         coord += "," + Altitude.ToString();
     kml.WriteElementString("coordinates", coord);
 }
 public Object DeserializeObject(String pXmlizedString)
 {
     XmlSerializer xs = new XmlSerializer(typeof(EntryList));
     MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(pXmlizedString));
     XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
     return xs.Deserialize(memoryStream);
 }
		private void SetUpWriter()
		{
			sw = new StringWriter ();
			xtw = new XmlTextWriter (sw);
			xtw.QuoteChar = '\'';
			xtw.Formatting = Formatting.None;
		}
Exemple #14
1
 protected virtual void WriteChild(XmlTextWriter writer, ContentItem child)
 {
     using (ElementWriter childElement = new ElementWriter("child", writer))
     {
         childElement.WriteAttribute("id", child.ID);
     }
 }
    /// <summary>Renders the specified component name.</summary>
    /// <param name="output">The output.</param>
    /// <param name="componentName">Name of the component.</param>
    private void Render(XmlTextWriter output, string componentName)
    {
      var renderings = Context.Database.SelectItems("fast://*[@@templateid='{99F8905D-4A87-4EB8-9F8B-A9BEBFB3ADD6}']");

      var matches = renderings.Where(r => string.Compare(r.Name, componentName, StringComparison.InvariantCultureIgnoreCase) == 0).ToList();

      if (matches.Count == 0)
      {
        matches = renderings.Where(r => r.Name.IndexOf(componentName, StringComparison.InvariantCultureIgnoreCase) >= 0).ToList();
      }

      if (matches.Count > 1)
      {
        output.WriteString(string.Format("Ambigeous match. {0} matches found.", matches.Count));
        return;
      }

      if (matches.Count == 0)
      {
        output.WriteString("The component was not found.");
        return;
      }

      this.Render(output, matches.First());
    }
Exemple #16
1
 private void AddKey(XmlTextWriter xml, string key, string value)
 {
     xml.WriteStartElement("add");
     xml.WriteAttributeString("key", key);
     xml.WriteAttributeString("value", value);
     xml.WriteEndElement(); //add
 }
Exemple #17
1
        public static void Main()
        {
            using (XmlTextWriter writer = new XmlTextWriter(DirPath, Encoding.UTF8))
            {
                writer.Formatting = Formatting.Indented;
                writer.IndentChar = ' ';
                writer.Indentation = 2;

                string desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
                writer.WriteStartDocument();
                writer.WriteStartElement("directories");

                try
                {
                    TraverseDirectory(desktopPath, writer);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    Console.WriteLine("Change the desktopPath.");
                }

                writer.WriteEndDocument();
            }

            Console.WriteLine("Xml document successfully created.");
        }
Exemple #18
1
		public static void Save( WorldSaveEventArgs e )
		{
			if ( !Directory.Exists( "Saves/Accounts" ) )
				Directory.CreateDirectory( "Saves/Accounts" );

			string filePath = Path.Combine( "Saves/Accounts", "accounts.xml" );

			using ( StreamWriter op = new StreamWriter( filePath ) )
			{
				XmlTextWriter xml = new XmlTextWriter( op );

				xml.Formatting = Formatting.Indented;
				xml.IndentChar = '\t';
				xml.Indentation = 1;

				xml.WriteStartDocument( true );

				xml.WriteStartElement( "accounts" );

				xml.WriteAttributeString( "count", m_Accounts.Count.ToString() );

				foreach ( Account a in GetAccounts() )
					a.Save( xml );

				xml.WriteEndElement();

				xml.Close();
			}
		}
		private void InternalMergeFormChanges(XmlTextWriter xml)
		{
			if (xml == null) {
				throw new ArgumentNullException("xml");
			}
			
			ReportDesignerWriter rpd = new ReportDesignerWriter();
			XmlHelper.CreatePropperDocument(xml);
			
			foreach (IComponent component in viewContent.Host.Container.Components) {
				if (!(component is Control)) {
					rpd.Save(component,xml);
				}
			}
			xml.WriteEndElement();
			xml.WriteStartElement("SectionCollection");
			
			// we look only for Sections
			foreach (IComponent component in viewContent.Host.Container.Components) {
				BaseSection b = component as BaseSection;
				if (b != null) {
					rpd.Save(component,xml);
				}
			}
			//SectionCollection
			xml.WriteEndElement();
			//Reportmodel
			xml.WriteEndElement();
			xml.WriteEndDocument();
			xml.Close();
		}
Exemple #20
1
		/// <summary>
		/// Serializes this AccountTag instance to an XmlTextWriter.
		/// </summary>
		/// <param name="xml">The XmlTextWriter instance from which to serialize.</param>
		public void Save(XmlTextWriter xml)
		{
			xml.WriteStartElement("tag");
			xml.WriteAttributeString("name", m_Name);
			xml.WriteString(m_Value);
			xml.WriteEndElement();
		}
		protected virtual void WriteRole(XmlTextWriter writer, AuthorizedRole ar)
		{
			using (ElementWriter role = new ElementWriter("role", writer))
			{
				role.Write(ar.Role);
			}
		}
Exemple #22
1
 public void DecodeArrayAllowsEmptyRootElementAsLongAsXmlWriterIsStarted()
 {
     StringWriter sw = new StringWriter();
     XmlTextWriter writer = new XmlTextWriter(sw);
     writer.WriteStartElement("root");
     JsonMLCodec.Decode(new JsonTextReader(new StringReader("[]")), writer);
 }
        public void Save(XmlTextWriter writer)
        {
            writer.WriteStartElement("PauseScreen");

            if (ChangeSound != null) ChangeSound.Save(writer);
            if (PauseSound != null) PauseSound.Save(writer);

            if (Background != null) writer.WriteElementString("Background", Background.Relative);

            foreach (PauseWeaponInfo weapon in weapons) weapon.Save(writer);

            if (LivesPosition != Point.Empty)
            {
                writer.WriteStartElement("Lives");
                writer.WriteAttributeString("x", LivesPosition.X.ToString());
                writer.WriteAttributeString("y", LivesPosition.Y.ToString());
                writer.WriteEndElement();
            }

            foreach (var item in inventory)
            {
                item.Save(writer);
            }

            writer.WriteEndElement();
        }
Exemple #24
0
        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
        {
            
            return Task.Factory.StartNew(() =>
            {
                XmlWriter writer = new XmlTextWriter(writeStream, new UTF8Encoding(false));
                bool summary = requestMessage.RequestSummary();

                if (type == typeof(OperationOutcome)) 
                {
                    Resource resource = (Resource)value;
                    FhirSerializer.SerializeResource(resource, writer, summary);
                }
                else if (type.IsAssignableFrom(typeof(Resource)))
                {
                    Resource resource = (Resource)value;
                    FhirSerializer.SerializeResource(resource, writer, summary);
                    
                    content.Headers.ContentLocation = resource.ExtractKey().ToUri();
                }
                else if (type == typeof(FhirResponse))
                {
                    FhirResponse response = (value as FhirResponse);
                    if (response.HasBody)
                    FhirSerializer.SerializeResource(response.Resource, writer, summary);
                }
                
                writer.Flush();
            });
        }
        /// <summary>Serialize the <c>XmlRpcResponse</c> to the output stream.</summary>
        /// <param name="output">An <c>XmlTextWriter</c> stream to write data to.</param>
        /// <param name="obj">An <c>Object</c> to serialize.</param>
        /// <seealso cref="XmlRpcResponse"/>
        public override void Serialize(XmlTextWriter output, Object obj)
        {
            XmlRpcResponse response = (XmlRpcResponse) obj;

            output.WriteStartDocument();
            output.WriteStartElement(METHOD_RESPONSE);

            if (response.IsFault)
              output.WriteStartElement(FAULT);
            else
              {
            output.WriteStartElement(PARAMS);
            output.WriteStartElement(PARAM);
              }

            output.WriteStartElement(VALUE);

            SerializeObject(output,response.Value);

            output.WriteEndElement();

            output.WriteEndElement();
            if (!response.IsFault)
              output.WriteEndElement();
            output.WriteEndElement();
        }
Exemple #26
0
        static int Main(string[] args)
        {
            Console.WriteLine("XMLTo v0.1 [www.mosa-project.org]");
            Console.WriteLine("Copyright 2009 by the MOSA Project. Licensed under the New BSD License.");
            Console.WriteLine("Written by Philipp Garcia ([email protected])");
            Console.WriteLine();
            Console.WriteLine("Usage: XMLTo <xml file> <xsl file> <output file>");
            Console.WriteLine();

            if (args.Length < 3)
             {
                Console.Error.WriteLine("ERROR: Missing arguments");
                return -1;
            }

            try {
                XPathDocument myXPathDoc = new XPathDocument(args[0]);
                XslCompiledTransform myXslTrans = new XslCompiledTransform();
                myXslTrans.Load(args[1]);
                XmlTextWriter myWriter = new XmlTextWriter(args[2], null);
                myXslTrans.Transform(myXPathDoc, null, myWriter);

                return 0;
            }
            catch (Exception e) {
                Console.Error.WriteLine("Exception: {0}", e.ToString());
                return -1;
            }
        }
        public override bool Execute()
        {
            try {
                var document = new XmlDocument();
                document.Load(this.XmlFileName);

                var navigator = document.CreateNavigator();
                var nsResolver = new XmlNamespaceManager(navigator.NameTable);

                if (!string.IsNullOrEmpty(this.Prefix) && !string.IsNullOrEmpty(this.Namespace)) {
                    nsResolver.AddNamespace(this.Prefix, this.Namespace);
                }

                var expr = XPathExpression.Compile(this.XPath, nsResolver);

                var iterator = navigator.Select(expr);
                while (iterator.MoveNext()) {
                    iterator.Current.DeleteSelf();
                }

                using (var writer = new XmlTextWriter(this.XmlFileName, Encoding.UTF8)) {
                    writer.Formatting = Formatting.Indented;
                    document.Save(writer);
                    writer.Close();
                }
            }
            catch (Exception exception) {
                base.Log.LogErrorFromException(exception);
                return false;
            }
            base.Log.LogMessage("Updated file '{0}'", new object[] { this.XmlFileName });
            return true;
        }
 /// <summary>
 /// Creates an instance of the given type from the specified Internet resource.
 /// </summary>
 /// <param name="htmlUrl">The requested URL, such as "http://Myserver/Mypath/Myfile.asp".</param>
 /// <param name="xsltUrl">The URL that specifies the XSLT stylesheet to load.</param>
 /// <param name="xsltArgs">An <see cref="XsltArgumentList"/> containing the namespace-qualified arguments used as input to the transform.</param>
 /// <param name="type">The requested type.</param>
 /// <param name="xmlPath">A file path where the temporary XML before transformation will be saved. Mostly used for debugging purposes.</param>
 /// <returns>An newly created instance.</returns>
 public object CreateInstance(string htmlUrl, string xsltUrl, XsltArgumentList xsltArgs, Type type,
                              string xmlPath)
 {
     StringWriter sw = new StringWriter();
     XmlTextWriter writer = new XmlTextWriter(sw);
     if (xsltUrl == null)
     {
         LoadHtmlAsXml(htmlUrl, writer);
     }
     else
     {
         if (xmlPath == null)
         {
             LoadHtmlAsXml(htmlUrl, xsltUrl, xsltArgs, writer);
         }
         else
         {
             LoadHtmlAsXml(htmlUrl, xsltUrl, xsltArgs, writer, xmlPath);
         }
     }
     writer.Flush();
     StringReader sr = new StringReader(sw.ToString());
     XmlTextReader reader = new XmlTextReader(sr);
     XmlSerializer serializer = new XmlSerializer(type);
     object o;
     try
     {
         o = serializer.Deserialize(reader);
     }
     catch (InvalidOperationException ex)
     {
         throw new Exception(ex + ", --- xml:" + sw);
     }
     return o;
 }
 private static void ProcessSearchQueries(XmlTextWriter writer)
 {
     XmlDocument xmlDoc = new XmlDocument();
     xmlDoc.Load("..\\..\\performance-test.xml");
     foreach (XmlNode query in xmlDoc.SelectNodes("review-queries/query"))
     {
         SaveQueryToLog(query.OuterXml);
         var type = query.Attributes.GetNamedItem("type");
         switch (type.Value)
         {
             case "by-period":
                 // Start date and end date are mandatory.
                 DateTime startDate = DateTime.Parse(query.GetChildText("start-date"));
                 DateTime endDate = DateTime.Parse(query.GetChildText("end-date"));
                 var reviewsByPeriod = BookstoreDAL.FindReviewsByPeriod(startDate, endDate);
                 WriteReviews(writer, reviewsByPeriod);
                 break;
             case "by-author":
                 string authorName = query.GetChildText("author-name");
                 var reviewsByAuthor = BookstoreDAL.FindReviewsByAuthor(authorName);
                 WriteReviews(writer, reviewsByAuthor);
                 break;
             default:
                 throw new ArgumentException("Type not supported!");
         }
     }
 }
        public ActionResult Index()
        {
            var doc = new XDocument(new XDeclaration("1.0", "utf-8", null));

            var indexElement = new XElement(SitemapXmlNamespace + "sitemapindex");

            foreach (var sitemapData in _sitemapRepository.GetAllSitemapData())
            {
                var sitemapElement = new XElement(
                    SitemapXmlNamespace + "sitemap",
                    new XElement(SitemapXmlNamespace + "loc", _sitemapRepository.GetSitemapUrl(sitemapData))
                );

                indexElement.Add(sitemapElement);
            }

            doc.Add(indexElement);

            Response.Filter = new GZipStream(Response.Filter, CompressionMode.Compress);
            Response.AppendHeader("Content-Encoding", "gzip");

            byte[] sitemapIndexData;

            using (var ms = new MemoryStream())
            {
                var xtw = new XmlTextWriter(ms, Encoding.UTF8);
                doc.Save(xtw);
                xtw.Flush();
                sitemapIndexData = ms.ToArray();
            }

            return new FileContentResult(sitemapIndexData, "text/xml");
        }
Exemple #31
0
        public virtual void SaveToXml(System.Xml.XmlTextWriter xmlWriter)
        {
            xmlWriter.WriteStartElement("Layer");
            xmlWriter.WriteAttributeString("Id", ID.ToString());
            xmlWriter.WriteAttributeString("Type", this.GetType().FullName);
            xmlWriter.WriteAttributeString("Name", Name);
            xmlWriter.WriteAttributeString("ReferenceFrame", referenceFrame);
            xmlWriter.WriteAttributeString("Color", SavedColor.Save(color));
            xmlWriter.WriteAttributeString("Opacity", opacity.ToString());
            xmlWriter.WriteAttributeString("StartTime", StartTime.ToString());
            xmlWriter.WriteAttributeString("EndTime", EndTime.ToString());
            xmlWriter.WriteAttributeString("FadeSpan", FadeSpan.ToString());
            xmlWriter.WriteAttributeString("FadeType", FadeType.ToString());

            this.WriteLayerProperties(xmlWriter);

            xmlWriter.WriteEndElement();
        }
Exemple #32
0
        // Form activated methods

        private bool transformBasicXML(String inputFilename, String outputFilename, String xslLocation)
        {
            System.Xml.Xsl.XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform();
            xslt.Load(xslLocation);

            //Create a new XPathDocument and load the XML data to be transformed.
            System.Xml.XPath.XPathDocument mydata = new System.Xml.XPath.XPathDocument(inputFilename);

            //Create an XmlTextWriter which outputs to the console.
            System.Xml.XmlWriter writer = new System.Xml.XmlTextWriter(outputFilename, System.Text.Encoding.UTF8);

            //Transform the data and send the output to the file.
            xslt.Transform(mydata, null, writer);

            writer.Close();

            return(true);
        }
Exemple #33
0
    // <Snippet1>
    private void WriteSchemaWithXmlTextWriter(DataSet thisDataSet)
    {
        // Set the file path and name. Modify this for your purposes.
        string filename = "SchemaDoc.xml";

        // Create a FileStream object with the file path and name.
        System.IO.FileStream stream = new System.IO.FileStream
                                          (filename, System.IO.FileMode.Create);

        // Create a new XmlTextWriter object with the FileStream.
        System.Xml.XmlTextWriter writer =
            new System.Xml.XmlTextWriter(stream,
                                         System.Text.Encoding.Unicode);

        // Write the schema into the DataSet and close the reader.
        thisDataSet.WriteXmlSchema(writer);
        writer.Close();
    }
 /// <summary>
 /// Serializes the object.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="inObject">The input object.</param>
 /// <returns></returns>
 public static string SerializeObject <T>(T inObject, Encoding encodeType)
 {
     if (encodeType == null)
     {
         encodeType = Encoding.UTF8;
     }
     // create a MemoryStream here, we are just working exclusively in memory
     using (Stream stream = new System.IO.MemoryStream())
     {
         // The XmlTextWriter takes a stream and encoding as one of its constructors
         using (XmlTextWriter xtWriter = new System.Xml.XmlTextWriter(stream, encodeType))
         {
             try
             {
                 XmlSerializer serializer = new XmlSerializer(typeof(T));
                 serializer.Serialize(xtWriter, inObject);
                 xtWriter.Flush();
                 // go back to the beginning of the Stream to read its contents
                 stream.Seek(0, System.IO.SeekOrigin.Begin);
                 // read back the contents of the stream and supply the encoding
                 using (StreamReader reader = new System.IO.StreamReader(stream, encodeType))
                 {
                     string result = reader.ReadToEnd();
                     return(result);
                 }
             }
             catch (Exception e)
             {
                 return(e.Message);
             }
             finally
             {
                 if (stream != null)
                 {
                     stream.Close();
                 }
                 if (xtWriter != null)
                 {
                     xtWriter.Close();
                 }
             }
         }
     }
 }
Exemple #35
0
        /// <summary>
        /// 获取xml字符串
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="xmlRootName"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string ObjectToXmlString <T>(string xmlRootName, T t) where T : class
        {
            string str = "";

            try
            {
                if (t == null)
                {
                    return(string.Empty);
                }
                if (string.IsNullOrEmpty(xmlRootName))
                {
                    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
                    using (MemoryStream memoryStream = new System.IO.MemoryStream())
                    {
                        using (XmlTextWriter xtw = new System.Xml.XmlTextWriter(memoryStream, Encoding.UTF8))
                        {
                            XmlSerializerNamespaces xns = new XmlSerializerNamespaces();
                            xns.Add("", "");
                            xmlSerializer.Serialize(xtw, t, xns);
                            memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                            using (System.IO.StreamReader streamReader = new System.IO.StreamReader(memoryStream, Encoding.UTF8))
                            {
                                return(streamReader.ReadToEnd());
                            }
                        }
                    }
                }
                else
                {
                    using (var writer = new StringWriter())
                    {
                        var xs = new XmlSerializer(typeof(T), new XmlRootAttribute(xmlRootName));
                        xs.Serialize(writer, t);
                        str = writer.ToString();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            return(str);
        }
Exemple #36
0
        /// <summary>
        /// creates logfile
        /// </summary>
        private void open()
        {
            if (this.opened_)
            {
                return;
            }
            try
            {
                if (theSwitch.Level > TraceLevel.Off)
                {
                    xmlwriter            = new System.Xml.XmlTextWriter(this.file_path, null);
                    xmlwriter.Formatting = System.Xml.Formatting.Indented;
                    xmlwriter.WriteStartDocument();
                    //Write the ProcessingInstruction node.
                    string PItext = theSwitch.style_instruction_pitext(string.Empty);
                    if (PItext != string.Empty)
                    {
                        xmlwriter.WriteProcessingInstruction("xml-stylesheet", PItext);
                    }

                    xmlwriter.WriteStartElement("trace");
                    xmlwriter.WriteAttributeString("timestamp", timestamp());
                    xmlwriter.WriteAttributeString("assembly", this.asm.FullName);
                    xmlwriter.WriteStartElement("switch");
                    // xmlwriter.WriteAttributeString( "displayname" , theSwitch.DisplayName) ;
                    // xmlwriter.WriteAttributeString( "description" , theSwitch.Description ) ;
                    xmlwriter.WriteAttributeString("level", theSwitch.Level.ToString());
                    xmlwriter.WriteEndElement();                     // close 'switch'
                }
                this.opened_ = true;
            }
            catch (Exception x)
            {
                evlog.internal_log.error(x); x = null;
            }
            finally
            {
                if (this.xmlwriter != null)
                {
                    xmlwriter.Close();
                }
                this.xmlwriter = null;
            }
        }
Exemple #37
0
        public void WriteDirectoryXMLFile(string folder, string fnaam)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();
            GlobalDataStore.Logger.Debug("Updating " + fnaam + " ...");
            List <LabelX.Toolbox.LabelXItem> items = new List <LabelX.Toolbox.LabelXItem>();
            DirectoryInfo FolderDirectoryInfo      = new DirectoryInfo(folder);

            LabelX.Toolbox.Toolbox.GetFilesFromFolderTree(FolderDirectoryInfo.FullName, ref items);

            //items = alle ingelezen bestanden. Nu gaan wegschrijven.
            System.Xml.XmlDocument doc  = new System.Xml.XmlDocument();
            System.Xml.XmlElement  root = doc.CreateElement("LabelXItems");

            foreach (LabelX.Toolbox.LabelXItem item in items)
            {
                if (getFileExt(item.Name) == ".xml")
                {
                    continue;
                }

                System.Xml.XmlElement itemXML = doc.CreateElement("item");
                itemXML.SetAttribute("name", item.Name);
                itemXML.SetAttribute("hash", item.Hash);

                root.AppendChild(itemXML);
            }

            doc.AppendChild(root);

            MemoryStream ms = new MemoryStream();

            System.Xml.XmlTextWriter tw = new System.Xml.XmlTextWriter(ms, Encoding.UTF8)
            {
                Formatting = System.Xml.Formatting.Indented
            };
            doc.WriteContentTo(tw);
            doc.Save(folder + fnaam);
            tw.Close();

            sw.Stop();
            GlobalDataStore.Logger.Debug("Creating the XML Hash file for the directory took: " + sw.ElapsedMilliseconds + " ms (" + folder + ")");
            sw.Reset();
        }
        /// <summary>
        /// 将对象序列化为指定编码格式的文本。
        /// </summary>
        /// <param name="obj">要序列化为文本的对象。</param>
        /// <param name="encoding">文本编码格式。如果为空引用则默认为UTF-8编码格式。</param>
        /// <param name="extraTypes">要序列化的其他对象类型的 Type 数组。</param>
        /// <returns>如果
        /// <paramref name="obj"/>是空引用,返回 <seealso cref="String.Empty"/>, 反之返回序列化文本。</returns>
        public override string ToSerializedString(T obj, Encoding encoding)
        {
            string ret = string.Empty;

            //XmlSerializer serializer = new XmlSerializer(typeof(T));
            MemoryStream  ms  = null;
            XmlTextWriter xtw = null;
            StreamReader  sr  = null;

            try {
                ms  = new MemoryStream();
                xtw = new System.Xml.XmlTextWriter(ms, encoding);

                //xtw.Formatting = System.Xml.Formatting.Indented;
                serializer.Serialize(xtw, obj);

                ms.Seek(0, SeekOrigin.Begin);
                sr  = new StreamReader(ms);
                ret = sr.ReadToEnd();
            }
            catch (Exception ex) {
                Logger.Error(ex.ToString());
                throw ex;
            }
            finally {
                if (xtw != null)
                {
                    xtw.Close();
                    xtw = null;
                }
                if (sr != null)
                {
                    sr.Dispose();
                    sr = null;
                }
                if (ms != null)
                {
                    ms.Dispose();
                    ms = null;
                }
            }

            return(ret);
        }
Exemple #39
0
        public void Save(System.Xml.XmlTextWriter tw, string localName)
        {
            tw.WriteStartElement(localName);
            tw.WriteAttributeString("Version", "1");

            tw.WriteElementString("DirectionRecentFirst", System.Xml.XmlConvert.ToString(_viewDirectionRecentIsFirst));

            tw.WriteStartElement("ColumnWidths");
            var colWidths = null != _view ? _view.ColumnWidths : new double[0];

            tw.WriteAttributeString("Count", XmlConvert.ToString(colWidths.Length));
            for (int i = 0; i < colWidths.Length; i++)
            {
                tw.WriteElementString("Width", XmlConvert.ToString(colWidths[i]));
            }
            tw.WriteEndElement(); // "ColumnWidths"

            tw.WriteEndElement(); // localName
        }
Exemple #40
0
        public static string IdentXML(string xml)
        {
            string result = "";

            MemoryStream mStream = new MemoryStream();

            System.Xml.XmlTextWriter writer   = new System.Xml.XmlTextWriter(mStream, Encoding.Unicode);
            System.Xml.XmlDocument   document = new System.Xml.XmlDocument();

            try
            {
                // Load the XmlDocument with the XML.
                document.LoadXml(xml);

                writer.Formatting = System.Xml.Formatting.Indented;

                // Write the XML into a formatting XmlTextWriter
                document.WriteContentTo(writer);
                writer.Flush();
                mStream.Flush();

                // Have to rewind the MemoryStream in order to read
                // its contents.
                mStream.Position = 0;

                // Read MemoryStream contents into a StreamReader.
                StreamReader sReader = new StreamReader(mStream);

                // Extract the text from the StreamReader.
                string formattedXml = sReader.ReadToEnd();

                result = formattedXml;
            }
            catch (System.Xml.XmlException)
            {
                // Handle the exception
            }

            mStream.Close();
            writer.Close();

            return(result);
        }
Exemple #41
0
        /// <summary>
        /// Serialises an object to XML.
        /// </summary>
        /// <param name="obj">The object to be serialised.</param>
        /// <param name="extraTypes">Any extra types needed in serialisation.</param>
        /// <returns>XML data.</returns>
        /// <exception cref="InvalidOperationException">Thrown if the serialisation fails.</exception>
        internal static byte[] ToXmlBytes(object obj, SysColl.ICollection <Type> extraTypes)
        {
            // Creating an XmlTextReader from the XML document
            using (var xmlStream = new System.IO.MemoryStream())
            {
                using (var xmlWriter = new SXml.XmlTextWriter(xmlStream, System.Text.Encoding.UTF8))
                {
                    var extraTypesArr = new Type[extraTypes.Count];
                    extraTypes.CopyTo(extraTypesArr, 0);

                    // Serialising
                    var serializer = m_serialiserCache.GetSerializer(obj.GetType(), extraTypesArr);
                    serializer.Serialize(xmlWriter, obj);

                    // Returning a byte array
                    return(xmlStream.ToArray());
                }
            }
        }
Exemple #42
0
        /// <summary>
        /// 序列化成xml字符串。用法:List《MyObject》 lMy = new List《MyObject》();  lMy.Add(ceshi);  lMy.Add(ceshi2);  string s = Serialize(lMy);
        /// </summary>
        /// <param name="obj"></param>
        /// <returns>序列化后的字符串</returns>
        public static string Serialize(object obj, Type type)
        {
            XmlSerializer xs = new XmlSerializer(type);

            using (MemoryStream ms = new MemoryStream())
            {
                System.Xml.XmlTextWriter xtw = new System.Xml.XmlTextWriter(ms, System.Text.Encoding.UTF8);
                xtw.Formatting = System.Xml.Formatting.Indented;
                xs.Serialize(xtw, obj);
                ms.Seek(0, SeekOrigin.Begin);
                using (StreamReader sr = new StreamReader(ms))
                {
                    string str = sr.ReadToEnd();
                    xtw.Close();
                    ms.Close();
                    return(str);
                }
            }
        }
 private void WriteDataSetToXmlFile(DataSet ds, string filename)
 {
     if (DropDownList1.SelectedItem.Text == "MYSQL")
     {
         string absoluteFileName = Server.MapPath("~/MYSQL/" + filename);
         System.IO.FileStream     myFileStream = new System.IO.FileStream(absoluteFileName, System.IO.FileMode.Create);
         System.Xml.XmlTextWriter myXmlWriter  = new System.Xml.XmlTextWriter(myFileStream, System.Text.Encoding.Unicode);
         ds.WriteXml(myXmlWriter);
         myXmlWriter.Close();
     }
     else
     {
         string absoluteFileName = Server.MapPath("~/SQLSERVER/" + filename);
         System.IO.FileStream     myFileStream = new System.IO.FileStream(absoluteFileName, System.IO.FileMode.Create);
         System.Xml.XmlTextWriter myXmlWriter  = new System.Xml.XmlTextWriter(myFileStream, System.Text.Encoding.Unicode);
         ds.WriteXml(myXmlWriter);
         myXmlWriter.Close();
     }
 }
Exemple #44
0
        private object GenerateXmlFromObject(string propName, object value)
        {
            object result = null;

            if (value is Type)
            {
                result = GenerateXmlFromTypeCore((Type)value);
            }

            //********************************
            if (value.GetType().ToString().EndsWith("[]"))
            {
                System.IO.MemoryStream   mem    = new MemoryStream();
                System.Xml.XmlTextWriter writer = new System.Xml.XmlTextWriter(mem, Encoding.UTF8);
                try
                {
                    System.Xml.Serialization.XmlSerializer serial =
                        new System.Xml.Serialization.XmlSerializer(value.GetType());
                    serial.Serialize(writer, value);
                    writer.Close();
                    result = Encoding.UTF8.GetString(mem.ToArray());
                    mem.Dispose();
                }
                catch (Exception)
                {
                }
                finally
                {
                    writer.Close();
                    mem.Dispose();
                }
            }
            //***************************************


            if (result == null)
            {
                result = value.ToString();
            }

            return(new XElement(propName, result));
        }
Exemple #45
0
 public override void WriteLayerProperties(System.Xml.XmlTextWriter xmlWriter)
 {
     xmlWriter.WriteAttributeString("TimeSeries", TimeSeries.ToString());
     xmlWriter.WriteAttributeString("BeginRange", BeginRange.ToString());
     xmlWriter.WriteAttributeString("EndRange", EndRange.ToString());
     xmlWriter.WriteAttributeString("Decay", Decay.ToString());
     xmlWriter.WriteAttributeString("CoordinatesType", CoordinatesType.ToString());
     xmlWriter.WriteAttributeString("LatColumn", LatColumn.ToString());
     xmlWriter.WriteAttributeString("LngColumn", LngColumn.ToString());
     xmlWriter.WriteAttributeString("GeometryColumn", GeometryColumn.ToString());
     xmlWriter.WriteAttributeString("AltType", AltType.ToString());
     xmlWriter.WriteAttributeString("MarkerMix", MarkerMix.ToString());
     xmlWriter.WriteAttributeString("ColorMap", ColorMap.ToString());
     xmlWriter.WriteAttributeString("MarkerColumn", MarkerColumn.ToString());
     xmlWriter.WriteAttributeString("ColorMapColumn", ColorMapColumn.ToString());
     xmlWriter.WriteAttributeString("PlotType", PlotType.ToString());
     xmlWriter.WriteAttributeString("MarkerIndex", MarkerIndex.ToString());
     xmlWriter.WriteAttributeString("MarkerScale", MarkerScale.ToString());
     xmlWriter.WriteAttributeString("AltUnit", AltUnit.ToString());
     xmlWriter.WriteAttributeString("AltColumn", AltColumn.ToString());
     xmlWriter.WriteAttributeString("StartDateColumn", StartDateColumn.ToString());
     xmlWriter.WriteAttributeString("EndDateColumn", EndDateColumn.ToString());
     xmlWriter.WriteAttributeString("SizeColumn", SizeColumn.ToString());
     xmlWriter.WriteAttributeString("HyperlinkFormat", HyperlinkFormat.ToString());
     xmlWriter.WriteAttributeString("HyperlinkColumn", HyperlinkColumn.ToString());
     xmlWriter.WriteAttributeString("ScaleFactor", ScaleFactor.ToString());
     xmlWriter.WriteAttributeString("PointScaleType", PointScaleType.ToString());
     xmlWriter.WriteAttributeString("ShowFarSide", ShowFarSide.ToString());
     xmlWriter.WriteAttributeString("RaUnits", RaUnits.ToString());
     xmlWriter.WriteAttributeString("HoverTextColumn", NameColumn.ToString());
     xmlWriter.WriteAttributeString("XAxisColumn", XAxisColumn.ToString());
     xmlWriter.WriteAttributeString("XAxisReverse", XAxisReverse.ToString());
     xmlWriter.WriteAttributeString("YAxisColumn", YAxisColumn.ToString());
     xmlWriter.WriteAttributeString("YAxisReverse", YAxisReverse.ToString());
     xmlWriter.WriteAttributeString("ZAxisColumn", ZAxisColumn.ToString());
     xmlWriter.WriteAttributeString("ZAxisReverse", ZAxisReverse.ToString());
     xmlWriter.WriteAttributeString("CartesianScale", CartesianScale.ToString());
     xmlWriter.WriteAttributeString("CartesianCustomScale", CartesianCustomScale.ToString());
     xmlWriter.WriteAttributeString("DynamicData", DynamicData.ToString());
     xmlWriter.WriteAttributeString("AutoUpdate", AutoUpdate.ToString());
     xmlWriter.WriteAttributeString("DataSourceUrl", DataSourceUrl.ToString());
 }
        public override void WriteLayerProperties(System.Xml.XmlTextWriter xmlWriter)
        {
            if (imageSet.WcsImage != null)
            {
                xmlWriter.WriteAttributeString("Extension", Path.GetExtension(imageSet.WcsImage.Filename));
            }

            if (imageSet.WcsImage is FitsImage)
            {
                FitsImage fi = imageSet.WcsImage as FitsImage;
                xmlWriter.WriteAttributeString("ScaleType", fi.lastScale.ToString());
                xmlWriter.WriteAttributeString("MinValue", fi.lastBitmapMin.ToString());
                xmlWriter.WriteAttributeString("MaxValue", fi.lastBitmapMax.ToString());
            }

            xmlWriter.WriteAttributeString("OverrideDefault", overrideDefaultLayer.ToString());

            ImageSetHelper.SaveToXml(xmlWriter, imageSet, "");
            base.WriteLayerProperties(xmlWriter);
        }
Exemple #47
0
        ///<summary>
        /// SyggestSync is a goodies to ask a proper sync of what's
        /// present in RAM, and what's present in the XML file.
        ///</summary>
        public void SuggestSync()
        {
            XmlTextWriter writer = new System.Xml.XmlTextWriter("configuration.xml", null);

            writer.Formatting = Formatting.Indented;
            writer.WriteStartDocument();
            writer.WriteStartElement("entries");

            foreach (string key in m_Matches.Keys)
            {
                writer.WriteStartElement("entry");
                writer.WriteElementString("key", key);
                writer.WriteElementString("value", (string)m_Matches[key]);
                writer.WriteEndElement();
            }
            writer.WriteEndElement();
            writer.WriteEndDocument();
            writer.Flush();
            writer.Close();
        }
Exemple #48
0
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            thread_showSth();
            txtMsg.Text = "";

            xmlWriter            = new XmlTextWriter(Server.MapPath("./1234.xml"), System.Text.Encoding.UTF8);
            xmlWriter.Formatting = Formatting.Indented;
            xmlWriter.WriteStartDocument();
            xmlWriter.WriteStartElement("队列");
            xmlWriter.WriteStartElement("跳舞");
            xmlWriter.WriteString("boy,girl");
            xmlWriter.WriteEndElement();
            //写文档结束,调用WriteEndDocument方法
            xmlWriter.WriteEndDocument();
            // 关闭textWriter
            xmlWriter.Close();
        }
    }
Exemple #49
0
        public string ConvertProject(string xsltPath, string projectName)
        {
            var xTrf    = new System.Xml.Xsl.XslCompiledTransform(true);
            var xTrfArg = new System.Xml.Xsl.XsltArgumentList();
            var xSet    = new System.Xml.Xsl.XsltSettings(true, true);
            var wSet    = new System.Xml.XmlWriterSettings();
            var mstr    = new System.Xml.XmlTextWriter(new System.IO.MemoryStream(), System.Text.Encoding.UTF8);
            //var mstr = new System.Xml.XmlTextWriter(xsltPath + "test.xml", System.Text.Encoding.UTF8);
            var doc = new System.Xml.XmlDocument();

            wSet = xTrf.OutputSettings;
            xTrf.Load(CopyXSLTFile(xsltPath), xSet, new XmlUrlResolver());
            xTrfArg.AddParam("ProjectName", "", projectName);
            mstr.WriteStartDocument();
            mstr.WriteDocType("Article", "-//RiQuest Software//DTD JBArticle v1.0 20020724//EN", "../dtd/JBArticle/jbarticle.dtd", null);
            xTrf.Transform(_extractPath + "/desktop.xml", xTrfArg, mstr);
            mstr.BaseStream.Flush();
            mstr.BaseStream.Seek(0, System.IO.SeekOrigin.Begin);
            return(new StreamReader(mstr.BaseStream).ReadToEnd());
        }
 public static string xmlNodeToString(System.Xml.XmlNode node, int indentation)
 {
     using (var sw = new System.IO.StringWriter())
     {
         using (var xw = new System.Xml.XmlTextWriter(sw))
         {
             xw.Formatting  = System.Xml.Formatting.Indented;
             xw.Indentation = indentation;
             if (node.ParentNode != null)
             {
                 node.ParentNode.WriteContentTo(xw);
             }
             else
             {
                 node.WriteContentTo(xw);
             }
         }
         return(sw.ToString());
     }
 }
Exemple #51
0
        static void Main()
        {
            WebClient client = new WebClient();

            //DS--Visual Indicators 1
            Console.WriteLine("Application Started, might take a while to Process...");

            //DS--Read Url through App.Config
            string url = ConfigurationManager.AppSettings["TargetUrl"];

            //DS--Path and file name to Save as XML from App.config
            string fileName = ConfigurationManager.AppSettings["FileName"];

            fileName = string.Concat(fileName, ".xml");
            Stream stream = client.OpenRead(url);

            //DS--Initializes a new instance of the StreamReader class
            StreamReader streamReader = new StreamReader(stream);
            JObject      jObject      = JObject.Parse(streamReader.ReadLine());

            //DS--Visual Indicators
            Console.WriteLine("JSON Serializing...");

            //DS--Create a JSON String
            string jsonString = JsonConvert.SerializeObject(jObject);

            //DS--Visual Indicators
            Console.WriteLine("Xml Conversion Started...");

            //DS--JSON to XML Conversion
            XmlDocument doc = (XmlDocument)JsonConvert.DeserializeXmlNode(jsonString, "Root");

            //DS--Visual Indicators
            Console.WriteLine("Xml is being Saved, might take a while..");

            //DS--Write to a file in XML format
            System.Xml.XmlTextWriter xmlTextWriter = new System.Xml.XmlTextWriter(fileName, null);
            xmlTextWriter.Formatting = System.Xml.Formatting.Indented;
            doc.Save(xmlTextWriter);
            stream.Close();
        }
Exemple #52
0
        public void UpdateXmlElement(string XmlfileName, string XmlelementName)
        {
            System.Xml.Serialization.XmlSerializer xmlSerializer =
                new System.Xml.Serialization.XmlSerializer(typeof(MVVM.Model.Config));
            System.IO.StringWriter stringWriter = new System.IO.StringWriter();
            System.Xml.XmlWriter   xmlWriter    = new System.Xml.XmlTextWriter(stringWriter);
            xmlSerializer.Serialize(xmlWriter, m_config);

            string      newSourceXml      = stringWriter.ToString();
            XElement    newSourceTypeElem = XElement.Parse(newSourceXml);
            XElement    newimport         = newSourceTypeElem.Element((XName)XmlelementName);
            XmlDocument xmlDoc            = new XmlDocument();

            xmlDoc.PreserveWhitespace = true;

            try
            {
                xmlDoc.Load(XmlfileName);
            }
            catch (XmlException e)
            {
                Console.WriteLine(e.Message);
            }
            // Now create StringWriter object to get data from xml document.
            StringWriter  sw = new StringWriter();
            XmlTextWriter xw = new XmlTextWriter(sw);

            xmlDoc.WriteTo(xw);

            string SourceXml = sw.ToString();

            // Replace the current view xml Sources node with the new one
            XElement viewXmlElem = XElement.Parse(SourceXml);
            XElement child       = viewXmlElem.Element((XName)XmlelementName);

            // viewXmlElem.Element("importOptions").ReplaceWith(newSourcesElem);
            child.ReplaceWith(newimport);

            xmlDoc.LoadXml(viewXmlElem.ToString());
            xmlDoc.Save(XmlfileName);
        }
Exemple #53
0
        public void WritePictureXMLFile(List <FileSystemEventArgs> listPictureChanged, bool init = false)
        {
            GlobalDataStore.Logger.Debug("Updating Pictures.xml ...");

            if (init)
            {
                items = new List <LabelX.Toolbox.LabelXItem>();
            }

            //List<LabelX.Toolbox.LabelXItem> items = new List<LabelX.Toolbox.LabelXItem>();
            DirectoryInfo PicturesRootFolderDirectoryInfo = new DirectoryInfo(PicturesRootFolder);

            LabelX.Toolbox.Toolbox.GetPicturesFromFolderTree(PicturesRootFolderDirectoryInfo.FullName, ref items, ref listPictureChanged);

            //items = alle ingelezen pictures. Nu gaan wegschrijven.
            System.Xml.XmlDocument doc  = new System.Xml.XmlDocument();
            System.Xml.XmlElement  root = doc.CreateElement("LabelXItems");

            foreach (LabelX.Toolbox.LabelXItem item in items)
            {
                System.Xml.XmlElement itemXML = doc.CreateElement("item");
                itemXML.SetAttribute("name", item.Name);
                itemXML.SetAttribute("hash", item.Hash);

                root.AppendChild(itemXML);
            }

            doc.AppendChild(root);

            MemoryStream ms = new MemoryStream();

            System.Xml.XmlTextWriter tw = new System.Xml.XmlTextWriter(ms, Encoding.UTF8);
            tw.Formatting = System.Xml.Formatting.Indented;
            doc.WriteContentTo(tw);
            doc.Save(PicturesRootFolder + "pictures.xml");


            tw.Close();

            GlobalDataStore.Logger.Debug("Updating Pictures.xml. Done.");
        }
Exemple #54
0
 // Get rid of this function
 public SymEntry LookupSymbol(Scope scope, string st, bool fMustExist)
 {
     SymEntry s = scope.LookupSymbol(st);        
     bool f= false;
     if (f) {
         System.Xml.XmlWriter o = new System.Xml.XmlTextWriter(new System.IO.StreamWriter("dump.xml"));
         scope.Dump(o, true);
         o.Close();
     }
     
     if (fMustExist && s == null)
     {
         FileRange range = new FileRange();
         range.Filename = "<not specified>";
         
         Identifier id = new Identifier(st, range);
         //ThrowError_UndefinedSymbol(id);
         ThrowError(SymbolError.UndefinedSymbol(id));
     }
     return s;
 }
Exemple #55
0
 public static string ConvertToXml(object o)
 {
     System.IO.StringWriter   sw = new System.IO.StringWriter();
     System.Xml.XmlTextWriter tw = default(System.Xml.XmlTextWriter);
     try
     {
         System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(o.GetType());
         tw = new System.Xml.XmlTextWriter(sw);
         serializer.Serialize(tw, o);
         return(sw.ToString());
     }
     catch (Exception ex)
     {
         return(ex.Message + " " + ex.StackTrace);
     }
     finally
     {
         sw.Close();
         tw.Close();
     }
 }
Exemple #56
0
        /// <summary>
        /// 序列化 对象到字符串;
        /// 不能序列化IDictionary接口.
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string XmlSerialize(object obj)
        {
            MemoryStream stream = new MemoryStream();

            try
            {
                XmlSerializer            serializer    = new XmlSerializer(obj.GetType());
                System.Xml.XmlTextWriter xmlTextWriter = new System.Xml.XmlTextWriter(stream, Encoding.UTF8);
                serializer.Serialize(xmlTextWriter, obj);
                stream = (MemoryStream)xmlTextWriter.BaseStream;
                return(System.Text.Encoding.UTF8.GetString(stream.GetBuffer()));
            }
            catch (Exception ex)
            {
                throw new Exception("XmlSerialize序列化失败", ex);
            }
            finally
            {
                stream.Dispose();
            }
        }
Exemple #57
0
 static string NodeToString(XmlNode node, int indentation)
 {
     try
     {
         using (var sw = new System.IO.StringWriter())
         {
             using (var xw = new System.Xml.XmlTextWriter(sw))
             {
                 xw.Formatting  = System.Xml.Formatting.Indented;
                 xw.Indentation = indentation;
                 node.WriteContentTo(xw);
             }
             return(sw.ToString());
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.Message);
         return("Convert to XML error");
     }
 }
Exemple #58
0
        public void DeleteAccount(Account account)
        {
            foreach (Account ac in _accounts)
            {
                if (ac.AccountName == account.AccountName)
                {
                    _accounts.Remove(ac);
                    break;
                }
            }
            var acc = (from acnt in _accountFile.Descendants("AccountType")
                       where (string)acnt.Attribute("name") == account.AccountName
                       select acnt);

            acc.Remove();
            System.Xml.XmlTextWriter writer = new System.Xml.XmlTextWriter(_fileName, null);
            writer.Formatting = System.Xml.Formatting.Indented;
            _accountFile.WriteTo(writer);
            _reloadAccounts = true;
            writer.Close();
        }
Exemple #59
0
        public void DeleteBudget(Budget b)
        {
            foreach (Budget budg in _budgets)
            {
                if (b.BudgetName == budg.BudgetName)
                {
                    _budgets.Remove(budg);
                    break;
                }
            }
            var budget = (from bud in _accountFile.Descendants("budget")
                          where (string)bud.Attribute("name") == b.BudgetName
                          select bud);

            budget.Remove();
            System.Xml.XmlTextWriter writer = new System.Xml.XmlTextWriter(_fileName, null);
            writer.Formatting = System.Xml.Formatting.Indented;
            _accountFile.WriteTo(writer);
            _reloadBudgets = true;
            writer.Close();
        }
Exemple #60
0
        /// <summary>
        /// 序列化成xml字符串。用法:List《MyObject》 lMy = new List《MyObject》();  lMy.Add(ceshi);  lMy.Add(ceshi2);  string s = Serialize(lMy);
        /// </summary>
        /// <param name="obj"></param>
        /// <returns>序列化后的字符串</returns>
        public static string SerializeCustom(object obj)
        {
            //Assembly assembly = typeof()

            XmlSerializer xs = CreateOverrider(obj.GetType());

            using (MemoryStream ms = new MemoryStream())
            {
                System.Xml.XmlTextWriter xtw = new System.Xml.XmlTextWriter(ms, System.Text.Encoding.UTF8);
                xtw.Formatting = System.Xml.Formatting.Indented;
                xs.Serialize(xtw, obj);
                ms.Seek(0, SeekOrigin.Begin);
                using (StreamReader sr = new StreamReader(ms))
                {
                    string str = sr.ReadToEnd();
                    xtw.Close();
                    ms.Close();
                    return(str);
                }
            }
        }