public string GetFullName(TypeMap typeMap) { if (!string.IsNullOrEmpty(_fullName)) { return(_fullName); } if (!IsGeneric) { _fullName = this.ToString(); } else { StringBuilder sb = new StringBuilder(); sb.Append(this.ToString()).Append("<"); bool isFirst = true; foreach (ushort s in GenericArguments) { if (!isFirst) { sb.Append(","); } else { isFirst = false; } BinaryTypeInfo ti = typeMap.GetTypeInfo(s); sb.Append(ti.GetFullName(typeMap)); } sb.Append(">"); _fullName = sb.ToString(); } return(_fullName); }
private Type CreateGenericType(TypeMap typeMap, Type type, BinaryTypeInfo typeInfo) { if (!typeInfo.IsGeneric || typeInfo.Type == TypeEnum.Array) { return(type); } Type[] genericArguments = new Type[typeInfo.GenericArgumentCount]; for (int i = 0; i < typeInfo.GenericArgumentCount; i++) { var ti = typeMap.GetTypeInfo(typeInfo.GenericArguments[i]); if (ti == null) { throw new Exception(); } if (TryResolveType(typeMap, ti, out Type t)) { genericArguments[i] = t; } else { throw new Exception(); } } return(type.MakeGenericType(genericArguments)); }
internal BinaryTypeInfo[] ReadTypeList() { ushort typeLen = ReadUInt16Value(); BinaryTypeInfo[] typeList = new BinaryTypeInfo[typeLen]; for (ushort i = 0; i < typeLen; i++) { typeList[i] = ReadTypeInfo(); } return(typeList); }
//public BinaryTypeInfo PrimaryTypeInfo //{ // get // { // return GetTypeInfo(0); // } //} internal string GetTypeName(ushort seq) { BinaryTypeInfo ti = GetTypeInfo(seq); if (ti == null) { return(null); } return(ti.GetFullName(this)); }
internal bool TrySetTypeMemberInfos(ushort seq, Func <BinaryMemberInfo[]> getMemberInfos) { BinaryTypeInfo ti = GetTypeInfo(seq); if (ti != null && ti.MemberInfos == null) { var mis = getMemberInfos(); ti.MemberInfos = new Dictionary <ushort, BinaryMemberInfo>(mis?.Select(mi => new KeyValuePair <ushort, BinaryMemberInfo>(mi.Seq, mi))); return(true); } return(false); }
public override bool TryResolveType(TypeMap typeMap, BinaryTypeInfo typeInfo, out Type type) { type = null; if (typeInfo.Type == TypeEnum.None) { return(true); } if (string.IsNullOrEmpty(typeInfo.FullName) && _internalTypeMaps.ContainsKey(typeInfo.Type)) { type = _internalTypeMaps[typeInfo.Type]; } if (type == null || type.IsGenericType) { string typeName = typeInfo.GetFullName(typeMap); Type tmp = type; type = _typeNameMaps.GetOrAdd(typeName, (tn) => { if (typeInfo.Type == TypeEnum.Array) { TryResolveType(typeMap, typeMap.GetTypeInfo(typeInfo.GenericArguments[0]), out Type elementType); if (elementType != null) { return(elementType.MakeArrayType()); } return(null); } else if (typeInfo.Type == TypeEnum.Tuple || typeInfo.Type == TypeEnum.ValueTuple) { tmp = GetTupleType(typeInfo); } // 从fullName获取Type Type t = tmp ?? ParseType(typeInfo.FullName); if (t != null) { t = CreateGenericType(typeMap, t, typeInfo); } return(t); }); } if (type != null) { return(true); } return(false); }
public BinaryConverter InitializeReEntry(Type type, BinarySerializerOptions options) { BinaryClassInfo classInfo = options.GetOrAddClass(type); // Set for exception handling calculation of BinaryPath. // BinaryPropertyNameAsString = propertyName; PolymorphicBinaryClassInfo = classInfo; PolymorphicBinaryTypeInfo = TypeMap.GetTypeInfo(classInfo.TypeSeq); return(classInfo.PropertyInfoForClassInfo.ConverterBase); }
public IReadOnlyList <ushort> GetGenericTypeSeqs(ushort seq) { List <ushort> seqList = new List <ushort>(); BinaryTypeInfo ti = GetTypeInfo(seq); if (ti == null || !ti.IsGeneric) { return(seqList); } GetGenericTypeSeqs(seq, seqList); return(seqList); }
//internal BitStack _bitStack; public BinaryReaderState(TypeMap typeMap, int version, BinaryReaderOptions options = default) { _bytePosition = default; _inObject = default; _isNotPrimitive = default; _tokenType = default; _previousTokenType = default; _readerOptions = options; _typeMap = typeMap; _typeSeq = default; _version = version; _typeInfo = default; _propertySeq = default; _dicKeySeq = default; }
private Type GetTupleType(BinaryTypeInfo ti) { if (!ti.IsGeneric) { return(null); } if (ti.Type == TypeEnum.Tuple) { return(_tupleTypeMaps[ti.GenericArgumentCount]); } else if (ti.Type == TypeEnum.ValueTuple) { return(_valueTupleTypeMaps[ti.GenericArgumentCount]); } return(null); }
private void GetGenericTypeSeqs(ushort seq, List <ushort> seqList) { BinaryTypeInfo ti = GetTypeInfo(seq); if (ti == null || !ti.IsGeneric) { return; } foreach (ushort s in ti.GenericArguments) { if (seqList.Contains(s)) { continue; } seqList.Add(s); GetGenericTypeSeqs(s, seqList); } }
internal bool TrySkipObjectProperties(ref int offset) { int curOffset = offset; // 读取属性 while (true) { if (!TryReadPropertySeq(ref curOffset, out ushort propertySeq)) { return(false); } if (propertySeq == BinarySerializerConstants.EndObjectSeq) { break; } // 记得处理扩展属性 if (!TryReadTypeSeq(ref curOffset, out ushort typeSeq)) { return(false); } if (typeSeq == TypeMap.NullTypeSeq) { continue; } BinaryTypeInfo ti = _typeMap.GetTypeInfo(typeSeq); if (ti == null) { } if (!TryForwardRead(ti, ref curOffset)) { return(false); } } offset = curOffset; return(true); }
public void Reset() { CtorArgumentStateIndex = 0; CtorArgumentState = null; BinaryClassInfo = null !; PolymorphicBinaryClassInfo = null; PolymorphicBinaryTypeInfo = null; BinaryTypeInfo = null; PropertyPolymorphicConverter = null; ObjectState = StackFrameObjectState.None; OriginalDepth = 0; PropertyIndex = 0; PropertyRefCache = null; ReturnValue = null; EnumerableIndexBytes = 0; EnumerableLength = 0; EnumerableIndex = 0; PropertyValueCache = null; RefState = RefState.None; EndProperty(); }
private BinaryTypeInfo ReadTypeInfo() { // ushort ushort seq = ReadUInt16Value(); ClassType sType = (ClassType)ReadByteValue(); bool isGeneric = ReadBooleanValue(); byte genericArgumentCount = ReadByteValue(); ushort[] genericArguments = new ushort[genericArgumentCount]; for (byte i = 0; i < genericArgumentCount; i++) { genericArguments[i] = ReadUInt16Value(); } TypeEnum type = (TypeEnum)ReadByteValue(); ushort nameLen = ReadUInt16Value(); string name = null; if (nameLen > 0) { name = ReadStringValue(nameLen); } BinaryTypeInfo ti = new BinaryTypeInfo() { Seq = seq, SerializeType = sType, IsGeneric = isGeneric, GenericArgumentCount = genericArgumentCount, GenericArguments = genericArguments, FullName = name, Type = type }; ti.MemberInfos = ReadMembers(); return(ti); }
public bool TryAdd(Type type, out BinaryTypeInfo typeInfo) { if (HasType(type)) { typeInfo = _typeInfoMap[type]; return(false); } lock (_typeSeqMap) { if (HasType(type)) { typeInfo = _typeInfoMap[type]; return(false); } ushort cur = (ushort)_currentSeq; if (cur >= 0xFF) { // OXFF 固定为Null值类型 // TODO throw new Exception(); } _currentSeq++; BinaryTypeInfo ti = new BinaryTypeInfo() { Seq = cur }; _typeSeqMap.Add(type, cur); _typeInfoMap.Add(type, ti); _seqTypeMap.Add(cur, type); _typeSeqToTypeInfoMap.Add(cur, ti); typeInfo = ti; return(true); } }
public abstract bool TryResolveType(TypeMap typeMap, BinaryTypeInfo typeInfo, out Type type);
public void Push(BinaryTypeInfo typeInfo) { if (_continuationCount == 0) { if (_count == 0) { // The first stack frame is held in Current. Current.BinaryTypeInfo = typeInfo; Current.TypeMap = TypeMap; _count = 1; } else { BinaryClassInfo binaryClassInfo; if (Current.BinaryClassInfo.ClassType == ClassType.Object) { if (Current.BinaryPropertyInfo != null) { binaryClassInfo = Current.PolymorphicBinaryClassInfo ?? Current.BinaryPropertyInfo.RuntimeClassInfo; } else { binaryClassInfo = Current.PolymorphicBinaryClassInfo ?? Current.CtorArgumentState !.BinaryParameterInfo !.RuntimeClassInfo; } } else if (((ClassType.Value | ClassType.NewValue) & Current.BinaryClassInfo.ClassType) != 0) { // Although ClassType.Value doesn't push, a custom custom converter may re-enter serialization. binaryClassInfo = Current.BinaryPropertyInfo !.RuntimeClassInfo; } else { Debug.Assert(((ClassType.Enumerable | ClassType.Dictionary) & Current.BinaryClassInfo.ClassType) != 0); binaryClassInfo = Current.PolymorphicBinaryClassInfo ?? Current.BinaryClassInfo.ElementClassInfo !; } AddCurrent(); Current.Reset(); Current.BinaryClassInfo = binaryClassInfo; Current.BinaryPropertyInfo = binaryClassInfo.PropertyInfoForClassInfo; Current.BinaryTypeInfo = typeInfo; Current.TypeMap = TypeMap; } } else if (_continuationCount == 1) { // No need for a push since there is only one stack frame. Debug.Assert(_count == 1); _continuationCount = 0; } else { // A continuation; adjust the index. Current = _previous[_count - 1]; // Check if we are done. if (_count == _continuationCount) { _continuationCount = 0; } else { _count++; } } SetConstructorArgumentState(); }
internal bool TryForwardRead(BinaryTypeInfo typeInfo, ref int offset) { if (typeInfo.SerializeType == ClassType.Value) { if (_binaryTypeToBytesLen.ContainsKey(typeInfo.Type)) { int len = _binaryTypeToBytesLen[typeInfo.Type]; if (!TryRequestData(offset, len)) { return(false); } offset += len; return(true); } else if (typeInfo.Type == TypeEnum.Nullable) { int curOffset = offset; if (!TryReadTypeSeq(ref curOffset, out ushort typeSeq)) { return(false); } if (typeSeq == TypeMap.NullTypeSeq) { offset = curOffset; return(true); } if (!TryForwardRead(_typeMap.GetTypeInfo(typeSeq), ref curOffset)) { return(false); } offset = curOffset; return(true); } else { if (!TrySkipBytes(ref offset)) { return(false); } } } else if (typeInfo.SerializeType == ClassType.Object) { int curOffset = offset; // 引用、非引用 if (!TryRequestData(curOffset, 1)) { return(false); } byte _ = _buffer[curOffset++]; if (!TryRequestData(curOffset, 4)) { return(false); } curOffset += 4; // 读取属性 if (!TrySkipObjectProperties(ref curOffset)) { return(false); } offset = curOffset; } else if (typeInfo.SerializeType == ClassType.Enumerable) { int curOffset = offset; // 可枚举类型 // 引用、非引用 if (!TryRequestData(curOffset, 1)) { return(false); } byte refSign = _buffer[curOffset++]; // 引用 if (!TryRequestData(curOffset, 4)) { return(false); } curOffset += 4; // 非引用 if (refSign == 0x00) { // 索引长度 if (!TryRequestData(curOffset, 1)) { return(false); } byte lenBytes = _buffer[curOffset++]; if (!TryRequestData(curOffset, lenBytes)) { return(false); } var lenSpan = _buffer.Slice(curOffset, lenBytes); ulong len = GetEnumerableLength(lenSpan); curOffset += lenBytes; // 按顺序读取 ulong curIdx = 0; while (curIdx < len) { // 读取索引 if (!TrySkipBytes(ref curOffset, lenBytes)) { return(false); } if (!TryReadTypeSeq(ref curOffset, out ushort typeSeq)) { return(false); } if (typeSeq == TypeMap.NullTypeSeq) { continue; } BinaryTypeInfo ti = _typeMap.GetTypeInfo(typeSeq); if (!TryForwardRead(ti, ref curOffset)) { return(false); } curIdx++; } } // 读取自定义属性 if (!TrySkipObjectProperties(ref curOffset)) { return(false); } offset = curOffset; } else if (typeInfo.SerializeType == ClassType.Dictionary) { int curOffset = offset; // 引用、非引用 if (!TryRequestData(curOffset, 1)) { return(false); } byte refSign = _buffer[curOffset++]; if (!TryRequestData(curOffset, 4)) { return(false); } curOffset += 4; if (refSign == 0x00) { // Key Value while (true) { if (!TryRequestData(curOffset, 1)) { return(false); } byte keySeq = _buffer[curOffset++]; if (keySeq == BinarySerializerConstants.EndDictionaryKey) { break; } else if (keySeq != BinarySerializerConstants.DictionaryKeySeq) { ThrowHelper.ThrowBinaryReaderException(ref this, ExceptionResource.InvalidByte); } // Key if (!TryReadTypeSeq(ref curOffset, out ushort typeSeq)) { return(false); } if (typeSeq != TypeMap.NullTypeSeq) { BinaryTypeInfo ti = _typeMap.GetTypeInfo(typeSeq); if (!TryForwardRead(ti, ref curOffset)) { return(false); } } // Value if (!TryReadTypeSeq(ref curOffset, out typeSeq)) { return(false); } if (typeSeq != TypeMap.NullTypeSeq) { BinaryTypeInfo ti = _typeMap.GetTypeInfo(typeSeq); if (!TryForwardRead(ti, ref curOffset)) { return(false); } } } } // 读取属性 if (!TrySkipObjectProperties(ref curOffset)) { return(false); } offset = curOffset; } else { ThrowHelper.ThrowBinaryException(); } return(true); }