Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / clr / src / BCL / System / Runtime / Serialization / Formatters / Binary / BinaryParser.cs / 1 / BinaryParser.cs
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
/*============================================================
**
** Class: BinaryParser
**
**
** Purpose: Parses Binary Stream
**
**
===========================================================*/
namespace System.Runtime.Serialization.Formatters.Binary {
using System;
using System.IO;
using System.Collections;
using System.Reflection;
using System.Globalization;
using System.Runtime.Serialization.Formatters;
using System.Threading;
using System.Runtime.Remoting;
using System.Runtime.Serialization;
using System.Text;
internal sealed class __BinaryParser
{
internal ObjectReader objectReader;
internal Stream input;
internal long topId;
internal long headerId;
internal SizedArray objectMapIdTable;
internal SizedArray assemIdToAssemblyTable; // Used to hold assembly information
internal SerStack stack = new SerStack("ObjectProgressStack");
internal BinaryTypeEnum expectedType = BinaryTypeEnum.ObjectUrt;
internal Object expectedTypeInformation;
internal ParseRecord PRS;
private BinaryAssemblyInfo systemAssemblyInfo;
private BinaryReader dataReader;
private static Encoding encoding = new UTF8Encoding(false, true);
private SerStack opPool;
internal __BinaryParser(Stream stream, ObjectReader objectReader)
{
input = stream;
this.objectReader = objectReader;
dataReader = new BinaryReader(input, encoding);
}
internal BinaryAssemblyInfo SystemAssemblyInfo
{
get {
if (systemAssemblyInfo == null)
systemAssemblyInfo = new BinaryAssemblyInfo(Converter.urtAssemblyString, Converter.urtAssembly);
return systemAssemblyInfo;
}
}
internal SizedArray ObjectMapIdTable
{
get {
if (objectMapIdTable == null)
objectMapIdTable = new SizedArray();
return objectMapIdTable;
}
}
internal SizedArray AssemIdToAssemblyTable
{
get {
if (assemIdToAssemblyTable == null)
{
assemIdToAssemblyTable = new SizedArray(2);
}
return assemIdToAssemblyTable;
}
}
internal ParseRecord prs
{
get{
if (PRS == null)
PRS = new ParseRecord();
return PRS;
}
}
/*
* Parse the input
* Reads each record from the input stream. If the record is a primitive type (A number)
* then it doesn't have a BinaryHeaderEnum byte. For this case the expected type
* has been previously set to Primitive
* @internalonly
*/
internal void Run()
{
try
{
bool isLoop = true;
ReadBegin();
ReadSerializationHeaderRecord();
while (isLoop)
{
SerTrace.Log( this, "Run loop ",((Enum)expectedType).ToString());
BinaryHeaderEnum binaryHeaderEnum = BinaryHeaderEnum.Object;
switch (expectedType)
{
case BinaryTypeEnum.ObjectUrt:
case BinaryTypeEnum.ObjectUser:
case BinaryTypeEnum.String:
case BinaryTypeEnum.Object:
case BinaryTypeEnum.ObjectArray:
case BinaryTypeEnum.StringArray:
case BinaryTypeEnum.PrimitiveArray:
Byte inByte = dataReader.ReadByte();
binaryHeaderEnum = (BinaryHeaderEnum)inByte;
//Console.WriteLine("Beginning of loop "+((Enum)binaryHeaderEnum).ToString());
switch (binaryHeaderEnum)
{
case BinaryHeaderEnum.Assembly:
case BinaryHeaderEnum.CrossAppDomainAssembly:
ReadAssembly(binaryHeaderEnum);
break;
case BinaryHeaderEnum.Object:
ReadObject();
break;
case BinaryHeaderEnum.CrossAppDomainMap:
ReadCrossAppDomainMap();
break;
case BinaryHeaderEnum.ObjectWithMap:
case BinaryHeaderEnum.ObjectWithMapAssemId:
ReadObjectWithMap(binaryHeaderEnum);
break;
case BinaryHeaderEnum.ObjectWithMapTyped:
case BinaryHeaderEnum.ObjectWithMapTypedAssemId:
ReadObjectWithMapTyped(binaryHeaderEnum);
break;
case BinaryHeaderEnum.MethodCall:
case BinaryHeaderEnum.MethodReturn:
ReadMethodObject(binaryHeaderEnum);
break;
case BinaryHeaderEnum.ObjectString:
case BinaryHeaderEnum.CrossAppDomainString:
ReadObjectString(binaryHeaderEnum);
break;
case BinaryHeaderEnum.Array:
case BinaryHeaderEnum.ArraySinglePrimitive:
case BinaryHeaderEnum.ArraySingleObject:
case BinaryHeaderEnum.ArraySingleString:
ReadArray(binaryHeaderEnum);
break;
case BinaryHeaderEnum.MemberPrimitiveTyped:
ReadMemberPrimitiveTyped();
break;
case BinaryHeaderEnum.MemberReference:
ReadMemberReference();
break;
case BinaryHeaderEnum.ObjectNull:
case BinaryHeaderEnum.ObjectNullMultiple256:
case BinaryHeaderEnum.ObjectNullMultiple:
ReadObjectNull(binaryHeaderEnum);
break;
case BinaryHeaderEnum.MessageEnd:
isLoop = false;
ReadMessageEnd();
ReadEnd();
break;
default:
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_BinaryHeader"),inByte));
}
break;
case BinaryTypeEnum.Primitive:
ReadMemberPrimitiveUnTyped();
break;
default:
throw new SerializationException(Environment.GetResourceString("Serialization_TypeExpected"));
}
// If an assembly is encountered, don't advance
// object Progress,
if (binaryHeaderEnum != BinaryHeaderEnum.Assembly)
{
// End of parse loop.
bool isData = false;
// Set up loop for next iteration.
// If this is an object, and the end of object has been reached, then parse object end.
while (!isData)
{
ObjectProgress op = (ObjectProgress)stack.Peek();
if (op == null)
{
// No more object on stack, then the next record is a top level object
SerTrace.Log( this, "Run loop op null, top level object");
expectedType = BinaryTypeEnum.ObjectUrt;
expectedTypeInformation = null;
isData = true;
}
else
{
SerTrace.Log( this, "Run loop op not null, continue object");
// Find out what record is expected next
isData = op.GetNext(out op.expectedType, out op.expectedTypeInformation);
expectedType = op.expectedType;
expectedTypeInformation = op.expectedTypeInformation;
SerTrace.Log( this, "Run loop opName ",op.name,", expectedType ",((Enum)expectedType).ToString()," expectedTypeInformation, ",expectedTypeInformation);
SerTrace.Log( this, "Run ",isData);
if (!isData)
{
// No record is expected next, this is the end of an object or array
SerTrace.Log( this, "Run End of Object ");
stack.Dump();
prs.Init();
if (op.memberValueEnum == InternalMemberValueE.Nested)
{
// Nested object
prs.PRparseTypeEnum = InternalParseTypeE.MemberEnd;
prs.PRmemberTypeEnum = op.memberTypeEnum;
prs.PRmemberValueEnum = op.memberValueEnum;
objectReader.Parse(prs);
}
else
{
// Top level object
prs.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
prs.PRmemberTypeEnum = op.memberTypeEnum;
prs.PRmemberValueEnum = op.memberValueEnum;
objectReader.Parse(prs);
}
stack.Pop();
PutOp(op);
}
}
}
}
}
}
catch (EndOfStreamException)
{
// EOF should never be thrown since there is a MessageEnd record to stop parsing
BCLDebug.Trace("BINARY", "\n*****EOF*************************\n");
throw new SerializationException(Environment.GetResourceString("Serialization_StreamEnd"));
}
}
internal void ReadBegin()
{
BCLDebug.Trace("BINARY", "\n%%%%%BinaryReaderBegin%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
}
internal void ReadEnd()
{
BCLDebug.Trace("BINARY","\n%%%%%BinaryReaderEnd%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
}
/*
* Primitive Reads from Stream
* @internalonly
*/
internal bool ReadBoolean()
{
return dataReader.ReadBoolean();
}
internal Byte ReadByte()
{
return dataReader.ReadByte();
}
internal Byte[] ReadBytes(int length)
{
return dataReader.ReadBytes(length);
}
// Note: this method does a blocking read!
internal void ReadBytes(byte[] byteA, int offset, int size)
{
while (size > 0)
{
int n = dataReader.Read(byteA, offset, size);
if (n == 0)
__Error.EndOfFile();
offset += n;
size -= n;
}
}
internal Char ReadChar()
{
return dataReader.ReadChar();
}
internal Char[] ReadChars(int length)
{
return dataReader.ReadChars(length);
}
internal Decimal ReadDecimal()
{
return Decimal.Parse(dataReader.ReadString(), CultureInfo.InvariantCulture);
}
internal Single ReadSingle()
{
return dataReader.ReadSingle();
}
internal Double ReadDouble()
{
return dataReader.ReadDouble();
}
internal Int16 ReadInt16()
{
return dataReader.ReadInt16();
}
internal Int32 ReadInt32()
{
return dataReader.ReadInt32();
}
internal Int64 ReadInt64()
{
return dataReader.ReadInt64();
}
internal SByte ReadSByte()
{
return(SByte)ReadByte();
}
internal String ReadString()
{
return dataReader.ReadString();
}
internal TimeSpan ReadTimeSpan()
{
return new TimeSpan(ReadInt64());
}
internal DateTime ReadDateTime()
{
return DateTime.FromBinaryRaw(ReadInt64());
}
internal UInt16 ReadUInt16()
{
return dataReader.ReadUInt16();
}
internal UInt32 ReadUInt32()
{
return dataReader.ReadUInt32();
}
internal UInt64 ReadUInt64()
{
return dataReader.ReadUInt64();
}
// Binary Stream Record Reads
internal void ReadSerializationHeaderRecord()
{
SerTrace.Log( this, "ReadSerializationHeaderRecord");
SerializationHeaderRecord record = new SerializationHeaderRecord();
record.Read(this);
record.Dump();
this.topId = (record.topId > 0 ? objectReader.GetId(record.topId) : record.topId);
this.headerId = (record.headerId > 0 ? objectReader.GetId(record.headerId) : record.headerId);
}
internal void ReadAssembly(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadAssembly");
BinaryAssembly record = new BinaryAssembly();
if (binaryHeaderEnum == BinaryHeaderEnum.CrossAppDomainAssembly)
{
BinaryCrossAppDomainAssembly crossAppDomainAssembly = new BinaryCrossAppDomainAssembly();
crossAppDomainAssembly.Read(this);
crossAppDomainAssembly.Dump();
record.assemId = crossAppDomainAssembly.assemId;
record.assemblyString = objectReader.CrossAppDomainArray(crossAppDomainAssembly.assemblyIndex) as String;
if (record.assemblyString == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"),"String", crossAppDomainAssembly.assemblyIndex));
}
else
{
record.Read(this);
record.Dump();
}
AssemIdToAssemblyTable[record.assemId] = new BinaryAssemblyInfo(record.assemblyString);
}
internal void ReadMethodObject(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadMethodObject");
if (binaryHeaderEnum == BinaryHeaderEnum.MethodCall)
{
BinaryMethodCall record = new BinaryMethodCall();
record.Read(this);
record.Dump();
objectReader.SetMethodCall(record);
}
else
{
BinaryMethodReturn record = new BinaryMethodReturn();
record.Read(this);
record.Dump();
objectReader.SetMethodReturn(record);
}
}
private BinaryObject binaryObject;
private void ReadObject()
{
SerTrace.Log( this, "ReadObject");
if (binaryObject == null)
binaryObject = new BinaryObject();
binaryObject.Read(this);
binaryObject.Dump();
ObjectMap objectMap = (ObjectMap)ObjectMapIdTable[binaryObject.mapId];
if (objectMap == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Map"),binaryObject.mapId));
ObjectProgress op = GetOp();
ParseRecord pr = op.pr;
stack.Push(op);
op.objectTypeEnum = InternalObjectTypeE.Object;
op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
op.memberNames = objectMap.memberNames;
op.memberTypes = objectMap.memberTypes;
op.typeInformationA = objectMap.typeInformationA;
op.memberLength = op.binaryTypeEnumA.Length;
ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek();
if ((objectOp == null) || (objectOp.isInitial))
{
// Non-Nested Object
SerTrace.Log( this, "ReadObject non-nested ");
op.name = objectMap.objectName;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
SerTrace.Log( this, "ReadObject nested ");
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(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Map"),((Enum)objectOp.objectTypeEnum).ToString()));
}
}
pr.PRobjectId = objectReader.GetId((long)binaryObject.objectId);
SerTrace.Log( this, "ReadObject binaryObject.objectId ",pr.PRobjectId);
pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
if (pr.PRobjectId == topId)
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRkeyDt = objectMap.objectName;
pr.PRdtType = objectMap.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
objectReader.Parse(pr);
}
internal void ReadCrossAppDomainMap()
{
SerTrace.Log( this, "ReadObjectWithCrossAppDomainMap");
BinaryCrossAppDomainMap record = new BinaryCrossAppDomainMap();
record.Read(this);
record.Dump();
Object mapObject = objectReader.CrossAppDomainArray(record.crossAppDomainArrayIndex);
BinaryObjectWithMap binaryObjectWithMap = mapObject as BinaryObjectWithMap;
if (binaryObjectWithMap != null)
{
binaryObjectWithMap.Dump();
ReadObjectWithMap(binaryObjectWithMap);
}
else
{
BinaryObjectWithMapTyped binaryObjectWithMapTyped = mapObject as BinaryObjectWithMapTyped;
if (binaryObjectWithMapTyped != null)
{
#if _DEBUG
binaryObjectWithMapTyped.Dump();
#endif
ReadObjectWithMapTyped(binaryObjectWithMapTyped);
}
else
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"),"BinaryObjectMap", mapObject));
}
}
private BinaryObjectWithMap bowm;
internal void ReadObjectWithMap(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadObjectWithMap");
if (bowm == null)
bowm = new BinaryObjectWithMap(binaryHeaderEnum);
else
bowm.binaryHeaderEnum = binaryHeaderEnum;
bowm.Read(this);
bowm.Dump();
ReadObjectWithMap(bowm);
}
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(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Assembly"),record.name));
assemblyInfo = ((BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId]);
if (assemblyInfo == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, 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(CultureInfo.CurrentCulture, 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);
}
private BinaryObjectWithMapTyped bowmt;
internal void ReadObjectWithMapTyped(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadObjectWithMapTyped");
if (bowmt == null)
bowmt = new BinaryObjectWithMapTyped(binaryHeaderEnum);
else
bowmt.binaryHeaderEnum = binaryHeaderEnum;
bowmt.Read(this);
#if _DEBUG
bowmt.Dump();
#endif
ReadObjectWithMapTyped(bowmt);
}
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(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_AssemblyId"),record.name));
assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
if (assemblyInfo == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, 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(CultureInfo.CurrentCulture, 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);
}
internal BinaryObjectString objectString;
internal BinaryCrossAppDomainString crossAppDomainString;
private void ReadObjectString(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadObjectString");
if (objectString == null)
objectString = new BinaryObjectString();
if (binaryHeaderEnum == BinaryHeaderEnum.ObjectString)
{
objectString.Read(this);
objectString.Dump();
}
else
{
if (crossAppDomainString == null)
crossAppDomainString = new BinaryCrossAppDomainString();
crossAppDomainString.Read(this);
crossAppDomainString.Dump();
objectString.value = objectReader.CrossAppDomainArray(crossAppDomainString.value) as String;
if (objectString.value == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"),"String", crossAppDomainString.value));
objectString.objectId = crossAppDomainString.objectId;
}
prs.Init();
prs.PRparseTypeEnum = InternalParseTypeE.Object;
prs.PRobjectId = objectReader.GetId(objectString.objectId);
if (prs.PRobjectId == topId)
prs.PRobjectPositionEnum = InternalObjectPositionE.Top;
prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
prs.PRvalue = objectString.value;
prs.PRkeyDt = "System.String";
prs.PRdtType = Converter.typeofString;
prs.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
prs.PRvarValue = objectString.value; //Need to set it because ObjectReader is picking up value from variant, not pr.PRvalue
if (objectOp == null)
{
// Top level String
SerTrace.Log( this, "ReadObjectString, Non-Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Object;
prs.PRname = "System.String";
}
else
{
// Nested in an Object
SerTrace.Log( this, "ReadObjectString, Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
prs.PRname = objectOp.name;
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"),((Enum)objectOp.objectTypeEnum).ToString()));
}
}
objectReader.Parse(prs);
}
internal MemberPrimitiveTyped memberPrimitiveTyped;
private void ReadMemberPrimitiveTyped()
{
SerTrace.Log( this, "ReadObjectPrimitive");
if (memberPrimitiveTyped == null)
memberPrimitiveTyped = new MemberPrimitiveTyped();
memberPrimitiveTyped.Read(this);
memberPrimitiveTyped.Dump();
prs.PRobjectTypeEnum = InternalObjectTypeE.Object; //Get rid of
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
prs.Init();
prs.PRvarValue = memberPrimitiveTyped.value;
prs.PRkeyDt = Converter.ToComType(memberPrimitiveTyped.primitiveTypeEnum);
prs.PRdtType = Converter.ToType(memberPrimitiveTyped.primitiveTypeEnum);
prs.PRdtTypeCode = memberPrimitiveTyped.primitiveTypeEnum;
if (objectOp == null)
{
// Top level boxed primitive
SerTrace.Log( this, "ReadObjectPrimitive, Non-Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Object;
prs.PRname = "System.Variant";
}
else
{
// Nested in an Object
SerTrace.Log( this, "ReadObjectPrimitive, Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
prs.PRname = objectOp.name;
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"),((Enum)objectOp.objectTypeEnum).ToString()));
}
}
objectReader.Parse(prs);
}
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
{
BinaryAssemblyInfo assemblyInfo = null;
SerTrace.Log( this, "ReadArray ");
BinaryArray record = new BinaryArray(binaryHeaderEnum);
record.Read(this);
#if _DEBUG
record.Dump();
SerTrace.Log( this, "Read 1 ",((Enum)binaryHeaderEnum).ToString());
#endif
if (record.binaryTypeEnum == BinaryTypeEnum.ObjectUser)
{
if (record.assemId < 1)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, 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(CultureInfo.CurrentCulture, 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 0)
{
int n = dataReader.Read(byteA, offset, size);
if (n == 0)
__Error.EndOfFile();
offset += n;
size -= n;
}
}
internal Char ReadChar()
{
return dataReader.ReadChar();
}
internal Char[] ReadChars(int length)
{
return dataReader.ReadChars(length);
}
internal Decimal ReadDecimal()
{
return Decimal.Parse(dataReader.ReadString(), CultureInfo.InvariantCulture);
}
internal Single ReadSingle()
{
return dataReader.ReadSingle();
}
internal Double ReadDouble()
{
return dataReader.ReadDouble();
}
internal Int16 ReadInt16()
{
return dataReader.ReadInt16();
}
internal Int32 ReadInt32()
{
return dataReader.ReadInt32();
}
internal Int64 ReadInt64()
{
return dataReader.ReadInt64();
}
internal SByte ReadSByte()
{
return(SByte)ReadByte();
}
internal String ReadString()
{
return dataReader.ReadString();
}
internal TimeSpan ReadTimeSpan()
{
return new TimeSpan(ReadInt64());
}
internal DateTime ReadDateTime()
{
return DateTime.FromBinaryRaw(ReadInt64());
}
internal UInt16 ReadUInt16()
{
return dataReader.ReadUInt16();
}
internal UInt32 ReadUInt32()
{
return dataReader.ReadUInt32();
}
internal UInt64 ReadUInt64()
{
return dataReader.ReadUInt64();
}
// Binary Stream Record Reads
internal void ReadSerializationHeaderRecord()
{
SerTrace.Log( this, "ReadSerializationHeaderRecord");
SerializationHeaderRecord record = new SerializationHeaderRecord();
record.Read(this);
record.Dump();
this.topId = (record.topId > 0 ? objectReader.GetId(record.topId) : record.topId);
this.headerId = (record.headerId > 0 ? objectReader.GetId(record.headerId) : record.headerId);
}
internal void ReadAssembly(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadAssembly");
BinaryAssembly record = new BinaryAssembly();
if (binaryHeaderEnum == BinaryHeaderEnum.CrossAppDomainAssembly)
{
BinaryCrossAppDomainAssembly crossAppDomainAssembly = new BinaryCrossAppDomainAssembly();
crossAppDomainAssembly.Read(this);
crossAppDomainAssembly.Dump();
record.assemId = crossAppDomainAssembly.assemId;
record.assemblyString = objectReader.CrossAppDomainArray(crossAppDomainAssembly.assemblyIndex) as String;
if (record.assemblyString == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"),"String", crossAppDomainAssembly.assemblyIndex));
}
else
{
record.Read(this);
record.Dump();
}
AssemIdToAssemblyTable[record.assemId] = new BinaryAssemblyInfo(record.assemblyString);
}
internal void ReadMethodObject(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadMethodObject");
if (binaryHeaderEnum == BinaryHeaderEnum.MethodCall)
{
BinaryMethodCall record = new BinaryMethodCall();
record.Read(this);
record.Dump();
objectReader.SetMethodCall(record);
}
else
{
BinaryMethodReturn record = new BinaryMethodReturn();
record.Read(this);
record.Dump();
objectReader.SetMethodReturn(record);
}
}
private BinaryObject binaryObject;
private void ReadObject()
{
SerTrace.Log( this, "ReadObject");
if (binaryObject == null)
binaryObject = new BinaryObject();
binaryObject.Read(this);
binaryObject.Dump();
ObjectMap objectMap = (ObjectMap)ObjectMapIdTable[binaryObject.mapId];
if (objectMap == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Map"),binaryObject.mapId));
ObjectProgress op = GetOp();
ParseRecord pr = op.pr;
stack.Push(op);
op.objectTypeEnum = InternalObjectTypeE.Object;
op.binaryTypeEnumA = objectMap.binaryTypeEnumA;
op.memberNames = objectMap.memberNames;
op.memberTypes = objectMap.memberTypes;
op.typeInformationA = objectMap.typeInformationA;
op.memberLength = op.binaryTypeEnumA.Length;
ObjectProgress objectOp = (ObjectProgress)stack.PeekPeek();
if ((objectOp == null) || (objectOp.isInitial))
{
// Non-Nested Object
SerTrace.Log( this, "ReadObject non-nested ");
op.name = objectMap.objectName;
pr.PRparseTypeEnum = InternalParseTypeE.Object;
op.memberValueEnum = InternalMemberValueE.Empty;
}
else
{
// Nested Object
SerTrace.Log( this, "ReadObject nested ");
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(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Map"),((Enum)objectOp.objectTypeEnum).ToString()));
}
}
pr.PRobjectId = objectReader.GetId((long)binaryObject.objectId);
SerTrace.Log( this, "ReadObject binaryObject.objectId ",pr.PRobjectId);
pr.PRobjectInfo = objectMap.CreateObjectInfo(ref pr.PRsi, ref pr.PRmemberData);
if (pr.PRobjectId == topId)
pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
pr.PRkeyDt = objectMap.objectName;
pr.PRdtType = objectMap.objectType;
pr.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
objectReader.Parse(pr);
}
internal void ReadCrossAppDomainMap()
{
SerTrace.Log( this, "ReadObjectWithCrossAppDomainMap");
BinaryCrossAppDomainMap record = new BinaryCrossAppDomainMap();
record.Read(this);
record.Dump();
Object mapObject = objectReader.CrossAppDomainArray(record.crossAppDomainArrayIndex);
BinaryObjectWithMap binaryObjectWithMap = mapObject as BinaryObjectWithMap;
if (binaryObjectWithMap != null)
{
binaryObjectWithMap.Dump();
ReadObjectWithMap(binaryObjectWithMap);
}
else
{
BinaryObjectWithMapTyped binaryObjectWithMapTyped = mapObject as BinaryObjectWithMapTyped;
if (binaryObjectWithMapTyped != null)
{
#if _DEBUG
binaryObjectWithMapTyped.Dump();
#endif
ReadObjectWithMapTyped(binaryObjectWithMapTyped);
}
else
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"),"BinaryObjectMap", mapObject));
}
}
private BinaryObjectWithMap bowm;
internal void ReadObjectWithMap(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadObjectWithMap");
if (bowm == null)
bowm = new BinaryObjectWithMap(binaryHeaderEnum);
else
bowm.binaryHeaderEnum = binaryHeaderEnum;
bowm.Read(this);
bowm.Dump();
ReadObjectWithMap(bowm);
}
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(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Assembly"),record.name));
assemblyInfo = ((BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId]);
if (assemblyInfo == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, 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(CultureInfo.CurrentCulture, 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);
}
private BinaryObjectWithMapTyped bowmt;
internal void ReadObjectWithMapTyped(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadObjectWithMapTyped");
if (bowmt == null)
bowmt = new BinaryObjectWithMapTyped(binaryHeaderEnum);
else
bowmt.binaryHeaderEnum = binaryHeaderEnum;
bowmt.Read(this);
#if _DEBUG
bowmt.Dump();
#endif
ReadObjectWithMapTyped(bowmt);
}
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(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_AssemblyId"),record.name));
assemblyInfo = (BinaryAssemblyInfo)AssemIdToAssemblyTable[record.assemId];
if (assemblyInfo == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, 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(CultureInfo.CurrentCulture, 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);
}
internal BinaryObjectString objectString;
internal BinaryCrossAppDomainString crossAppDomainString;
private void ReadObjectString(BinaryHeaderEnum binaryHeaderEnum)
{
SerTrace.Log( this, "ReadObjectString");
if (objectString == null)
objectString = new BinaryObjectString();
if (binaryHeaderEnum == BinaryHeaderEnum.ObjectString)
{
objectString.Read(this);
objectString.Dump();
}
else
{
if (crossAppDomainString == null)
crossAppDomainString = new BinaryCrossAppDomainString();
crossAppDomainString.Read(this);
crossAppDomainString.Dump();
objectString.value = objectReader.CrossAppDomainArray(crossAppDomainString.value) as String;
if (objectString.value == null)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_CrossAppDomainError"),"String", crossAppDomainString.value));
objectString.objectId = crossAppDomainString.objectId;
}
prs.Init();
prs.PRparseTypeEnum = InternalParseTypeE.Object;
prs.PRobjectId = objectReader.GetId(objectString.objectId);
if (prs.PRobjectId == topId)
prs.PRobjectPositionEnum = InternalObjectPositionE.Top;
prs.PRobjectTypeEnum = InternalObjectTypeE.Object;
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
prs.PRvalue = objectString.value;
prs.PRkeyDt = "System.String";
prs.PRdtType = Converter.typeofString;
prs.PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
prs.PRvarValue = objectString.value; //Need to set it because ObjectReader is picking up value from variant, not pr.PRvalue
if (objectOp == null)
{
// Top level String
SerTrace.Log( this, "ReadObjectString, Non-Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Object;
prs.PRname = "System.String";
}
else
{
// Nested in an Object
SerTrace.Log( this, "ReadObjectString, Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
prs.PRname = objectOp.name;
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"),((Enum)objectOp.objectTypeEnum).ToString()));
}
}
objectReader.Parse(prs);
}
internal MemberPrimitiveTyped memberPrimitiveTyped;
private void ReadMemberPrimitiveTyped()
{
SerTrace.Log( this, "ReadObjectPrimitive");
if (memberPrimitiveTyped == null)
memberPrimitiveTyped = new MemberPrimitiveTyped();
memberPrimitiveTyped.Read(this);
memberPrimitiveTyped.Dump();
prs.PRobjectTypeEnum = InternalObjectTypeE.Object; //Get rid of
ObjectProgress objectOp = (ObjectProgress)stack.Peek();
prs.Init();
prs.PRvarValue = memberPrimitiveTyped.value;
prs.PRkeyDt = Converter.ToComType(memberPrimitiveTyped.primitiveTypeEnum);
prs.PRdtType = Converter.ToType(memberPrimitiveTyped.primitiveTypeEnum);
prs.PRdtTypeCode = memberPrimitiveTyped.primitiveTypeEnum;
if (objectOp == null)
{
// Top level boxed primitive
SerTrace.Log( this, "ReadObjectPrimitive, Non-Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Object;
prs.PRname = "System.Variant";
}
else
{
// Nested in an Object
SerTrace.Log( this, "ReadObjectPrimitive, Nested");
prs.PRparseTypeEnum = InternalParseTypeE.Member;
prs.PRmemberValueEnum = InternalMemberValueE.InlineValue;
switch (objectOp.objectTypeEnum)
{
case InternalObjectTypeE.Object:
prs.PRname = objectOp.name;
prs.PRmemberTypeEnum = InternalMemberTypeE.Field;
break;
case InternalObjectTypeE.Array:
prs.PRmemberTypeEnum = InternalMemberTypeE.Item;
break;
default:
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_ObjectTypeEnum"),((Enum)objectOp.objectTypeEnum).ToString()));
}
}
objectReader.Parse(prs);
}
private void ReadArray(BinaryHeaderEnum binaryHeaderEnum)
{
BinaryAssemblyInfo assemblyInfo = null;
SerTrace.Log( this, "ReadArray ");
BinaryArray record = new BinaryArray(binaryHeaderEnum);
record.Read(this);
#if _DEBUG
record.Dump();
SerTrace.Log( this, "Read 1 ",((Enum)binaryHeaderEnum).ToString());
#endif
if (record.binaryTypeEnum == BinaryTypeEnum.ObjectUser)
{
if (record.assemId < 1)
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, 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(CultureInfo.CurrentCulture, 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
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ReflectionPermission.cs
- TabOrder.cs
- SpanIndex.cs
- Win32NamedPipes.cs
- InternalEnumValidatorAttribute.cs
- RegexCode.cs
- DetailsViewRowCollection.cs
- SeparatorAutomationPeer.cs
- InfoCardUIAgent.cs
- PenContext.cs
- XmlSchemaSimpleTypeList.cs
- ScrollChangedEventArgs.cs
- FormViewInsertedEventArgs.cs
- HostingEnvironmentException.cs
- DrawingGroup.cs
- WebSysDisplayNameAttribute.cs
- TraceSection.cs
- Script.cs
- ProtocolsConfigurationHandler.cs
- HtmlInputReset.cs
- FindCriteriaCD1.cs
- oledbmetadatacollectionnames.cs
- HtmlTableCellCollection.cs
- XPathQilFactory.cs
- RulePatternOps.cs
- PolyLineSegment.cs
- StandardToolWindows.cs
- LogReservationCollection.cs
- MessageHeaders.cs
- PrintPreviewGraphics.cs
- XmlSchemaSequence.cs
- WebPartEditorApplyVerb.cs
- CellPartitioner.cs
- ThumbButtonInfo.cs
- Int32CAMarshaler.cs
- RegexGroupCollection.cs
- WizardPanel.cs
- TypeListConverter.cs
- GeneratedContractType.cs
- HtmlUtf8RawTextWriter.cs
- SimpleType.cs
- EnvironmentPermission.cs
- Compensate.cs
- FrugalList.cs
- NamespaceEmitter.cs
- ToolStripRenderer.cs
- ConnectionStringEditor.cs
- StretchValidation.cs
- KerberosTokenFactoryCredential.cs
- PlatformNotSupportedException.cs
- DependencyObjectProvider.cs
- Literal.cs
- IdentifierCollection.cs
- TextFindEngine.cs
- PartitionResolver.cs
- PropertyDescriptorCollection.cs
- GiveFeedbackEvent.cs
- DynamicMethod.cs
- ContextMenuStrip.cs
- _StreamFramer.cs
- Image.cs
- ProxyFragment.cs
- ColorContextHelper.cs
- ObjectHandle.cs
- WhileDesigner.xaml.cs
- SecurityUtils.cs
- UpdateTranslator.cs
- Internal.cs
- WhitespaceRule.cs
- ObjectParameter.cs
- ConfigUtil.cs
- QuaternionValueSerializer.cs
- FocusTracker.cs
- RuntimeResourceSet.cs
- FaultDesigner.cs
- DataGridViewSelectedRowCollection.cs
- InkCanvas.cs
- CallbackHandler.cs
- NavigationWindow.cs
- ControlEvent.cs
- HandledMouseEvent.cs
- QueueNameHelper.cs
- FakeModelPropertyImpl.cs
- SQLMoneyStorage.cs
- LocalFileSettingsProvider.cs
- ConfigUtil.cs
- TypeNameParser.cs
- Enumerable.cs
- StringStorage.cs
- PropertyChangedEventManager.cs
- GridViewEditEventArgs.cs
- TraceListeners.cs
- ToolStripDropDownClosingEventArgs.cs
- SamlSecurityToken.cs
- Transform3D.cs
- InstanceCreationEditor.cs
- SqlUtil.cs
- DynamicRendererThreadManager.cs
- WebPartMinimizeVerb.cs
- BevelBitmapEffect.cs