// wellknown serialized objects static Context Wellknown() { var result = new Context(); // 0 is null ulong index = 1; result.Register(index++, RuntimeType.GetType(typeof(object)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(string)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(Type)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(Nullable <>)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(IList)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(IDictionary)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(ICollection <>)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(IDictionary <,>)).TypeData()); // other well known values, to speed up read-write and reduce stream size result.Register(index++, ""); result.Register(index++, RuntimeType.GetType(typeof(byte[])).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(Guid)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(bool)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(char)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(byte)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(sbyte)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(short)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(ushort)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(int)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(uint)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(long)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(ulong)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(float)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(double)).TypeData()); result.Register(index++, RuntimeType.GetType(typeof(decimal)).TypeData()); return(result); }
public object Read(Type type, object suggested = null) { if (suggested != null && !type.IsInstanceOfType(suggested)) suggested = null; readRaw = false; var args = new ReadArgs(RObject.TypeData(), RuntimeType.GetType(type), suggested); return Read(args); }
protected object AsMetaData(object obj) { if (obj is Type) { return(RuntimeType.GetType((Type)obj).TypeData()); } if (obj is RuntimeType) { return(((RuntimeType)obj).TypeData()); } return(obj); }
/// <summary> /// Generates the C# class that can be used to deserialize all given types. /// </summary> /// <param name="namespace">The namespace of the generated class.</param> /// <param name="types">The types that will be rewritten with only the serialization information.</param> /// <returns>A generated C# code file as string.</returns> public string GenerateCSharpCode(string @namespace, params Type[] types) { foreach (var t in types) { var rt = RuntimeType.GetType(t); RecursiveAdd(rt); } var sb = new StringBuilder(256); GenerateCSharpCode(new StringWriter(sb), @namespace); return(sb.ToString()); }
internal SurrogateInfo(Type target, Type surrogate) { Target = RuntimeType.GetType(target); SurrogateType = RuntimeType.GetType(surrogate); var tInterface = typeof(ISurrogate <>).MakeGenericType(target); Initialize = tInterface.TryGetMethods(nameof(ISurrogate <int> .Convert), null, target).First(); Instantiate = tInterface.GetRuntimeMethod(nameof(ISurrogate <int> .Revert), Array.Empty <Type>()); Populate = tInterface.TryGetMethods(nameof(ISurrogate <int> .Populate), null, target).First(); CanPopulate = tInterface.GetProperty(nameof(ISurrogate <int> .CanPopulate)); }
void WriteCollection <T>(ICollection <T> value) { output.Write(value.IsReadOnly); if (value.IsReadOnly) { return; } var count = value.Count; output.WriteVInt(count); var surt = RuntimeType.GetType(typeof(T)); foreach (var item in value) { count--; Write(surt, item); } if (count != 0) { throw new ArgumentException($"({value}.Count reported an incorrect value ({value.Count})"); } }
void WriteDictionary <K, V>(IDictionary <K, V> value) { output.Write(value.IsReadOnly); if (value.IsReadOnly) { return; } var count = value.Count; output.WriteVInt(count); var surk = RuntimeType.GetType(typeof(K)); var surv = RuntimeType.GetType(typeof(V)); foreach (var kv in value) { count--; Write(surk, kv.Key); Write(surv, kv.Value); } if (count != 0) { throw new ArgumentException($"({value}.Count reported an incorrect value ({value.Count})"); } }
public T Read<T>(T suggested = default(T)) { readRaw = false; var args = new ReadArgs(RObject.TypeData(), RuntimeType.GetType(typeof(T)), suggested); return (T)Read(args); }
internal void Write(RuntimeType expected, object value) { value = AsMetaData(value); // write id, continue if first time if (expected.IsReference) { if (TryGetId(value, out var id)) { output.WriteVInt(id); return; } id = NewId(); Register(id, value); output.WriteVInt(id); } // write class info if needed var actual = expected; if (expected.IsReference && !expected.IsSealed) { actual = RuntimeType.GetType(value); Write(RType, actual); } // only proceed further if value is supported if (!expected.IsSupported || !actual.IsSupported) { return; } // dispatch to the appropriate write method if (actual.Surrogate != null) { Write(RObject, actual.Surrogate.Convert(value)); } else if (actual.Converter != null && !settings.IgnoreTypeConverter) { WriteConverter(actual, value); } else if (actual.IsISerializable && !Settings.IgnoreISerializable) { WriteISerializable(value); } else { switch (actual.Kind) { default: case PrimitiveType.None: throw new InvalidOperationException("shouldn't be there"); case PrimitiveType.Object: if (actual.IsArray) { WriteArray(actual, value); } else if (actual.IsNullable) { if (value == null) { output.Write(false); } else { output.Write(true); Write(actual.GenericParameters[0], value); } } else if (actual.IsEnum) { Write(actual.Element, value); } else { WriteObject(actual, value); } break; case PrimitiveType.Type: ((TypeData)value).Write(this, output); break; case PrimitiveType.String: output.Write((string)value); break; case PrimitiveType.Bytes: output.Write((byte[])value); break; case PrimitiveType.Guid: output.Write((Guid)value); break; case PrimitiveType.Bool: output.Write((bool)value); break; case PrimitiveType.Char: output.Write((char)value); break; case PrimitiveType.Byte: output.Write((byte)value); break; case PrimitiveType.SByte: output.Write((sbyte)value); break; case PrimitiveType.Int16: output.Write((short)value); break; case PrimitiveType.UInt16: output.Write((ushort)value); break; case PrimitiveType.Int32: output.Write((int)value); break; case PrimitiveType.UInt32: output.Write((uint)value); break; case PrimitiveType.Int64: output.Write((long)value); break; case PrimitiveType.UInt64: output.Write((ulong)value); break; case PrimitiveType.Single: output.Write((float)value); break; case PrimitiveType.Double: output.Write((double)value); break; case PrimitiveType.Decimal: output.Write((decimal)value); break; } } }