| static private IsWriteAsByteArray ( InternalPrimitiveTypeE code ) : bool | ||
| code | InternalPrimitiveTypeE | |
| return | bool | |
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;
Debug.Assert(record._lengthA != null);
switch (record._binaryArrayTypeEnum)
{
case BinaryArrayTypeEnum.Single:
case BinaryArrayTypeEnum.SingleOffset:
op._numItems = record._lengthA[0];
pr._arrayTypeEnum = InternalArrayTypeE.Single;
Debug.Assert(record._lowerBoundA != null);
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);
}
}
// Writes out an array
private void WriteArray(WriteObjectInfo objectInfo, NameInfo?memberNameInfo, WriteObjectInfo?memberObjectInfo)
{
bool isAllocatedMemberNameInfo = false;
if (memberNameInfo == null)
{
memberNameInfo = TypeToNameInfo(objectInfo);
isAllocatedMemberNameInfo = true;
}
memberNameInfo._isArray = true;
long objectId = objectInfo._objectId;
memberNameInfo._objectId = objectInfo._objectId;
// Get array type
Array array = (Array)objectInfo._obj !;
//Type arrayType = array.GetType();
Type arrayType = objectInfo._objectType !;
// Get type of array element
Type arrayElemType = arrayType.GetElementType() !;
WriteObjectInfo?arrayElemObjectInfo = null;
if (!arrayElemType.IsPrimitive)
{
Debug.Assert(_serObjectInfoInit != null && _formatterConverter != null);
arrayElemObjectInfo = WriteObjectInfo.Serialize(arrayElemType, _surrogates, _context, _serObjectInfoInit, _formatterConverter, _binder);
arrayElemObjectInfo._assemId = GetAssemblyId(arrayElemObjectInfo);
}
NameInfo arrayElemTypeNameInfo = arrayElemObjectInfo == null?
TypeToNameInfo(arrayElemType) :
TypeToNameInfo(arrayElemObjectInfo);
arrayElemTypeNameInfo._isArray = arrayElemTypeNameInfo._type !.IsArray;
NameInfo arrayNameInfo = memberNameInfo;
arrayNameInfo._objectId = objectId;
arrayNameInfo._isArray = true;
arrayElemTypeNameInfo._objectId = objectId;
arrayElemTypeNameInfo._transmitTypeOnMember = memberNameInfo._transmitTypeOnMember;
arrayElemTypeNameInfo._transmitTypeOnObject = memberNameInfo._transmitTypeOnObject;
arrayElemTypeNameInfo._isParentTypeOnObject = memberNameInfo._isParentTypeOnObject;
// Get rank and length information
int rank = array.Rank;
int[] lengthA = new int[rank];
int[] lowerBoundA = new int[rank];
int[] upperBoundA = new int[rank];
for (int i = 0; i < rank; i++)
{
lengthA[i] = array.GetLength(i);
lowerBoundA[i] = array.GetLowerBound(i);
upperBoundA[i] = array.GetUpperBound(i);
}
InternalArrayTypeE arrayEnum;
if (arrayElemTypeNameInfo._isArray)
{
arrayEnum = rank == 1 ? InternalArrayTypeE.Jagged : InternalArrayTypeE.Rectangular;
}
else if (rank == 1)
{
arrayEnum = InternalArrayTypeE.Single;
}
else
{
arrayEnum = InternalArrayTypeE.Rectangular;
}
arrayElemTypeNameInfo._arrayEnum = arrayEnum;
Debug.Assert(_serWriter != null);
// Byte array
if ((ReferenceEquals(arrayElemType, Converter.s_typeofByte)) && (rank == 1) && (lowerBoundA[0] == 0))
{
_serWriter.WriteObjectByteArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0], (byte[])array);
return;
}
if (ReferenceEquals(arrayElemType, Converter.s_typeofObject) || Nullable.GetUnderlyingType(arrayElemType) != null)
{
memberNameInfo._transmitTypeOnMember = true;
arrayElemTypeNameInfo._transmitTypeOnMember = true;
}
if (CheckTypeFormat(_formatterEnums._typeFormat, FormatterTypeStyle.TypesAlways))
{
memberNameInfo._transmitTypeOnObject = true;
arrayElemTypeNameInfo._transmitTypeOnObject = true;
}
if (arrayEnum == InternalArrayTypeE.Single)
{
// Single Dimensional array
// BinaryFormatter array of primitive types is written out in the WriteSingleArray statement
// as a byte buffer
_serWriter.WriteSingleArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0], array);
if (!(Converter.IsWriteAsByteArray(arrayElemTypeNameInfo._primitiveTypeEnum) && (lowerBoundA[0] == 0)))
{
object[]? objectA = null;
if (!arrayElemType.IsValueType)
{
// Non-primitive type array
objectA = (object[])array;
}
int upperBound = upperBoundA[0] + 1;
for (int i = lowerBoundA[0]; i < upperBound; i++)
{
if (objectA == null)
{
WriteArrayMember(objectInfo, arrayElemTypeNameInfo, array.GetValue(i));
}
else
{
WriteArrayMember(objectInfo, arrayElemTypeNameInfo, objectA[i]);
}
}
_serWriter.WriteItemEnd();
}
}
else if (arrayEnum == InternalArrayTypeE.Jagged)
{
// Jagged Array
arrayNameInfo._objectId = objectId;
_serWriter.WriteJaggedArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0]);
var objectA = (Array)array;
for (int i = lowerBoundA[0]; i < upperBoundA[0] + 1; i++)
{
WriteArrayMember(objectInfo, arrayElemTypeNameInfo, objectA.GetValue(i));
}
_serWriter.WriteItemEnd();
}
else
{
// Rectangle Array
// Get the length for all the ranks
arrayNameInfo._objectId = objectId;
_serWriter.WriteRectangleArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, rank, lengthA, lowerBoundA);
// Check for a length of zero
bool bzero = false;
for (int i = 0; i < rank; i++)
{
if (lengthA[i] == 0)
{
bzero = true;
break;
}
}
if (!bzero)
{
WriteRectangle(objectInfo, rank, lengthA, array, arrayElemTypeNameInfo, lowerBoundA);
}
_serWriter.WriteItemEnd();
}
_serWriter.WriteObjectEnd(memberNameInfo, arrayNameInfo);
PutNameInfo(arrayElemTypeNameInfo);
if (isAllocatedMemberNameInfo)
{
PutNameInfo(memberNameInfo);
}
}
private void ParseArray(ParseRecord pr)
{
long probjectId = pr.PRobjectId;
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
if (pr.PRvalue.Length > 0)
{
pr.PRnewObj = Convert.FromBase64String(pr.PRvalue);
}
else
{
pr.PRnewObj = new byte[0];
}
if (this.stack.Peek() == pr)
{
this.stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if (pr.PRnewObj != null && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr2 = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr2);
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged || pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
bool flag = true;
if (pr.PRlowerBoundA == null || pr.PRlowerBoundA[0] == 0)
{
if (pr.PRarrayElementType == Converter.typeofString)
{
pr.PRobjectA = new string[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
flag = false;
}
else if (pr.PRarrayElementType == Converter.typeofObject)
{
pr.PRobjectA = new object[pr.PRlengthA[0]];
pr.PRnewObj = pr.PRobjectA;
flag = false;
}
else if (pr.PRarrayElementType != null)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
}
pr.PRisLowerBound = false;
}
else
{
if (pr.PRarrayElementType != null)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
pr.PRisLowerBound = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr.PRisLowerBound && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
pr.PRprimitiveArray = new PrimitiveArray(pr.PRarrayElementTypeCode, (Array)pr.PRnewObj);
}
else if (flag && pr.PRarrayElementType != null && !pr.PRarrayElementType.IsValueType && !pr.PRisLowerBound)
{
pr.PRobjectA = (object[])pr.PRnewObj;
}
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
this.headers = (Header[])pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else
{
if (pr.PRarrayTypeEnum != InternalArrayTypeE.Rectangular)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", new object[]
{
pr.PRarrayTypeEnum
}));
}
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int i = 0; i < pr.PRrank; i++)
{
if (pr.PRlowerBoundA[i] != 0)
{
pr.PRisLowerBound = true;
}
}
}
if (pr.PRarrayElementType != null)
{
if (!pr.PRisLowerBound)
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA);
}
else
{
pr.PRnewObj = Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
}
int num = 1;
for (int j = 0; j < pr.PRrank; j++)
{
num *= pr.PRlengthA[j];
}
pr.PRindexMap = new int[pr.PRrank];
pr.PRrectangularMap = new int[pr.PRrank];
pr.PRlinearlength = num;
}
this.CheckSecurity(pr);
}
private void WriteArray(WriteObjectInfo objectInfo, NameInfo memberNameInfo, WriteObjectInfo memberObjectInfo)
{
InternalArrayTypeE jagged;
bool flag2;
bool flag = false;
if (memberNameInfo == null)
{
memberNameInfo = this.TypeToNameInfo(objectInfo);
flag = true;
}
memberNameInfo.NIisArray = true;
long objectId = objectInfo.objectId;
memberNameInfo.NIobjectId = objectInfo.objectId;
Array array = (Array)objectInfo.obj;
Type elementType = objectInfo.objectType.GetElementType();
WriteObjectInfo info = null;
if (!elementType.IsPrimitive)
{
info = WriteObjectInfo.Serialize(elementType, this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this.m_binder);
info.assemId = this.GetAssemblyId(info);
}
NameInfo arrayElemTypeNameInfo = null;
if (info == null)
{
arrayElemTypeNameInfo = this.TypeToNameInfo(elementType);
}
else
{
arrayElemTypeNameInfo = this.TypeToNameInfo(info);
}
arrayElemTypeNameInfo.NIisArray = arrayElemTypeNameInfo.NItype.IsArray;
NameInfo arrayNameInfo = memberNameInfo;
arrayNameInfo.NIobjectId = objectId;
arrayNameInfo.NIisArray = true;
arrayElemTypeNameInfo.NIobjectId = objectId;
arrayElemTypeNameInfo.NItransmitTypeOnMember = memberNameInfo.NItransmitTypeOnMember;
arrayElemTypeNameInfo.NItransmitTypeOnObject = memberNameInfo.NItransmitTypeOnObject;
arrayElemTypeNameInfo.NIisParentTypeOnObject = memberNameInfo.NIisParentTypeOnObject;
int rank = array.Rank;
int[] lengthA = new int[rank];
int[] lowerBoundA = new int[rank];
int[] numArray3 = new int[rank];
for (int i = 0; i < rank; i++)
{
lengthA[i] = array.GetLength(i);
lowerBoundA[i] = array.GetLowerBound(i);
numArray3[i] = array.GetUpperBound(i);
}
if (arrayElemTypeNameInfo.NIisArray)
{
if (rank == 1)
{
jagged = InternalArrayTypeE.Jagged;
}
else
{
jagged = InternalArrayTypeE.Rectangular;
}
}
else if (rank == 1)
{
jagged = InternalArrayTypeE.Single;
}
else
{
jagged = InternalArrayTypeE.Rectangular;
}
arrayElemTypeNameInfo.NIarrayEnum = jagged;
if ((object.ReferenceEquals(elementType, Converter.typeofByte) && (rank == 1)) && (lowerBoundA[0] == 0))
{
this.serWriter.WriteObjectByteArray(memberNameInfo, arrayNameInfo, info, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0], (byte[])array);
return;
}
if (object.ReferenceEquals(elementType, Converter.typeofObject) || (Nullable.GetUnderlyingType(elementType) != null))
{
memberNameInfo.NItransmitTypeOnMember = true;
arrayElemTypeNameInfo.NItransmitTypeOnMember = true;
}
if (this.CheckTypeFormat(this.formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
memberNameInfo.NItransmitTypeOnObject = true;
arrayElemTypeNameInfo.NItransmitTypeOnObject = true;
}
switch (jagged)
{
case InternalArrayTypeE.Single:
this.serWriter.WriteSingleArray(memberNameInfo, arrayNameInfo, info, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0], array);
if (!Converter.IsWriteAsByteArray(arrayElemTypeNameInfo.NIprimitiveTypeEnum) || (lowerBoundA[0] != 0))
{
object[] objArray = null;
if (!elementType.IsValueType)
{
objArray = (object[])array;
}
int num4 = numArray3[0] + 1;
for (int j = lowerBoundA[0]; j < num4; j++)
{
if (objArray == null)
{
this.WriteArrayMember(objectInfo, arrayElemTypeNameInfo, array.GetValue(j));
}
else
{
this.WriteArrayMember(objectInfo, arrayElemTypeNameInfo, objArray[j]);
}
}
this.serWriter.WriteItemEnd();
}
goto Label_0365;
case InternalArrayTypeE.Jagged:
{
arrayNameInfo.NIobjectId = objectId;
this.serWriter.WriteJaggedArray(memberNameInfo, arrayNameInfo, info, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0]);
object[] objArray2 = (object[])array;
for (int k = lowerBoundA[0]; k < (numArray3[0] + 1); k++)
{
this.WriteArrayMember(objectInfo, arrayElemTypeNameInfo, objArray2[k]);
}
this.serWriter.WriteItemEnd();
goto Label_0365;
}
default:
arrayNameInfo.NIobjectId = objectId;
this.serWriter.WriteRectangleArray(memberNameInfo, arrayNameInfo, info, arrayElemTypeNameInfo, rank, lengthA, lowerBoundA);
flag2 = false;
for (int m = 0; m < rank; m++)
{
if (lengthA[m] == 0)
{
flag2 = true;
break;
}
}
break;
}
if (!flag2)
{
this.WriteRectangle(objectInfo, rank, lengthA, array, arrayElemTypeNameInfo, lowerBoundA);
}
this.serWriter.WriteItemEnd();
Label_0365:
this.serWriter.WriteObjectEnd(memberNameInfo, arrayNameInfo);
this.PutNameInfo(arrayElemTypeNameInfo);
if (flag)
{
this.PutNameInfo(memberNameInfo);
}
}
// Array object encountered in stream
private void ParseArray(ParseRecord pr)
{
Debug.Assert(_stack != null);
if (pr._arrayTypeEnum == InternalArrayTypeE.Base64)
{
Debug.Assert(pr._value != null);
// ByteArray
pr._newObj = pr._value.Length > 0 ?
Convert.FromBase64String(pr._value) :
Array.Empty <byte>();
if (_stack.Peek() == pr)
{
_stack.Pop();
}
if (pr._objectPositionEnum == InternalObjectPositionE.Top)
{
TopObject = pr._newObj;
}
ParseRecord?parentPr = (ParseRecord?)_stack.Peek();
// Base64 can be registered at this point because it is populated
RegisterObject(pr._newObj, pr, parentPr);
}
else if ((pr._newObj != null) && Converter.IsWriteAsByteArray(pr._arrayElementTypeCode))
{
// Primtive typed Array has already been read
if (pr._objectPositionEnum == InternalObjectPositionE.Top)
{
TopObject = pr._newObj;
}
ParseRecord?parentPr = (ParseRecord?)_stack.Peek();
// Primitive typed array can be registered at this point because it is populated
RegisterObject(pr._newObj, pr, parentPr);
}
else if ((pr._arrayTypeEnum == InternalArrayTypeE.Jagged) || (pr._arrayTypeEnum == InternalArrayTypeE.Single))
{
Debug.Assert(pr._lengthA != null);
// Multidimensional jagged array or single array
bool couldBeValueType = true;
if ((pr._lowerBoundA == null) || (pr._lowerBoundA[0] == 0))
{
if (ReferenceEquals(pr._arrayElementType, Converter.s_typeofString))
{
pr._objectA = new string[pr._lengthA[0]];
pr._newObj = pr._objectA;
couldBeValueType = false;
}
else if (ReferenceEquals(pr._arrayElementType, Converter.s_typeofObject))
{
pr._objectA = new object[pr._lengthA[0]];
pr._newObj = pr._objectA;
couldBeValueType = false;
}
else if (pr._arrayElementType != null)
{
pr._newObj = Array.CreateInstance(pr._arrayElementType, pr._lengthA[0]);
}
pr._isLowerBound = false;
}
else
{
if (pr._arrayElementType != null)
{
pr._newObj = Array.CreateInstance(pr._arrayElementType, pr._lengthA, pr._lowerBoundA);
}
pr._isLowerBound = true;
}
if (pr._arrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr._isLowerBound && (Converter.IsWriteAsByteArray(pr._arrayElementTypeCode)))
{
Debug.Assert(pr._newObj != null);
pr._primitiveArray = new PrimitiveArray(pr._arrayElementTypeCode, (Array)pr._newObj);
}
else if (couldBeValueType && pr._arrayElementType != null)
{
if (!pr._arrayElementType.IsValueType && !pr._isLowerBound)
{
pr._objectA = (object[]?)pr._newObj;
}
}
}
pr._indexMap = new int[1];
}
else if (pr._arrayTypeEnum == InternalArrayTypeE.Rectangular)
{
// Rectangle array
pr._isLowerBound = false;
if (pr._lowerBoundA != null)
{
for (int i = 0; i < pr._rank; i++)
{
if (pr._lowerBoundA[i] != 0)
{
pr._isLowerBound = true;
}
}
}
Debug.Assert(pr._lengthA != null);
if (pr._arrayElementType != null)
{
Debug.Assert(pr._lowerBoundA != null);
pr._newObj = !pr._isLowerBound ?
Array.CreateInstance(pr._arrayElementType, pr._lengthA) :
Array.CreateInstance(pr._arrayElementType, pr._lengthA, pr._lowerBoundA);
}
// Calculate number of items
int sum = 1;
for (int i = 0; i < pr._rank; i++)
{
sum = sum * pr._lengthA[i];
}
pr._indexMap = new int[pr._rank];
pr._rectangularMap = new int[pr._rank];
pr._linearlength = sum;
}
else
{
throw new SerializationException(SR.Format(SR.Serialization_ArrayType, pr._arrayTypeEnum));
}
}
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 WriteArray(WriteObjectInfo objectInfo, NameInfo memberNameInfo, WriteObjectInfo memberObjectInfo)
{
bool flag = false;
if (memberNameInfo == null)
{
memberNameInfo = this.TypeToNameInfo(objectInfo);
flag = true;
}
memberNameInfo.NIisArray = true;
long objectId = objectInfo.objectId;
memberNameInfo.NIobjectId = objectInfo.objectId;
Array array = (Array)objectInfo.obj;
Type objectType = objectInfo.objectType;
Type elementType = objectType.GetElementType();
WriteObjectInfo writeObjectInfo = null;
if (!elementType.IsPrimitive)
{
writeObjectInfo = WriteObjectInfo.Serialize(elementType, this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this.m_binder);
writeObjectInfo.assemId = this.GetAssemblyId(writeObjectInfo);
}
NameInfo nameInfo;
if (writeObjectInfo == null)
{
nameInfo = this.TypeToNameInfo(elementType);
}
else
{
nameInfo = this.TypeToNameInfo(writeObjectInfo);
}
nameInfo.NIisArray = nameInfo.NItype.IsArray;
NameInfo nameInfo2 = memberNameInfo;
nameInfo2.NIobjectId = objectId;
nameInfo2.NIisArray = true;
nameInfo.NIobjectId = objectId;
nameInfo.NItransmitTypeOnMember = memberNameInfo.NItransmitTypeOnMember;
nameInfo.NItransmitTypeOnObject = memberNameInfo.NItransmitTypeOnObject;
nameInfo.NIisParentTypeOnObject = memberNameInfo.NIisParentTypeOnObject;
int rank = array.Rank;
int[] array2 = new int[rank];
int[] array3 = new int[rank];
int[] array4 = new int[rank];
for (int i = 0; i < rank; i++)
{
array2[i] = array.GetLength(i);
array3[i] = array.GetLowerBound(i);
array4[i] = array.GetUpperBound(i);
}
InternalArrayTypeE internalArrayTypeE;
if (nameInfo.NIisArray)
{
if (rank == 1)
{
internalArrayTypeE = InternalArrayTypeE.Jagged;
}
else
{
internalArrayTypeE = InternalArrayTypeE.Rectangular;
}
}
else if (rank == 1)
{
internalArrayTypeE = InternalArrayTypeE.Single;
}
else
{
internalArrayTypeE = InternalArrayTypeE.Rectangular;
}
nameInfo.NIarrayEnum = internalArrayTypeE;
if (elementType == Converter.typeofByte && rank == 1 && array3[0] == 0)
{
this.serWriter.WriteObjectByteArray(memberNameInfo, nameInfo2, writeObjectInfo, nameInfo, array2[0], array3[0], (byte[])array);
return;
}
if (elementType == Converter.typeofObject || Nullable.GetUnderlyingType(elementType) != null)
{
memberNameInfo.NItransmitTypeOnMember = true;
nameInfo.NItransmitTypeOnMember = true;
}
if (this.CheckTypeFormat(this.formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
memberNameInfo.NItransmitTypeOnObject = true;
nameInfo.NItransmitTypeOnObject = true;
}
if (internalArrayTypeE == InternalArrayTypeE.Single)
{
this.serWriter.WriteSingleArray(memberNameInfo, nameInfo2, writeObjectInfo, nameInfo, array2[0], array3[0], array);
if (!Converter.IsWriteAsByteArray(nameInfo.NIprimitiveTypeEnum) || array3[0] != 0)
{
object[] array5 = null;
if (!elementType.IsValueType)
{
array5 = (object[])array;
}
int num = array4[0] + 1;
for (int j = array3[0]; j < num; j++)
{
if (array5 == null)
{
this.WriteArrayMember(objectInfo, nameInfo, array.GetValue(j));
}
else
{
this.WriteArrayMember(objectInfo, nameInfo, array5[j]);
}
}
this.serWriter.WriteItemEnd();
}
}
else if (internalArrayTypeE == InternalArrayTypeE.Jagged)
{
nameInfo2.NIobjectId = objectId;
this.serWriter.WriteJaggedArray(memberNameInfo, nameInfo2, writeObjectInfo, nameInfo, array2[0], array3[0]);
object[] array6 = (object[])array;
for (int k = array3[0]; k < array4[0] + 1; k++)
{
this.WriteArrayMember(objectInfo, nameInfo, array6[k]);
}
this.serWriter.WriteItemEnd();
}
else
{
nameInfo2.NIobjectId = objectId;
this.serWriter.WriteRectangleArray(memberNameInfo, nameInfo2, writeObjectInfo, nameInfo, rank, array2, array3);
bool flag2 = false;
for (int l = 0; l < rank; l++)
{
if (array2[l] == 0)
{
flag2 = true;
break;
}
}
if (!flag2)
{
this.WriteRectangle(objectInfo, rank, array2, array, nameInfo, array3);
}
this.serWriter.WriteItemEnd();
}
this.serWriter.WriteObjectEnd(memberNameInfo, nameInfo2);
this.PutNameInfo(nameInfo);
if (flag)
{
this.PutNameInfo(memberNameInfo);
}
}
private void ParseArray(ParseRecord pr)
{
long num1 = pr.PRobjectId;
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
pr.PRnewObj = pr.PRvalue.Length <= 0 ? (object)new byte[0] : (object)Convert.FromBase64String(pr.PRvalue);
if (this.stack.Peek() == pr)
{
this.stack.Pop();
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if (pr.PRnewObj != null && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
{
this.TopObject = pr.PRnewObj;
}
ParseRecord objectPr = (ParseRecord)this.stack.Peek();
this.RegisterObject(pr.PRnewObj, pr, objectPr);
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged || pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
bool flag = true;
if (pr.PRlowerBoundA == null || pr.PRlowerBoundA[0] == 0)
{
if (pr.PRarrayElementType == Converter.typeofString)
{
ParseRecord parseRecord1 = pr;
string[] strArray = new string[parseRecord1.PRlengthA[0]];
parseRecord1.PRobjectA = (object[])strArray;
ParseRecord parseRecord2 = pr;
object[] objArray = parseRecord2.PRobjectA;
parseRecord2.PRnewObj = (object)objArray;
flag = false;
}
else if (pr.PRarrayElementType == Converter.typeofObject)
{
ParseRecord parseRecord1 = pr;
object[] objArray1 = new object[parseRecord1.PRlengthA[0]];
parseRecord1.PRobjectA = objArray1;
ParseRecord parseRecord2 = pr;
object[] objArray2 = parseRecord2.PRobjectA;
parseRecord2.PRnewObj = (object)objArray2;
flag = false;
}
else if (pr.PRarrayElementType != null)
{
pr.PRnewObj = (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA[0]);
}
pr.PRisLowerBound = false;
}
else
{
if (pr.PRarrayElementType != null)
{
pr.PRnewObj = (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
}
pr.PRisLowerBound = true;
}
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)
{
if (!pr.PRisLowerBound && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))
{
ParseRecord parseRecord = pr;
PrimitiveArray primitiveArray = new PrimitiveArray(parseRecord.PRarrayElementTypeCode, (Array)pr.PRnewObj);
parseRecord.PRprimitiveArray = primitiveArray;
}
else if (flag && pr.PRarrayElementType != null && (!pr.PRarrayElementType.IsValueType && !pr.PRisLowerBound))
{
ParseRecord parseRecord = pr;
object[] objArray = (object[])parseRecord.PRnewObj;
parseRecord.PRobjectA = objArray;
}
}
if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers)
{
this.headers = (Header[])pr.PRnewObj;
}
pr.PRindexMap = new int[1];
}
else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
pr.PRisLowerBound = false;
if (pr.PRlowerBoundA != null)
{
for (int index = 0; index < pr.PRrank; ++index)
{
if (pr.PRlowerBoundA[index] != 0)
{
pr.PRisLowerBound = true;
}
}
}
if (pr.PRarrayElementType != null)
{
pr.PRnewObj = pr.PRisLowerBound ? (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA) : (object)Array.UnsafeCreateInstance(pr.PRarrayElementType, pr.PRlengthA);
}
int num2 = 1;
for (int index = 0; index < pr.PRrank; ++index)
{
num2 *= pr.PRlengthA[index];
}
ParseRecord parseRecord1 = pr;
int[] numArray1 = new int[parseRecord1.PRrank];
parseRecord1.PRindexMap = numArray1;
ParseRecord parseRecord2 = pr;
int[] numArray2 = new int[parseRecord2.PRrank];
parseRecord2.PRrectangularMap = numArray2;
pr.PRlinearlength = num2;
}
else
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayType", (object)pr.PRarrayTypeEnum));
}
this.CheckSecurity(pr);
}
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);
}
}
private void WriteArray(WriteObjectInfo objectInfo, NameInfo memberNameInfo, WriteObjectInfo memberObjectInfo)
{
bool flag1 = false;
if (memberNameInfo == null)
{
memberNameInfo = this.TypeToNameInfo(objectInfo);
flag1 = true;
}
memberNameInfo.NIisArray = true;
long num1 = objectInfo.objectId;
memberNameInfo.NIobjectId = objectInfo.objectId;
Array array = (Array)objectInfo.obj;
Type elementType = objectInfo.objectType.GetElementType();
WriteObjectInfo objectInfo1 = (WriteObjectInfo)null;
if (!elementType.IsPrimitive)
{
objectInfo1 = WriteObjectInfo.Serialize(elementType, this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this.m_binder);
objectInfo1.assemId = this.GetAssemblyId(objectInfo1);
}
NameInfo nameInfo1 = objectInfo1 != null?this.TypeToNameInfo(objectInfo1) : this.TypeToNameInfo(elementType);
NameInfo nameInfo2 = nameInfo1;
int num2 = nameInfo2.NItype.IsArray ? 1 : 0;
nameInfo2.NIisArray = num2 != 0;
NameInfo nameInfo3 = memberNameInfo;
nameInfo3.NIobjectId = num1;
nameInfo3.NIisArray = true;
nameInfo1.NIobjectId = num1;
nameInfo1.NItransmitTypeOnMember = memberNameInfo.NItransmitTypeOnMember;
nameInfo1.NItransmitTypeOnObject = memberNameInfo.NItransmitTypeOnObject;
nameInfo1.NIisParentTypeOnObject = memberNameInfo.NIisParentTypeOnObject;
int rank = array.Rank;
int[] numArray1 = new int[rank];
int[] lowerBoundA = new int[rank];
int[] numArray2 = new int[rank];
for (int dimension = 0; dimension < rank; ++dimension)
{
numArray1[dimension] = array.GetLength(dimension);
lowerBoundA[dimension] = array.GetLowerBound(dimension);
numArray2[dimension] = array.GetUpperBound(dimension);
}
InternalArrayTypeE internalArrayTypeE = !nameInfo1.NIisArray ? (rank != 1 ? InternalArrayTypeE.Rectangular : InternalArrayTypeE.Single) : (rank != 1 ? InternalArrayTypeE.Rectangular : InternalArrayTypeE.Jagged);
nameInfo1.NIarrayEnum = internalArrayTypeE;
if (elementType == Converter.typeofByte && rank == 1 && lowerBoundA[0] == 0)
{
this.serWriter.WriteObjectByteArray(memberNameInfo, nameInfo3, objectInfo1, nameInfo1, numArray1[0], lowerBoundA[0], (byte[])array);
}
else
{
if (elementType == Converter.typeofObject || Nullable.GetUnderlyingType(elementType) != null)
{
memberNameInfo.NItransmitTypeOnMember = true;
nameInfo1.NItransmitTypeOnMember = true;
}
if (this.CheckTypeFormat(this.formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
memberNameInfo.NItransmitTypeOnObject = true;
nameInfo1.NItransmitTypeOnObject = true;
}
if (internalArrayTypeE == InternalArrayTypeE.Single)
{
this.serWriter.WriteSingleArray(memberNameInfo, nameInfo3, objectInfo1, nameInfo1, numArray1[0], lowerBoundA[0], array);
if (!Converter.IsWriteAsByteArray(nameInfo1.NIprimitiveTypeEnum) || lowerBoundA[0] != 0)
{
object[] objArray = (object[])null;
if (!elementType.IsValueType)
{
objArray = (object[])array;
}
int num3 = numArray2[0] + 1;
for (int index = lowerBoundA[0]; index < num3; ++index)
{
if (objArray == null)
{
this.WriteArrayMember(objectInfo, nameInfo1, array.GetValue(index));
}
else
{
this.WriteArrayMember(objectInfo, nameInfo1, objArray[index]);
}
}
this.serWriter.WriteItemEnd();
}
}
else if (internalArrayTypeE == InternalArrayTypeE.Jagged)
{
nameInfo3.NIobjectId = num1;
this.serWriter.WriteJaggedArray(memberNameInfo, nameInfo3, objectInfo1, nameInfo1, numArray1[0], lowerBoundA[0]);
object[] objArray = (object[])array;
for (int index = lowerBoundA[0]; index < numArray2[0] + 1; ++index)
{
this.WriteArrayMember(objectInfo, nameInfo1, objArray[index]);
}
this.serWriter.WriteItemEnd();
}
else
{
nameInfo3.NIobjectId = num1;
this.serWriter.WriteRectangleArray(memberNameInfo, nameInfo3, objectInfo1, nameInfo1, rank, numArray1, lowerBoundA);
bool flag2 = false;
for (int index = 0; index < rank; ++index)
{
if (numArray1[index] == 0)
{
flag2 = true;
break;
}
}
if (!flag2)
{
this.WriteRectangle(objectInfo, rank, numArray1, array, nameInfo1, lowerBoundA);
}
this.serWriter.WriteItemEnd();
}
this.serWriter.WriteObjectEnd(memberNameInfo, nameInfo3);
this.PutNameInfo(nameInfo1);
if (!flag1)
{
return;
}
this.PutNameInfo(memberNameInfo);
}
}
