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