private void LogMessage(string messageType, Message message) { var writerSettings = new XmlWriterSettings { Encoding = Encoding.UTF8, Indent = false }; using (var memoryStream = new MemoryStream()) { using (var writer = XmlDictionaryWriter.Create(memoryStream, writerSettings)) { message.WriteMessage(writer); writer.Flush(); var size = Math.Round(memoryStream.Position / 1024d, 2); logger.Info($"{messageType} message size: ~{size} KB"); } if (messageLogger.IsDebugEnabled) { memoryStream.Position = 0; using (var reader = new StreamReader(memoryStream)) { messageLogger.Debug(reader.ReadToEnd()); } } } }
public static async void Save(string FileName, T _Data) { MemoryStream _MemoryStream = new MemoryStream(); XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.Indent = true; XmlWriter writer = XmlDictionaryWriter.Create(_MemoryStream, xmlWriterSettings); DataContractSerializer Serializer = new DataContractSerializer(typeof(T)); Serializer.WriteObject(writer, _Data); writer.Flush(); StorageFile _File = await ApplicationData.Current.LocalFolder.CreateFileAsync(FileName, CreationCollisionOption.ReplaceExisting); using (Stream fileStream = await _File.OpenStreamForWriteAsync()) { _MemoryStream.Seek(0, SeekOrigin.Begin); await _MemoryStream.CopyToAsync(fileStream); await fileStream.FlushAsync(); fileStream.Dispose(); } }
public static string SerializeDataContract <T>(T value) { if (value == null) { return(null); } DataContractSerializer serializer = new DataContractSerializer(typeof(T)); // XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateTextWriter(someStream, Encoding.UTF8); // dcs.WriteObject(xdw, p); XmlWriterSettings settings = new XmlWriterSettings(); settings.Encoding = Encoding.UTF8; //new UTF8Encoding(false, false); // no BOM in a .NET string settings.Indent = false; settings.OmitXmlDeclaration = false; using (StringWriter textWriter = new StringWriter()) { using (XmlWriter xmlWriter = XmlDictionaryWriter.Create(textWriter, settings)) { serializer.WriteObject(xmlWriter, value); } return(textWriter.ToString()); } }
public void Serialize(object o, Type rootType, object rootInstance, DataContractResolver resolver) { var serializer = new DataContractSerializer(rootType, null, Int16.MaxValue, false, false, null, resolver); var builder = new StringBuilder(); var writer = XmlDictionaryWriter.Create(builder); serializer.WriteObject(writer, rootInstance); writer.Close(); Serialized = builder.ToString(); }
public void Serialize(object o, Type rootType) { var serializer = new DataContractSerializer(rootType); var builder = new StringBuilder(); var writer = XmlDictionaryWriter.Create(builder); serializer.WriteObject(writer, o); writer.Close(); Serialized = builder.ToString(); }
/// <summary> /// Saves the configuration file. /// </summary> /// <param name="filePath">The file path.</param> /// <remarks>Calls GetType() on the current instance and passes that to the DataContractSerializer.</remarks> public void SaveToFile(string filePath) { XmlWriterSettings settings = Utils.DefaultXmlWriterSettings(); settings.CloseOutput = true; using (Stream ostrm = File.Open(filePath, FileMode.Create, FileAccess.ReadWrite)) using (XmlWriter writer = XmlDictionaryWriter.Create(ostrm, settings)) { DataContractSerializer serializer = new DataContractSerializer(GetType()); serializer.WriteObject(writer, this); } }
/// <summary> /// Save a <see cref="PubSubConfigurationDataType"/> instance as XML /// </summary> /// <param name="pubSubConfiguration">The configuration object that shall be saved in the file.</param> /// <param name="filePath">The file path from where the configuration shall be saved.</param> public static void SaveConfiguration(PubSubConfigurationDataType pubSubConfiguration, string filePath) { Stream ostrm = File.Open(filePath, FileMode.Create, FileAccess.ReadWrite); XmlWriterSettings settings = Utils.DefaultXmlWriterSettings(); settings.CloseOutput = true; using (XmlWriter writer = XmlDictionaryWriter.Create(ostrm, settings)) { DataContractSerializer serializer = new DataContractSerializer(typeof(PubSubConfigurationDataType)); serializer.WriteObject(writer, pubSubConfiguration); } }
/// <summary> /// Saves the configuration file. /// </summary> /// <param name="filePath">The file path.</param> /// <remarks>Calls GetType() on the current instance and passes that to the DataContractSerializer.</remarks> public void SaveToFile(string filePath) { Stream ostrm = File.Open(filePath, FileMode.Create, FileAccess.ReadWrite); XmlWriterSettings settings = new XmlWriterSettings(); settings.Encoding = System.Text.Encoding.UTF8; settings.Indent = true; settings.CloseOutput = true; using (XmlWriter writer = XmlDictionaryWriter.Create(ostrm, settings)) { DataContractSerializer serializer = new DataContractSerializer(GetType()); serializer.WriteObject(writer, this); } }
// using NetDataContractSerializer public void Save2() { using (FileStream fs = new FileStream(SettingsPathAndFile, FileMode.Create)) { XmlWriterSettings s = new XmlWriterSettings(); s.Indent = true; XmlWriter w = XmlDictionaryWriter.Create(fs, s); NetDataContractSerializer ns = new NetDataContractSerializer(); logMsgDbLn2("max items| ", ns.MaxItemsInObjectGraph); ns.WriteObject(w, Settings); w.Flush(); w.Close(); } }
public static void Serialize(int objects = 1001) { var type = typeof(Terraria.NPC); FileStream fs = new FileStream("DEBUG_NPC.xml", FileMode.OpenOrCreate); XmlDictionaryWriter.Create(fs, new XmlWriterSettings() { Indent = true } ); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs); writer.WriteStartElement("ArrayOf" + type.Name); /* Set this to true to avoid the main textures....I guess in a way, it's a truer examination :P */ Terraria.Main.dedServ = true; for (var npcId = 0; npcId < objects; npcId++) { var npc = Activator.CreateInstance(type) as Terraria.NPC; npc.SetDefaults(npcId); if (npc.name == String.Empty) { continue; } SerializeNPC(npc, writer); } foreach (var npcName in NPCNames) { var npc = Activator.CreateInstance(type) as Terraria.NPC; npc.SetDefaults(npcName); SerializeNPC(npc, writer, false); } writer.WriteEndElement(); writer.Flush(); writer.Close(); }
public DataSourceClient(ApplicationConfiguration configuration) { DataContractSerializer serializer = new DataContractSerializer(configuration.GetType()); // serialize and reload configuration to ensure object has its own copy. MemoryStream ostrm = new MemoryStream(); XmlWriterSettings settings = new XmlWriterSettings(); settings.Encoding = System.Text.Encoding.UTF8; settings.Indent = false; settings.CloseOutput = true; settings.ConformanceLevel = ConformanceLevel.Document; settings.OmitXmlDeclaration = false; XmlWriter writer = XmlDictionaryWriter.Create(ostrm, settings); try { serializer.WriteObject(writer, configuration); } finally { writer.Close(); } MemoryStream istrm = new MemoryStream(ostrm.ToArray()); XmlReader reader = XmlReader.Create(istrm); m_configuration = (ApplicationConfiguration)serializer.ReadObject(reader, false); m_configuration.Validate(ApplicationType.Client); // always accept server certificates. m_CertificateValidation = new CertificateValidationEventHandler(CertificateValidator_CertificateValidation); m_configuration.CertificateValidator.CertificateValidation += m_CertificateValidation; m_monitoredItems = new Dictionary <uint, MonitoredItem>(); }
public static void SnippetReadFrom() { AddressHeader addressHeader1 = AddressHeader.CreateAddressHeader("specialservice1", "http://localhost:8000/service", 1); AddressHeader addressHeader2 = AddressHeader.CreateAddressHeader("specialservice2", "http://localhost:8000/service", 2); AddressHeader[] addressHeaders = new AddressHeader[2] { addressHeader1, addressHeader2 }; AddressHeaderCollection headers = new AddressHeaderCollection(addressHeaders); EndpointAddress endpointAddress = new EndpointAddress( new Uri("http://localhost:8003/servicemodelsamples/service/incode/identity"), addressHeaders); XmlDictionaryWriter writer = (XmlDictionaryWriter)XmlDictionaryWriter.Create("addressdata.xml"); endpointAddress.WriteTo(AddressingVersion.WSAddressing10, writer); writer.Close(); // <Snippet24> XmlDictionaryReader reader = (XmlDictionaryReader)XmlDictionaryReader.Create("addressdata.xml"); EndpointAddress createdEA = EndpointAddress.ReadFrom(reader); // </Snippet24> }
/// <summary> /// Reads XML conforming to https://www.w3.org/TR/2001/PR-xmldsig-core-20010820/#sec-SignedInfo /// </summary> /// <param name="reader">a <see cref="XmlReader"/>positioned on a <SignedInfo> element.</param> /// <exception cref="ArgumentNullException">if <paramref name="reader"/> is null.</exception> /// <exception cref="XmlReadException">if there is a problem reading the XML.</exception> /// <returns><see cref="SignedInfo"/></returns> public virtual SignedInfo ReadSignedInfo(XmlReader reader) { XmlUtil.CheckReaderOnEntry(reader, XmlSignatureConstants.Elements.SignedInfo, XmlSignatureConstants.Namespace); try { var defaultNamespace = reader.LookupNamespace(string.Empty); var bufferedStream = new MemoryStream(); var settings = new XmlWriterSettings { Encoding = Encoding.UTF8, NewLineHandling = NewLineHandling.None }; // need to read into buffer since the canonicalization reader needs a stream. using (XmlWriter bufferWriter = XmlDictionaryWriter.Create(bufferedStream, settings)) { bufferWriter.WriteNode(reader, true); bufferWriter.Flush(); } bufferedStream.Position = 0; // // We are creating a XmlDictionaryReader with a hard-coded Max XmlDictionaryReaderQuotas. This is a reader that we // are creating over an already buffered content. The content was initially read off user provided XmlDictionaryReader // with the correct quotas and hence we know the data is valid. // using (var canonicalizingReader = XmlDictionaryReader.CreateTextReader(bufferedStream, XmlDictionaryReaderQuotas.Max)) { var signedInfo = new SignedInfo(); signedInfo.CanonicalStream = new MemoryStream(); // TODO - should not always use 'false' canonicalizingReader.StartCanonicalization(signedInfo.CanonicalStream, false, null); canonicalizingReader.MoveToStartElement(XmlSignatureConstants.Elements.SignedInfo, XmlSignatureConstants.Namespace); signedInfo.Prefix = canonicalizingReader.Prefix; signedInfo.Id = canonicalizingReader.GetAttribute(XmlSignatureConstants.Attributes.Id, null); // read <SignedInfo ...> start element canonicalizingReader.Read(); // TODO - if comments are not false, then we need to reset. // this should be very rare. signedInfo.CanonicalizationMethod = ReadCanonicalizationMethod(canonicalizingReader); signedInfo.SignatureMethod = ReadSignatureMethod(canonicalizingReader); signedInfo.References.Add(ReadReference(canonicalizingReader)); if (canonicalizingReader.IsStartElement(XmlSignatureConstants.Elements.Reference, XmlSignatureConstants.Namespace)) { throw XmlUtil.LogReadException(LogMessages.IDX30020); } canonicalizingReader.ReadEndElement(); canonicalizingReader.EndCanonicalization(); signedInfo.CanonicalStream.Flush(); return(signedInfo); } } catch (Exception ex) { if (ex is XmlReadException) { throw; } throw XmlUtil.LogReadException(LogMessages.IDX30016, ex, XmlSignatureConstants.Elements.SignedInfo); } }
/// <summary> /// Supports Serialization of NPC, Items & Projectiles. /// It also supports multiple formats by specifing the Method. /// </summary> /// <param name="type"></param> /// <param name="ignoreFields"></param> /// <param name="SetDefaults"></param> /// <param name="invokeType"></param> /// <param name="input"></param> public static Dictionary <Int32, String> Serialize(Type type, string[] ignoreFields, MethodInfo SetDefaults, InvokeType invokeType = InvokeType.ITEM_NPC, string[] inputs = null, int MaxObjects = 1000) { var FilePath = (invokeType == InvokeType.ITEM_NPC_BY_NAME) ? type.Name + "sByName.xml" : type.Name + "s.xml"; if (File.Exists(FilePath)) { File.Delete(FilePath); } DiffSerializer serializer = new DiffSerializer(type, ignoreFields); FileStream fs = new FileStream(FilePath, FileMode.OpenOrCreate); XmlWriterSettings ws = new XmlWriterSettings(); ws.Indent = true; XmlDictionaryWriter.Create(fs, ws); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs); writer.WriteStartElement("ArrayOf" + type.Name); var returnData = new Dictionary <Int32, String>(); int count = 0; for (int i = 0; i < MaxObjects; i++) { object obj = Activator.CreateInstance(type); try { if (invokeType == InvokeType.ITEM_NPC) { SetDefaults.Invoke(obj, new object[] { i, null }); } else if (invokeType == InvokeType.ITEM_NPC_BY_NAME) { SetDefaults.Invoke(obj, new object[] { inputs[i] }); } else { SetDefaults.Invoke(obj, new object[] { i }); } } catch //(Exception e) //Usually catches player data which is not set { //Console.WriteLine("[Error] {0}", e.Message); } FieldInfo info = type.GetField("Name"); string value = String.Empty; try { value = (String)info.GetValue(obj); } catch (NullReferenceException) { //Close writer.WriteString("\n"); writer.WriteEndElement(); writer.Close(); fs.Close(); Console.WriteLine("Please restart this application, The Assemblies need refreshing."); Console.ReadKey(true); Environment.Exit(0); } if (!String.IsNullOrWhiteSpace(value)) { Console.WriteLine("Processing `{0}`...", value); serializer.WriteObject(writer, obj); count++; returnData.Add(count, value); } Thread.Sleep(5); } writer.WriteString("\n"); writer.WriteEndElement(); writer.Close(); fs.Close(); Console.WriteLine("Found {0} {1}s.", count, type.Name); return(returnData); }
/// <summary> /// Write Message to the string /// </summary> /// <param name="message"></param> /// <returns></returns> public static string WriteToString(this System.ServiceModel.Channels.Message message) { StringBuilder sb = new StringBuilder(); XmlWriterSettings settings = new XmlWriterSettings() { OmitXmlDeclaration = true, Indent = true, Encoding = UTF8Encoding.UTF8 }; using (XmlDictionaryWriter dwr = XmlDictionaryWriter.CreateDictionaryWriter(XmlDictionaryWriter.Create(sb, settings))) { dwr.WriteStartDocument(); message.WriteMessage(dwr); dwr.WriteEndDocument(); dwr.Flush(); } return(sb.ToString()); }
public void WriteToStream(Stream stream) { try { XmlWriterSettings settings = new XmlWriterSettings { CloseOutput = false, Encoding = System.Text.Encoding.UTF8, Indent = false, OmitXmlDeclaration = false }; using (XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateDictionaryWriter(XmlDictionaryWriter.Create(stream, settings))) { OnWriteBodyContents(xdw); xdw.Flush(); } } catch (Exception ex) { Console.WriteLine(ex); throw; } }