public string Cancelar() { try { XmlSerializerNamespaces nameSpaces = new XmlSerializerNamespaces(); nameSpaces.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); nameSpaces.Add("tipos", "http://*****:*****@"D:\Ret_CANC_LOTE_2805131157.xml"; RetornoCancelamentoNFSe objretorno = SerializeClassToXml.DeserializeClasse<RetornoCancelamentoNFSe>(sPathRetConsultaCanc); string sMessageRetorno = TrataRetornoCancelamento(objretorno); return sMessageRetorno; } catch (Exception ex) { throw ex; } }
public byte[] getRequestContent( string doctype, string root, Type type, object obj) { XmlSerializer serializer = null; if (root == null) { //... root element will be the object type name serializer = new XmlSerializer(type); } else { //... root element set explicitely var xattribs = new XmlAttributes(); var xroot = new XmlRootAttribute(root); xattribs.XmlRoot = xroot; var xoverrides = new XmlAttributeOverrides(); xoverrides.Add(type, xattribs); serializer = new XmlSerializer(type, xoverrides); } XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = false; settings.OmitXmlDeclaration = false; settings.Encoding = new UTF8Encoding(false/*no BOM*/, true/*throw if input illegal*/); XmlSerializerNamespaces xmlNameSpace = new XmlSerializerNamespaces(); xmlNameSpace.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); xmlNameSpace.Add("noNamespaceSchemaLocation", m_schemadir + "/" + doctype + "." + m_schemaext); StringWriter sw = new StringWriter(); XmlWriter xw = XmlWriter.Create( sw, settings); xw.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'"); serializer.Serialize(xw, obj, xmlNameSpace); return settings.Encoding.GetBytes( sw.ToString()); }
public AccessPointInfoBase() { this.typeField = "tdc:Door"; xmlns = new XmlSerializerNamespaces(); xmlns.Add("tdc1", "http://www.onvif.org/ver10/doorcontrol/wsdl"); xmlns.Add("not", "http://www.onvif.org/v3/notDoorControl/wsdl"); }
public XmlDocument ToXML() { using (MemoryStream stream = new MemoryStream()) { // xmlns:georss="http://www.georss.org/georss" // xmlns:gml="http://www.opengis.net/gml" //xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" //xmlns:kml="http://www.opengis.net/kml/2.2" //xmlns:dc="http://purl.org/dc/elements/1.1/" var ns = new XmlSerializerNamespaces(); ns.Add("georss", "http://www.georss.org/georss"); ns.Add("gml", "http://www.opengis.net/gml"); ns.Add("geo", "http://www.w3.org/2003/01/geo/wgs84_pos#"); ns.Add("kml", "http://www.opengis.net/kml/2.2"); ns.Add("dc", "http://purl.org/dc/elements/1.1/"); XmlSerializer s = new XmlSerializer(this.GetType()); Console.WriteLine("Testing for type: {0}", this.GetType()); s.Serialize(XmlWriter.Create(stream), this, ns); stream.Flush(); stream.Seek(0, SeekOrigin.Begin); //object o = s.Deserialize(XmlReader.Create(stream)); //Console.WriteLine(" Deserialized type: {0}", o.GetType()); XmlDocument xml = new XmlDocument(); xml.Load(stream); Console.Write(xml.InnerXml); return xml; } //var serializer = new XmlSerializer(this.GetType()); //serializer.Serialize(new StreamWriter("test.xml"), this); }
/// <summary> /// Parses the export file at the specified disk path. /// </summary> /// <param name="diskPathToExportFile">The disk path to the export file.</param> public Feed Parse(string diskPathToExportFile) { diskPathToExportFile.CheckNullOrEmpty("diskPathToExportFile"); Log.InfoFormat("blogger2jekyll.Blogger.ExportXmlParses conversion started at {0}.", DateTime.Now); Log.InfoFormat("Using Blogger import file at {0}", diskPathToExportFile); XmlDocument sourceDocument = new XmlDocument(); sourceDocument.Load(diskPathToExportFile); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add(string.Empty, string.Empty); ns.Add("app", "http://purl.org/atom/app#"); XmlSerializer serializer = new XmlSerializer(typeof(Feed)); Feed feed = (Feed)serializer.Deserialize(new StringReader(sourceDocument.OuterXml)); ProcessComments(feed); ProcessPages(feed); ProcessSettings(feed); Log.InfoFormat("blogger2jekyll.Blogger.ExportXmlParses conversion completed at {0}.", DateTime.Now); Log.InfoFormat("The blog {0} was converted.", feed.Title); Log.InfoFormat("{0} posts were found in the export file.", feed.Posts.Count); return feed; }
public bool WriteObject(XPathResult result, XPathNavigator node, object value) { var rootOverride = new XmlRootAttribute(node.LocalName) { Namespace = node.NamespaceURI }; var xml = new StringBuilder(); var settings = new XmlWriterSettings { OmitXmlDeclaration = true, Indent = false }; var namespaces = new XmlSerializerNamespaces(); namespaces.Add(string.Empty, string.Empty); if (string.IsNullOrEmpty(node.NamespaceURI) == false) { var prefix = result.Context.AddNamespace(node.NamespaceURI); namespaces.Add(prefix, node.NamespaceURI); } var serializer = new XmlSerializer(result.Type, rootOverride); using (var writer = XmlWriter.Create(xml, settings)) { serializer.Serialize(writer, value, namespaces); writer.Flush(); } node.ReplaceSelf(xml.ToString()); return true; }
public void DeserializeCapabilities() { System.IO.FileStream atom = new System.IO.FileStream("../../Terradue.Portal/Schemas/examples/geohazards-capabilities.xml", System.IO.FileMode.Open); XmlSerializer serializer = new XmlSerializer(typeof(WPSCapabilitiesType)); WPSCapabilitiesType capabilities = (WPSCapabilitiesType)serializer.Deserialize(atom); Assert.AreEqual("Geohazard Tep WPS", capabilities.ServiceIdentification.Title[0].Value); Assert.AreEqual("WPS", capabilities.ServiceIdentification.ServiceType.Value); Assert.AreEqual(4, capabilities.ServiceIdentification.Keywords[0].Keyword.Count); Assert.AreEqual("Geohazards Tep", capabilities.ServiceProvider.ProviderName); Assert.AreEqual(3, capabilities.OperationsMetadata.Operation.Count); Assert.AreEqual(28, capabilities.ProcessOfferings.Process.Count); Assert.AreEqual("2ceb1e69-6ab2-4dab-9f7e-4a594924267c", capabilities.ProcessOfferings.Process[0].Identifier.Value); Assert.AreEqual("ASAR PF", capabilities.ProcessOfferings.Process[0].Title.Value); Assert.AreEqual("The ENVISAT ASAR PF is the ESA operational Level-1 processor developed by MDA. This processor, integrated on the ESA's Grid Processing On Demand , perform on-demand production of L1 products.", capabilities.ProcessOfferings.Process[0].Abstract.Value); var stream = new MemoryStream(); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("wps", "http://www.opengis.net/wps/1.0.0"); ns.Add("ows", "http://www.opengis.net/ows/1.1"); ns.Add("xlink", "http://www.w3.org/1999/xlink"); serializer.Serialize(stream, capabilities, ns); stream.Seek(0, SeekOrigin.Begin); string capabilitiesText; using (StreamReader reader = new StreamReader(stream, System.Text.Encoding.UTF8)) { capabilitiesText = reader.ReadToEnd(); } Assert.IsNotNull(capabilitiesText); }
public void DeserializeExecute() { System.IO.FileStream atom = new System.IO.FileStream("../../Terradue.Portal/Schemas/examples/execute.xml", System.IO.FileMode.Open); XmlSerializer serializer = new XmlSerializer(typeof(Execute)); Execute execute = (Execute)serializer.Deserialize(atom); Assert.AreEqual("b4d3a590-c29c-46db-9b55-7e82cf74ab2e", execute.Identifier.Value); Assert.AreEqual(14, execute.DataInputs.Count); Assert.True(execute.DataInputs[1].Data.Item is BoundingBoxType); Assert.AreEqual("-54.58 35.532", ((BoundingBoxType)execute.DataInputs[1].Data.Item).LowerCorner); Assert.AreEqual("-16.875 59.356", ((BoundingBoxType)execute.DataInputs[1].Data.Item).UpperCorner); var stream = new MemoryStream(); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("wps", "http://www.opengis.net/wps/1.0.0"); ns.Add("ows", "http://www.opengis.net/ows/1.1"); ns.Add("xlink", "http://www.w3.org/1999/xlink"); serializer.Serialize(stream, execute, ns); stream.Seek(0, SeekOrigin.Begin); string executeText; using (StreamReader reader = new StreamReader(stream, System.Text.Encoding.UTF8)) { executeText = reader.ReadToEnd(); } Assert.IsNotNull(executeText); }
public void Write(Stream outputStream, object artifact) { using (var stream = new MemoryStream()) { var serializer = new XmlSerializer(artifact.GetType(), "http://schemas.microsoft.com/winfx/2006/xaml/presentation"); var ns = new XmlSerializerNamespaces(); ns.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation"); ns.Add("ds", "http://schemas.allscripts.com/cds/evaluation"); ns.Add("am", "http://schemas.allscripts.com/mom"); serializer.Serialize(stream, artifact, ns); // This seems like a bug with the serializer to me, but the outer-most instance of // Composite expression within the artifact is serialized with the prefix ds, instead // of am, even though the CompositeAssertion class has the XmlNamespaceAttribute with // allscripts.com/mom as given above. So we serialize the output to a temporary stream, // read it into a string, replace the offending instance with the correct value, and // then write the output stream with that string. stream.Position = 0; using (var sr = new StreamReader(stream)) { var result = sr.ReadToEnd(); using (var sw = new StreamWriter(outputStream)) { sw.Write(result.Replace("ds:CompositeAssertion", "am:CompositeAssertion")); } } } }
public static void SaveDelta(Delta delta, string file) { var ns = new XmlSerializerNamespaces(); ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); ns.Add("xsd", "http://www.w3.org/2001/XMLSchema"); var serializer = new XmlSerializer(typeof(Delta)); var list = new List<ImportObject>(); foreach (var obj in delta.Objects.Where(x => x.NeedsInclude())) { var newObj = new ImportObject(); newObj.SourceObjectIdentifier = obj.SourceObjectIdentifier; newObj.TargetObjectIdentifier = obj.TargetObjectIdentifier; newObj.ObjectType = obj.ObjectType; newObj.State = obj.State; newObj.Changes = obj.Changes != null ? obj.Changes.Where(x => x.IsIncluded).ToArray() : null; newObj.AnchorPairs = obj.AnchorPairs; list.Add(newObj); } var newDelta = new Delta(); newDelta.Objects = list.ToArray(); var settings = new XmlWriterSettings(); settings.OmitXmlDeclaration = false; settings.Indent = true; using (var w = XmlWriter.Create(file, settings)) serializer.Serialize(w, newDelta, ns); }
public void DeserializeExecuteResponse() { System.IO.FileStream atom = new System.IO.FileStream("../../Terradue.Portal/Schemas/examples/executeresponse.xml", System.IO.FileMode.Open); XmlSerializer serializer = new XmlSerializer(typeof(ExecuteResponse)); ExecuteResponse execute = (ExecuteResponse)serializer.Deserialize(atom); Assert.AreEqual("com.terradue.wps_oozie.process.OozieAbstractAlgorithm", execute.Process.Identifier.Value); Assert.AreEqual("ADORE DORIS interferometric processor", execute.Process.Title.Value); Assert.True(execute.Status.Item is ProcessAcceptedType); var stream = new MemoryStream(); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("wps", "http://www.opengis.net/wps/1.0.0"); ns.Add("ows", "http://www.opengis.net/ows/1.1"); ns.Add("xlink", "http://www.w3.org/1999/xlink"); serializer.Serialize(stream, execute, ns); stream.Seek(0, SeekOrigin.Begin); string executeText; using (StreamReader reader = new StreamReader(stream, System.Text.Encoding.UTF8)) { executeText = reader.ReadToEnd(); } Assert.IsNotNull(executeText); }
public Step() { ScreenAnnotations = new List<ScreenAnnotation>(); Xmlns = new XmlSerializerNamespaces(); Xmlns.Add("ns3", ScenarioDocuXMLFileUtil.ScenarioNameSpace); Xmlns.Add("xs", ScenarioDocuXMLFileUtil.XmlSchema); }
public UseCase() { Xmlns = new XmlSerializerNamespaces(); Xmlns.Add("ns3", ScenarioDocuXMLFileUtil.ScenarioNameSpace); Xmlns.Add("xs", ScenarioDocuXMLFileUtil.XmlSchema); Details = new Details(); }
/// <summary> /// helper /// </summary> /// <returns></returns> public static System.Xml.Serialization.XmlSerializerNamespaces GetNamespaces() { System.Xml.Serialization.XmlSerializerNamespaces ns; ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("", "http://www.w3.org/2001/XMLSchema"); ns.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); return(ns); }
public SpreadsheetXmlSerializer() { _xmlSerializer = new XmlSerializer(typeof (Workbook), "urn:schemas-microsoft-com:office:spreadsheet"); _xmlNamespaces = new XmlSerializerNamespaces(); _xmlNamespaces.Add("ss", "urn:schemas-microsoft-com:office:spreadsheet"); _xmlNamespaces.Add("x", "urn:schemas-microsoft-com:office:excel"); _xmlNamespaces.Add("o", "urn:schemas-microsoft-com:office:office"); _xmlNamespaces.Add("c", "urn:schemas-microsoft-com:office:component:spreadsheet"); _xmlNamespaces.Add("html", "http://www.w3.org/TR/REC-html40"); }
public static Rss ReadRSS(Stream source) { XmlSerializerNamespaces xsn = new XmlSerializerNamespaces(); xsn.Add("atom", "http://www.w3.org/2005/Atom"); xsn.Add("dc", "http://purl.org/dc/elements/1.1/"); xsn.Add("content", "http://purl.org/rss/1.0/modules/content/"); XmlSerializer ser = new XmlSerializer(typeof(Rss)); return (Rss)ser.Deserialize(source); }
public static void WriteRss(Structure.RssFeed value, Stream destination) { var xsn = new XmlSerializerNamespaces(); xsn.Add("atom", "http://www.w3.org/2005/Atom"); xsn.Add("dc", "http://purl.org/dc/elements/1.1/"); xsn.Add("content", "http://purl.org/rss/1.0/modules/content/"); var ser = new XmlSerializer(value.GetType()); ser.Serialize(destination, value, xsn); }
public static Structure.RssFeed ReadRss(Stream source) { var xsn = new XmlSerializerNamespaces(); xsn.Add("atom", "http://www.w3.org/2005/Atom"); xsn.Add("dc", "http://purl.org/dc/elements/1.1/"); xsn.Add("content", "http://purl.org/rss/1.0/modules/content/"); var ser = new XmlSerializer(typeof(Structure.RssFeed)); return (Structure.RssFeed)ser.Deserialize(source); }
public Scenario() { Xmlns = new XmlSerializerNamespaces(); Xmlns.Add("ns3", ScenarioDocuXMLFileUtil.ScenarioNameSpace); Xmlns.Add("xs", ScenarioDocuXMLFileUtil.XmlSchema); Name = string.Empty; Description = string.Empty; Status = string.Empty; Details = new Details(); }
public static void Serialize(Manifest manifest, StreamWriter writer) { var xs = new XmlSerializer(typeof(Manifest)); var xsn = new XmlSerializerNamespaces(); xsn.Add(SCORM.Adlcp, SCORM.AdlcpNamespaceV1P3); xsn.Add(SCORM.Imsss, SCORM.ImsssNamespace); xsn.Add(SCORM.Adlseq, SCORM.AdlseqNamespace); xsn.Add(SCORM.Adlnav, SCORM.AdlnavNamespace); xsn.Add(SCORM.Imsss, SCORM.ImsssNamespace); xs.Serialize(writer, manifest, xsn); }
public void Serialize(string path) { XmlSerializer serializer = new XmlSerializer(typeof(UrlSet), ""); StreamWriter writer = new StreamWriter(path); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", "http://www.sitemaps.org/schemas/sitemap/0.9"); ns.Add("image", "http://www.google.com/schemas/sitemap-image/1.1"); ns.Add("video", "http://www.google.com/schemas/sitemap-video/1.1"); serializer.Serialize(writer, this, ns); writer.Close(); writer.Dispose(); }
public string ToXml() { string ret = ""; Type serializableObjectType = this.GetType(); using (System.IO.StringWriter output = new System.IO.StringWriter(new System.Text.StringBuilder())) { System.Xml.Serialization.XmlSerializer s = new System.Xml.Serialization.XmlSerializer(serializableObjectType); System.Xml.Serialization.XmlSerializerNamespaces xsn = new System.Xml.Serialization.XmlSerializerNamespaces(); xsn.Add("", ""); // get a list of the xml type attributes so that we can clean up the xml. In other words. remove extra namespace text. object[] attributes = serializableObjectType.GetCustomAttributes(typeof(System.Xml.Serialization.XmlTypeAttribute), false); if (attributes != null) { System.Xml.Serialization.XmlTypeAttribute xta; for (int i = 0; i < attributes.Length; i++) { xta = (System.Xml.Serialization.XmlTypeAttribute)attributes[i]; //xsn.Add("ns" + 1, xta.Namespace); } } s.Serialize(output, this, xsn); ret = output.ToString().Replace("utf-16", "utf-8").Trim(); } return(ret); }
/* * // use reflection to get all derived types * var knownTypes = Assembly.GetExecutingAssembly().GetTypes().Where( t => typeof(Car).IsAssignableFrom(t) || typeof(Wheel).IsAssignableFrom(t) || typeof(Door).IsAssignableFrom(t)).ToArray(); * * // prepare to serialize a car object * XmlSerializer serializer = new XmlSerializer(typeof(Car), knownTypes); */ public static string Serialize(object objectToSerialize, System.Text.Encoding encoding, bool formatXml, bool removeNamespaces) { System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(objectToSerialize.GetType()); string xml = ""; using (MemoryStream memoryStream = new MemoryStream()) { ModifiedXmlTextWriter xmlTextWriter = new ModifiedXmlTextWriter(memoryStream, encoding); if (removeNamespaces) { System.Xml.Serialization.XmlSerializerNamespaces namespaces = new System.Xml.Serialization.XmlSerializerNamespaces(); namespaces.Add("", ""); xs.Serialize(xmlTextWriter, objectToSerialize, namespaces); } else { xs.Serialize(xmlTextWriter, objectToSerialize); } byte[] bytes = memoryStream.ToArray(); xml = encoding.GetString(bytes); } if (formatXml) { return(Utility.FormatXml(xml)); } else { return(xml); } }
public override int Run(string[] args) { string schemaFileName = args[0]; string outschemaFileName = args[1]; XmlTextReader xr = new XmlTextReader(schemaFileName); SchemaInfo schemaInfo = SchemaManager.ReadAndValidateSchema(xr, Path.GetDirectoryName(schemaFileName)); schemaInfo.Includes.Clear(); schemaInfo.Classes.Sort(CompareNames); schemaInfo.Relations.Sort(CompareNames); XmlSerializer ser = new XmlSerializer(typeof(SchemaInfo)); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", SchemaInfo.XmlNamespace); using (FileStream fs = File.Create(outschemaFileName)) { try { ser.Serialize(fs, schemaInfo, ns); } finally { fs.Flush(); fs.Close(); } } return 0; }
public static byte[] getRequestContent(string doctype, string root, Type type, object obj) { var xattribs = new XmlAttributes(); var xroot = new XmlRootAttribute(root); xattribs.XmlRoot = xroot; var xoverrides = new XmlAttributeOverrides(); //... have to use XmlAttributeOverrides because .NET insists on the object name as root element name otherwise ([XmlRoot(..)] has no effect) xoverrides.Add(type, xattribs); XmlSerializer serializer = new XmlSerializer(type, xoverrides); StringWriter sw = new StringWriter(); XmlWriterSettings wsettings = new XmlWriterSettings(); wsettings.OmitXmlDeclaration = false; wsettings.Encoding = new UTF8Encoding(); XmlWriter xw = XmlWriter.Create(sw, wsettings); xw.WriteProcessingInstruction("xml", "version='1.0' standalone='no'"); //... have to write header by hand (OmitXmlDeclaration=false has no effect) xw.WriteDocType(root, null, doctype + ".sfrm", null); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", ""); //... trick to avoid printing of xmlns:xsi xmlns:xsd attributes of the root element serializer.Serialize(xw, obj, ns); return sw.ToArray(); }
//private readonly Utilities sUtilities = Singleton<Utilities>.Instance; /// <summary> /// Serializes the current instance and returns the result as a <see cref="string"/> /// <para>Should be used with XML serialization only.</para> /// </summary> /// <returns>The serialized instance.</returns> public string Serialize() { //if(!sPlatform.IsLinux) // Contract.Ensures(!string.IsNullOrEmpty(Contract.Result<string>())); string data; try { using(var ms = new MemoryStream()) { var serializer = new XmlSerializer(GetType()); var nss = new XmlSerializerNamespaces(); nss.Add(string.Empty, string.Empty); serializer.Serialize(ms, this, nss); using(var reader = new StreamReader(ms)) { data = reader.ReadToEnd(); } } } catch(InvalidOperationException x) { throw new WolframException(sLConsole.GetString("Error during serialization"), x); } if(string.IsNullOrEmpty(data)) throw new WolframException(string.Format(sLConsole.GetString("Error while serializing instance! Type: {0}"), GetType().FullName)); return data; }
public void ExportDefinition(Project project) { TextWriter resultsWriter = new StringWriter(); XmlTextWriter xslResultsWriter = new XmlTextWriter(resultsWriter); MemoryStream outStrm = new MemoryStream(); XmlSerializer xs = new XmlSerializer(typeof(Project)); TextWriter stringWriter = new StringWriter(); XmlTextWriter xtr = new XmlTextWriter(stringWriter); string xmlnamespace = _Settings.XmlNameSpace; XmlSerializerNamespaces xns = new XmlSerializerNamespaces(); xns.Add("tt", xmlnamespace); try { //xs.Serialize(xtr, model, xns); xs.Serialize(outStrm, project, xns); } catch (Exception ee) { string m = ee.Message; } outStrm.Position = 0; FileStream fs = new FileStream(Settings.FileName, FileMode.OpenOrCreate, FileAccess.Write); outStrm.WriteTo(fs); fs.Flush(); fs.Close(); //string str = stringWriter.ToString(); outStrm.Position = 0; }
public static string Serialize <T>(this T value) { if (value == null) { return(string.Empty); } try { var xmlserializer = new XmlSerializer(typeof(T)); var ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("", ""); var stringWriter = new StringWriter(); using (var writer = XmlWriter.Create(stringWriter, new XmlWriterSettings { OmitXmlDeclaration = true, })) { xmlserializer.Serialize(writer, value, ns); return(stringWriter.ToString()); } } catch (Exception ex) { throw new Exception("An error occurred", ex); } }
/// <summary> /// This method converts any object into xml format. /// </summary> /// <param name="data"></param> /// <returns></returns> public static string SerializeData(object data) { //StringBuilder sbData = new StringBuilder(); //StringWriter swWriter; //XmlSerializer employeeSerializer = new XmlSerializer(typeof(object)); //swWriter = new StringWriter(sbData); //employeeSerializer.Serialize(swWriter, data); //return sbData.ToString(); if (data == null) { return string.Empty; } try { XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add(String.Empty, String.Empty); var xmlserializer = new XmlSerializer(data.GetType(),String.Empty); var stringWriter = new StringWriter(); XmlWriterSettings settings = new XmlWriterSettings(); settings.OmitXmlDeclaration = true; using (var writer = XmlWriter.Create(stringWriter,settings)) { xmlserializer.Serialize(writer, data,ns); return stringWriter.ToString(); } } catch (Exception ex) { throw new Exception("An error occurred", ex); } }
public async Task<HttpResponseMessage> Post() { TextMessage recievedMessage; XmlSerializer xmlSerializer = new XmlSerializer(typeof(TextMessage)); Stream stream = await Request.Content.ReadAsStreamAsync(); using (var reader = new StreamReader(stream)) { recievedMessage = (TextMessage)xmlSerializer.Deserialize(reader); } TextMessage sendingMessage = new TextMessage() { ToUserName = recievedMessage.FromUserName, FromUserName = recievedMessage.ToUserName, CreateTime = ConvertToUnixTimestamp(DateTime.Now).ToString(), Content = recievedMessage.Content }; Trace.TraceInformation(Request.Headers.Accept.ToString()); string messageStr = string.Empty; using (StringWriter textWriter = new StringWriter()) { var xns = new XmlSerializerNamespaces(); xns.Add(string.Empty, string.Empty); xmlSerializer.Serialize(textWriter, sendingMessage, xns); messageStr = textWriter.ToString(); } return new HttpResponseMessage() { Content = new StringContent( messageStr, Encoding.UTF8, "text/html" ) }; }
public XmlElement SerializeGovTalkMessageGovTalkDetails(hmrcclasses.GovTalkMessageGovTalkDetails gtDetails) { // copy of IRenvelope serializer using (MemoryStream memStream = new MemoryStream()) { XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add(String.Empty, "http://www.govtalk.gov.uk/CM/envelope"); var knownTypes = new Type[] { typeof(hmrcclasses.GovTalkMessageGovTalkDetails), typeof(hmrcclasses.GovTalkMessageGovTalkDetailsKey) }; XmlSerializer serializer = new XmlSerializer(typeof(hmrcclasses.GovTalkMessageGovTalkDetails), knownTypes); XmlTextWriter tw = new XmlTextWriter(memStream, UTF8Encoding.UTF8); XmlDocument doc = new XmlDocument(); tw.Formatting = Formatting.Indented; tw.IndentChar = ' '; serializer.Serialize(tw, gtDetails, ns); memStream.Seek(0, SeekOrigin.Begin); doc.Load(memStream); XmlElement returnVal = doc.DocumentElement; return returnVal; } }
static XmlSerializerAdapter() { settings = new XmlWriterSettings(); settings.OmitXmlDeclaration = true; ns = new XmlSerializerNamespaces(); ns.Add("", ""); }
// Similar code exist in O2.DotNetWrappers.DotNet.Serialize public static bool createSerializedXmlFileFromObject(Object oObjectToProcess, String sTargetFile, Type[] extraTypes) { FileStream fileStream = null; try { var xnsXmlSerializerNamespaces = new XmlSerializerNamespaces(); xnsXmlSerializerNamespaces.Add("", ""); var xsXmlSerializer = (extraTypes != null) ? new XmlSerializer(oObjectToProcess.GetType(), extraTypes) : new XmlSerializer(oObjectToProcess.GetType()); fileStream = new FileStream(sTargetFile, FileMode.Create); xsXmlSerializer.Serialize(fileStream, oObjectToProcess, xnsXmlSerializerNamespaces); //fileStream.Close(); return true; } catch (Exception ex) { DI.log.ex(ex, "In createSerializedXmlStringFromObject"); return false; } finally { if (fileStream != null) { fileStream.Close(); } } }
static XmlConfigService() { _xmlSerializer = new XmlSerializer(typeof(JobSchedulingData)); _xmlSerializerNamespaces = new XmlSerializerNamespaces(); _xmlSerializerNamespaces.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); }
public static String createSerializedXmlStringFromObject(Object oObjectToProcess , Type[] extraTypes) { if (oObjectToProcess == null) DI.log.error("in createSerializedXmlStringFromObject: oObjectToProcess == null"); else { try { /*// handle cases file names are bigger than 220 if (sTargetFile.Length > 220) { sTargetFile = sTargetFile.Substring(0, 200) + ".xml"; DI.log.error("sTargetFile.Length was > 200, so renamig it to: {0}", sTargetFile); }*/ var xnsXmlSerializerNamespaces = new XmlSerializerNamespaces(); xnsXmlSerializerNamespaces.Add("", ""); var xsXmlSerializer = (extraTypes != null) ? new XmlSerializer(oObjectToProcess.GetType(), extraTypes) : new XmlSerializer(oObjectToProcess.GetType()); var memoryStream = new MemoryStream(); xsXmlSerializer.Serialize(memoryStream, oObjectToProcess, xnsXmlSerializerNamespaces); return Encoding.ASCII.GetString(memoryStream.ToArray()); } catch (Exception ex) { DI.log.ex(ex,"In createSerializedXmlStringFromObject"); } } return ""; }
/// <summary> /// Сериализация Базы знаний в xml. /// </summary> /// <param name="frames"></param> /// <returns></returns> public bool SaveXml(GroopFrame frames) { bool result = false; using (StreamWriter writer = new StreamWriter("frame.xml")) { try { XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", ""); XmlSerializer serializer = new XmlSerializer(frames.GetType()); serializer.Serialize(writer, frames, ns); result = true; } catch (Exception e) { // Логирование } finally { writer.Close(); } } return result; }
public static void Serialize(Stream stream, object value) { var ns = new XmlSerializerNamespaces(); ns.Add("", ""); var serializer = new XmlSerializer(value.GetType(), ""); using (var xml = XmlWriter.Create(stream, XmlWriterSettings)) serializer.Serialize(xml, value, ns); }
public void TestMethod1() { XmlSerializer xsSubmit = new XmlSerializer(typeof(TestSection)); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", ""); var mySection = new TestSection(); mySection.myDecimal = 2.15M; mySection.myInt = 215; mySection.myString = "215"; using (StringWriter sww = new StringWriter()) using (XmlWriter writer = XmlWriter.Create(sww, new XmlWriterSettings() { OmitXmlDeclaration = true })) { xsSubmit.Serialize(writer, mySection, ns); var xml = sww.ToString(); } // Save Xml string configutaionFilePath = Environment.CurrentDirectory; var Xml = @"<?xml version=""1.0"" encoding=""utf-8"" ?> <configuration> <configSections> </configSections> </configuration> "; XmlDocument xdoc = new XmlDocument(); xdoc.LoadXml(Xml); xdoc.Save(configutaionFilePath + @"\config.xml"); }
/// <summary> /// 转换为xml字符串 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="entity"></param> /// <param name="NotNs">不包含命名空间</param> /// <returns></returns> private static string ObjToXml <T>(T entity, bool NotNs) { string result = string.Empty; XmlSerializer serializer = new XmlSerializer(typeof(T)); using (System.IO.MemoryStream stream = new System.IO.MemoryStream()) { XmlWriterSettings setting = new XmlWriterSettings(); setting.Encoding = new UTF8Encoding(false); setting.Indent = true; XmlWriter writer = XmlWriter.Create(stream, setting); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); if (NotNs) { ns.Add("", "");//不输出xmlns } serializer.Serialize(writer, entity, ns); stream.Position = 0; byte[] buf = new byte[stream.Length]; stream.Read(buf, 0, buf.Length); //result = Convert.ToBase64String(buf); result = System.Text.Encoding.UTF8.GetString(buf); } return(result); }
public void Serialize(Type type, object data, Stream outStream) { xml.XmlSerializer serializer = new xml.XmlSerializer(type); xml.XmlSerializerNamespaces ns = new xml.XmlSerializerNamespaces(); ns.Add("xlink", "http://www.w3.org/1999/xlink"); serializer.Serialize(outStream, data, ns); }
public ClipStorage() { if (s_ser == null) { s_ser = new XmlSerializer(typeof(Clips)); s_xsn = new XmlSerializerNamespaces(); s_xsn.Add("", ""); } }
public string ObjectToXml <T>(T objectToSerialise) { System.IO.StringWriter Output = new System.IO.StringWriter(new StringBuilder()); System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(objectToSerialise.GetType()); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("fac", "http://www.facturante.com.API"); xs.Serialize(Output, objectToSerialise, ns); return(Output.ToString()); }
/// <summary> Saves to document format. </summary> /// /// <remarks> Asim Naeem, 7/20/2017. </remarks> /// /// <param name="serializableObject"> Serializable object to be saved to file. </param> /// <param name="extraTypes"> Extra data types to enable serialization of custom /// types within the object. </param> /// <param name="path"> Path of the file to save the object to. </param> /// <param name="isolatedStorageFolder"> Pathname of the isolated storage folder. </param> private static void SaveToDocumentFormat(T serializableObject, System.Type[] extraTypes, string path, IsolatedStorageFile isolatedStorageFolder) { using (TextWriter textWriter = CreateTextWriter(isolatedStorageFolder, path)) { XmlSerializer xmlSerializer = CreateXmlSerializer(extraTypes); var xmlns = new System.Xml.Serialization.XmlSerializerNamespaces(); xmlns.Add(string.Empty, string.Empty); xmlSerializer.Serialize(textWriter, serializableObject, xmlns); } }
public void DeserializeDescribeProcess() { System.IO.FileStream atom = new System.IO.FileStream("../../Terradue.Portal/Schemas/examples/describeprocess.xml", System.IO.FileMode.Open); XmlSerializer serializer = new XmlSerializer(typeof(ProcessDescriptions)); ProcessDescriptions describe = (ProcessDescriptions)serializer.Deserialize(atom); Assert.AreEqual("com.terradue.wps_oozie.process.OozieAbstractAlgorithm", describe.ProcessDescription[0].Identifier.Value); Assert.AreEqual("SRTM Digital Elevation Model", describe.ProcessDescription[0].Title.Value); Assert.AreEqual(2, describe.ProcessDescription[0].DataInputs.Count); Assert.AreEqual("Level0_ref", describe.ProcessDescription[0].DataInputs[0].Identifier.Value); Assert.AreEqual("string", describe.ProcessDescription[0].DataInputs[0].LiteralData.DataType.Value); Assert.AreEqual("https://data.terradue.com/gs/catalogue/tepqw/gtfeature/search?format=json&uid=ASA_IM__0PNPAM20120407_082248_000001263113_00251_52851_2317.N1", describe.ProcessDescription[0].DataInputs[0].LiteralData.DefaultValue); Assert.AreEqual("format", describe.ProcessDescription[0].DataInputs[1].Identifier.Value); Assert.AreEqual("string", describe.ProcessDescription[0].DataInputs[1].LiteralData.DataType.Value); Assert.AreEqual("gamma", describe.ProcessDescription[0].DataInputs[1].LiteralData.DefaultValue); Assert.AreEqual(2, describe.ProcessDescription[0].ProcessOutputs.Count); Assert.AreEqual("result_distribution", describe.ProcessDescription[0].ProcessOutputs[0].Identifier.Value); Assert.True(describe.ProcessDescription[0].ProcessOutputs[0].Item is SupportedComplexDataType); Assert.AreEqual("result_osd", describe.ProcessDescription[0].ProcessOutputs[1].Identifier.Value); var stream = new MemoryStream(); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("wps", "http://www.opengis.net/wps/1.0.0"); ns.Add("ows", "http://www.opengis.net/ows/1.1"); ns.Add("xlink", "http://www.w3.org/1999/xlink"); serializer.Serialize(stream, describe, ns); stream.Seek(0, SeekOrigin.Begin); string executeText; using (StreamReader reader = new StreamReader(stream, System.Text.Encoding.UTF8)) { executeText = reader.ReadToEnd(); } Assert.IsNotNull(executeText); }
public static void Object2XmlFile(object obj, string sFileName) { var x = new System.Xml.Serialization.XmlSerializer(obj.GetType()); var ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("", ""); using (var fs = new System.IO.FileStream(sFileName, System.IO.FileMode.Create)) { var settings = new System.Xml.XmlWriterSettings(); settings.Indent = true; settings.OmitXmlDeclaration = true; settings.Encoding = System.Text.Encoding.UTF8; var writer = System.Xml.XmlWriter.Create(fs, settings); x.Serialize(writer, obj, ns); } }
public string ToXml() { //メモリストリームに一旦書き出す using (var stream = new System.IO.MemoryStream()) using (var writer = new System.IO.StreamWriter(stream, System.Text.Encoding.UTF8)) { System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add(String.Empty, String.Empty); //シリアライズ System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(CommentPostData)); serializer.Serialize(writer, this, ns); writer.Flush(); return(Encoding.UTF8.GetString(stream.ToArray())); } }
/// <summary> /// Serializer T to xml /// </summary> /// <typeparam name="T">the type</typeparam> /// <param name="t">the T entity</param> /// <returns>return a xml string</returns> public static string SerializerToStream <T>(T t) { System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(t.GetType()); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); // Add two namespaces with prefixes. ns.Add(string.Empty, string.Empty); MemoryStream stream = new MemoryStream(); XmlWriterSettings setting = new XmlWriterSettings(); setting.Encoding = new UTF8Encoding(false); setting.Indent = true; using (XmlWriter writer = XmlWriter.Create(stream, setting)) { xs.Serialize(writer, t, ns); } return(Encoding.UTF8.GetString(stream.ToArray())); }
public void Serialize<T>(Stream stream, T data) { var settings = new XmlWriterSettings { OmitXmlDeclaration = true }; using (var writer = XmlWriter.Create(stream, settings)) { var ns = new Xml.XmlSerializerNamespaces(); if (typeof(T).Namespace == HermesNameSpace) { ns.Add("", Facade.XmlNamespaces.Default); } var serializer = new Xml.XmlSerializer(typeof(T)); serializer.Serialize(writer, data, ns); writer.Close(); } }
public static string Object2Xml(object obj) { string sXml = ""; var x = new System.Xml.Serialization.XmlSerializer(obj.GetType()); var ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("", ""); using (var ms = new System.IO.MemoryStream()) { var settings = new System.Xml.XmlWriterSettings(); settings.Indent = false; settings.OmitXmlDeclaration = true; settings.Encoding = System.Text.Encoding.UTF8; var writer = System.Xml.XmlWriter.Create(ms, settings); x.Serialize(writer, obj, ns); sXml = System.Text.Encoding.UTF8.GetString(ms.GetBuffer()); } return(sXml); }
/// <summary> /// Serializer Xml To File /// </summary> /// <typeparam name="T"></typeparam> /// <param name="t"></param> /// <param name="fileFullPath"></param> public static void SerializerXmlToFile <T>(T t, string fileFullPath) { System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(t.GetType()); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); // Add two namespaces with prefixes. ns.Add(string.Empty, string.Empty); //ns.Add("ExportDate", DateTime.Now.ToString() ); Stream fs = new FileStream(fileFullPath, FileMode.OpenOrCreate); XmlTextWriter writer = new XmlTextWriter(fs, Encoding.GetEncoding("utf-8")); writer.Formatting = Formatting.Indented; writer.Indentation = 4; // Serialize using the XmlTextWriter. serializer.Serialize(writer, t, ns); writer.Close(); }
private static string SystemXmlWriter <T>(T value, System.Xml.XmlWriterSettings settings) { if (value == null) { return(String.Empty); } var buffer = new System.Text.StringBuilder(); var writer = System.Xml.XmlWriter.Create(buffer, settings); var namespaces = new System.Xml.Serialization.XmlSerializerNamespaces(); namespaces.Add(String.Empty, String.Empty); // tricks the serializer into not emitting default xmlns attributes // serialize feed var serializer = new System.Xml.Serialization.XmlSerializer(value.GetType()); serializer.Serialize(writer, value, namespaces); return(buffer.ToString()); }
private static string ToXML <T>(T obj, bool includetype, bool indent = false) { if (includetype) { XElement xml = XMLConverter.ToXml(obj, null, includetype); if (indent) { return(xml.ToString()); } else { return(xml.ToString(SaveOptions.DisableFormatting)); } } else { System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); XmlSerializer xs = new XmlSerializer(typeof(T)); StringBuilder sbuilder = new StringBuilder(); var xmlws = new System.Xml.XmlWriterSettings() { OmitXmlDeclaration = true, Indent = indent }; ns.Add(string.Empty, string.Empty); using (var writer = System.Xml.XmlWriter.Create(sbuilder, xmlws)) { xs.Serialize(writer, obj, ns); } string result = sbuilder.ToString(); ns = null; xs = null; sbuilder = null; xmlws = null; return(result); } }
static ChoNullNSXmlSerializer() { _xmlnsEmpty.Add("", ""); }
static XmlSerializer() { defaultNamespaces = new XmlSerializerNamespaces(); defaultNamespaces.Add("xsi", XmlSchema.InstanceNamespace); defaultNamespaces.Add("xsd", XmlSchema.Namespace); }
public static bool Submit(string url, CapitalRequest cr, TradeLink.API.DebugDelegate deb) { d = deb; if (cr.usingresults && !ResultsSubmittable(cr.SubmittedResults)) { debug("To submit capital connection request, results must be profitable over at least two symbol days."); return(false); } HttpWebRequest hr = WebRequest.Create(url) as HttpWebRequest; //hr.Credentials = new System.Net.NetworkCredential(user, password); //hr.PreAuthenticate = true; //hr.Headers.Add( hr.Method = "POST"; //hr.ContentType = "application/xml"; XmlWriterSettings writerSettings = new XmlWriterSettings(); writerSettings.OmitXmlDeclaration = true; System.IO.StringWriter stringWriter = new System.IO.StringWriter(); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(CapitalRequest)); XmlWriter xmlWriter = XmlTextWriterFormattedNoDeclaration.Create(stringWriter, writerSettings); System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces(); ns.Add("", ""); serializer.Serialize(xmlWriter, cr, ns); string xml = stringWriter.ToString(); System.Xml.Linq.XDocument xd = System.Xml.Linq.XDocument.Parse(xml); StringBuilder sb = new StringBuilder(); // get parameter list int i = 0; foreach (System.Xml.Linq.XElement xe in xd.Descendants()) { if (xe.HasElements) { continue; } if (i++ > 0) { sb.Append("&"); } if (xe.Name.LocalName.ToLower() == "result") { sb.Append(xe.Name.LocalName + "=" + System.Web.HttpUtility.HtmlEncode(xe.Value)); } else { sb.Append(xe.Name.LocalName + "=" + xe.Value); } } string data = sb.ToString(); // encode byte[] bytes = UTF8Encoding.UTF8.GetBytes(data); hr.ContentLength = bytes.Length; // prepare id int id = 0; try { // write it System.IO.Stream post = hr.GetRequestStream(); post.Write(bytes, 0, bytes.Length); // get response System.IO.StreamReader response = new System.IO.StreamReader(hr.GetResponse().GetResponseStream()); // get string version string key = response.ReadToEnd(); // display it debug("added request: " + key); return(true); } catch (Exception ex) { debug("error adding: " + Util.Serialize <CapitalRequest>(cr) + " " + ex.Message + ex.StackTrace); return(false); } }