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;
}
}
