internal ObjectMap(string objectName, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) { this.isInitObjectInfo = true; this.objectName = objectName; this.memberNames = memberNames; this.binaryTypeEnumA = binaryTypeEnumA; this.typeInformationA = typeInformationA; this.objectReader = objectReader; this.objectId = objectId; this.assemblyInfo = assemblyInfo; if (assemblyInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", new object[] { objectName })); } this.objectType = objectReader.GetType(assemblyInfo, objectName); this.memberTypes = new Type[memberNames.Length]; for (int i = 0; i < memberNames.Length; i++) { InternalPrimitiveTypeE ee; string str; Type type; bool flag; BinaryConverter.TypeFromInfo(binaryTypeEnumA[i], typeInformationA[i], objectReader, (BinaryAssemblyInfo)assemIdToAssemblyTable[memberAssemIds[i]], out ee, out str, out type, out flag); this.memberTypes[i] = type; } this.objectInfo = objectReader.CreateReadObjectInfo(this.objectType, memberNames, null); if (!this.objectInfo.isSi) { this.objectInfo.GetMemberTypes(memberNames, this.objectInfo.objectType); } }
internal ObjectMap(string objectName, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) { this.isInitObjectInfo = true; this.objectName = objectName; this.memberNames = memberNames; this.binaryTypeEnumA = binaryTypeEnumA; this.typeInformationA = typeInformationA; this.objectReader = objectReader; this.objectId = objectId; this.assemblyInfo = assemblyInfo; if (assemblyInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", new object[] { objectName })); } this.objectType = objectReader.GetType(assemblyInfo, objectName); this.memberTypes = new Type[memberNames.Length]; for (int i = 0; i < memberNames.Length; i++) { InternalPrimitiveTypeE ee; string str; Type type; bool flag; BinaryConverter.TypeFromInfo(binaryTypeEnumA[i], typeInformationA[i], objectReader, (BinaryAssemblyInfo) assemIdToAssemblyTable[memberAssemIds[i]], out ee, out str, out type, out flag); this.memberTypes[i] = type; } this.objectInfo = objectReader.CreateReadObjectInfo(this.objectType, memberNames, null); if (!this.objectInfo.isSi) { this.objectInfo.GetMemberTypes(memberNames, this.objectInfo.objectType); } }
internal ObjectMap( string objectName, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type objectType, string[] memberNames, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo) { _objectName = objectName; _objectType = objectType; _memberNames = memberNames; _objectReader = objectReader; _objectId = objectId; _assemblyInfo = assemblyInfo; _objectInfo = objectReader.CreateReadObjectInfo(objectType); _memberTypes = _objectInfo.GetMemberTypes(memberNames, objectType) !; _binaryTypeEnumA = new BinaryTypeEnum[_memberTypes.Length]; _typeInformationA = new object[_memberTypes.Length]; for (int i = 0; i < _memberTypes.Length; i++) { BinaryTypeEnum binaryTypeEnum = BinaryTypeConverter.GetParserBinaryTypeInfo(_memberTypes[i] !, out object?typeInformation); _binaryTypeEnumA[i] = binaryTypeEnum; _typeInformationA[i] = typeInformation; } }
internal Type GetType(BinaryAssemblyInfo assemblyInfo, string name) { Type type = null; if (this.previousName != null && this.previousName.Length == name.Length && this.previousName.Equals(name) && this.previousAssemblyString != null && this.previousAssemblyString.Length == assemblyInfo.assemblyString.Length && this.previousAssemblyString.Equals(assemblyInfo.assemblyString)) { type = this.previousType; } else { type = this.Bind(assemblyInfo.assemblyString, name); if (type == null) { Assembly assembly = assemblyInfo.GetAssembly(); if (this.bSimpleAssembly) { ObjectReader.GetSimplyNamedTypeFromAssembly(assembly, name, ref type); } else { type = FormatterServices.GetTypeFromAssembly(assembly, name); } if (type != null) { ObjectReader.CheckTypeForwardedTo(assembly, type.Assembly, type); } } this.previousAssemblyString = assemblyInfo.assemblyString; this.previousName = name; this.previousType = type; } return(type); }
internal ObjectMap(string objectName, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object?[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) { _objectName = objectName; _memberNames = memberNames; _binaryTypeEnumA = binaryTypeEnumA; _typeInformationA = typeInformationA; _objectReader = objectReader; _objectId = objectId; _assemblyInfo = assemblyInfo; if (assemblyInfo == null) { throw new SerializationException(SR.Format(SR.Serialization_Assembly, objectName)); } _objectType = objectReader.GetType(assemblyInfo, objectName); _memberTypes = new Type[memberNames.Length]; for (int i = 0; i < memberNames.Length; i++) { BinaryTypeConverter.TypeFromInfo( binaryTypeEnumA[i], typeInformationA[i], objectReader, (BinaryAssemblyInfo?)assemIdToAssemblyTable[memberAssemIds[i]], out _, out _, out Type? type, out _); _memberTypes[i] = type; } _objectInfo = objectReader.CreateReadObjectInfo(_objectType, memberNames, null); if (!_objectInfo._isSi) { _objectInfo.GetMemberTypes(memberNames, _objectInfo._objectType); // Check version match } }
internal ObjectMap(string objectName, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) { this.objectName = objectName; this.memberNames = memberNames; this.binaryTypeEnumA = binaryTypeEnumA; this.typeInformationA = typeInformationA; this.objectReader = objectReader; this.objectId = objectId; this.assemblyInfo = assemblyInfo; if (assemblyInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", (object)objectName)); } this.objectType = objectReader.GetType(assemblyInfo, objectName); this.memberTypes = new Type[memberNames.Length]; for (int index = 0; index < memberNames.Length; ++index) { InternalPrimitiveTypeE primitiveTypeEnum; string typeString; Type type; bool isVariant; BinaryConverter.TypeFromInfo(binaryTypeEnumA[index], typeInformationA[index], objectReader, (BinaryAssemblyInfo)assemIdToAssemblyTable[memberAssemIds[index]], out primitiveTypeEnum, out typeString, out type, out isVariant); this.memberTypes[index] = type; } this.objectInfo = objectReader.CreateReadObjectInfo(this.objectType, memberNames, (Type[])null); if (this.objectInfo.isSi) { return; } this.objectInfo.GetMemberTypes(memberNames, this.objectInfo.objectType); }
internal Type GetType(BinaryAssemblyInfo assemblyInfo, string name) { Type typeFromAssembly = null; if ((((this.previousName != null) && (this.previousName.Length == name.Length)) && (this.previousName.Equals(name) && (this.previousAssemblyString != null))) && ((this.previousAssemblyString.Length == assemblyInfo.assemblyString.Length) && this.previousAssemblyString.Equals(assemblyInfo.assemblyString))) { return(this.previousType); } typeFromAssembly = this.Bind(assemblyInfo.assemblyString, name); if (typeFromAssembly == null) { Assembly assm = assemblyInfo.GetAssembly(); if (this.bSimpleAssembly) { GetSimplyNamedTypeFromAssembly(assm, name, ref typeFromAssembly); } else { typeFromAssembly = FormatterServices.GetTypeFromAssembly(assm, name); } if (typeFromAssembly != null) { CheckTypeForwardedTo(assm, typeFromAssembly.Assembly, typeFromAssembly); } } this.previousAssemblyString = assemblyInfo.assemblyString; this.previousName = name; this.previousType = typeFromAssembly; return(typeFromAssembly); }
// No member type information internal static ObjectMap Create( string name, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type objectType, string[] memberNames, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo) => new ObjectMap(name, objectType, memberNames, objectReader, objectId, assemblyInfo);
internal ObjectMap(string objectName, Type objectType, string[] memberNames, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo) { this.isInitObjectInfo = true; this.objectName = objectName; this.objectType = objectType; this.memberNames = memberNames; this.objectReader = objectReader; this.objectId = objectId; this.assemblyInfo = assemblyInfo; this.objectInfo = objectReader.CreateReadObjectInfo(objectType); this.memberTypes = this.objectInfo.GetMemberTypes(memberNames, objectType); this.binaryTypeEnumA = new BinaryTypeEnum[this.memberTypes.Length]; this.typeInformationA = new object[this.memberTypes.Length]; for (int i = 0; i < this.memberTypes.Length; i++) { object typeInformation = null; this.binaryTypeEnumA[i] = BinaryConverter.GetParserBinaryTypeInfo(this.memberTypes[i], out typeInformation); this.typeInformationA[i] = typeInformation; } }
internal ObjectMap(string objectName, Type objectType, string[] memberNames, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo) { this.isInitObjectInfo = true; this.objectName = objectName; this.objectType = objectType; this.memberNames = memberNames; this.objectReader = objectReader; this.objectId = objectId; this.assemblyInfo = assemblyInfo; this.objectInfo = objectReader.CreateReadObjectInfo(objectType); this.memberTypes = this.objectInfo.GetMemberTypes(memberNames, objectType); this.binaryTypeEnumA = new BinaryTypeEnum[this.memberTypes.Length]; this.typeInformationA = new object[this.memberTypes.Length]; for (int i = 0; i < this.memberTypes.Length; i++) { object typeInformation = null; this.binaryTypeEnumA[i] = BinaryConverter.GetParserBinaryTypeInfo(this.memberTypes[i], out typeInformation); this.typeInformationA[i] = typeInformation; } }
internal Type?GetType(BinaryAssemblyInfo assemblyInfo, string name) { Type?objectType; if (((_previousName != null) && (_previousName.Length == name.Length) && (_previousName.Equals(name))) && ((_previousAssemblyString != null) && (_previousAssemblyString.Length == assemblyInfo._assemblyString.Length) && (_previousAssemblyString.Equals(assemblyInfo._assemblyString)))) { objectType = _previousType; } else { objectType = Bind(assemblyInfo._assemblyString, name); if (objectType == null) { Assembly sourceAssembly = assemblyInfo.GetAssembly(); if (_isSimpleAssembly) { GetSimplyNamedTypeFromAssembly(sourceAssembly, name, ref objectType); } else { objectType = FormatterServices.GetTypeFromAssembly(sourceAssembly, name); } // here let us do the security check if (objectType != null) { CheckTypeForwardedTo(sourceAssembly, objectType.Assembly, objectType); } } _previousAssemblyString = assemblyInfo._assemblyString; _previousName = name; _previousType = objectType; } return(objectType); }
[System.Security.SecurityCritical] // auto-generated internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, Object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out String typeString, out Type type, out bool isVariant) { SerTrace.Log( "BinaryConverter", "TypeFromInfo Entry ",((Enum)binaryTypeEnum).ToString()); isVariant = false; primitiveTypeEnum = InternalPrimitiveTypeE.Invalid; typeString = null; type = null; switch (binaryTypeEnum) { case BinaryTypeEnum.Primitive: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; typeString = Converter.ToComType(primitiveTypeEnum); type = Converter.ToType(primitiveTypeEnum); break; case BinaryTypeEnum.String: //typeString = "System.String"; type = Converter.typeofString; break; case BinaryTypeEnum.Object: //typeString = "System.Object"; type = Converter.typeofObject; isVariant = true; break; case BinaryTypeEnum.ObjectArray: //typeString = "System.Object[]"; type = Converter.typeofObjectArray; break; case BinaryTypeEnum.StringArray: //typeString = "System.String[]"; type = Converter.typeofStringArray; break; case BinaryTypeEnum.PrimitiveArray: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; type = Converter.ToArrayType(primitiveTypeEnum); break; case BinaryTypeEnum.ObjectUser: case BinaryTypeEnum.ObjectUrt: if (typeInformation != null) { typeString = typeInformation.ToString(); type = objectReader.GetType(assemblyInfo, typeString); // Temporary for backward compatibility if (Object.ReferenceEquals(type, Converter.typeofObject)) isVariant = true; } break; default: throw new SerializationException(Environment.GetResourceString("Serialization_TypeRead",((Enum)binaryTypeEnum).ToString())); } #if _DEBUG SerTrace.Log( "BinaryConverter", "TypeFromInfo Exit " ,((Enum)primitiveTypeEnum).ToString(),",typeString ",Util.PString(typeString) ,", type ",Util.PString(type),", isVariant ",isVariant); #endif }
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum) { BinaryAssemblyInfo assemblyInfo = null; BinaryArray record = new BinaryArray(binaryHeaderEnum); record.Read(this); if (record._binaryTypeEnum == BinaryTypeEnum.ObjectUser) { if (record._assemId < 1) { throw new SerializationException(SR.Format(SR.Serialization_AssemblyId, record._typeInformation)); } assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record._assemId]; } else { assemblyInfo = SystemAssemblyInfo; //Urt assembly } ObjectProgress op = GetOp(); ParseRecord pr = op._pr; op._objectTypeEnum = InternalObjectTypeE.Array; op._binaryTypeEnum = record._binaryTypeEnum; op._typeInformation = record._typeInformation; ObjectProgress objectOp = (ObjectProgress)_stack.PeekPeek(); if ((objectOp == null) || (record._objectId > 0)) { // Non-Nested Object op._name = "System.Array"; pr._parseTypeEnum = InternalParseTypeE.Object; op._memberValueEnum = InternalMemberValueE.Empty; } else { // Nested Object pr._parseTypeEnum = InternalParseTypeE.Member; pr._memberValueEnum = InternalMemberValueE.Nested; op._memberValueEnum = InternalMemberValueE.Nested; switch (objectOp._objectTypeEnum) { case InternalObjectTypeE.Object: pr._name = objectOp._name; pr._memberTypeEnum = InternalMemberTypeE.Field; op._memberTypeEnum = InternalMemberTypeE.Field; pr._keyDt = objectOp._name; pr._dtType = objectOp._dtType; break; case InternalObjectTypeE.Array: pr._memberTypeEnum = InternalMemberTypeE.Item; op._memberTypeEnum = InternalMemberTypeE.Item; break; default: throw new SerializationException(SR.Format(SR.Serialization_ObjectTypeEnum, objectOp._objectTypeEnum.ToString())); } } pr._objectId = _objectReader.GetId(record._objectId); if (pr._objectId == _topId) { pr._objectPositionEnum = InternalObjectPositionE.Top; } else if ((_headerId > 0) && (pr._objectId == _headerId)) { pr._objectPositionEnum = InternalObjectPositionE.Headers; // Headers are an array of header objects } else { pr._objectPositionEnum = InternalObjectPositionE.Child; } pr._objectTypeEnum = InternalObjectTypeE.Array; BinaryTypeConverter.TypeFromInfo(record._binaryTypeEnum, record._typeInformation, _objectReader, assemblyInfo, out pr._arrayElementTypeCode, out pr._arrayElementTypeString, out pr._arrayElementType, out pr._isArrayVariant); pr._dtTypeCode = InternalPrimitiveTypeE.Invalid; pr._rank = record._rank; pr._lengthA = record._lengthA; pr._lowerBoundA = record._lowerBoundA; bool isPrimitiveArray = false; switch (record._binaryArrayTypeEnum) { case BinaryArrayTypeEnum.Single: case BinaryArrayTypeEnum.SingleOffset: op._numItems = record._lengthA[0]; pr._arrayTypeEnum = InternalArrayTypeE.Single; if (Converter.IsWriteAsByteArray(pr._arrayElementTypeCode) && (record._lowerBoundA[0] == 0)) { isPrimitiveArray = true; ReadArrayAsBytes(pr); } break; case BinaryArrayTypeEnum.Jagged: case BinaryArrayTypeEnum.JaggedOffset: op._numItems = record._lengthA[0]; pr._arrayTypeEnum = InternalArrayTypeE.Jagged; break; case BinaryArrayTypeEnum.Rectangular: case BinaryArrayTypeEnum.RectangularOffset: int arrayLength = 1; for (int i = 0; i < record._rank; i++) { arrayLength = arrayLength * record._lengthA[i]; } op._numItems = arrayLength; pr._arrayTypeEnum = InternalArrayTypeE.Rectangular; break; default: throw new SerializationException(SR.Format(SR.Serialization_ArrayType, record._binaryArrayTypeEnum.ToString())); } if (!isPrimitiveArray) { _stack.Push(op); } else { PutOp(op); } _objectReader.Parse(pr); if (isPrimitiveArray) { pr._parseTypeEnum = InternalParseTypeE.ObjectEnd; _objectReader.Parse(pr); } }
internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out string typeString, out Type type, out bool isVariant) { isVariant = false; primitiveTypeEnum = InternalPrimitiveTypeE.Invalid; typeString = null; type = null; switch (binaryTypeEnum) { case BinaryTypeEnum.Primitive: primitiveTypeEnum = (InternalPrimitiveTypeE) typeInformation; typeString = Converter.ToComType(primitiveTypeEnum); type = Converter.ToType(primitiveTypeEnum); return; case BinaryTypeEnum.String: type = Converter.typeofString; return; case BinaryTypeEnum.Object: type = Converter.typeofObject; isVariant = true; return; case BinaryTypeEnum.ObjectUrt: case BinaryTypeEnum.ObjectUser: if (typeInformation == null) { break; } typeString = typeInformation.ToString(); type = objectReader.GetType(assemblyInfo, typeString); if (!object.ReferenceEquals(type, Converter.typeofObject)) { break; } isVariant = true; return; case BinaryTypeEnum.ObjectArray: type = Converter.typeofObjectArray; return; case BinaryTypeEnum.StringArray: type = Converter.typeofStringArray; return; case BinaryTypeEnum.PrimitiveArray: primitiveTypeEnum = (InternalPrimitiveTypeE) typeInformation; type = Converter.ToArrayType(primitiveTypeEnum); return; default: throw new SerializationException(Environment.GetResourceString("Serialization_TypeRead", new object[] { binaryTypeEnum.ToString() })); } }
//private int hit; internal Type GetType(BinaryAssemblyInfo assemblyInfo, String name) { //Console.WriteLine("Get Type "+name+" "+assemblyInfo.assemblyString); Type objectType = null; if (((previousName != null) && (previousName.Length == name.Length) && (previousName.Equals(name))) && ((previousAssemblyString != null) && (previousAssemblyString.Length == assemblyInfo.assemblyString.Length) &&(previousAssemblyString.Equals(assemblyInfo.assemblyString)))) { objectType = previousType; //Console.WriteLine("Hit "+(++hit)+" "+objectType); } else { objectType = Bind(assemblyInfo.assemblyString, name); if (objectType == null) objectType = FormatterServices.GetTypeFromAssembly(assemblyInfo.GetAssembly(), name); if (objectType == null) throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TypeResolved"), name+", "+assemblyInfo.assemblyString)); previousAssemblyString = assemblyInfo.assemblyString; previousName = name; previousType = objectType; } //Console.WriteLine("name "+name+" assembly "+assemblyInfo.assemblyString+" objectType "+objectType); return objectType; }
private void ReadObjectWithMapTyped(BinaryObjectWithMapTyped record) { BinaryAssemblyInfo assemblyInfo = null; ObjectProgress op = GetOp(); ParseRecord pr = op._pr; _stack.Push(op); if (record._binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId) { if (record._assemId < 1) { throw new SerializationException(SR.Format(SR.Serialization_AssemblyId, record._name)); } assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record._assemId]; if (assemblyInfo == null) { throw new SerializationException(SR.Format(SR.Serialization_AssemblyId, record._assemId + " " + record._name)); } } else if (record._binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTyped) { assemblyInfo = SystemAssemblyInfo; // Urt assembly } ObjectMap objectMap = ObjectMap.Create(record._name, record._memberNames, record._binaryTypeEnumA, record._typeInformationA, record._memberAssemIds, _objectReader, record._objectId, assemblyInfo, AssemIdToAssemblyTable); ObjectMapIdTable[record._objectId] = objectMap; op._objectTypeEnum = InternalObjectTypeE.Object; op._binaryTypeEnumA = objectMap._binaryTypeEnumA; op._typeInformationA = objectMap._typeInformationA; op._memberLength = op._binaryTypeEnumA.Length; op._memberNames = objectMap._memberNames; op._memberTypes = objectMap._memberTypes; ObjectProgress objectOp = (ObjectProgress)_stack.PeekPeek(); if ((objectOp == null) || (objectOp._isInitial)) { // Non-Nested Object op._name = record._name; pr._parseTypeEnum = InternalParseTypeE.Object; op._memberValueEnum = InternalMemberValueE.Empty; } else { // Nested Object pr._parseTypeEnum = InternalParseTypeE.Member; pr._memberValueEnum = InternalMemberValueE.Nested; op._memberValueEnum = InternalMemberValueE.Nested; switch (objectOp._objectTypeEnum) { case InternalObjectTypeE.Object: pr._name = objectOp._name; pr._memberTypeEnum = InternalMemberTypeE.Field; op._memberTypeEnum = InternalMemberTypeE.Field; break; case InternalObjectTypeE.Array: pr._memberTypeEnum = InternalMemberTypeE.Item; op._memberTypeEnum = InternalMemberTypeE.Item; break; default: throw new SerializationException(SR.Format(SR.Serialization_ObjectTypeEnum, objectOp._objectTypeEnum.ToString())); } } pr._objectTypeEnum = InternalObjectTypeE.Object; pr._objectInfo = objectMap.CreateObjectInfo(ref pr._si, ref pr._memberData); pr._objectId = _objectReader.GetId(record._objectId); if (pr._objectId == _topId) { pr._objectPositionEnum = InternalObjectPositionE.Top; } pr._keyDt = record._name; pr._dtType = objectMap._objectType; pr._dtTypeCode = InternalPrimitiveTypeE.Invalid; _objectReader.Parse(pr); }
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum) { BinaryAssemblyInfo assemblyInfo = null; BinaryArray array = new BinaryArray(binaryHeaderEnum); array.Read(this); if (array.binaryTypeEnum == BinaryTypeEnum.ObjectUser) { if (array.assemId < 1) { throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", new object[] { array.typeInformation })); } assemblyInfo = (BinaryAssemblyInfo)this.AssemIdToAssemblyTable[array.assemId]; } else { assemblyInfo = this.SystemAssemblyInfo; } ObjectProgress op = this.GetOp(); ParseRecord pr = op.pr; op.objectTypeEnum = InternalObjectTypeE.Array; op.binaryTypeEnum = array.binaryTypeEnum; op.typeInformation = array.typeInformation; ObjectProgress progress2 = (ObjectProgress)this.stack.PeekPeek(); if ((progress2 == null) || (array.objectId > 0)) { op.name = "System.Array"; pr.PRparseTypeEnum = InternalParseTypeE.Object; op.memberValueEnum = InternalMemberValueE.Empty; } else { pr.PRparseTypeEnum = InternalParseTypeE.Member; pr.PRmemberValueEnum = InternalMemberValueE.Nested; op.memberValueEnum = InternalMemberValueE.Nested; switch (progress2.objectTypeEnum) { case InternalObjectTypeE.Object: pr.PRname = progress2.name; pr.PRmemberTypeEnum = InternalMemberTypeE.Field; op.memberTypeEnum = InternalMemberTypeE.Field; pr.PRkeyDt = progress2.name; pr.PRdtType = progress2.dtType; goto Label_0177; case InternalObjectTypeE.Array: pr.PRmemberTypeEnum = InternalMemberTypeE.Item; op.memberTypeEnum = InternalMemberTypeE.Item; goto Label_0177; } throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", new object[] { progress2.objectTypeEnum.ToString() })); } Label_0177: pr.PRobjectId = this.objectReader.GetId((long)array.objectId); if (pr.PRobjectId == this.topId) { pr.PRobjectPositionEnum = InternalObjectPositionE.Top; } else if ((this.headerId > 0L) && (pr.PRobjectId == this.headerId)) { pr.PRobjectPositionEnum = InternalObjectPositionE.Headers; } else { pr.PRobjectPositionEnum = InternalObjectPositionE.Child; } pr.PRobjectTypeEnum = InternalObjectTypeE.Array; BinaryConverter.TypeFromInfo(array.binaryTypeEnum, array.typeInformation, this.objectReader, assemblyInfo, out pr.PRarrayElementTypeCode, out pr.PRarrayElementTypeString, out pr.PRarrayElementType, out pr.PRisArrayVariant); pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid; pr.PRrank = array.rank; pr.PRlengthA = array.lengthA; pr.PRlowerBoundA = array.lowerBoundA; bool flag = false; switch (array.binaryArrayTypeEnum) { case BinaryArrayTypeEnum.Single: case BinaryArrayTypeEnum.SingleOffset: op.numItems = array.lengthA[0]; pr.PRarrayTypeEnum = InternalArrayTypeE.Single; if (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode) && (array.lowerBoundA[0] == 0)) { flag = true; this.ReadArrayAsBytes(pr); } break; case BinaryArrayTypeEnum.Jagged: case BinaryArrayTypeEnum.JaggedOffset: op.numItems = array.lengthA[0]; pr.PRarrayTypeEnum = InternalArrayTypeE.Jagged; break; case BinaryArrayTypeEnum.Rectangular: case BinaryArrayTypeEnum.RectangularOffset: { int num = 1; for (int i = 0; i < array.rank; i++) { num *= array.lengthA[i]; } op.numItems = num; pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular; break; } default: throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", new object[] { array.binaryArrayTypeEnum.ToString() })); } if (!flag) { this.stack.Push(op); } else { this.PutOp(op); } this.objectReader.Parse(pr); if (flag) { pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd; this.objectReader.Parse(pr); } }
private void ReadObjectWithMap(BinaryObjectWithMap record) { BinaryAssemblyInfo assemblyInfo = null; ObjectProgress op = this.GetOp(); ParseRecord pr = op.pr; this.stack.Push(op); if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId) { if (record.assemId < 1) { throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", new object[] { record.name })); } assemblyInfo = (BinaryAssemblyInfo)this.AssemIdToAssemblyTable[record.assemId]; if (assemblyInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_Assembly", new object[] { record.assemId + " " + record.name })); } } else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMap) { assemblyInfo = this.SystemAssemblyInfo; } Type objectType = this.objectReader.GetType(assemblyInfo, record.name); ObjectMap map = ObjectMap.Create(record.name, objectType, record.memberNames, this.objectReader, record.objectId, assemblyInfo); this.ObjectMapIdTable[record.objectId] = map; op.objectTypeEnum = InternalObjectTypeE.Object; op.binaryTypeEnumA = map.binaryTypeEnumA; op.typeInformationA = map.typeInformationA; op.memberLength = op.binaryTypeEnumA.Length; op.memberNames = map.memberNames; op.memberTypes = map.memberTypes; ObjectProgress progress2 = (ObjectProgress)this.stack.PeekPeek(); if ((progress2 == null) || progress2.isInitial) { op.name = record.name; pr.PRparseTypeEnum = InternalParseTypeE.Object; op.memberValueEnum = InternalMemberValueE.Empty; } else { pr.PRparseTypeEnum = InternalParseTypeE.Member; pr.PRmemberValueEnum = InternalMemberValueE.Nested; op.memberValueEnum = InternalMemberValueE.Nested; switch (progress2.objectTypeEnum) { case InternalObjectTypeE.Object: pr.PRname = progress2.name; pr.PRmemberTypeEnum = InternalMemberTypeE.Field; op.memberTypeEnum = InternalMemberTypeE.Field; goto Label_0213; case InternalObjectTypeE.Array: pr.PRmemberTypeEnum = InternalMemberTypeE.Item; op.memberTypeEnum = InternalMemberTypeE.Field; goto Label_0213; } throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", new object[] { progress2.objectTypeEnum.ToString() })); } Label_0213: pr.PRobjectTypeEnum = InternalObjectTypeE.Object; pr.PRobjectId = this.objectReader.GetId((long)record.objectId); pr.PRobjectInfo = map.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData); if (pr.PRobjectId == this.topId) { pr.PRobjectPositionEnum = InternalObjectPositionE.Top; } pr.PRkeyDt = record.name; pr.PRdtType = map.objectType; pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid; this.objectReader.Parse(pr); }
[System.Security.SecurityCritical] // auto-generated internal Type GetType(BinaryAssemblyInfo assemblyInfo, String name) { Type objectType = null; if (((previousName != null) && (previousName.Length == name.Length) && (previousName.Equals(name))) && ((previousAssemblyString != null) && (previousAssemblyString.Length == assemblyInfo.assemblyString.Length) &&(previousAssemblyString.Equals(assemblyInfo.assemblyString)))) { objectType = previousType; //Console.WriteLine("Hit "+(++hit)+" "+objectType); } else { objectType = Bind(assemblyInfo.assemblyString, name); if ((object)objectType == null) { if (bSimpleAssembly) { ObjectReader.GetSimplyNamedTypeFromAssembly(assemblyInfo.GetAssembly(), name, ref objectType); } else { objectType = FormatterServices.GetTypeFromAssembly(assemblyInfo.GetAssembly(), name); } } previousAssemblyString = assemblyInfo.assemblyString; previousName = name; previousType = objectType; } //Console.WriteLine("name "+name+" assembly "+assemblyInfo.assemblyString+" objectType "+objectType); return objectType; }
internal Type GetType(BinaryAssemblyInfo assemblyInfo, string name) { Type objectType = null; if (((_previousName != null) && (_previousName.Length == name.Length) && (_previousName.Equals(name))) && ((_previousAssemblyString != null) && (_previousAssemblyString.Length == assemblyInfo._assemblyString.Length) && (_previousAssemblyString.Equals(assemblyInfo._assemblyString)))) { objectType = _previousType; } else { objectType = Bind(assemblyInfo._assemblyString, name); if (objectType == null) { Assembly sourceAssembly = assemblyInfo.GetAssembly(); if (_isSimpleAssembly) { GetSimplyNamedTypeFromAssembly(sourceAssembly, name, ref objectType); } else { objectType = FormatterServices.GetTypeFromAssembly(sourceAssembly, name); } // here let us do the security check if (objectType != null) { CheckTypeForwardedTo(sourceAssembly, objectType.GetTypeInfo().Assembly, objectType); } } _previousAssemblyString = assemblyInfo._assemblyString; _previousName = name; _previousType = objectType; } return objectType; }
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum) { BinaryAssemblyInfo assemblyInfo = null; SerTrace.Log(this, "ReadArray "); BinaryArray record = new BinaryArray(binaryHeaderEnum); record.Read(this); record.Dump(); SerTrace.Log(this, "Read 1 ", ((Enum)binaryHeaderEnum).ToString()); if (record.binaryTypeEnum == BinaryTypeEnum.ObjectUser) { if (record.assemId < 1) { throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyId"), record.typeInformation)); } assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId]; SerTrace.Log(this, "ReadArray lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString); } else { assemblyInfo = SystemAssemblyInfo; //Urt assembly } ObjectProgress op = GetOp(); ParseRecord pr = op.pr; op.objectTypeEnum = InternalObjectTypeE.Array; op.binaryTypeEnum = record.binaryTypeEnum; op.typeInformation = record.typeInformation; ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek(); if ((objectOp == null) || (record.objectId > 0)) { // Non-Nested Object op.name = "System.Array"; pr.PRparseTypeEnum = InternalParseTypeE.Object; op.memberValueEnum = InternalMemberValueE.Empty; } else { // Nested Object pr.PRparseTypeEnum = InternalParseTypeE.Member; pr.PRmemberValueEnum = InternalMemberValueE.Nested; op.memberValueEnum = InternalMemberValueE.Nested; switch (objectOp.objectTypeEnum) { case InternalObjectTypeE.Object: pr.PRname = objectOp.name; pr.PRmemberTypeEnum = InternalMemberTypeE.Field; op.memberTypeEnum = InternalMemberTypeE.Field; pr.PRkeyDt = objectOp.name; pr.PRdtType = objectOp.dtType; break; case InternalObjectTypeE.Array: pr.PRmemberTypeEnum = InternalMemberTypeE.Item; op.memberTypeEnum = InternalMemberTypeE.Item; break; default: throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString())); } } pr.PRobjectId = objectReader.GetId((long)record.objectId); if (pr.PRobjectId == topId) { pr.PRobjectPositionEnum = InternalObjectPositionE.Top; } else if ((headerId > 0) && (pr.PRobjectId == headerId)) { pr.PRobjectPositionEnum = InternalObjectPositionE.Headers; // Headers are an array of header objects } else { pr.PRobjectPositionEnum = InternalObjectPositionE.Child; } pr.PRobjectTypeEnum = InternalObjectTypeE.Array; BinaryConverter.TypeFromInfo(record.binaryTypeEnum, record.typeInformation, objectReader, assemblyInfo, out pr.PRarrayElementTypeCode, out pr.PRarrayElementTypeString, out pr.PRarrayElementType, out pr.PRisArrayVariant); pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid; pr.PRrank = record.rank; pr.PRlengthA = record.lengthA; pr.PRlowerBoundA = record.lowerBoundA; bool isPrimitiveArray = false; switch (record.binaryArrayTypeEnum) { case BinaryArrayTypeEnum.Single: case BinaryArrayTypeEnum.SingleOffset: op.numItems = record.lengthA[0]; pr.PRarrayTypeEnum = InternalArrayTypeE.Single; if (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode) && (record.lowerBoundA[0] == 0)) { isPrimitiveArray = true; ReadArrayAsBytes(pr); } break; case BinaryArrayTypeEnum.Jagged: case BinaryArrayTypeEnum.JaggedOffset: op.numItems = record.lengthA[0]; pr.PRarrayTypeEnum = InternalArrayTypeE.Jagged; break; case BinaryArrayTypeEnum.Rectangular: case BinaryArrayTypeEnum.RectangularOffset: int arrayLength = 1; for (int i = 0; i < record.rank; i++) { arrayLength = arrayLength * record.lengthA[i]; } op.numItems = arrayLength; pr.PRarrayTypeEnum = InternalArrayTypeE.Rectangular; break; default: throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ArrayType"), ((Enum)record.binaryArrayTypeEnum).ToString())); } if (!isPrimitiveArray) { stack.Push(op); } else { PutOp(op); } SerTrace.Log(this, "ReadArray ", ((Enum)record.binaryArrayTypeEnum).ToString(), " length ", op.numItems); objectReader.Parse(pr); if (isPrimitiveArray) { pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd; objectReader.Parse(pr); } }
[System.Security.SecurityCritical] // auto-generated internal static ObjectMap Create(String name, String[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, Object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) { return new ObjectMap(name, memberNames, binaryTypeEnumA, typeInformationA, memberAssemIds, objectReader, objectId, assemblyInfo, assemIdToAssemblyTable); }
internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out string typeString, out Type type, out bool isVariant) { isVariant = false; primitiveTypeEnum = InternalPrimitiveTypeE.Invalid; typeString = (string)null; type = (Type)null; switch (binaryTypeEnum) { case BinaryTypeEnum.Primitive: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; typeString = Converter.ToComType(primitiveTypeEnum); type = Converter.ToType(primitiveTypeEnum); break; case BinaryTypeEnum.String: type = Converter.typeofString; break; case BinaryTypeEnum.Object: type = Converter.typeofObject; isVariant = true; break; case BinaryTypeEnum.ObjectUrt: case BinaryTypeEnum.ObjectUser: if (typeInformation == null) { break; } typeString = typeInformation.ToString(); type = objectReader.GetType(assemblyInfo, typeString); if (type != Converter.typeofObject) { break; } isVariant = true; break; case BinaryTypeEnum.ObjectArray: type = Converter.typeofObjectArray; break; case BinaryTypeEnum.StringArray: type = Converter.typeofStringArray; break; case BinaryTypeEnum.PrimitiveArray: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; type = Converter.ToArrayType(primitiveTypeEnum); break; default: throw new SerializationException(Environment.GetResourceString("Serialization_TypeRead", (object)binaryTypeEnum.ToString())); } }
internal static ObjectMap Create(string name, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) { return(new ObjectMap(name, memberNames, binaryTypeEnumA, typeInformationA, memberAssemIds, objectReader, objectId, assemblyInfo, assemIdToAssemblyTable)); }
// Given the wire type information, returns the actual type and additional information internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out string typeString, out Type type, out bool isVariant) { isVariant = false; primitiveTypeEnum = InternalPrimitiveTypeE.Invalid; typeString = null; type = null; switch (binaryTypeEnum) { case BinaryTypeEnum.Primitive: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; typeString = Converter.ToComType(primitiveTypeEnum); type = Converter.ToType(primitiveTypeEnum); break; case BinaryTypeEnum.String: type = Converter.s_typeofString; break; case BinaryTypeEnum.Object: type = Converter.s_typeofObject; isVariant = true; break; case BinaryTypeEnum.ObjectArray: type = Converter.s_typeofObjectArray; break; case BinaryTypeEnum.StringArray: type = Converter.s_typeofStringArray; break; case BinaryTypeEnum.PrimitiveArray: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; type = Converter.ToArrayType(primitiveTypeEnum); break; case BinaryTypeEnum.ObjectUser: case BinaryTypeEnum.ObjectUrt: if (typeInformation != null) { typeString = typeInformation.ToString(); type = objectReader.GetType(assemblyInfo, typeString); if (ReferenceEquals(type, Converter.s_typeofObject)) { isVariant = true; } } break; default: throw new SerializationException(SR.Format(SR.Serialization_TypeRead, binaryTypeEnum.ToString())); } }
private void ReadObjectWithMapTyped(BinaryObjectWithMapTyped record) { BinaryAssemblyInfo assemblyInfo = (BinaryAssemblyInfo)null; ObjectProgress op = this.GetOp(); ParseRecord pr = op.pr; this.stack.Push((object)op); if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId) { if (record.assemId < 1) { throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", (object)record.name)); } assemblyInfo = (BinaryAssemblyInfo)this.AssemIdToAssemblyTable[record.assemId]; if (assemblyInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", (object)(record.assemId.ToString() + " " + record.name))); } } else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTyped) { assemblyInfo = this.SystemAssemblyInfo; } ObjectMap objectMap = ObjectMap.Create(record.name, record.memberNames, record.binaryTypeEnumA, record.typeInformationA, record.memberAssemIds, this.objectReader, record.objectId, assemblyInfo, this.AssemIdToAssemblyTable); this.ObjectMapIdTable[record.objectId] = (object)objectMap; op.objectTypeEnum = InternalObjectTypeE.Object; op.binaryTypeEnumA = objectMap.binaryTypeEnumA; op.typeInformationA = objectMap.typeInformationA; ObjectProgress objectProgress1 = op; int length = objectProgress1.binaryTypeEnumA.Length; objectProgress1.memberLength = length; op.memberNames = objectMap.memberNames; op.memberTypes = objectMap.memberTypes; ObjectProgress objectProgress2 = (ObjectProgress)this.stack.PeekPeek(); if (objectProgress2 == null || objectProgress2.isInitial) { op.name = record.name; pr.PRparseTypeEnum = InternalParseTypeE.Object; op.memberValueEnum = InternalMemberValueE.Empty; } else { pr.PRparseTypeEnum = InternalParseTypeE.Member; pr.PRmemberValueEnum = InternalMemberValueE.Nested; op.memberValueEnum = InternalMemberValueE.Nested; switch (objectProgress2.objectTypeEnum) { case InternalObjectTypeE.Object: pr.PRname = objectProgress2.name; pr.PRmemberTypeEnum = InternalMemberTypeE.Field; op.memberTypeEnum = InternalMemberTypeE.Field; break; case InternalObjectTypeE.Array: pr.PRmemberTypeEnum = InternalMemberTypeE.Item; op.memberTypeEnum = InternalMemberTypeE.Item; break; default: throw new SerializationException(Environment.GetResourceString("Serialization_ObjectTypeEnum", (object)objectProgress2.objectTypeEnum.ToString())); } } pr.PRobjectTypeEnum = InternalObjectTypeE.Object; pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData); pr.PRobjectId = this.objectReader.GetId((long)record.objectId); if (pr.PRobjectId == this.topId) { pr.PRobjectPositionEnum = InternalObjectPositionE.Top; } pr.PRkeyDt = record.name; pr.PRdtType = objectMap.objectType; pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid; this.objectReader.Parse(pr); }
// Given the wire type information, returns the actual type and additional information internal static void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out string typeString, out Type type, out bool isVariant) { isVariant = false; primitiveTypeEnum = InternalPrimitiveTypeE.Invalid; typeString = null; type = null; switch (binaryTypeEnum) { case BinaryTypeEnum.Primitive: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; typeString = Converter.ToComType(primitiveTypeEnum); type = Converter.ToType(primitiveTypeEnum); break; case BinaryTypeEnum.String: type = Converter.s_typeofString; break; case BinaryTypeEnum.Object: type = Converter.s_typeofObject; isVariant = true; break; case BinaryTypeEnum.ObjectArray: type = Converter.s_typeofObjectArray; break; case BinaryTypeEnum.StringArray: type = Converter.s_typeofStringArray; break; case BinaryTypeEnum.PrimitiveArray: primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation; type = Converter.ToArrayType(primitiveTypeEnum); break; case BinaryTypeEnum.ObjectUser: case BinaryTypeEnum.ObjectUrt: if (typeInformation != null) { typeString = typeInformation.ToString(); type = objectReader.GetType(assemblyInfo, typeString); if (ReferenceEquals(type, Converter.s_typeofObject)) { isVariant = true; } } break; default: throw new SerializationException(SR.Format(SR.Serialization_TypeRead, binaryTypeEnum.ToString())); } }
internal static ObjectMap Create(string name, Type objectType, string[] memberNames, ObjectReader objectReader, int objectId, BinaryAssemblyInfo assemblyInfo) { return(new ObjectMap(name, objectType, memberNames, objectReader, objectId, assemblyInfo)); }
[System.Security.SecurityCritical] // auto-generated internal ObjectMap(String objectName, Type objectType, String[] memberNames, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo) { SerTrace.Log( this, "Constructor 1 objectName ",objectName, ", objectType ",objectType); this.objectName = objectName; this.objectType = objectType; this.memberNames = memberNames; this.objectReader = objectReader; this.objectId = objectId; this.assemblyInfo = assemblyInfo; objectInfo = objectReader.CreateReadObjectInfo(objectType); memberTypes = objectInfo.GetMemberTypes(memberNames, objectType); binaryTypeEnumA = new BinaryTypeEnum[memberTypes.Length]; typeInformationA = new Object[memberTypes.Length]; for (int i=0; i<memberTypes.Length; i++) { Object typeInformation = null; BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetParserBinaryTypeInfo(memberTypes[i], out typeInformation); binaryTypeEnumA[i] = binaryTypeEnum; typeInformationA[i] = typeInformation; } }
internal Type GetType(BinaryAssemblyInfo assemblyInfo, string name) { Type typeFromAssembly = null; if ((((this.previousName != null) && (this.previousName.Length == name.Length)) && (this.previousName.Equals(name) && (this.previousAssemblyString != null))) && ((this.previousAssemblyString.Length == assemblyInfo.assemblyString.Length) && this.previousAssemblyString.Equals(assemblyInfo.assemblyString))) { return this.previousType; } typeFromAssembly = this.Bind(assemblyInfo.assemblyString, name); if (typeFromAssembly == null) { Assembly assm = assemblyInfo.GetAssembly(); if (this.bSimpleAssembly) { GetSimplyNamedTypeFromAssembly(assm, name, ref typeFromAssembly); } else { typeFromAssembly = FormatterServices.GetTypeFromAssembly(assm, name); } if (typeFromAssembly != null) { CheckTypeForwardedTo(assm, typeFromAssembly.Assembly, typeFromAssembly); } } this.previousAssemblyString = assemblyInfo.assemblyString; this.previousName = name; this.previousType = typeFromAssembly; return typeFromAssembly; }
[System.Security.SecurityCritical] // auto-generated internal ObjectMap(String objectName, String[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, Object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable) { SerTrace.Log( this, "Constructor 2 objectName ",objectName); this.objectName = objectName; this.memberNames = memberNames; this.binaryTypeEnumA = binaryTypeEnumA; this.typeInformationA = typeInformationA; this.objectReader = objectReader; this.objectId = objectId; this.assemblyInfo = assemblyInfo; if (assemblyInfo == null) throw new SerializationException(Environment.GetResourceString("Serialization_Assembly",objectName)); objectType = objectReader.GetType(assemblyInfo, objectName); memberTypes = new Type[memberNames.Length]; for (int i=0; i<memberNames.Length; i++) { InternalPrimitiveTypeE primitiveTypeEnum; String typeString; Type type; bool isVariant; BinaryConverter.TypeFromInfo(binaryTypeEnumA[i], typeInformationA[i], objectReader, (BinaryAssemblyInfo)assemIdToAssemblyTable[memberAssemIds[i]], out primitiveTypeEnum, out typeString, out type, out isVariant); //if ((object)type == null) // throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TypeResolved"),objectName+" "+memberNames[i]+" "+typeInformationA[i])); memberTypes[i] = type; } objectInfo = objectReader.CreateReadObjectInfo(objectType, memberNames, null); if (!objectInfo.isSi) objectInfo.GetMemberTypes(memberNames, objectInfo.objectType); // Check version match }
[System.Security.SecurityCritical] // auto-generated internal static ObjectMap Create(String name, Type objectType, String[] memberNames, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo) { return new ObjectMap(name, objectType, memberNames, objectReader, objectId, assemblyInfo); }
private void ReadObjectWithMapTyped(BinaryObjectWithMapTyped record) { BinaryAssemblyInfo assemblyInfo = null; ObjectProgress op = GetOp(); ParseRecord pr = op.pr; stack.Push(op); if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId) { if (record.assemId < 1) { throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyId"), record.name)); } assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId]; if (assemblyInfo == null) { throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_AssemblyId"), record.assemId + " " + record.name)); } SerTrace.Log(this, "ReadObjectWithMapTyped lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString); } else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTyped) { assemblyInfo = SystemAssemblyInfo; // Urt assembly } ObjectMap objectMap = ObjectMap.Create(record.name, record.memberNames, record.binaryTypeEnumA, record.typeInformationA, record.memberAssemIds, objectReader, record.objectId, assemblyInfo, AssemIdToAssemblyTable); ObjectMapIdTable[record.objectId] = objectMap; op.objectTypeEnum = InternalObjectTypeE.Object; op.binaryTypeEnumA = objectMap.binaryTypeEnumA; op.typeInformationA = objectMap.typeInformationA; op.memberLength = op.binaryTypeEnumA.Length; op.memberNames = objectMap.memberNames; op.memberTypes = objectMap.memberTypes; ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek(); if ((objectOp == null) || (objectOp.isInitial)) { // Non-Nested Object op.name = record.name; pr.PRparseTypeEnum = InternalParseTypeE.Object; op.memberValueEnum = InternalMemberValueE.Empty; } else { // Nested Object pr.PRparseTypeEnum = InternalParseTypeE.Member; pr.PRmemberValueEnum = InternalMemberValueE.Nested; op.memberValueEnum = InternalMemberValueE.Nested; switch (objectOp.objectTypeEnum) { case InternalObjectTypeE.Object: pr.PRname = objectOp.name; pr.PRmemberTypeEnum = InternalMemberTypeE.Field; op.memberTypeEnum = InternalMemberTypeE.Field; break; case InternalObjectTypeE.Array: pr.PRmemberTypeEnum = InternalMemberTypeE.Item; op.memberTypeEnum = InternalMemberTypeE.Item; break; default: throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString())); } } pr.PRobjectTypeEnum = InternalObjectTypeE.Object; pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData); pr.PRobjectId = objectReader.GetId((long)record.objectId); if (pr.PRobjectId == topId) { pr.PRobjectPositionEnum = InternalObjectPositionE.Top; } pr.PRkeyDt = record.name; pr.PRdtType = objectMap.objectType; pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid; objectReader.Parse(pr); }