public override void Deserialize(IPrimitiveReader reader) { IsEmpty = reader.ReadBoolean(); Code = reader.ReadString(); TitaAppId = reader.ReadInt32(); TenantId = reader.ReadInt32(); UserId = reader.ReadInt32(); State = (QrCodeLoginState)reader.ReadInt16(); }
/// <summary> /// Reads a <see cref="TypeInfo"/> object from the specified reader. /// </summary> /// <param name="reader">The reader to read from.</param> /// <returns> /// <para>The <see cref="TypeInfo"/> read from <paramref name="reader"/>.</para> /// </returns> /// <exception cref="InvalidDataException"> /// <para>Unexpected data is encountered in the stream.</para> /// </exception> public static TypeInfo ReadFrom(IPrimitiveReader reader) { var mode = (Mode)reader.ReadByte(); switch (mode) { case Mode.Id: return(Get(reader.ReadInt16())); case Mode.Name: return(_typeInfoByTypeName(reader.ReadString())); } throw new InvalidDataException(string.Format("Unexpected mode encountered {0}", (byte)mode)); }
public void Deserialize(IPrimitiveReader reader, int version) { if (version >= 1) { MessageType = (MessageType)reader.ReadInt32(); PayloadLength = reader.ReadInt32(); int bytesLength = reader.ReadInt32(); if (bytesLength > -1) { byte[] bytes = reader.ReadBytes(bytesLength); MessageStream = new MemoryStream(bytes); } } if (version >= 2) { TypeId = reader.ReadInt16(); } }
/// <summary> /// Deserializes a <see cref="RelayPayload"/> from an <see cref="IPrimitiveReader"/>. /// </summary> /// <param name="reader">The reader.</param> /// <param name="version">The version of the <paramref name="reader"/> data.</param> public void Deserialize(IPrimitiveReader reader, int version) { this.TypeId = reader.ReadInt16(); this.Id = reader.ReadInt32(); this.LastUpdatedTicks = reader.ReadInt64(); this.Compressed = reader.ReadBoolean(); this.ttl = reader.ReadInt32(); this.expirationTicks = reader.ReadInt64(); int byteLength = reader.ReadInt32(); if (byteLength > 0) { this.ByteArray = reader.ReadBytes(byteLength); } if (version > 1) { int keyLength = reader.ReadInt32(); this.ExtendedId = reader.ReadBytes(keyLength); } }
/// <summary> /// Reads the serialized header /// </summary> /// <param name="reader"></param> public void Read(IPrimitiveReader reader) { this.headerPosition = reader.BaseStream.Position; this.headerVersion = reader.ReadByte(); this.headerLength = reader.ReadInt16(); this.flags = (TypeSerializationHeaderFlags)reader.ReadByte(); this.dataVersion = reader.ReadByte(); this.dataMinVersion = reader.ReadByte(); this.dataLength = reader.ReadInt32(); this.dataPosition = this.headerPosition + this.headerLength; if (this.headerVersion > CurrentHeaderVersion) { throw new ApplicationException("This object was serialized with a newer version of the serialization framework"); } if ((this.flags & ~TypeSerializationHeaderFlags.KnownFlags) != 0) { throw new ApplicationException("This object was serialized with features that are not supported in this version of the serialization framework"); } reader.BaseStream.Seek(this.dataPosition, System.IO.SeekOrigin.Begin); }
internal object ReadImpl(ReadArgs args) { // check id first ulong oid = 0; if (args.TypeData.IsReference) { oid = input.ReadVUInt(); if (TryGetObject(oid, out var result)) return result; } // if expected is not final if (args.TypeData.IsReference && !args.TypeData.IsSealed) args = new ReadArgs((TypeData)ReadImpl(AType), args.TypeHint, args.Instance); object ReturnRegister(object value) { if (oid != 0) Register(oid, value); return value; } // only proceed further if type is supported if (!args.TypeData.IsSupported) return ReturnRegister(new ObjectData(args.TypeData)); // dispatch to appropriate read method if (args.TypeData.Surrogate != null) { return ReturnRegister(ReadSurrogate(args)); } else if (args.TypeData.HasConverter && !settings.IgnoreTypeConverter) { return ReturnRegister(ReadConverter(args)); } else if (args.TypeData.IsISerializable && !settings.IgnoreISerializable) { return ReturnRegister(ReadISerializable(args)); } else { switch (args.TypeData.Kind) { default: case PrimitiveType.None: throw new InvalidOperationException("shouldn't be there"); case PrimitiveType.Object: if (args.TypeData.IsArray) { return ReadArray(args, oid); } else if (args.TypeData.IsNullable) { object o = null; var isNotNull = input.ReadBool(); if (isNotNull) o = ReadImpl(new ReadArgs(args.TypeData.GenericParameters[0])); return ReturnRegister(o); } else if (args.TypeData.IsEnum) { var val = ReadImpl(new ReadArgs(args.TypeData.Element)); var eType = args.InstanceType(readRaw); if (eType != null) { val = Enum.ToObject(eType.Type, val); } else { // leave it as is? // or return an ObjectData? } return ReturnRegister(val); } else { return ReturnRegister(ReadObject(args, oid)); } case PrimitiveType.Type: { var result = new TypeData(); ReturnRegister(result); result.Read(this, input); return result; } case PrimitiveType.String: return ReturnRegister(input.ReadString()); case PrimitiveType.Bytes: return ReturnRegister(input.ReadBytes()); case PrimitiveType.Guid: return ReturnRegister(input.ReadGuid()); case PrimitiveType.Bool: return ReturnRegister(input.ReadBool()); case PrimitiveType.Char: return ReturnRegister(input.ReadChar()); case PrimitiveType.Byte: return ReturnRegister(input.ReadByte()); case PrimitiveType.SByte: return ReturnRegister(input.ReadSByte()); case PrimitiveType.Int16: return ReturnRegister(input.ReadInt16()); case PrimitiveType.UInt16: return ReturnRegister(input.ReadUInt16()); case PrimitiveType.Int32: return ReturnRegister(input.ReadInt32()); case PrimitiveType.UInt32: return ReturnRegister(input.ReadUInt32()); case PrimitiveType.Int64: return ReturnRegister(input.ReadInt64()); case PrimitiveType.UInt64: return ReturnRegister(input.ReadUInt64()); case PrimitiveType.Single: return ReturnRegister(input.ReadSingle()); case PrimitiveType.Double: return ReturnRegister(input.ReadDouble()); case PrimitiveType.Decimal: return ReturnRegister(input.ReadDecimal()); } } }
//*************************************************************** // // Deserialize // /// <summary> /// Determines if the stream contains a name table and loads it if it exists /// </summary> /// <param name="reader"></param> public void Deserialize(IPrimitiveReader reader, TypeSerializationHeader header) { long oldPosition = reader.BaseStream.Position; long endPosition = 0; short size = 0; short signature = 0; byte assemblyCount = 0; byte typeCount = 0; byte index = 0; string assemblyName = null; string[] assemblyNames = null; string typeName = null; string namespaceName = null; string[] namespaceNames = null; byte namespaceCount = 0; // Determine if the stream contains a name table if ((reader.BaseStream.Length - oldPosition) < HeaderLength) { return; } endPosition = reader.BaseStream.Seek(-HeaderLength, System.IO.SeekOrigin.End); size = reader.ReadInt16(); signature = reader.ReadInt16(); if (signature == Signature) { reader.BaseStream.Seek(endPosition - size, System.IO.SeekOrigin.Begin); // Load assembly names assemblyCount = reader.ReadByte(); assemblyNames = new string[assemblyCount]; for (index = 0; index < assemblyCount; index++) { assemblyNames[index] = reader.ReadString(); } // Load namespace names namespaceCount = reader.ReadByte(); namespaceNames = new string[namespaceCount]; for (index = 0; index < namespaceCount; index++) { namespaceNames[index] = reader.ReadString(); } // Load types typeCount = reader.ReadByte(); this.resolvedTypeTable = new TypeInfo[typeCount]; for (index = 0; index < typeCount; index++) { TypeInfo rti = new TypeInfo(); if ((header != null) && (header.HeaderVersion >= 1)) { rti.Version = reader.ReadByte(); } assemblyName = assemblyNames[reader.ReadByte()]; namespaceName = namespaceNames[reader.ReadByte()]; typeName = reader.ReadString(); rti.TypeName = string.Format("{1}.{0},{2}", typeName, namespaceName, assemblyName); this.resolvedTypeTable[index] = rti; } } // Reset stream position reader.BaseStream.Seek(oldPosition, System.IO.SeekOrigin.Begin); }
/// <summary> /// Am even faster way to et known value type, using strongly typed accessor on platform supporting it. /// </summary> /// <param name="reader">The source of the value</param> /// <param name="instance">The instance which member would be set</param> /// <returns>Whether the value could be set. If not the <paramref name="reader"/> won't be read.</returns> public bool TryFastReadSet(IPrimitiveReader reader, object instance) { #if __NET__ || __NETCORE__ if (hasFastSetter && instance != null) { switch (Type.Kind) { case PrimitiveType.Guid: setterGuid(instance, reader.ReadGuid()); break; case PrimitiveType.Bool: setterBool(instance, reader.ReadBool()); break; case PrimitiveType.Char: setterChar(instance, reader.ReadChar()); break; case PrimitiveType.Byte: setterByte(instance, reader.ReadByte()); break; case PrimitiveType.SByte: setterSByte(instance, reader.ReadSByte()); break; case PrimitiveType.Int16: setterInt16(instance, reader.ReadInt16()); break; case PrimitiveType.UInt16: setterUInt16(instance, reader.ReadUInt16()); break; case PrimitiveType.Int32: setterInt32(instance, reader.ReadInt32()); break; case PrimitiveType.UInt32: setterUInt32(instance, reader.ReadUInt32()); break; case PrimitiveType.Int64: setterInt64(instance, reader.ReadInt64()); break; case PrimitiveType.UInt64: setterUInt64(instance, reader.ReadUInt64()); break; case PrimitiveType.Single: setterSingle(instance, reader.ReadSingle()); break; case PrimitiveType.Double: setterDouble(instance, reader.ReadDouble()); break; case PrimitiveType.Decimal: setterDecimal(instance, reader.ReadDecimal()); break; } return(true); } #endif return(false); }