public byte[] GetByteArray(string body) { MemoryStream stream = new MemoryStream(); DataContractSerializer s = new DataContractSerializer(typeof(string)); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream); writer.WriteStartDocument(); s.WriteStartObject(writer, body); s.WriteObjectContent(writer, body); s.WriteEndObject(writer); writer.Flush(); stream.Position = 0; return(stream.ToArray()); }
private static void Serialize <T>(ref T obj, string fileName, ref Exception ex) { string fullName = string.Format("{0}{1}.xml", ConfigurationManager.AppSettings["SerializeLocation"], fileName); #region Error Xml Format XmlDocument doc = new XmlDocument(); XmlNode ErrorDetailsNode = doc.CreateElement("ErrorDetails"); XmlNode ExceptionTypeNode = doc.CreateElement("ExceptionType"); ExceptionTypeNode.InnerText = ex.GetType().ToString(); ErrorDetailsNode.AppendChild(ExceptionTypeNode); XmlNode MessageNode = doc.CreateElement("Message"); MessageNode.InnerText = ex.Message; ErrorDetailsNode.AppendChild(MessageNode); XmlNode InnerExceptionNode = doc.CreateElement("InnerException"); InnerExceptionNode.InnerText = ex.InnerException != null ? ex.InnerException.Message : ""; ErrorDetailsNode.AppendChild(InnerExceptionNode); XmlNode StackTraceNode = doc.CreateElement("StackTrace"); StackTraceNode.InnerText = ex.StackTrace; ErrorDetailsNode.AppendChild(StackTraceNode); doc.AppendChild(ErrorDetailsNode); #endregion DataContractSerializer s = new DataContractSerializer(typeof(T)); XmlSerializer xs = new XmlSerializer(typeof(XmlDocument)); using (System.IO.FileStream fs = File.Open(fullName, FileMode.Create)) { XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs); writer.WriteStartDocument(true); writer.WriteStartElement("FailedSaveCall"); s.WriteStartObject(writer, obj); s.WriteObjectContent(writer, obj); s.WriteEndObject(writer); xs.Serialize(writer, doc); writer.WriteEndElement(); writer.WriteEndDocument(); } }
public override void SerializeToXml(XmlWriter xw) { DataContractSerializer ser = new DataContractSerializer(this.GetType()); using (var ms = new MemoryStream()) { ser.WriteStartObject(xw, this); ser.WriteObjectContent(xw, this); xw.WriteElementString("Length", Bytes.Length.ToString()); if (Bytes.Length > 0) { xw.WriteElementString("Bytes", HexStr(Bytes)); } ser.WriteEndObject(xw); } }
private void _WriteSequenceDataToXmlWriter(ISequence sequence, XmlWriter xmlWriter) { ISequenceTypeModuleInstance sequenceTypeModule = _GetSequenceTypeModule(_fileType); DataContractSerializer serializer = SequenceTypeService.GetSequenceTypeDataSerializer(sequenceTypeModule); if (serializer == null) { throw new Exception(string.Format("Can't save sequence {0}, no serializer present. ", sequence.Name)); } serializer.WriteStartObject(xmlWriter, sequence.SequenceData); WriteVersion(xmlWriter); _WriteKnownNamespaces(xmlWriter); serializer.WriteObjectContent(xmlWriter, sequence.SequenceData); serializer.WriteEndObject(xmlWriter); }
public static void WriteObject( this DataContractSerializer serializer, Stream stream, object data, Dictionary <string, string> namespaces) { using (var writer = XmlWriter.Create(stream)) { serializer.WriteStartObject(writer, data); foreach (var pair in namespaces) { writer.WriteAttributeString("xmlns", pair.Key, null, pair.Value); } serializer.WriteObjectContent(writer, data); serializer.WriteEndObject(writer); } }
/// <summary> /// Write the header to a byte stream. /// </summary> /// <param name="header">The header.</param> /// <returns>The serialized data.</returns> private static byte[] Write(MiniProfilerResultsHeader header) { var serializer = new DataContractSerializer(typeof(MiniProfilerResultsHeader), HeaderName, HeaderNamespace); using (var stream = new MemoryStream()) { using (var writer = new XmlTextWriter(stream, Encoding.Unicode)) { writer.WriteStartElement(HeaderName, HeaderNamespace); serializer.WriteObjectContent(writer, header); writer.WriteEndElement(); writer.Flush(); byte[] buffer = stream.GetBuffer(); Array.Resize(ref buffer, (int)stream.Length); return(buffer); } } }
public virtual void SerializeToXml(XmlWriter xw) { DataContractSerializer ser = new DataContractSerializer(this.GetType()); using (var ms = new MemoryStream()) { ser.WriteStartObject(xw, this); ser.WriteObjectContent(xw, this); if (GetEditableVariables() != null) { foreach (var v in GetEditableVariables()) { v.SerializeToXml(xw); } } ser.WriteEndObject(xw); } }
public void SaveXml(string filePath) { using (XmlTextWriter writer = new XmlTextWriter(filePath, Encoding.UTF8)) { writer.Formatting = Formatting.Indented; DataContractSerializer ser = new DataContractSerializer(typeof(AgriCoop)); // Using references for Machine and Producer means that the Id attribute is used, which is defined in the MS Serialization namespace // To get cleaner XML, we declare this namespace first. // ser.WriteObject(writer, this); // replace by following lines. ser.WriteStartObject(writer, this); writer.WriteAttributeString("xmlns", "z", null, "http://schemas.microsoft.com/2003/10/Serialization/"); ser.WriteObjectContent(writer, this); ser.WriteEndObject(writer); writer.Close(); } }
public async Task PostAsync(String data) { MemoryStream contentStream = new MemoryStream(); DataContractSerializer serializer = new DataContractSerializer(typeof(String)); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(contentStream); writer.WriteStartDocument(); serializer.WriteStartObject(writer, data); serializer.WriteObjectContent(writer, data); serializer.WriteEndObject(writer); writer.Flush(); String fullAddress = "https://darkbird.servicebus.windows.net/checkpointtouches/messages"; this.client.DefaultRequestHeaders.TryAddWithoutValidation("Content-Type", "application/atom+xml;type=entry;charset=utf-8"); this.client.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", GetSASToken(this.url, "RootManageSharedAccessKey", this.sasKey)); this.client.DefaultRequestHeaders.TryAddWithoutValidation("BrokerProperties", @"{ ""MessageId"": """ + Guid.NewGuid().ToString() + @"""}"); var result = await this.client.PostAsync(fullAddress, new StreamContent(new System.IO.MemoryStream(contentStream.ToArray()))); System.Diagnostics.Debug.WriteLine(result.StatusCode.ToString()); }
public override void SerializeToXml(XmlWriter xw) { DataContractSerializer ser = new DataContractSerializer(this.GetType()); using (var ms = new MemoryStream()) { ser.WriteStartObject(xw, this); ser.WriteObjectContent(xw, this); } if (GetEditableVariables() != null) { xw.WriteStartElement("array"); foreach (CVariable v in GetEditableVariables()) { v.SerializeToXml(xw); } xw.WriteEndElement(); } ser.WriteEndObject(xw); }
public void WriteSaveData(System.Xml.XmlWriter writer) { //We simply skip null values; if (value == null) { return; } writer.WriteStartElement("Data"); writer.WriteAttributeString("Key", key); // Todo: does this create a security hole? Though mods can do everything anyway, this may abuse a mod to do sth harmful. Consider it! writer.WriteAttributeString("Type", value.GetType().AssemblyQualifiedName); var dcs = new DataContractSerializer(value.GetType(), "", "", null, Int32.MaxValue, false, false, null, ModSaveFile.GetDataContractResolver()); dcs.WriteObjectContent(writer, value); //var dcjs = new System.Runtime.Serialization.Json.DataContractJsonSerializer(value.GetType() writer.WriteEndElement(); }
private static Message PrepareResponse <T>(T order, Message request) { var dcs = new DataContractSerializer(typeof(T)); Action <XmlDictionaryWriter, T> onWrite = (writer, o) => { writer.WriteStartElement("GetOrderResponse", "http://tempuri.org/"); writer.WriteStartElement("GetOrderResult", "http://tempuri.org/"); dcs.WriteObjectContent(writer, o); writer.WriteEndElement(); writer.WriteEndElement(); }; var msg = Message.CreateMessage(request.Version, "http://tempuri.org/IService/GetOrderResponse", new DelegatingBodyWriter <T>( onWrite, order)); msg.Headers.RelatesTo = request.Headers.MessageId; return(msg); }
public static void WriteObject(this DataContractSerializer serializer, XmlWriter stream, object data, Dictionary <string, string> namespaces) { XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.Indent = true; xmlWriterSettings.NewLineOnAttributes = true; xmlWriterSettings.OmitXmlDeclaration = true; xmlWriterSettings.NamespaceHandling = NamespaceHandling.Default; using (var writer = XmlWriter.Create(stream, xmlWriterSettings)) { serializer.WriteStartObject(writer, data); foreach (var pair in namespaces) { writer.WriteAttributeString("xmlns", pair.Key, null, pair.Value); } serializer.WriteObjectContent(writer, data); serializer.WriteEndObject(writer); } }
public static void WriteObjectData(string path) { // Create the object to serialize. Person p = new Person("Lynn", "Tsoflias", 9876); // Create the writer. FileStream fs = new FileStream(path, FileMode.Create); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs); DataContractSerializer ser = new DataContractSerializer(typeof(Person)); // Use the writer to start a document. writer.WriteStartDocument(true); // Use the serializer to write the start of the // object data. Use it again to write the object // data. ser.WriteStartObject(writer, p); ser.WriteObjectContent(writer, p); // Use the writer to add an XML element to the document. writer.WriteElementString("Citizen", "true"); // Use the serializer to write the end of the // object data. Then use the writer to write the end // of the document. ser.WriteEndObject(writer); writer.WriteEndDocument(); Console.WriteLine("Done"); // Close and release the writer resources. writer.Flush(); fs.Flush(); fs.Close(); }
//</snippet6> //<snippet7> public static void WriteObjectContentInDocument(string path) { // Create the object to serialize. Person p = new Person("Lynn", "Tsoflias", 9876); // Create the writer object. FileStream fs = new FileStream(path, FileMode.Create); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs); DataContractSerializer ser = new DataContractSerializer(typeof(Person)); // Use the writer to start a document. writer.WriteStartDocument(true); // Use the writer to write the root element. writer.WriteStartElement("Company"); // Use the writer to write an element. writer.WriteElementString("Name", "Microsoft"); // Use the serializer to write the start, // content, and end data. ser.WriteStartObject(writer, p); ser.WriteObjectContent(writer, p); ser.WriteEndObject(writer); // Use the writer to write the end element and // the end of the document. writer.WriteEndElement(); writer.WriteEndDocument(); // Close and release the writer resources. writer.Flush(); fs.Flush(); fs.Close(); }
public void WriteConstraints(string fileName) { object[] attributes; attributes = this.GetType().GetCustomAttributes(typeof(NamespaceAttribute), true); var ds = new DataContractSerializer(typeof(SkeletonConstraintsCollection)); var settings = new XmlWriterSettings { Indent = true, NewLineOnAttributes = true }; using (var w = XmlWriter.Create(fileName, settings)) { ds.WriteStartObject(w, this); foreach (NamespaceAttribute ns in attributes) { w.WriteAttributeString("xmlns", ns.Prefix, null, ns.Uri); } // content ds.WriteObjectContent(w, this); ds.WriteEndObject(w); } }
public static void Main(string[] args) { var xmlSettings = new XmlWriterSettings() { Indent = true, NewLineChars = "\r\n", NewLineHandling = NewLineHandling.Replace, }; var configBasePath = Path.Combine(GetExecutablePath(), "serializers", "objects"); var config = Configuration.Load(configBasePath); string schemaName = null; var mode = Mode.Unknown; var showHelp = false; var options = new OptionSet() { { "b|xml2bin", "convert xml to bin", v => mode = v != null ? Mode.Import : mode }, { "x|bin2xml", "convert bin to xml", v => mode = v != null ? Mode.Export : mode }, { "s|schema=", "override schema name", v => schemaName = v }, { "h|help", "show this message and exit", v => showHelp = v != null }, }; List <string> extras; try { extras = options.Parse(args); } catch (OptionException e) { Console.Write("{0}: ", GetExecutableName()); Console.WriteLine(e.Message); Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName()); return; } // try to figure out what they want to do if (mode == Mode.Unknown && extras.Count >= 1) { var testPath = extras[0]; if (Directory.Exists(testPath) == true) { mode = Mode.Import; } else if (File.Exists(testPath) == true) { mode = Mode.Export; } } if (extras.Count < 1 || extras.Count > 2 || showHelp == true || mode == Mode.Unknown) { Console.WriteLine("Usage: {0} [OPTIONS]+ -x input_bin [output_xml]", GetExecutableName()); Console.WriteLine(" {0} [OPTIONS]+ -b input_xml [output_bin]", GetExecutableName()); Console.WriteLine(); Console.WriteLine("Options:"); options.WriteOptionDescriptions(Console.Out); return; } if (mode == Mode.Export) { var inputPath = extras[0]; var outputPath = extras.Count > 1 ? extras[1] : Path.ChangeExtension(inputPath, ".xml"); using (var input = File.OpenRead(inputPath)) { Console.WriteLine("Loading bin..."); var blob = new BlobFile(); blob.Deserialize(input); if (schemaName == null) { schemaName = Path.GetFileNameWithoutExtension(inputPath); } var schema = config.GetSchema(schemaName); if (schema == null) { Console.WriteLine("Don't know how to handle '{0}' with a hash of '{1}'.", schemaName, blob.ParserHash); return; } var target = schema.GetTarget(blob.ParserHash); if (target == null) { Console.WriteLine("Don't know how to handle '{0}' with a hash of '{1}'.", schemaName, blob.ParserHash); return; } var version = target.FirstVersion(); if (version == null) { Console.WriteLine("No support for '{0}' with a hash of '{1}'.", schemaName, blob.ParserHash); return; } var assemblyPath = Path.Combine(GetExecutablePath(), "serializers", "assemblies", version + ".dll"); if (File.Exists(assemblyPath) == false) { Console.WriteLine("Assembly '{0}' appears to be missing!", Path.GetFileName(assemblyPath)); return; } var assembly = Assembly.LoadFrom(assemblyPath); var type = assembly.GetType(target.Class); if (type == null) { Console.WriteLine("Assembly '{0}' does not expose '{1}'!", Path.GetFileName(assemblyPath), target.Class); return; } var resource = new Resource { Schema = schemaName, ParserHash = blob.ParserHash, }; foreach (var file in blob.Files) { resource.Files.Add(new Resource.FileEntry() { Name = file.Name, Timestamp = file.Timestamp, }); } foreach (var dependency in blob.Dependencies) { resource.Dependencies.Add(new Resource.DependencyEntry() { Type = dependency.Type, Name = dependency.Name, Hash = dependency.Hash, }); } Func <int, string> getFileNameFromIndex = i => { if (i < 0 || i >= resource.Files.Count) { throw new KeyNotFoundException("file index " + i.ToString(CultureInfo.InvariantCulture) + " is out of range"); } return(resource.Files[i].Name); }; var loadObject = typeof(BlobDataReader) .GetMethod("LoadObject", BindingFlags.Public | BindingFlags.Static) .MakeGenericMethod(type); var data = loadObject.Invoke( null, new object[] { input, schema.IsClient, schema.IsServer, getFileNameFromIndex }); Console.WriteLine("Saving object to XML..."); using (var output = File.Create(outputPath)) { var writer = XmlWriter.Create(output, xmlSettings); writer.WriteStartDocument(); writer.WriteStartElement("object"); writer.WriteStartElement("data"); var objectWriter = XmlWriter.Create(writer, xmlSettings); var objectSerializer = new DataContractSerializer(type); objectSerializer.WriteStartObject(objectWriter, type); objectWriter.WriteAttributeString("xmlns", "c", "", "http://datacontract.gib.me/cryptic"); //objectWriter.WriteAttributeString("xmlns", "i", "", "http://www.w3.org/2001/XMLSchema-instance"); objectWriter.WriteAttributeString("xmlns", "a", "", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); //objectWriter.WriteAttributeString("xmlns", "s", "", "http://datacontract.gib.me/startrekonline"); objectSerializer.WriteObjectContent(objectWriter, data); objectSerializer.WriteEndObject(objectWriter); objectWriter.Flush(); writer.WriteEndElement(); var resourceWriter = XmlWriter.Create(writer, xmlSettings); var resourceSerializer = new XmlSerializer(typeof(Resource)); resourceSerializer.Serialize(resourceWriter, resource); resourceWriter.Flush(); writer.WriteEndElement(); writer.WriteEndDocument(); writer.Flush(); } } } else if (mode == Mode.Import) { var inputPath = extras[0]; var outputPath = extras.Count > 1 ? extras[1] : Path.ChangeExtension(inputPath, ".bin"); Console.WriteLine("Loading XML..."); var blob = new BlobFile(); using (var input = File.OpenRead(inputPath)) { var doc = new XPathDocument(input); var nav = doc.CreateNavigator(); var resourceNode = nav.SelectSingleNode("/object/resource"); if (resourceNode == null) { throw new InvalidOperationException(); } var resourceSerializer = new XmlSerializer(typeof(Resource)); var resource = (Resource)resourceSerializer.Deserialize(resourceNode.ReadSubtree()); var schema = config.GetSchema(resource.Schema); if (schema == null) { Console.WriteLine("Don't know how to handle '{0}'!", resource.Schema); return; } var target = schema.GetTarget(resource.ParserHash); if (target == null) { Console.WriteLine("Don't know how to handle '{0}' with a hash of {1}.", resource.Schema, resource.ParserHash); return; } var version = target.FirstVersion(); if (version == null) { Console.WriteLine("No support for '{0}' with a hash of {1:X8}.", resource.Schema, resource.ParserHash); return; } var assemblyPath = Path.Combine(GetExecutablePath(), "serializers", "assemblies", version + ".dll"); if (File.Exists(assemblyPath) == false) { Console.WriteLine("Assembly '{0}' appears to be missing!", Path.GetFileName(assemblyPath)); return; } var assembly = Assembly.LoadFrom(assemblyPath); var type = assembly.GetType(target.Class); if (type == null) { Console.WriteLine("Assembly '{0}' does not expose '{1}'!", Path.GetFileName(assemblyPath), target.Class); return; } blob.ParserHash = resource.ParserHash; foreach (var file in resource.Files) { blob.Files.Add(new Blob.FileEntry() { Name = file.Name, Timestamp = file.Timestamp, }); } foreach (var dependency in resource.Dependencies) { blob.Dependencies.Add(new Blob.DependencyEntry() { Type = dependency.Type, Name = dependency.Name, Hash = dependency.Hash, }); } var objectNode = nav.SelectSingleNode("/object/data"); if (objectNode == null) { throw new InvalidOperationException(); } objectNode.MoveToFirstChild(); var subtree = objectNode.ReadSubtree(); var objectSerializer = new DataContractSerializer(type); var data = objectSerializer.ReadObject(subtree); Func <string, int> getIndexFromFileName = s => blob.Files.FindIndex(fe => fe.Name == s); Console.WriteLine("Saving object..."); var saveResource = typeof(BlobDataWriter) .GetMethod("SaveObject", BindingFlags.Public | BindingFlags.Static) .MakeGenericMethod(type); using (var output = File.Create(outputPath)) { blob.Serialize(output); saveResource.Invoke( null, new[] { data, output, schema.IsClient, schema.IsServer, getIndexFromFileName }); } } } else { throw new InvalidOperationException(); } }
public override void WriteObjectContent(XmlDictionaryWriter writer, object graph) { _serializer.WriteObjectContent(new SecurePayXmlDictionaryWriter(writer), graph); }
static void Main(string[] args) { test_w_point_size(); //test_getInstance(); //test_w_knowtype(); //test_w_resolver(); lTableInfo_config tbl1 = new lTableInfo_config(); tbl1.m_tblName = "receipts"; tbl1.m_tblAlias = "Bang thu"; tbl1.m_cols = new lColInfo[] { new lColInfo { m_alias = "alias", m_field = "field", m_lookupTbl = "lookupTbl", m_type = lColInfo.lColType.text }, new lColInfo { m_alias = "col2", m_field = "field", m_lookupTbl = "lookupTbl", m_type = lColInfo.lColType.text }, }; lTableInfo_config[] tbls = new lTableInfo_config[] { tbl1 }; DataContractJsonSerializer jsonz = new DataContractJsonSerializer(typeof(lTableInfo_config[])); jsonz.WriteObject(Console.OpenStandardOutput(), tbls); lReceiptsSearchPanel panel = new lReceiptsSearchPanel(); lSearchPanel_config panel_config = (lSearchPanel_config)panel; lSearchPanel_config[] panels = new lSearchPanel_config[] { panel_config }; //jsonz = new DataContractJsonSerializer(typeof(lSearchPanel_config[])); //jsonz.WriteObject(Console.OpenStandardOutput(), panels); XmlSerializer xs = new XmlSerializer(typeof(lColInfo)); xs.Serialize(Console.OpenStandardOutput(), tbl1.m_cols[0]); //xs.Deserialize() lSearchCtrl_config[] ctrls = new lSearchCtrl_config[] { new lSearchCtrl_config { m_fieldName = "date", m_pos = new myPoint(1, 1), m_size = new mySize(1, 1) }, new lSearchCtrl_config { m_fieldName = "receipt_number", m_pos = new myPoint(1, 2), m_size = new mySize(1, 1), m_searchMatch = true } }; DataContractJsonSerializerSettings jsonsettings = new DataContractJsonSerializerSettings(); jsonz = new DataContractJsonSerializer(typeof(lSearchCtrl_config[])); jsonz.WriteObject(Console.OpenStandardOutput(), ctrls); { DataContractSerializerSettings settings = new DataContractSerializerSettings(); XmlDictionary dic = new XmlDictionary(); settings.RootName = new XmlDictionaryString(dic, "tableInfo", 1); DataContractSerializer tmpz = new DataContractSerializer(typeof(lTableInfo_config), settings); tmpz.WriteObject(Console.OpenStandardOutput(), tbl1); } DataContractSerializer xmlz = new DataContractSerializer(typeof(lTableInfo_config[])); DataContractSerializer xmlz2 = new DataContractSerializer(typeof(lSearchCtrl_config[])); string pathXml = "config.xml"; XmlDocument doc = new XmlDocument(); XmlWriter wrt; //XmlReader rd; if (!System.IO.File.Exists(pathXml)) { XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.IndentChars = "\t"; wrt = XmlWriter.Create("config.xml", settings); wrt.WriteStartElement("config"); wrt.WriteStartElement("dataPanel"); xmlz.WriteObjectContent(wrt, tbls); wrt.WriteEndElement(); wrt.WriteStartElement("searchPanel"); //xmlz2.WriteObjectContent(wrt, ctrls); //jsonz.WriteObject(wrt, ctrls); jsonz.WriteObjectContent(wrt, ctrls); wrt.WriteEndElement(); wrt.WriteEndElement(); wrt.Close(); } //doc.Load(pathXml); //XmlNode node = doc.SelectSingleNode("searchPanel"); XmlReader rd = XmlReader.Create(pathXml); rd.Read(); rd.ReadToFollowing("dataPanel"); var objs1 = xmlz.ReadObject(rd, false); rd.ReadToFollowing("searchPanel"); #if false rd.ReadToDescendant("root"); rd.MoveToContent(); rd.MoveToElement(); rd.ReadEndElement(); rd.Skip(); Console.WriteLine(rd.Name); var objs = jsonz.ReadObject(rd); #else var objs = jsonz.ReadObject(rd, false); #endif //XmlNode node = doc.FirstChild; //doc.SelectSingleNode("dataPanel"); }
public static void SerializeObjectContent <T>(XmlWriter xw, T val) { DataContractSerializer ser = new DataContractSerializer(typeof(T)); ser.WriteObjectContent(xw, val); }
public static void Main(string[] args) { var xmlSettings = new XmlWriterSettings() { Indent = true, NewLineChars = "\r\n", NewLineHandling = NewLineHandling.Replace, }; var configBasePath = Path.Combine(GetExecutablePath(), "serializers", "resources"); var config = Configuration.Load(configBasePath); string parseName = null; var mode = Mode.Unknown; var showHelp = false; var options = new OptionSet() { { "b|xml2bin", "convert xml to bin", v => mode = v != null ? Mode.Import : mode }, { "x|bin2xml", "convert bin to xml", v => mode = v != null ? Mode.Export : mode }, { "p|parse=", "override parse name", v => parseName = v }, { "h|help", "show this message and exit", v => showHelp = v != null }, }; List <string> extras; try { extras = options.Parse(args); } catch (OptionException e) { Console.Write("{0}: ", GetExecutableName()); Console.WriteLine(e.Message); Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName()); return; } // try to figure out what they want to do if (mode == Mode.Unknown && extras.Count >= 1) { var testPath = extras[0]; if (Directory.Exists(testPath) == true) { mode = Mode.Import; } else if (File.Exists(testPath) == true) { mode = Mode.Export; } } if (extras.Count < 1 || extras.Count > 2 || showHelp == true || mode == Mode.Unknown) { Console.WriteLine("Usage: {0} [OPTIONS]+ -x input_bin [output_dir]", GetExecutableName()); Console.WriteLine(" {0} [OPTIONS]+ -b input_dir [output_bin]", GetExecutableName()); Console.WriteLine(); Console.WriteLine("Options:"); options.WriteOptionDescriptions(Console.Out); return; } if (mode == Mode.Export) { var inputPath = extras[0]; var outputPath = extras.Count > 1 ? extras[1] : Path.ChangeExtension(inputPath, null); using (var input = File.OpenRead(inputPath)) { Console.WriteLine("Loading bin..."); var blob = new BlobFile(); blob.Deserialize(input); if (parseName == null) { parseName = Path.GetFileNameWithoutExtension(inputPath); } var parse = config.GetParse(parseName); if (parse == null) { Console.WriteLine( "Don't know how to handle '{0}' with a hash of '{1}'.", parseName, blob.ParseHash); return; } var target = parse.GetTarget(blob.ParseHash); if (target == null) { Console.WriteLine( "Don't know how to handle '{0}' with a hash of '{1}'.", parseName, blob.ParseHash); return; } var version = target.FirstVersion(); if (version == null) { Console.WriteLine( "No support for '{0}' with a hash of '{1}'.", parseName, blob.ParseHash); return; } var assemblyPath = Path.Combine( GetExecutablePath(), "serializers", "assemblies", version + ".dll"); if (File.Exists(assemblyPath) == false) { Console.WriteLine( "Assembly '{0}' appears to be missing!", Path.GetFileName(assemblyPath)); return; } var assembly = Assembly.LoadFrom(assemblyPath); var type = assembly.GetType(target.Class); if (type == null) { Console.WriteLine( "Assembly '{0}' does not expose '{1}'!", Path.GetFileName(assemblyPath), target.Class); return; } var resource = new Resource() { Parse = parseName, ParseHash = blob.ParseHash, }; foreach (var file in blob.Files) { resource.Files.Add(new Resource.FileEntry() { Name = file.Name, Timestamp = file.Timestamp, }); } foreach (var dependency in blob.Dependencies) { resource.Dependencies.Add(new Resource.DependencyEntry() { Type = dependency.Type, Name = dependency.Name, Hash = dependency.Hash, }); } var loadResource = typeof(BlobDataReader) .GetMethod("LoadResource", BindingFlags.Public | BindingFlags.Static) .MakeGenericMethod(type); Console.WriteLine("Loading entries..."); Func <int, string> getFileNameFromIndex = i => { if (i < 0 || i >= resource.Files.Count) { throw new KeyNotFoundException($"file index {i} is out of range"); } return(resource.Files[i].Name); }; var list = (IList)loadResource.Invoke( null, new object[] { input, parse.IsClient, parse.IsServer, getFileNameFromIndex }); var entries = list.Cast <object>(); var listType = typeof(List <>).MakeGenericType(type); Console.WriteLine("Saving entries to XML..."); switch (parse.Mode.ToLowerInvariant()) { case "single": { var serializer = new DataContractSerializer(listType); const string entryName = "entries.xml"; resource.Entries.Add(entryName); var entryPath = Path.Combine(outputPath, entryName); if (File.Exists(entryPath) == true) { throw new InvalidOperationException(); } var entryParentPath = Path.GetDirectoryName(entryPath); if (string.IsNullOrEmpty(entryParentPath) == false) { Directory.CreateDirectory(entryParentPath); } using (var output = File.Create(entryPath)) { var localList = (IList)Activator.CreateInstance(listType); foreach (var entry in entries) { localList.Add(entry); } var writer = XmlWriter.Create(output, xmlSettings); serializer.WriteStartObject(writer, listType); writer.WriteAttributeString("xmlns", "c", "", "http://datacontract.gib.me/cryptic"); //writer.WriteAttributeString("xmlns", "i", "", "http://www.w3.org/2001/XMLSchema-instance"); writer.WriteAttributeString( "xmlns", "a", "", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); //writer.WriteAttributeString("xmlns", "s", "", "http://datacontract.gib.me/startrekonline"); serializer.WriteObjectContent(writer, localList); serializer.WriteEndObject(writer); writer.Flush(); } break; } case "file": { var serializer = new DataContractSerializer(listType); var fileNameFieldName = "FileName"; if (string.IsNullOrEmpty(target.FileNameKey) == false) { fileNameFieldName = target.FileNameKey; } var fileNameField = type.GetField( fileNameFieldName, BindingFlags.Public | BindingFlags.Instance); if (fileNameField == null) { Console.WriteLine("Class '{0}' does not expose '{1}'!", target.Class, fileNameFieldName); return; } var uniqueFileNames = entries .Select(i => (string)fileNameField.GetValue(i)) .Distinct(); foreach (var fileName in uniqueFileNames) { var entryName = fileName; entryName = entryName.Replace('/', '\\'); entryName = Path.ChangeExtension(entryName, ".xml"); resource.Entries.Add(entryName); var entryPath = Path.Combine(outputPath, entryName); if (File.Exists(entryPath) == true) { throw new InvalidOperationException(); } var entryParentPath = Path.GetDirectoryName(entryPath); if (string.IsNullOrEmpty(entryParentPath) == false) { Directory.CreateDirectory(entryParentPath); } using (var output = File.Create(entryPath)) { var localEntries = (IList)Activator.CreateInstance(listType); string name = fileName; foreach (var entry in entries .Where(e => (string)(fileNameField.GetValue(e)) == name)) { localEntries.Add(entry); } var writer = XmlWriter.Create(output, xmlSettings); serializer.WriteStartObject(writer, listType); writer.WriteAttributeString("xmlns", "c", "", "http://datacontract.gib.me/cryptic"); //writer.WriteAttributeString("xmlns", "i", "", "http://www.w3.org/2001/XMLSchema-instance"); writer.WriteAttributeString( "xmlns", "a", "", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); //writer.WriteAttributeString("xmlns", "s", "", "http://datacontract.gib.me/startrekonline"); serializer.WriteObjectContent(writer, localEntries); serializer.WriteEndObject(writer); writer.Flush(); } } break; } case "name": { var serializer = new DataContractSerializer(type); if (string.IsNullOrEmpty(target.Key) == true) { Console.WriteLine("No key set for '{0}'!", parseName); return; } var keyField = type.GetField( target.Key, BindingFlags.Public | BindingFlags.Instance); if (keyField == null) { Console.WriteLine("Class '{0}' does not expose '{1}'!", target.Class, target.Key); return; } foreach (var entry in entries) { var entryName = Path.ChangeExtension((string)keyField.GetValue(entry), ".xml"); resource.Entries.Add(entryName); var entryPath = Path.Combine(outputPath, entryName); if (File.Exists(entryPath) == true) { throw new InvalidOperationException(); } var entryParentPath = Path.GetDirectoryName(entryPath); if (string.IsNullOrEmpty(entryParentPath) == false) { Directory.CreateDirectory(entryParentPath); } using (var output = File.Create(entryPath)) { var writer = XmlWriter.Create(output, xmlSettings); serializer.WriteStartObject(writer, entry); writer.WriteAttributeString("xmlns", "c", "", "http://datacontract.gib.me/cryptic"); //writer.WriteAttributeString("xmlns", "i", "", "http://www.w3.org/2001/XMLSchema-instance"); writer.WriteAttributeString( "xmlns", "a", "", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); //writer.WriteAttributeString("xmlns", "s", "", "http://datacontract.gib.me/startrekonline"); serializer.WriteObjectContent(writer, entry); serializer.WriteEndObject(writer); writer.Flush(); } } break; } case "entry": { var serializer = new DataContractSerializer(type); var fileNameFieldName = "FileName"; if (string.IsNullOrEmpty(target.FileNameKey) == false) { fileNameFieldName = target.FileNameKey; } var fileNameField = type.GetField( fileNameFieldName, BindingFlags.Public | BindingFlags.Instance); if (fileNameField == null) { Console.WriteLine("Class '{0}' does not expose '{1}'!", target.Class, fileNameFieldName); return; } if (string.IsNullOrEmpty(target.Key) == true) { Console.WriteLine("No key set for '{0}'!", parseName); return; } var keyField = type.GetField( target.Key, BindingFlags.Public | BindingFlags.Instance); if (keyField == null) { Console.WriteLine("Class '{0}' does not expose '{1}'!", target.Class, target.Key); return; } foreach (var entry in entries) { var entryName = (string)fileNameField.GetValue(entry); entryName = entryName.Replace('/', '\\'); entryName = Path.ChangeExtension( Path.Combine(entryName, (string)keyField.GetValue(entry)), ".xml"); resource.Entries.Add(entryName); var entryPath = Path.Combine(outputPath, entryName); if (File.Exists(entryPath) == true) { throw new InvalidOperationException(); } var entryParentPath = Path.GetDirectoryName(entryPath); if (string.IsNullOrEmpty(entryParentPath) == false) { Directory.CreateDirectory(entryParentPath); } using (var output = File.Create(entryPath)) { var writer = XmlWriter.Create(output, xmlSettings); serializer.WriteStartObject(writer, entry); writer.WriteAttributeString("xmlns", "c", "", "http://datacontract.gib.me/cryptic"); //writer.WriteAttributeString("xmlns", "i", "", "http://www.w3.org/2001/XMLSchema-instance"); writer.WriteAttributeString( "xmlns", "a", "", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); //writer.WriteAttributeString("xmlns", "s", "", "http://datacontract.gib.me/startrekonline"); serializer.WriteObjectContent(writer, entry); serializer.WriteEndObject(writer); writer.Flush(); } } break; } default: { throw new NotSupportedException(); } } Console.WriteLine("Saving index..."); using (var output = File.Create(Path.Combine(outputPath, "@resource.xml"))) { var writer = XmlWriter.Create(output, xmlSettings); var serializer = new XmlSerializer(typeof(Resource)); serializer.Serialize(writer, resource); writer.Flush(); } } } else if (mode == Mode.Import) { var inputPath = extras[0]; var outputPath = extras.Count > 1 ? extras[1] : Path.ChangeExtension(inputPath, ".bin"); Console.WriteLine("Loading index..."); Resource resource; using (var input = File.OpenRead(Path.Combine(inputPath, "@resource.xml"))) { var reader = XmlReader.Create(input); var serializer = new XmlSerializer(typeof(Resource)); resource = (Resource)serializer.Deserialize(reader); } var schema = config.GetParse(resource.Parse); if (schema == null) { Console.WriteLine("Don't know how to handle '{0}'!", resource.Parse); return; } var target = schema.GetTarget(resource.ParseHash); if (target == null) { Console.WriteLine( "Don't know how to handle '{0}' with a hash of {1}.", resource.Parse, resource.ParseHash); return; } var version = target.FirstVersion(); if (version == null) { Console.WriteLine( "No support for '{0}' with a hash of {1:X8}.", resource.Parse, resource.ParseHash); return; } var assemblyPath = Path.Combine( GetExecutablePath(), "serializers", "assemblies", version + ".dll"); if (File.Exists(assemblyPath) == false) { Console.WriteLine( "Assembly '{0}' appears to be missing!", Path.GetFileName(assemblyPath)); return; } var assembly = Assembly.LoadFrom(assemblyPath); var type = assembly.GetType(target.Class); if (type == null) { Console.WriteLine( "Assembly '{0}' does not expose '{1}'!", Path.GetFileName(assemblyPath), target.Class); return; } var blob = new BlobFile() { ParseHash = resource.ParseHash, }; foreach (var file in resource.Files) { blob.Files.Add(new Blob.FileEntry() { Name = file.Name, Timestamp = file.Timestamp, }); } foreach (var dependency in resource.Dependencies) { blob.Dependencies.Add(new Blob.DependencyEntry() { Type = dependency.Type, Name = dependency.Name, Hash = dependency.Hash, }); } var listType = typeof(List <>).MakeGenericType(type); var entries = (IList)Activator.CreateInstance(listType); Console.WriteLine("Loading entries from XML..."); switch (schema.Mode.ToLowerInvariant()) { case "single": case "file": { var serializer = new DataContractSerializer(listType); foreach (var entryName in resource.Entries) { var entryPath = Path.IsPathRooted(entryName) == true ? entryName : Path.Combine(inputPath, entryName); using (var input = File.OpenRead(entryPath)) { var reader = XmlReader.Create(input); var localEntries = (IList)serializer.ReadObject(reader); foreach (var entry in localEntries) { entries.Add(entry); } } } break; } case "name": case "entry": { var serializer = new DataContractSerializer(type); foreach (var entryName in resource.Entries) { var entryPath = Path.IsPathRooted(entryName) == true ? entryName : Path.Combine(inputPath, entryName); using (var input = File.OpenRead(entryPath)) { var reader = XmlReader.Create(input); var entry = serializer.ReadObject(reader); entries.Add(entry); } } break; } default: { throw new NotSupportedException(); } } if (string.IsNullOrEmpty(target.Key) == false) { var keyField = type.GetField( target.Key, BindingFlags.Public | BindingFlags.Instance); if (keyField == null) { Console.WriteLine("Class '{0}' does not expose '{1}'!", target.Class, target.Key); return; } Console.WriteLine("Sorting entries..."); var sortedEntries = entries .Cast <object>() .OrderBy(keyField.GetValue) .ToList(); entries.Clear(); foreach (var entry in sortedEntries) { entries.Add(entry); } Func <string, int> getIndexFromFileName = s => blob.Files.FindIndex(fe => fe.Name == s); Console.WriteLine("Saving entries..."); var saveResource = typeof(BlobDataWriter) .GetMethod("SaveResource", BindingFlags.Public | BindingFlags.Static) .MakeGenericMethod(type); using (var output = File.Create(outputPath)) { blob.Serialize(output); saveResource.Invoke( null, new object[] { entries, output, schema.IsClient, schema.IsServer, getIndexFromFileName }); } } } else { throw new InvalidOperationException(); } }
public override void WriteObjectContent(XmlDictionaryWriter writer, object graph) { dataContractSerializer.WriteObjectContent(writer, graph); }
public void CompareXml() { var auditConfiguration = AuditConfiguration.Default; auditConfiguration.IncludeRelationships = true; auditConfiguration.LoadRelationships = true; auditConfiguration.DefaultAuditable = true; // customize the audit for Task entity //auditConfiguration.IsAuditable<Task>() // .NotAudited(t => t.TaskExtended) // .FormatWith(t => t.Status, v => FormatStatus(v)); // set name as the display member when status is a foreign key auditConfiguration.IsAuditable <Status>() .DisplayMember(t => t.Name); var db = new TrackerContext(); var audit = db.BeginAudit(); var user = db.Users.Find(1); user.Comment = "Testing: " + DateTime.Now.Ticks; var task = new Task() { AssignedId = 1, CreatedId = 1, StatusId = 1, PriorityId = 2, Summary = "Summary: " + DateTime.Now.Ticks }; db.Tasks.Add(task); var task2 = db.Tasks.Find(1); task2.PriorityId = 2; task2.StatusId = 2; task2.Summary = "Summary: " + DateTime.Now.Ticks; var log = audit.CreateLog(); Assert.IsNotNull(log); string xml = log.ToXml(); Assert.IsNotNull(xml); File.WriteAllText(@"test.xml.xml", xml); foreach (var property in log.Entities.SelectMany(e => e.Properties)) { Assert.AreNotEqual(property.Current, "{error}"); Assert.AreNotEqual(property.Original, "{error}"); } var builder = new StringBuilder(); var settings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true }; var writer = XmlWriter.Create(builder, settings); var serializer = new DataContractSerializer(typeof(AuditLog)); serializer.WriteStartObject(writer, log); writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema"); serializer.WriteObjectContent(writer, log); serializer.WriteEndObject(writer); writer.Flush(); string xml2 = builder.ToString(); File.WriteAllText(@"test.data.xml", xml2); string json = JsonConvert.SerializeObject(log, Newtonsoft.Json.Formatting.Indented, new StringEnumConverter()); File.WriteAllText(@"test.data.json", json); }
public override void WriteObjectContent(XmlDictionaryWriter writer, object graph) { _serializer.WriteObjectContent(_createWriter(writer), graph); }
public virtual void Save(string directoryPath) { Stopwatch sw = new Stopwatch(); sw.Start(); if (!Directory.Exists(directoryPath)) { Directory.CreateDirectory(directoryPath); } Parallel.ForEach(_dic, new ParallelOptions() { MaxDegreeOfParallelism = 8 }, item => { try { var name = item.Key; var type = item.Value.Type; var value = item.Value.Value; string uniquePath = null; using (FileStream stream = SettingsBase.GetUniqueFileStream(Path.Combine(directoryPath, name + ".tmp"))) using (CacheStream cacheStream = new CacheStream(stream, _cacheSize, BufferManager.Instance)) { uniquePath = stream.Name; using (GZipStream compressStream = new GZipStream(cacheStream, CompressionMode.Compress)) using (XmlDictionaryWriter xml = XmlDictionaryWriter.CreateBinaryWriter(compressStream)) { var serializer = new DataContractSerializer(type); serializer.WriteStartObject(xml, value); xml.WriteAttributeString("xmlns", "xa", "http://www.w3.org/2000/xmlns/", "http://schemas.microsoft.com/2003/10/Serialization/"); xml.WriteAttributeString("xmlns", "xc", "http://www.w3.org/2000/xmlns/", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"); xml.WriteAttributeString("xmlns", "xb", "http://www.w3.org/2000/xmlns/", "http://www.w3.org/2001/XMLSchema"); serializer.WriteObjectContent(xml, value); serializer.WriteEndObject(xml); } } string newPath = Path.Combine(directoryPath, name + ".v2"); string bakPath = Path.Combine(directoryPath, name + ".v2.bak"); if (File.Exists(newPath)) { if (File.Exists(bakPath)) { File.Delete(bakPath); } File.Move(newPath, bakPath); } File.Move(uniquePath, newPath); { foreach (var extension in new string[] { ".gz", ".gz.bak" }) { string deleteFilePath = Path.Combine(directoryPath, name + extension); if (File.Exists(deleteFilePath)) { File.Delete(deleteFilePath); } } } } catch (Exception e) { Log.Warning(e); } }); sw.Stop(); Debug.WriteLine("Settings Save {0} {1}", Path.GetFileName(directoryPath), sw.ElapsedMilliseconds); }