public static dynamic DynDeserialize(this string objectString, SerializerMode mode = SerializerMode.Default) { if (mode == SerializerMode.Default) { mode = DefaultMode; } //todo onError? switch (mode) { case SerializerMode.Default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); case SerializerMode.Xml: var doc = XDocument.Parse(objectString); //or XDocument.Load(path) var jsonText = JsonConvert.SerializeXNode(doc); dynamic dyn = JObject.Parse(jsonText); //or JsonConvert.DeserializeObject<ExpandoObject>(jsonText); return(dyn); case SerializerMode.Json: return(JObject.Parse(objectString)); default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); } }
public SerializationContext(ContextMode contextMode, [NotNull] IStreamSource streamSource, SerializerMode serializerMode) { ContextMode = contextMode; StreamSource = streamSource; SerializerMode = serializerMode; _backgroundStream = new BackgroundStream(); }
/// <summary> /// Supports serializing a dynamic object /// </summary> /// <param name="o"></param> /// <param name="mode"></param> /// <param name="xmlroot">If an object has more than 1 top-level field this must be specified</param> /// <returns></returns> public static string DynSerialize(object o, SerializerMode mode, string xmlroot = null) { if (mode == SerializerMode.Default) { mode = DefaultMode; } //todo а как удалить из динамика проперть? //for json var json = JsonConvert.SerializeObject(o); if (mode == SerializerMode.Json) { return(json); } var xmldoc = JsonConvert.DeserializeXmlNode(json, xmlroot); //beautifying (could simply do return xmldoc.OuterXml;) var sb = new StringBuilder(); var xmlWriterSettings = new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true }; using (var writer = XmlWriter.Create(sb, xmlWriterSettings)) { xmldoc.Save(writer); } return(sb.ToString()); }
public ShaderGraphSerializer(Stream stream, SerializerMode mode) : base(stream, mode) { parsedVariables = new Dictionary <string, Variable>(); parsedNodes = new Dictionary <string, NodeBase>(); parsedMethods = new Dictionary <string, MethodBase>(); AllowIdentity = true; }
private static BinarySerializer GetSerializer(Stream stream, SerializerMode mode) { var serializer = new BinarySerializer(stream, mode, Text.Encoding.ASCII); serializer.ArrayLengthType = ArrayLengthType.Int; serializer.RegisterDynamicList <MaterialTexture>("MATL"); return(serializer); }
private SerializationContext(ContextMode contextMode, [NotNull] IStreamSource streamSource, SerializerMode serializerMode, [NotNull] BackgroundStream parentStream) { ContextMode = contextMode; StreamSource = streamSource; SerializerMode = serializerMode; _backgroundStream = parentStream; }
public override void Init(SerializerMode mode) { _mode = mode; if (_cache != null) { _cache = new SerializerCache <DateTime>(mode); } }
public override void Init(SerializerMode mode) { _mode = mode; if (_refCache != null) { _refCache = new SerializerCache <byte[]>(mode); } }
public override void Init(SerializerMode mode) { _mode = mode; Cache?.Clear(mode); Cache16?.Clear(mode); Cache32?.Clear(mode); _useCache = (mode != SerializerMode.NoCached); }
private static BinarySerializer GetSerializer(Stream stream, SerializerMode mode) { var serializer = new BinarySerializer(stream, mode, Encoding.BigEndianUnicode) { ArrayLengthType = ArrayLengthType.Int }; return(serializer); }
public void Progress(object graph, TContext context, SerializerMode mode) { foreach (var mappingEntry in _mapper.Entries) { mappingEntry.Progress(graph, context, mode); } CleanUp(context); }
private Stream OpenStream(object target, SerializerMode mode) { if (_current != null) { throw new InvalidOperationException(); } _current = _open(target, mode); return(_current); }
private DeserializersTable(SerializerMode mode) { Mode = mode; DateTimeOffsetSerializer.Init(mode); DateTimeSerializer.Init(mode); GuidSerializer.Init(mode); NumberSerializer.Init(mode); TimeSpanSerializer.Init(mode); ByteArraySerializer.Init(mode); StringSerializer.Init(mode); }
/// <summary> /// Default constructor /// </summary> /// <param name="rawData">serialized packet</param> /// <param name="offset">rawData offset</param> /// <param name="count">rawData byte size</param> /// <param name="serializerMode">serializer mode</param> public PacketSerializer(byte[] rawData, int offset, int count, SerializerMode serializerMode = SerializerMode.SILVERLIGHT_SERIALIZER) { m_formatter.AssemblyFormat = FormatterAssemblyStyle.Simple; Mode = serializerMode; switch (Mode) { case SerializerMode.ALLOW_ALL_ASSEMBLY_VERSION_DESERIALIZATION: m_formatter.Binder = new AllowAllAssemblyVersionDeserializationBinder(); break; case SerializerMode.DEFAULT: case SerializerMode.SILVERLIGHT_SERIALIZER: break; } m_stream = new MemoryStream(rawData, offset, count); }
/// <summary> /// Default copy constructor /// </summary> /// <param name="orig">the object to copy from</param> public PacketSerializer(PacketSerializer <PacketStruct> orig) { m_formatter.AssemblyFormat = FormatterAssemblyStyle.Simple; Mode = orig.Mode; switch (Mode) { case SerializerMode.ALLOW_ALL_ASSEMBLY_VERSION_DESERIALIZATION: m_formatter.Binder = new AllowAllAssemblyVersionDeserializationBinder(); break; case SerializerMode.DEFAULT: case SerializerMode.SILVERLIGHT_SERIALIZER: break; } m_stream = orig.m_stream; }
private void ProgressString(SerializerMode mode, ref string str, ref object?obj) { switch (mode) { case SerializerMode.Deserialize: obj = _converter?.ConvertBack(str); break; case SerializerMode.Serialize: str = _converter?.Convert(obj) ?? string.Empty; break; default: throw new ArgumentOutOfRangeException(nameof(mode)); } }
public override void Progress(object target, TContext context, SerializerMode mode) { switch (mode) { case SerializerMode.Deserialize: Deserialize(target, context); break; case SerializerMode.Serialize: Serialize(target, context); break; default: throw new ArgumentOutOfRangeException(nameof(mode)); } }
/// <summary> /// Default constructor /// </summary> /// <param name="packet">packet class object</param> /// <param name="serializerMode">serializer mode</param> public PacketSerializer(PacketStruct packet = null, SerializerMode serializerMode = SerializerMode.SILVERLIGHT_SERIALIZER) { m_formatter.AssemblyFormat = FormatterAssemblyStyle.Simple; m_stream = new MemoryStream(); Mode = serializerMode; switch (Mode) { case SerializerMode.DEFAULT: case SerializerMode.ALLOW_ALL_ASSEMBLY_VERSION_DESERIALIZATION: m_formatter.Serialize(m_stream, packet); break; case SerializerMode.SILVERLIGHT_SERIALIZER: SilverlightSerializer.Serialize(packet, m_stream); break; } }
public static DeserializersTable GetTable(SerializerMode mode) { switch (mode) { case SerializerMode.CachedUShort: return(CachedUShortTablePool.New()); case SerializerMode.Cached2048: return(Cached2048TablePool.New()); case SerializerMode.Cached1024: return(Cached1024TablePool.New()); case SerializerMode.Cached512: return(Cached512TablePool.New()); default: return(NoCachedTablePool.New()); } }
public static string Serialize(this object @this, SerializerMode mode = SerializerMode.Default) { if (mode == SerializerMode.Default) { mode = DefaultMode; } switch (mode) { case SerializerMode.Default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); case SerializerMode.Xml: return(XmlSerialize(@this)); case SerializerMode.Json: return(JsonSerialize(@this)); default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); } }
public static T Deserialize <T>(this string objectString, SerializerMode mode = SerializerMode.Default, Action <string> onError = null) { if (mode == SerializerMode.Default) { mode = DefaultMode; } switch (mode) { case SerializerMode.Default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); case SerializerMode.Xml: return(XmlDeserialize <T>(objectString, onError)); case SerializerMode.Json: return(JsonDeserialize <T>(objectString, onError)); default: throw new ArgumentOutOfRangeException(nameof(mode), mode, null); } }
public override void Init(SerializerMode mode) { _mode = mode; if (_decimalCache != null) { _decimalCache = new SerializerCache <decimal>(mode); } if (_doubleCache != null) { _doubleCache = new SerializerCache <double>(mode); } if (_floatCache != null) { _floatCache = new SerializerCache <float>(mode); } if (_longCache != null) { _longCache = new SerializerCache <long>(mode); } if (_uLongCache != null) { _uLongCache = new SerializerCache <ulong>(mode); } if (_intCache != null) { _intCache = new SerializerCache <int>(mode); } if (_uIntCache != null) { _uIntCache = new SerializerCache <uint>(mode); } if (_shortCache != null) { _shortCache = new SerializerCache <short>(mode); } if (_uShortCache != null) { _uShortCache = new SerializerCache <ushort>(mode); } }
private void ProgressElement(SerializerMode mode, XObject?xobj, ref object?obj) { if (xobj == null) { return; } var attr = xobj as XAttribute; var str = attr != null ? attr.Value : ((XElement)xobj).Value; switch (mode) { case SerializerMode.Deserialize: ProgressString(mode, ref str, ref obj); break; case SerializerMode.Serialize: ProgressString(mode, ref str, ref obj); break; default: throw new ArgumentOutOfRangeException(nameof(mode)); } if (mode != SerializerMode.Serialize) { return; } if (attr != null) { attr.Value = str; } else { ((XElement)xobj).Value = str; } }
static int WithSerializer(SerializerMode mode, MemoryStream stream, Action <ISerializer> func, ISerializer parentSerializer, ref int fakeOffset) { switch (mode) { case SerializerMode.Writing: { using var bw = new BinaryWriter(stream, Encoding.GetEncoding(850), true); var s = new AlbionWriter(bw); func(s); return((int)s.Offset); } case SerializerMode.WritingAnnotated: { using var tw = new StreamWriter(stream, Encoding.GetEncoding(850), 1024, true); using var s = new AnnotatedFormatWriter(tw, (AnnotatedFormatWriter)parentSerializer); s.Seek(fakeOffset); func(s); int length = (int)s.Offset - fakeOffset; fakeOffset = (int)s.Offset; return(length); } case SerializerMode.WritingJson: { using var tw = new StreamWriter(stream, Encoding.GetEncoding(850), 1024, true); using var s = new JsonWriter(tw, (JsonWriter)parentSerializer); s.Seek(fakeOffset); func(s); int length = (int)s.Offset - fakeOffset; fakeOffset = (int)s.Offset; return(length); } default: throw new InvalidOperationException(); } }
public void Clear(SerializerMode mode) { switch (mode) { case SerializerMode.Cached512: _maxIndex = 511; break; case SerializerMode.Cached1024: _maxIndex = 1023; break; case SerializerMode.Cached2048: _maxIndex = 2047; break; case SerializerMode.CachedUShort: _maxIndex = 65534; break; } _currentIndex = 0; _serializationCache.Clear(); _deserializationCache.Clear(); }
public SerializerCache(SerializerMode mode, IEqualityComparer <T> sercomparer = null, IEqualityComparer <int> descomparer = null) { _serializationCache = new Dictionary <T, int>(sercomparer); _deserializationCache = new Dictionary <int, T>(descomparer); switch (mode) { case SerializerMode.Cached512: _maxIndex = 511; break; case SerializerMode.Cached1024: _maxIndex = 1023; break; case SerializerMode.Cached2048: _maxIndex = 2047; break; case SerializerMode.CachedUShort: _maxIndex = 65534; break; } _currentIndex = 0; }
protected override SerializationContext GetRealContext(XmlElementContext origial, SerializerMode mode) { if (!(XmlElementSerializer.GetElement(origial.XElement, mode == SerializerMode.Serialize, _target) is XElement ele)) { _useSnapShot = false; return(origial.Original); } _useSnapShot = true; return(origial.Original.CreateSnapshot(ele.Value)); }
public void Initialize(object target, SerializerMode mode) { _target = Argument.NotNull(target, nameof(target)); _mode = mode; }
private void ProgressElement(SerializerMode mode, [CanBeNull] XObject xobj, [NotNull] ref object obj) { if (xobj == null) return; var attr = xobj as XAttribute; string str = attr != null ? attr.Value : ((XElement) xobj).Value; switch (mode) { case SerializerMode.Deserialize: ProgressString(mode, ref str, ref obj); break; case SerializerMode.Serialize: ProgressString(mode, ref str, ref obj); break; default: throw new ArgumentOutOfRangeException("mode"); } if (mode != SerializerMode.Serialize) return; if (attr != null) attr.Value = str; else ((XElement) xobj).Value = str; }
private static BinarySerializer GetSerializer(Stream stream, SerializerMode mode) { var serializer = new BinarySerializer(stream, mode, Text.Encoding.ASCII); return(serializer); }
private void ProgressString(SerializerMode mode, [NotNull] ref string str, [CanBeNull] ref object obj) { switch (mode) { case SerializerMode.Deserialize: obj = _converter.ConvertBack(str); break; case SerializerMode.Serialize: str = _converter.Convert(obj); break; default: throw new ArgumentOutOfRangeException("mode"); } }
private static BinarySerializer GetSerializer(Stream stream, SerializerMode mode) { var serializer = new BinarySerializer(stream, mode, Text.Encoding.ASCII); return serializer; }
public abstract void Init(SerializerMode mode);
public override void Init(SerializerMode mode) { }
private void Progress(object graph, IStreamSource target, SerializerMode mode) { var context = BuildContext(new SerializationContext(_contextMode, target, mode)); Progress(graph, context, mode); }
private static BinarySerializer GetSerializer(Stream stream, SerializerMode mode) { var serializer = new BinarySerializer(stream, mode, Text.Encoding.ASCII); serializer.RegisterDynamic<Vector4>(); serializer.RegisterDynamic<Vector3>(); serializer.RegisterDynamic<Vector2>(); return serializer; }
private static BinarySerializer GetSerializer(Stream stream, SerializerMode mode) { var serializer = new BinarySerializer(stream, mode, Text.Encoding.ASCII); serializer.ArrayLengthType = ArrayLengthType.Int; serializer.RegisterDynamicList<MaterialTexture>("MATL"); return serializer; }