|
private GetType ( |
||
| assemblyInfo | ||
| name | string | |
| return | ||
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, 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 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)
{
typeString = typeInformation.ToString();
type = objectReader.GetType(assemblyInfo, typeString);
if (type == Converter.typeofObject)
{
isVariant = true;
return;
}
}
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()
}));
}
}
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 void ReadObjectWithMap(BinaryObjectWithMap record)
{
BinaryAssemblyInfo assemblyInfo = null;
ObjectProgress op = GetOp();
ParseRecord pr = op._pr;
_stack.Push(op);
if (record._binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId)
{
if (record._assemId < 1)
{
throw new SerializationException(SR.Format(SR.Serialization_Assembly, record._name));
}
assemblyInfo = ((BinaryAssemblyInfo)AssemIdToAssemblyTable[record._assemId]);
if (assemblyInfo == null)
{
throw new SerializationException(SR.Format(SR.Serialization_Assembly, record._assemId + " " + record._name));
}
}
else if (record._binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMap)
{
assemblyInfo = SystemAssemblyInfo; //Urt assembly
}
Type objectType = _objectReader.GetType(assemblyInfo, record._name);
ObjectMap objectMap = ObjectMap.Create(record._name, objectType, record._memberNames, _objectReader, record._objectId, assemblyInfo);
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.Field;
break;
default:
throw new SerializationException(SR.Format(SR.Serialization_ObjectTypeEnum, objectOp._objectTypeEnum.ToString()));
}
}
pr._objectTypeEnum = InternalObjectTypeE.Object;
pr._objectId = _objectReader.GetId(record._objectId);
pr._objectInfo = objectMap.CreateObjectInfo(ref pr._si, ref pr._memberData);
if (pr._objectId == _topId)
{
pr._objectPositionEnum = InternalObjectPositionE.Top;
}
pr._keyDt = record._name;
pr._dtType = objectMap._objectType;
pr._dtTypeCode = InternalPrimitiveTypeE.Invalid;
_objectReader.Parse(pr);
}
[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 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
}
// 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()));
}
}
// 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 ReadObjectWithMap(BinaryObjectWithMap record)
{
BinaryAssemblyInfo assemblyInfo = null;
ObjectProgress op = GetOp();
ParseRecord pr = op.pr;
stack.Push(op);
if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId)
{
if (record.assemId < 1)
{
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_Assembly"), record.name));
}
assemblyInfo = ((BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId]);
if (assemblyInfo == null)
{
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_Assembly"), record.assemId + " " + record.name));
}
SerTrace.Log(this, "ReadObjectWithMap lookup assemIdToAssembly assemId ", record.assemId, " assembly ", assemblyInfo.assemblyString);
}
else if (record.binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMap)
{
assemblyInfo = SystemAssemblyInfo; //Urt assembly
}
Type objectType = objectReader.GetType(assemblyInfo, record.name);
ObjectMap objectMap = ObjectMap.Create(record.name, objectType, record.memberNames, objectReader, record.objectId, assemblyInfo);
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.Field;
break;
default:
throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_ObjectTypeEnum"), ((Enum)objectOp.objectTypeEnum).ToString()));
}
}
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRobjectId = objectReader.GetId((long)record.objectId);
pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
if (pr.PRobjectId == topId)
{
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
}
pr.PRkeyDt = record.name;
pr.PRdtType = objectMap.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
objectReader.Parse(pr);
}
