public XmlSerializer(string rootName = "root", TextSerializer textSerializer = null)
{
SetTextSerializer(textSerializer);
_document = new XDocument();
CreateRoot(rootName);
_currentElement = _document.Root;
}
public static DateTime LoadLastCutoff(string tableName, string configurationName, bool rebuild)
{
if (String.IsNullOrEmpty(tableName))
{
throw new ArgumentException("tableName is null or empty.", "tableName");
}
if (String.IsNullOrEmpty(configurationName))
{
throw new ArgumentException("configurationName is null or empty.", "configurationName");
}
DateTime allItemsCutoff = DateTime.UtcNow.AddYears(-20);
DateTime cutoff;
if (rebuild)
{
cutoff = allItemsCutoff;
}
else
{
cutoff = TextSerializer.ReadDateTime(String.Format(CutoffLocationFormatString, tableName, configurationName), allItemsCutoff);
}
return(cutoff);
}
/*public override bool Export(MindMapView view, string filename)
* {
* string str = string.Empty;
*
* if (view.Map != null && view.Map.Root != null)
* {
* TextSerializer ts = new TextSerializer();
* str = ts.SerializeObjects(new ChartObject[] { view.Map.Root });
* }
*
* using (StreamWriter sw = new StreamWriter(filename, false, Encoding.Default))
* {
* sw.Write(str);
* sw.Close();
* }
*
* return true;
* }*/
protected override bool ExportChartToFile(Document document, ChartPage chart, string filename)
{
string str = string.Empty;
if (chart is MindMap)
{
var mindMap = (MindMap)chart;
if (mindMap.Root != null)
{
var ts = new TextSerializer();
str = ts.SerializeObjects(new ChartObject[] { mindMap.Root }, true);
}
using (var sw = new StreamWriter(filename, false, Encoding.Default))
{
sw.Write(str);
sw.Close();
}
return(true);
}
return(false);
//return base.ExportChartToFile(document, chart, filename);
}
public object DeserializeFromString(string json, Type returnType)
{
if (TextSerializer != null)
{
return(TextSerializer.DeserializeFromString(json, returnType));
}
if (!UseBcl)
{
return(JsonSerializer.DeserializeFromString(json, returnType));
}
try
{
using (var ms = new MemoryStream())
{
var bytes = Encoding.UTF8.GetBytes(json);
ms.Write(bytes, 0, bytes.Length);
ms.Position = 0;
var serializer = new DataContractJsonSerializer(returnType);
return(serializer.ReadObject(ms));
}
}
catch (Exception ex)
{
throw new SerializationException("JsonDataContractDeserializer: Error converting to type: " + ex.Message, ex);
}
}
public object DeserializeFromString(string json, Type returnType)
{
if (TextSerializer != null)
{
return(TextSerializer.DeserializeFromString(json, returnType));
}
#if !(SL5 || __IOS__ || XBOX || ANDROID || PCL || NETSTANDARD1_1 || NETSTANDARD2_0)
if (!UseBcl)
{
return(JsonSerializer.DeserializeFromString(json, returnType));
}
try
{
using (var ms = MemoryStreamFactory.GetStream())
{
var bytes = Encoding.UTF8.GetBytes(json);
ms.Write(bytes, 0, bytes.Length);
ms.Position = 0;
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(returnType);
return(serializer.ReadObject(ms));
}
}
catch (Exception ex)
{
throw new SerializationException("JsonDataContractDeserializer: Error converting to type: " + ex.Message, ex);
}
#else
return(JsonSerializer.DeserializeFromString(json, returnType));
#endif
}
public TvDbApi(RestService http, TextSerializer serializer, string apiKey)
{
_http = http;
_serializer = serializer;
_apiKey = apiKey;
_http.SetBaseUrl("https://api.thetvdb.com");
}
public string SerializeToString <T>(T obj)
{
if (TextSerializer != null)
{
return(TextSerializer.SerializeToString(obj));
}
if (!UseBcl)
{
return(JsonSerializer.SerializeToString(obj));
}
if (obj == null)
{
return(null);
}
var type = obj.GetType();
try
{
using (var ms = MemoryStreamFactory.GetStream())
{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(type);
serializer.WriteObject(ms, obj);
return(ms.ReadToEnd());
}
}
catch (Exception ex)
{
throw new SerializationException("JsonDataContractSerializer: Error converting type: " + ex.Message, ex);
}
}
public T With_TextSerializer <T>(T dto)
{
var dtoString = TextSerializer.SerializeToString(dto);
LogDto(dtoString);
return(TextSerializer.DeserializeFromString <T>(dtoString));
}
/// <summary>Deserialize from string.</summary>
///
/// <exception cref="SerializationException">Thrown when a Serialization error condition occurs.</exception>
///
/// <param name="json"> The JSON.</param>
/// <param name="returnType">Type of the return.</param>
///
/// <returns>An object.</returns>
public object DeserializeFromString(string json, Type returnType)
{
if (TextSerializer != null)
{
return(TextSerializer.DeserializeFromString(json, returnType));
}
#if !SILVERLIGHT && !MONOTOUCH && !XBOX && !ANDROIDINDIE
if (!UseBcl)
{
return(JsonSerializer.DeserializeFromString(json, returnType));
}
try
{
using (var ms = new MemoryStream())
{
var bytes = Encoding.UTF8.GetBytes(json);
ms.Write(bytes, 0, bytes.Length);
ms.Position = 0;
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(returnType);
return(serializer.ReadObject(ms));
}
}
catch (Exception ex)
{
throw new SerializationException("JsonDataContractDeserializer: Error converting to type: " + ex.Message, ex);
}
#else
return(JsonSerializer.DeserializeFromString(json, returnType));
#endif
}
protected override void OnExecute()
{
var authentication = this.CommandContext.GetAuthentication(this);
var accessible = this.GetObject(authentication, this.Path);
if (this.MemberIDToAdd != string.Empty)
{
this.Invoke(authentication, accessible, () => accessible.AddAccessMember(authentication, this.MemberIDToAdd, this.AccessType));
}
else if (this.MemberIDToSet != string.Empty)
{
this.Invoke(authentication, accessible, () => accessible.SetAccessMember(authentication, this.MemberIDToSet, this.AccessType));
}
else if (this.MemberIDToRemove != string.Empty)
{
this.Invoke(authentication, accessible, () => accessible.RemoveAccessMember(authentication, this.MemberIDToRemove));
}
else if (this.Information == true)
{
var accessInfo = this.Invoke(authentication, accessible, () => accessible.AccessInfo);
var prop = accessInfo.ToDictionary();
var text = TextSerializer.Serialize(prop, this.FormatType);
this.Out.WriteLine(text);
}
else
{
this.Invoke(authentication, accessible, () => accessible.SetPrivate(authentication));
}
}
static void Main(string[] args)
{
string str = "Wally M065201011161";
Console.WriteLine("Text='" + str + "'");
Console.WriteLine("-----");
var serializer = new TextSerializer <Dog>();
Console.WriteLine("Deserialized:");
var deserialized = serializer.Deserialize(str);
foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(deserialized))
{
string name = descriptor.Name;
object value = descriptor.GetValue(deserialized);
Console.WriteLine("{0}={1}", name, value);
}
Console.WriteLine("-----");
Console.WriteLine("Serialized:");
var serialized = serializer.Serialize(deserialized);
Console.WriteLine(serialized);
}
public static XmlSerializer Load(string file, string rootName = "root", TextSerializer textSerializer = null)
{
XmlSerializer xmlSerializer = new XmlSerializer();
xmlSerializer.SetTextSerializer(textSerializer);
xmlSerializer._Load(file, rootName);
return(xmlSerializer);
}
public static void SaveLastCutoff(string tableName, string configurationName, DateTime cutoff)
{
// Write the new cutoff as long as it's not still the default one
if (cutoff.Year > (DateTime.UtcNow.Year - 19))
{
TextSerializer.Write(cutoff, String.Format(CutoffLocationFormatString, tableName, configurationName));
}
}
/// <summary>
/// Parse text block.
/// </summary>
public virtual void Serialize(TextSerializer parser, Managed managed)
{
parser.WriteAttribute(ClassName);
parser.OpenBlock();
this.SerializeContent(parser,managed);
parser.CloseBlock();
}
////////////////////////////////////////
// StringToString
public static string StringToString(string text, bool formatted) => JsonException.Wrap(() =>
{
using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
{
TextSerializer.Serialize(new TokenItemizer(new StringTokenizer(text)), Constants.GetIndent(formatted), writer);
return(writer.ToString());
}
});
public void DeserializeOrder(string cityOrigin, string cityDestination)
{
var line = $"{cityOrigin} {cityDestination}";
var textSerializer = new TextSerializer();
var order = textSerializer.DeserializeObject <OrderViewModel>(line);
AssertOrder(cityOrigin, cityDestination, order);
}
public static ITextSerializer <BridgeMessage> DefaultSerializerFactory()
=> TextSerializer.NewAsymmetric(
new TypeDecoratingSerializer(
SystemJsonSerializer.Default,
t => typeof(ReplicatorRequest).IsAssignableFrom(t)),
new TypeDecoratingSerializer(
SystemJsonSerializer.Default,
t => typeof(PublisherReply).IsAssignableFrom(t)
)).ToTyped <BridgeMessage>();
public void Info(string tableName)
{
var table = this.GetTable(tableName);
var tableInfo = table.Dispatcher.Invoke(() => table.TableInfo);
var props = tableInfo.ToDictionary(true);
var text = TextSerializer.Serialize(props);
this.Out.WriteLine(text);
}
public void Float_Success()
{
string str = "12.3 ";
var serializer = new TextSerializer <SimpleFloat>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual(12.3, deserialized.Value, 0.001);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
public void Char_Success()
{
string str = "a";
var serializer = new TextSerializer <SimpleChar>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual('a', deserialized.Value);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
public void Ushort_Success()
{
string str = "1234 ";
var serializer = new TextSerializer <SimpleUshort>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual((ushort)1234, deserialized.Value);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
public void String_Success()
{
string str = "asdf ";
var serializer = new TextSerializer <SimpleString>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual("asdf", deserialized.Value);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
public void Length_Success()
{
string str = "10charlong";
var serializer = new TextSerializer <StringClass>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual(str, deserialized.Value);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
public void Bool_Success()
{
string str = "1";
var serializer = new TextSerializer <SimpleBool>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual(true, deserialized.Value);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
public void TextAlignmentRight_Success()
{
string original = " abc";
var serializer = new TextSerializer <StringClassRight>();
var deserialized = serializer.Deserialize(original);
Assert.AreEqual("abc", deserialized.Value);
Assert.AreEqual(original, serializer.Serialize(deserialized));
}
protected override void OnExecute()
{
var authentication = this.CommandContext.GetAuthentication(this);
var drive = this.CommandContext.Drive;
var provider = this.GetObject(authentication, this.AbsolutePath);
var info = this.Invoke(provider, () => provider.Info);
var text = TextSerializer.Serialize(info, this.FormatType);
this.Out.WriteLine(text);
}
public void DateTimeTest()
{
string original = "20141017 18:30:00";
var serializer = new TextSerializer <SimpleDateTime>();
var deserialized = serializer.Deserialize(original);
Assert.AreEqual(new DateTime(2014, 10, 17, 18, 30, 0), deserialized.Value);
Assert.AreEqual(original, serializer.Serialize(deserialized));
}
public void Long_Success()
{
string str = "1234 ";
var serializer = new TextSerializer <SimpleLong>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual((long)1234, deserialized.Value);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
public void Double_Success()
{
string str = "12.3 ";
var serializer = new TextSerializer <SimpleDouble>();
var deserialized = serializer.Deserialize(str);
Assert.AreEqual(12.3, deserialized.Value);
Assert.AreEqual(str, serializer.Serialize(deserialized));
}
private void SetTextSerializer(TextSerializer textSerializer)
{
if (textSerializer != null)
{
_textSerializer = textSerializer;
}
else
{
_textSerializer = TextSerializer.CurrentTextSerializer;
}
}
public void InstantiateNonZeroBased_Success()
{
var serializer = new TextSerializer <NonZeroBased>();
Assert.IsFalse(serializer.ZeroBased);
string str = "a";
var deserialized = serializer.Deserialize(str);
Assert.AreEqual('a', deserialized.Value);
}
public void TextSerializerConstructorTest()
{
TextSerializer target = new TextSerializer();
Assert.IsNotNull(target);
}
/// <summary>
/// Parse text block.
/// </summary>
public override void SerializeContent(TextSerializer parser, Managed managed)
{
base.SerializeContent(parser, managed);
var variables = (Model)managed;
int i = 1;
foreach (var mesh in variables.Meshes)
{
parser.WriteAttribute("CMesh");
parser.OpenBlock();
parser.WriteAttribute("name");
parser.WriteStringValue(mesh.Name,"mesh"+i);
parser.WriteAttribute("scale");
parser.WriteFloatValue(1);
if (mesh.IsVertexStreamAvailable)
{
parser.WriteAttribute("CVerts");
parser.OpenBlock();
parser.WriteAttribute("numVerts");
parser.WriteIntValue(mesh.Vertices.Count);
foreach (var vector3 in mesh.Vertices)
{
parser.WriteAttribute("v");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Z);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsNormalStreamAvailable)
{
parser.WriteAttribute("CVertNorms");
parser.OpenBlock();
parser.WriteAttribute("numVertNorms");
parser.WriteIntValue(mesh.Normals.Count);
foreach (var vector3 in mesh.Normals)
{
parser.WriteAttribute("vn");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Z);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsColorStreamAvailable)
{
parser.WriteAttribute("CVertCols");
parser.OpenBlock();
parser.WriteAttribute("numVertCols");
parser.WriteIntValue(mesh.Colors.Count);
foreach (var vector3 in mesh.Colors)
{
parser.WriteAttribute("col");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.R / 255.0f);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.G / 255.0f);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.B / 255.0f);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.A/255.0f);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsUV0StreamAvailable)
{
parser.WriteAttribute("CUVs");
parser.OpenBlock();
parser.WriteAttribute("setID");
parser.WriteIntValue(0);
parser.WriteAttribute("numUVs");
parser.WriteIntValue(mesh.UV0.Count);
foreach (var vector3 in mesh.UV0)
{
parser.WriteAttribute("uv");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
if (mesh.IsUV1StreamAvailable)
{
parser.WriteAttribute("CUVs");
parser.OpenBlock();
parser.WriteAttribute("setID");
parser.WriteIntValue(1);
parser.WriteAttribute("numUVs");
parser.WriteIntValue(mesh.UV1.Count);
foreach (var vector3 in mesh.UV1)
{
parser.WriteAttribute("uv");
parser.WriteRaw(" {");
parser.WriteFloatValue(vector3.X);
parser.WriteRaw(",");
parser.WriteFloatValue(vector3.Y);
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
foreach (var surface in mesh.Surfaces)
{
parser.WriteAttribute("CSurface");
parser.OpenBlock();
parser.WriteAttribute("material");
parser.WriteStringValue(surface.Material.NameReference,"noskin");
switch (surface.VertexSourceType)
{
case VertexSourceType.TriangleList:
WriteTriList(parser, surface, mesh);
break;
//case VertexSourceType.TrianleStrip:
// break;
//case VertexSourceType.QuadList:
// break;
//case VertexSourceType.QuadStrip:
// break;
//case VertexSourceType.LineLine:
// break;
//case VertexSourceType.LineStrip:
// break;
default:
throw new ArgumentOutOfRangeException();
}
WriteTriList(parser, surface, mesh);
parser.CloseBlock();
}
parser.CloseBlock();
++i;
}
}
private static void WriteTriList(TextSerializer parser, Surface surface, Mesh mesh)
{
parser.WriteAttribute("CTris");
parser.OpenBlock();
parser.WriteAttribute("numTris");
parser.WriteIntValue(surface.Count / 3);
int tri = 0;
var posIndex = surface.GetIndexReader(Streams.Position, 0);
var posEnumerator = (posIndex != null)?posIndex.GetEnumerator():null;
var normalIndex = surface.GetIndexReader(Streams.Normal, 0);
var normalEnumerator = (normalIndex != null) ? normalIndex.GetEnumerator() : null;
var uv0Index = surface.GetIndexReader(Streams.TexCoord, 0);
var uv0Enumerator = (uv0Index != null) ? uv0Index.GetEnumerator() : null;
var uv1Index = surface.GetIndexReader(Streams.TexCoord, 1);
var uv1Enumerator = (uv1Index != null) ? uv1Index.GetEnumerator() : null;
var colorIndex = surface.GetIndexReader(Streams.Color, 0);
var colorEnumerator = (colorIndex != null) ? colorIndex.GetEnumerator() : null;
for (int index = 0; index < surface.Count; ++index)
{
if (tri % 3 == 0)
{
parser.WriteAttribute("t");
}
++tri;
parser.WriteRaw(" {");
if (posEnumerator != null)
{
posEnumerator.MoveNext();
parser.WriteIntValue(posEnumerator.Current);
}
else
{
parser.WriteIntValue(-1);
}
parser.WriteRaw(",");
if (normalEnumerator != null)
{
normalEnumerator.MoveNext();
parser.WriteIntValue(normalEnumerator.Current);
}
else
{
parser.WriteIntValue(-1);
}
parser.WriteRaw(",");
if (uv0Enumerator != null)
{
uv0Enumerator.MoveNext();
parser.WriteIntValue(uv0Enumerator.Current);
}
else
{
parser.WriteIntValue(-1);
}
parser.WriteRaw(",");
if (uv1Enumerator != null)
{
uv1Enumerator.MoveNext();
parser.WriteIntValue(uv1Enumerator.Current);
}
else
{
parser.WriteIntValue(-1);
}
parser.WriteRaw(",");
if (colorEnumerator != null)
{
colorEnumerator.MoveNext();
parser.WriteIntValue(colorEnumerator.Current);
}
else
{
parser.WriteIntValue(-1);
}
parser.WriteRaw(" }");
}
parser.CloseBlock();
}
public void SerializerTest()
{
TextSerializer target = new TextSerializer(); // TODO: Initialize to an appropriate value
IComponent component = new AppSettingsBean(); // TODO: Initialize to an appropriate value
Encoding encode = null; // TODO: Initialize to an appropriate value
string actual;
actual = target.Serializer(component, encode);
Assert.IsNotNull( actual);
Assert.IsTrue(actual.Length > 0);
}
/// <summary>
/// 得到序列化器
/// </summary>
/// <param name="request">HttpRequest</param>
/// <returns>序列化器</returns>
private ISerializer GetSerializer(HttpRequest request)
{
string serType = (request.QueryString[AppConst.QueryFormat] ?? string.Empty).ToLowerInvariant();
ISerializer serializer;
if (!formatStr.Contains(serType) && string.IsNullOrEmpty(request.UserAgent)) serType = "json";
switch (serType)
{
case "xml":
serializer = new XMLSerializer();
break;
case "json":
serializer = new JSONSerializer();
break;
case "text":
serializer = new TextSerializer();
break;
default:
serializer = new HTMLSerializer();
break;
}
return serializer;
}
private Action<Stream> GetTextContents(object model)
{
ISerializer textSerializer = new TextSerializer();
return stream => textSerializer.Serialize("text/html", model, stream);
}
/// <summary>
/// Parse text block.
/// </summary>
public virtual void SerializeContent(TextSerializer parser, Managed managed)
{
parser.WriteAttribute("name");
parser.WriteStringValue(managed.Name);
}
