// Writes a null member into the stream
private bool CheckForNull(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, object data)
{
bool isNull = data == null;
// Optimization, Null members are only written for Binary
if ((isNull) && (((_formatterEnums._serializerTypeEnum == InternalSerializerTypeE.Binary)) ||
memberNameInfo._isArrayItem ||
memberNameInfo._transmitTypeOnObject ||
memberNameInfo._transmitTypeOnMember ||
objectInfo._isSi ||
(CheckTypeFormat(_formatterEnums._typeFormat, FormatterTypeStyle.TypesAlways))))
{
if (typeNameInfo._isArrayItem)
{
if (typeNameInfo._arrayEnum == InternalArrayTypeE.Single)
{
_serWriter.WriteDelayedNullItem();
}
else
{
_serWriter.WriteNullItem(memberNameInfo, typeNameInfo);
}
}
else
{
_serWriter.WriteNullMember(memberNameInfo, typeNameInfo);
}
}
return(isNull);
}
internal static WriteObjectInfo Serialize(object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
WriteObjectInfo woi = GetObjectInfo(serObjectInfoInit);
woi.InitSerialize(obj, surrogateSelector, context, serObjectInfoInit, converter, objectWriter, binder);
return(woi);
}
internal static BinaryTypeEnum GetBinaryTypeInfo(Type type, WriteObjectInfo objectInfo, string typeName, ObjectWriter objectWriter, out object typeInformation, out int assemId)
{
BinaryTypeEnum primitive;
assemId = 0;
typeInformation = null;
if (object.ReferenceEquals(type, Converter.typeofString))
{
return BinaryTypeEnum.String;
}
if (((objectInfo == null) || ((objectInfo != null) && !objectInfo.isSi)) && object.ReferenceEquals(type, Converter.typeofObject))
{
return BinaryTypeEnum.Object;
}
if (object.ReferenceEquals(type, Converter.typeofStringArray))
{
return BinaryTypeEnum.StringArray;
}
if (object.ReferenceEquals(type, Converter.typeofObjectArray))
{
return BinaryTypeEnum.ObjectArray;
}
if (Converter.IsPrimitiveArray(type, out typeInformation))
{
return BinaryTypeEnum.PrimitiveArray;
}
InternalPrimitiveTypeE ee = objectWriter.ToCode(type);
switch (ee)
{
case InternalPrimitiveTypeE.Invalid:
{
string fullName = null;
if (objectInfo == null)
{
fullName = type.Assembly.FullName;
typeInformation = type.FullName;
}
else
{
fullName = objectInfo.GetAssemblyString();
typeInformation = objectInfo.GetTypeFullName();
}
if (fullName.Equals(Converter.urtAssemblyString))
{
primitive = BinaryTypeEnum.ObjectUrt;
assemId = 0;
return primitive;
}
primitive = BinaryTypeEnum.ObjectUser;
assemId = (int) objectInfo.assemId;
if (assemId == 0)
{
throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId", new object[] { typeInformation }));
}
return primitive;
}
}
primitive = BinaryTypeEnum.Primitive;
typeInformation = ee;
return primitive;
}
private void WriteMemberSetup(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, string memberName, Type memberType, object memberData, WriteObjectInfo memberObjectInfo)
{
NameInfo info = this.MemberToNameInfo(memberName);
if (memberObjectInfo != null)
{
info.NIassemId = memberObjectInfo.assemId;
}
info.NItype = memberType;
NameInfo memberTypeNameInfo = null;
if (memberObjectInfo == null)
{
memberTypeNameInfo = this.TypeToNameInfo(memberType);
}
else
{
memberTypeNameInfo = this.TypeToNameInfo(memberObjectInfo);
}
info.NItransmitTypeOnObject = memberNameInfo.NItransmitTypeOnObject;
info.NIisParentTypeOnObject = memberNameInfo.NIisParentTypeOnObject;
this.WriteMembers(info, memberTypeNameInfo, memberData, objectInfo, typeNameInfo, memberObjectInfo);
this.PutNameInfo(info);
this.PutNameInfo(memberTypeNameInfo);
}
// Token: 0x0600537F RID: 21375 RVA: 0x00127814 File Offset: 0x00125A14
private bool CheckForNull(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, object data)
{
bool flag = false;
if (data == null)
{
flag = true;
}
if (flag && (this.formatterEnums.FEserializerTypeEnum == InternalSerializerTypeE.Binary || memberNameInfo.NIisArrayItem || memberNameInfo.NItransmitTypeOnObject || memberNameInfo.NItransmitTypeOnMember || objectInfo.isSi || this.CheckTypeFormat(this.formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways)))
{
if (typeNameInfo.NIisArrayItem)
{
if (typeNameInfo.NIarrayEnum == InternalArrayTypeE.Single)
{
this.serWriter.WriteDelayedNullItem();
}
else
{
this.serWriter.WriteNullItem(memberNameInfo, typeNameInfo);
}
}
else
{
this.serWriter.WriteNullMember(memberNameInfo, typeNameInfo);
}
}
return(flag);
}
internal static WriteObjectInfo Serialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder)
{
WriteObjectInfo objectInfo = GetObjectInfo(serObjectInfoInit);
objectInfo.InitSerialize(objectType, surrogateSelector, context, serObjectInfoInit, converter, binder);
return(objectInfo);
}
// Iterates over a Rectangle array, for each element of the array invokes WriteArrayMember
private void WriteRectangle(WriteObjectInfo objectInfo, int rank, int[] maxA, Array array, NameInfo arrayElemNameTypeInfo, int[]?lowerBoundA)
{
int[] currentA = new int[rank];
int[]? indexMap = null;
bool isLowerBound = false;
if (lowerBoundA != null)
{
for (int i = 0; i < rank; i++)
{
if (lowerBoundA[i] != 0)
{
isLowerBound = true;
}
}
}
if (isLowerBound)
{
indexMap = new int[rank];
}
bool isLoop = true;
while (isLoop)
{
isLoop = false;
if (isLowerBound)
{
for (int i = 0; i < rank; i++)
{
indexMap ![i] = currentA[i] + lowerBoundA ![i];
private void WriteMemberSetup(WriteObjectInfo objectInfo,
NameInfo memberNameInfo,
NameInfo typeNameInfo,
string memberName,
Type memberType,
object memberData,
WriteObjectInfo memberObjectInfo)
{
NameInfo newMemberNameInfo = MemberToNameInfo(memberName); // newMemberNameInfo contains the member type
if (memberObjectInfo != null)
{
newMemberNameInfo._assemId = memberObjectInfo._assemId;
}
newMemberNameInfo._type = memberType;
// newTypeNameInfo contains the data type
NameInfo newTypeNameInfo = null;
if (memberObjectInfo == null)
{
newTypeNameInfo = TypeToNameInfo(memberType);
}
else
{
newTypeNameInfo = TypeToNameInfo(memberObjectInfo);
}
newMemberNameInfo._transmitTypeOnObject = memberNameInfo._transmitTypeOnObject;
newMemberNameInfo._isParentTypeOnObject = memberNameInfo._isParentTypeOnObject;
WriteMembers(newMemberNameInfo, newTypeNameInfo, memberData, objectInfo, typeNameInfo, memberObjectInfo);
PutNameInfo(newMemberNameInfo);
PutNameInfo(newTypeNameInfo);
}
private long GetAssemblyId(WriteObjectInfo objectInfo)
{
if (this.assemblyToIdTable == null)
{
this.assemblyToIdTable = new Hashtable(5);
}
long num = 0L;
bool isNew = false;
string assemblyString = objectInfo.GetAssemblyString();
string str2 = assemblyString;
if (assemblyString.Length == 0)
{
return 0L;
}
if (assemblyString.Equals(Converter.urtAssemblyString))
{
return 0L;
}
if (this.assemblyToIdTable.ContainsKey(assemblyString))
{
num = (long) this.assemblyToIdTable[assemblyString];
isNew = false;
}
else
{
num = this.InternalGetId("___AssemblyString___" + assemblyString, false, null, out isNew);
this.assemblyToIdTable[assemblyString] = num;
}
this.serWriter.WriteAssembly(objectInfo.objectType, str2, (int) num, isNew);
return num;
}
private long GetAssemblyId(WriteObjectInfo objectInfo)
{
if (this.assemblyToIdTable == null)
{
this.assemblyToIdTable = new Hashtable(5);
}
bool isNew = false;
string assemblyString1 = objectInfo.GetAssemblyString();
string assemblyString2 = assemblyString1;
long num;
if (assemblyString1.Length == 0)
{
num = 0L;
}
else if (assemblyString1.Equals(Converter.urtAssemblyString))
{
num = 0L;
}
else
{
if (this.assemblyToIdTable.ContainsKey((object)assemblyString1))
{
num = (long)this.assemblyToIdTable[(object)assemblyString1];
isNew = false;
}
else
{
num = this.InternalGetId((object)("___AssemblyString___" + assemblyString1), false, (Type)null, out isNew);
this.assemblyToIdTable[(object)assemblyString1] = (object)num;
}
this.serWriter.WriteAssembly(objectInfo.objectType, assemblyString2, (int)num, isNew);
}
return(num);
}
private long GetAssemblyId(WriteObjectInfo objectInfo)
{
if (this.assemblyToIdTable == null)
{
this.assemblyToIdTable = new Hashtable(5);
}
long num = 0L;
bool isNew = false;
string assemblyString = objectInfo.GetAssemblyString();
string str2 = assemblyString;
if (assemblyString.Length == 0)
{
return(0L);
}
if (assemblyString.Equals(Converter.urtAssemblyString))
{
return(0L);
}
if (this.assemblyToIdTable.ContainsKey(assemblyString))
{
num = (long)this.assemblyToIdTable[assemblyString];
isNew = false;
}
else
{
num = this.InternalGetId("___AssemblyString___" + assemblyString, false, null, out isNew);
this.assemblyToIdTable[assemblyString] = num;
}
this.serWriter.WriteAssembly(objectInfo.objectType, str2, (int)num, isNew);
return(num);
}
internal static WriteObjectInfo Serialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter)
{
WriteObjectInfo soi = GetObjectInfo(serObjectInfoInit);
soi.InitSerialize(obj, surrogateSelector, context, serObjectInfoInit, converter);
return(soi);
}
internal void Serialize(object graph, BinaryFormatterWriter serWriter, bool fCheck)
{
if (graph == null)
{
throw new ArgumentNullException(nameof(graph));
}
if (serWriter == null)
{
throw new ArgumentNullException(nameof(serWriter));
}
_serWriter = serWriter;
serWriter.WriteBegin();
long headerId = 0;
object obj;
long objectId;
bool isNew;
// allocations if methodCall or methodResponse and no graph
_idGenerator = new ObjectIDGenerator();
_objectQueue = new Queue <object>();
_formatterConverter = new FormatterConverter();
_serObjectInfoInit = new SerObjectInfoInit();
_topId = InternalGetId(graph, false, null, out isNew);
headerId = -1;
WriteSerializedStreamHeader(_topId, headerId);
_objectQueue.Enqueue(graph);
while ((obj = GetNext(out objectId)) != null)
{
WriteObjectInfo objectInfo = null;
// GetNext will return either an object or a WriteObjectInfo.
// A WriteObjectInfo is returned if this object was member of another object
if (obj is WriteObjectInfo)
{
objectInfo = (WriteObjectInfo)obj;
}
else
{
objectInfo = WriteObjectInfo.Serialize(obj, _surrogates, _context, _serObjectInfoInit, _formatterConverter, this, _binder);
objectInfo._assemId = GetAssemblyId(objectInfo);
}
objectInfo._objectId = objectId;
NameInfo typeNameInfo = TypeToNameInfo(objectInfo);
Write(objectInfo, typeNameInfo, typeNameInfo);
PutNameInfo(typeNameInfo);
objectInfo.ObjectEnd();
}
serWriter.WriteSerializationHeaderEnd();
serWriter.WriteEnd();
// Invoke OnSerialized Event
_objectManager.RaiseOnSerializedEvent();
}
private void Write(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, string[] memberNames, Type[] memberTypes, object[] memberData, WriteObjectInfo[] memberObjectInfos)
{
int length = memberNames.Length;
NameInfo nameInfo1 = (NameInfo)null;
if (memberNameInfo != null)
{
memberNameInfo.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObject(memberNameInfo, typeNameInfo, length, memberNames, memberTypes, memberObjectInfos);
}
else if (objectInfo.objectId == this.topId && this.topName != null)
{
nameInfo1 = this.MemberToNameInfo(this.topName);
nameInfo1.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObject(nameInfo1, typeNameInfo, length, memberNames, memberTypes, memberObjectInfos);
}
else if (objectInfo.objectType != Converter.typeofString)
{
typeNameInfo.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObject(typeNameInfo, (NameInfo)null, length, memberNames, memberTypes, memberObjectInfos);
}
if (memberNameInfo.NIisParentTypeOnObject)
{
memberNameInfo.NItransmitTypeOnObject = true;
memberNameInfo.NIisParentTypeOnObject = false;
}
else
{
memberNameInfo.NItransmitTypeOnObject = false;
}
for (int index = 0; index < length; ++index)
{
this.WriteMemberSetup(objectInfo, memberNameInfo, typeNameInfo, memberNames[index], memberTypes[index], memberData[index], memberObjectInfos[index]);
}
if (memberNameInfo != null)
{
memberNameInfo.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObjectEnd(memberNameInfo, typeNameInfo);
}
else if (objectInfo.objectId == this.topId && this.topName != null)
{
this.serWriter.WriteObjectEnd(nameInfo1, typeNameInfo);
this.PutNameInfo(nameInfo1);
}
else
{
if (objectInfo.objectType == Converter.typeofString)
{
return;
}
__BinaryWriter binaryWriter = this.serWriter;
NameInfo nameInfo2 = typeNameInfo;
binaryWriter.WriteObjectEnd(nameInfo2, nameInfo2);
}
}
private void WriteRectangle(WriteObjectInfo objectInfo, int rank, int[] maxA, Array array, NameInfo arrayElemNameTypeInfo, int[] lowerBoundA)
{
int[] array2 = new int[rank];
int[] array3 = null;
bool flag = false;
if (lowerBoundA != null)
{
for (int i = 0; i < rank; i++)
{
if (lowerBoundA[i] != 0)
{
flag = true;
}
}
}
if (flag)
{
array3 = new int[rank];
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
if (flag)
{
for (int j = 0; j < rank; j++)
{
array3[j] = array2[j] + lowerBoundA[j];
}
this.WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(array3));
}
else
{
this.WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(array2));
}
for (int k = rank - 1; k > -1; k--)
{
if (array2[k] < maxA[k] - 1)
{
array2[k]++;
if (k < rank - 1)
{
for (int l = k + 1; l < rank; l++)
{
array2[l] = 0;
}
}
flag2 = true;
break;
}
}
}
}
private void WriteRectangle(WriteObjectInfo objectInfo, int rank, int[] maxA, Array array, NameInfo arrayElemNameTypeInfo, int[] lowerBoundA)
{
int[] numArray1 = new int[rank];
int[] numArray2 = (int[])null;
bool flag1 = false;
if (lowerBoundA != null)
{
for (int index = 0; index < rank; ++index)
{
if (lowerBoundA[index] != 0)
{
flag1 = true;
}
}
}
if (flag1)
{
numArray2 = new int[rank];
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
if (flag1)
{
for (int index = 0; index < rank; ++index)
{
numArray2[index] = numArray1[index] + lowerBoundA[index];
}
this.WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(numArray2));
}
else
{
this.WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(numArray1));
}
for (int index1 = rank - 1; index1 > -1; --index1)
{
if (numArray1[index1] < maxA[index1] - 1)
{
++numArray1[index1];
if (index1 < rank - 1)
{
for (int index2 = index1 + 1; index2 < rank; ++index2)
{
numArray1[index2] = 0;
}
}
flag2 = true;
break;
}
}
}
}
private void WriteRectangle(WriteObjectInfo objectInfo, int rank, int[] maxA, Array array, NameInfo arrayElemNameTypeInfo, int[] lowerBoundA)
{
int[] indices = new int[rank];
int[] numArray2 = null;
bool flag = false;
if (lowerBoundA != null)
{
for (int i = 0; i < rank; i++)
{
if (lowerBoundA[i] != 0)
{
flag = true;
}
}
}
if (flag)
{
numArray2 = new int[rank];
}
bool flag2 = true;
while (flag2)
{
flag2 = false;
if (flag)
{
for (int k = 0; k < rank; k++)
{
numArray2[k] = indices[k] + lowerBoundA[k];
}
this.WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(numArray2));
}
else
{
this.WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(indices));
}
for (int j = rank - 1; j > -1; j--)
{
if (indices[j] < (maxA[j] - 1))
{
indices[j]++;
if (j < (rank - 1))
{
for (int m = j + 1; m < rank; m++)
{
indices[m] = 0;
}
}
flag2 = true;
continue;
}
}
}
}
private void Write(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo)
{
object obj = objectInfo.obj;
if (obj == null)
{
throw new ArgumentNullException("objectInfo.obj", Environment.GetResourceString("ArgumentNull_Obj"));
}
Type type1 = objectInfo.objectType;
long num = objectInfo.objectId;
Type type2 = Converter.typeofString;
if (type1 == type2)
{
memberNameInfo.NIobjectId = num;
this.serWriter.WriteObjectString((int)num, obj.ToString());
}
else if (objectInfo.isArray)
{
this.WriteArray(objectInfo, memberNameInfo, (WriteObjectInfo)null);
}
else
{
string[] outMemberNames;
Type[] outMemberTypes;
object[] outMemberData;
objectInfo.GetMemberInfo(out outMemberNames, out outMemberTypes, out outMemberData);
if (objectInfo.isSi || this.CheckTypeFormat(this.formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
memberNameInfo.NItransmitTypeOnObject = true;
memberNameInfo.NIisParentTypeOnObject = true;
typeNameInfo.NItransmitTypeOnObject = true;
typeNameInfo.NIisParentTypeOnObject = true;
}
WriteObjectInfo[] memberObjectInfos = new WriteObjectInfo[outMemberNames.Length];
for (int index = 0; index < outMemberTypes.Length; ++index)
{
Type type3 = outMemberTypes[index] == null ? (outMemberData[index] == null ? Converter.typeofObject : this.GetType(outMemberData[index])) : outMemberTypes[index];
if (this.ToCode(type3) == InternalPrimitiveTypeE.Invalid && type3 != Converter.typeofString)
{
if (outMemberData[index] != null)
{
memberObjectInfos[index] = WriteObjectInfo.Serialize(outMemberData[index], this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this, this.m_binder);
memberObjectInfos[index].assemId = this.GetAssemblyId(memberObjectInfos[index]);
}
else
{
memberObjectInfos[index] = WriteObjectInfo.Serialize(outMemberTypes[index], this.m_surrogates, this.m_context, this.serObjectInfoInit, this.m_formatterConverter, this.m_binder);
memberObjectInfos[index].assemId = this.GetAssemblyId(memberObjectInfos[index]);
}
}
}
this.Write(objectInfo, memberNameInfo, typeNameInfo, outMemberNames, outMemberTypes, outMemberData, memberObjectInfos);
}
}
internal void InitSerialize(object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
{
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
if (RemotingServices.IsTransparentProxy(obj))
{
this.objectType = Converter.typeofMarshalByRefObject;
}
else
{
this.objectType = obj.GetType();
}
if (this.objectType.IsArray)
{
this.isArray = true;
this.InitNoMembers();
return;
}
this.InvokeSerializationBinder(binder);
objectWriter.ObjectManager.RegisterObject(obj);
ISurrogateSelector surrogateSelector2;
if (surrogateSelector != null && (this.serializationSurrogate = surrogateSelector.GetSurrogate(this.objectType, context, out surrogateSelector2)) != null)
{
this.si = new SerializationInfo(this.objectType, converter);
if (!this.objectType.IsPrimitive)
{
this.serializationSurrogate.GetObjectData(obj, this.si, context);
}
this.InitSiWrite();
return;
}
if (!(obj is ISerializable))
{
this.InitMemberInfo();
WriteObjectInfo.CheckTypeForwardedFrom(this.cache, this.objectType, this.binderAssemblyString);
return;
}
if (!this.objectType.IsSerializable)
{
throw new SerializationException(Environment.GetResourceString("Serialization_NonSerType", new object[]
{
this.objectType.FullName,
this.objectType.Assembly.FullName
}));
}
this.si = new SerializationInfo(this.objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled());
((ISerializable)obj).GetObjectData(this.si, context);
this.InitSiWrite();
WriteObjectInfo.CheckTypeForwardedFrom(this.cache, this.objectType, this.binderAssemblyString);
}
internal static WriteObjectInfo Serialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder)
{
WriteObjectInfo objectInfo = WriteObjectInfo.GetObjectInfo(serObjectInfoInit);
Type objectType1 = objectType;
ISurrogateSelector surrogateSelector1 = surrogateSelector;
StreamingContext context1 = context;
SerObjectInfoInit serObjectInfoInit1 = serObjectInfoInit;
IFormatterConverter converter1 = converter;
SerializationBinder binder1 = binder;
objectInfo.InitSerialize(objectType1, surrogateSelector1, context1, serObjectInfoInit1, converter1, binder1);
return(objectInfo);
}
internal static WriteObjectInfo Serialize(
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type objectType,
ISurrogateSelector?surrogateSelector,
StreamingContext context,
SerObjectInfoInit serObjectInfoInit,
IFormatterConverter converter,
SerializationBinder?binder)
{
WriteObjectInfo woi = GetObjectInfo(serObjectInfoInit);
woi.InitSerialize(objectType, surrogateSelector, context, serObjectInfoInit, converter, binder);
return(woi);
}
private void Write(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, string[] memberNames, Type[] memberTypes, object[] memberData, WriteObjectInfo[] memberObjectInfos)
{
int num = memberNames.Length;
NameInfo nameInfo = null;
if (memberNameInfo != null)
{
memberNameInfo.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObject(memberNameInfo, typeNameInfo, num, memberNames, memberTypes, memberObjectInfos);
}
else if (objectInfo.objectId == this.topId && this.topName != null)
{
nameInfo = this.MemberToNameInfo(this.topName);
nameInfo.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObject(nameInfo, typeNameInfo, num, memberNames, memberTypes, memberObjectInfos);
}
else if (objectInfo.objectType != Converter.typeofString)
{
typeNameInfo.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObject(typeNameInfo, null, num, memberNames, memberTypes, memberObjectInfos);
}
if (memberNameInfo.NIisParentTypeOnObject)
{
memberNameInfo.NItransmitTypeOnObject = true;
memberNameInfo.NIisParentTypeOnObject = false;
}
else
{
memberNameInfo.NItransmitTypeOnObject = false;
}
for (int i = 0; i < num; i++)
{
this.WriteMemberSetup(objectInfo, memberNameInfo, typeNameInfo, memberNames[i], memberTypes[i], memberData[i], memberObjectInfos[i]);
}
if (memberNameInfo != null)
{
memberNameInfo.NIobjectId = objectInfo.objectId;
this.serWriter.WriteObjectEnd(memberNameInfo, typeNameInfo);
return;
}
if (objectInfo.objectId == this.topId && this.topName != null)
{
this.serWriter.WriteObjectEnd(nameInfo, typeNameInfo);
this.PutNameInfo(nameInfo);
return;
}
if (objectInfo.objectType != Converter.typeofString)
{
this.serWriter.WriteObjectEnd(typeNameInfo, typeNameInfo);
}
}
private static WriteObjectInfo GetObjectInfo(SerObjectInfoInit serObjectInfoInit)
{
WriteObjectInfo info = null;
if (!serObjectInfoInit.oiPool.IsEmpty())
{
info = (WriteObjectInfo)serObjectInfoInit.oiPool.Pop();
info.InternalInit();
return(info);
}
return(new WriteObjectInfo {
objectInfoId = serObjectInfoInit.objectInfoIdCount++
});
}
// Writes a given object to the stream.
private void Write(WriteObjectInfo objectInfo,
NameInfo?memberNameInfo,
NameInfo typeNameInfo,
string[] memberNames,
Type[] memberTypes,
object?[] memberData,
WriteObjectInfo[] memberObjectInfos)
{
int numItems = memberNames.Length;
Debug.Assert(_serWriter != null);
if (memberNameInfo != null)
{
memberNameInfo._objectId = objectInfo._objectId;
_serWriter.WriteObject(memberNameInfo, typeNameInfo, numItems, memberNames, memberTypes, memberObjectInfos);
}
else if (!ReferenceEquals(objectInfo._objectType, Converter.s_typeofString))
{
typeNameInfo._objectId = objectInfo._objectId;
_serWriter.WriteObject(typeNameInfo, null, numItems, memberNames, memberTypes, memberObjectInfos);
}
Debug.Assert(memberNameInfo != null);
if (memberNameInfo._isParentTypeOnObject)
{
memberNameInfo._transmitTypeOnObject = true;
memberNameInfo._isParentTypeOnObject = false;
}
else
{
memberNameInfo._transmitTypeOnObject = false;
}
// Write members
for (int i = 0; i < numItems; i++)
{
WriteMemberSetup(objectInfo, memberNameInfo, typeNameInfo, memberNames[i], memberTypes[i], memberData[i], memberObjectInfos[i]);
}
if (memberNameInfo != null)
{
memberNameInfo._objectId = objectInfo._objectId;
_serWriter.WriteObjectEnd(memberNameInfo, typeNameInfo);
}
else if (!ReferenceEquals(objectInfo._objectType, Converter.s_typeofString))
{
_serWriter.WriteObjectEnd(typeNameInfo, typeNameInfo);
}
}
private long Schedule(object obj, bool assignUniqueIdToValueType, Type type, WriteObjectInfo objectInfo)
{
long id = 0;
if (obj != null)
{
bool isNew;
id = InternalGetId(obj, assignUniqueIdToValueType, type, out isNew);
if (isNew && id > 0)
{
_objectQueue.Enqueue(objectInfo ?? obj);
}
}
return(id);
}
private void WriteMemberSetup(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, string memberName, Type memberType, object memberData, WriteObjectInfo memberObjectInfo)
{
NameInfo nameInfo1 = this.MemberToNameInfo(memberName);
if (memberObjectInfo != null)
{
nameInfo1.NIassemId = memberObjectInfo.assemId;
}
nameInfo1.NItype = memberType;
NameInfo nameInfo2 = memberObjectInfo != null?this.TypeToNameInfo(memberObjectInfo) : this.TypeToNameInfo(memberType);
nameInfo1.NItransmitTypeOnObject = memberNameInfo.NItransmitTypeOnObject;
nameInfo1.NIisParentTypeOnObject = memberNameInfo.NIisParentTypeOnObject;
this.WriteMembers(nameInfo1, nameInfo2, memberData, objectInfo, typeNameInfo, memberObjectInfo);
this.PutNameInfo(nameInfo1);
this.PutNameInfo(nameInfo2);
}
private static WriteObjectInfo GetObjectInfo(SerObjectInfoInit serObjectInfoInit)
{
WriteObjectInfo objectInfo;
if (!serObjectInfoInit._oiPool.IsEmpty())
{
objectInfo = (WriteObjectInfo)serObjectInfoInit._oiPool.Pop();
objectInfo.InternalInit();
}
else
{
objectInfo = new WriteObjectInfo();
objectInfo._objectInfoId = serObjectInfoInit._objectInfoIdCount++;
}
return(objectInfo);
}
private long GetAssemblyId(WriteObjectInfo objectInfo)
{
//use objectInfo to get assembly string with new criteria
if (_assemblyToIdTable == null)
{
_assemblyToIdTable = new Dictionary <string, long>();
}
long assemId = 0;
string assemblyString = objectInfo.GetAssemblyString();
string serializedAssemblyString = assemblyString;
if (assemblyString.Length == 0)
{
assemId = 0;
}
else if (assemblyString.Equals(Converter.s_urtAssemblyString))
{
// Urt type is an assemId of 0. No assemblyString needs
// to be sent
assemId = 0;
}
else
{
// Assembly needs to be sent
// Need to prefix assembly string to separate the string names from the
// assemblyName string names. That is a string can have the same value
// as an assemblyNameString, but it is serialized differently
bool isNew = false;
if (_assemblyToIdTable.TryGetValue(assemblyString, out assemId))
{
isNew = false;
}
else
{
assemId = InternalGetId("___AssemblyString___" + assemblyString, false, null, out isNew);
_assemblyToIdTable[assemblyString] = assemId;
}
_serWriter.WriteAssembly(objectInfo._objectType, serializedAssemblyString, (int)assemId, isNew);
}
return(assemId);
}
private NameInfo TypeToNameInfo(Type type, WriteObjectInfo objectInfo, InternalPrimitiveTypeE code, NameInfo nameInfo)
{
if (nameInfo == null)
{
nameInfo = this.GetNameInfo();
}
else
{
nameInfo.Init();
}
if ((code == InternalPrimitiveTypeE.Invalid) && (objectInfo != null))
{
nameInfo.NIname = objectInfo.GetTypeFullName();
nameInfo.NIassemId = objectInfo.assemId;
}
nameInfo.NIprimitiveTypeEnum = code;
nameInfo.NItype = type;
return(nameInfo);
}
// Token: 0x060053B1 RID: 21425 RVA: 0x00128C9C File Offset: 0x00126E9C
private static WriteObjectInfo GetObjectInfo(SerObjectInfoInit serObjectInfoInit)
{
WriteObjectInfo writeObjectInfo;
if (!serObjectInfoInit.oiPool.IsEmpty())
{
writeObjectInfo = (WriteObjectInfo)serObjectInfoInit.oiPool.Pop();
writeObjectInfo.InternalInit();
}
else
{
writeObjectInfo = new WriteObjectInfo();
WriteObjectInfo writeObjectInfo2 = writeObjectInfo;
int objectInfoIdCount = serObjectInfoInit.objectInfoIdCount;
serObjectInfoInit.objectInfoIdCount = objectInfoIdCount + 1;
writeObjectInfo2.objectInfoId = objectInfoIdCount;
}
return(writeObjectInfo);
}
private static WriteObjectInfo GetObjectInfo(SerObjectInfoInit serObjectInfoInit)
{
WriteObjectInfo objectInfo = null;
if (!serObjectInfoInit.oiPool.IsEmpty())
{
objectInfo = (WriteObjectInfo)serObjectInfoInit.oiPool.Pop();
objectInfo.InternalInit();
//SerTrace.Log( "GetObjectInfo",objectInfo.objectInfoId," GetObjectInfo from pool");
}
else
{
objectInfo = new WriteObjectInfo();
objectInfo.objectInfoId = serObjectInfoInit.objectInfoIdCount++;
//SerTrace.Log( "GetObjectInfo",objectInfo.objectInfoId," GetObjectInfo new not from pool");
}
return(objectInfo);
}
private long Schedule(object obj, bool assignUniqueIdToValueType, Type type, WriteObjectInfo objectInfo)
{
bool flag;
if (obj == null)
{
return(0L);
}
long num = this.InternalGetId(obj, assignUniqueIdToValueType, type, out flag);
if (flag && (num > 0L))
{
if (objectInfo == null)
{
this.m_objectQueue.Enqueue(obj);
return(num);
}
this.m_objectQueue.Enqueue(objectInfo);
}
return(num);
}
private bool CheckForNull(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, object data)
{
bool flag = false;
if (data == null)
{
flag = true;
}
if (flag && ((((this.formatterEnums.FEserializerTypeEnum == InternalSerializerTypeE.Binary) || memberNameInfo.NIisArrayItem) || (memberNameInfo.NItransmitTypeOnObject || memberNameInfo.NItransmitTypeOnMember)) || (objectInfo.isSi || this.CheckTypeFormat(this.formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))))
{
if (typeNameInfo.NIisArrayItem)
{
if (typeNameInfo.NIarrayEnum == InternalArrayTypeE.Single)
{
this.serWriter.WriteDelayedNullItem();
return flag;
}
this.serWriter.WriteNullItem(memberNameInfo, typeNameInfo);
return flag;
}
this.serWriter.WriteNullMember(memberNameInfo, typeNameInfo);
}
return flag;
}
internal void WriteObject(NameInfo nameInfo, NameInfo typeNameInfo, int numMembers, string[] memberNames, Type[] memberTypes, WriteObjectInfo[] memberObjectInfos)
{
this.InternalWriteItemNull();
int nIobjectId = (int) nameInfo.NIobjectId;
string name = null;
if (nIobjectId < 0)
{
name = typeNameInfo.NIname;
}
else
{
name = nameInfo.NIname;
}
if (this.objectMapTable == null)
{
this.objectMapTable = new Hashtable();
}
ObjectMapInfo info = (ObjectMapInfo) this.objectMapTable[name];
if ((info != null) && info.isCompatible(numMembers, memberNames, memberTypes))
{
if (this.binaryObject == null)
{
this.binaryObject = new BinaryObject();
}
this.binaryObject.Set(nIobjectId, info.objectId);
this.binaryObject.Write(this);
}
else
{
int nIassemId;
if (!typeNameInfo.NItransmitTypeOnObject)
{
if (this.binaryObjectWithMap == null)
{
this.binaryObjectWithMap = new BinaryObjectWithMap();
}
nIassemId = (int) typeNameInfo.NIassemId;
this.binaryObjectWithMap.Set(nIobjectId, name, numMembers, memberNames, nIassemId);
this.binaryObjectWithMap.Dump();
this.binaryObjectWithMap.Write(this);
if (info == null)
{
this.objectMapTable.Add(name, new ObjectMapInfo(nIobjectId, numMembers, memberNames, memberTypes));
}
}
else
{
BinaryTypeEnum[] binaryTypeEnumA = new BinaryTypeEnum[numMembers];
object[] typeInformationA = new object[numMembers];
int[] memberAssemIds = new int[numMembers];
for (int i = 0; i < numMembers; i++)
{
object typeInformation = null;
binaryTypeEnumA[i] = BinaryConverter.GetBinaryTypeInfo(memberTypes[i], memberObjectInfos[i], null, this.objectWriter, out typeInformation, out nIassemId);
typeInformationA[i] = typeInformation;
memberAssemIds[i] = nIassemId;
}
if (this.binaryObjectWithMapTyped == null)
{
this.binaryObjectWithMapTyped = new BinaryObjectWithMapTyped();
}
nIassemId = (int) typeNameInfo.NIassemId;
this.binaryObjectWithMapTyped.Set(nIobjectId, name, numMembers, memberNames, binaryTypeEnumA, typeInformationA, memberAssemIds, nIassemId);
this.binaryObjectWithMapTyped.Write(this);
if (info == null)
{
this.objectMapTable.Add(name, new ObjectMapInfo(nIobjectId, numMembers, memberNames, memberTypes));
}
}
}
}
[System.Security.SecurityCritical] // auto-generated
private void WriteRectangle(WriteObjectInfo objectInfo, int rank, int[] maxA, System.Array array, NameInfo arrayElemNameTypeInfo, int[] lowerBoundA)
{
IndexTraceMessage("WriteRectangle Entry "+rank, maxA);
int[] currentA = new int[rank];
int[] indexMap = null;
bool isLowerBound = false;
if (lowerBoundA != null)
{
for (int i=0; i<rank; i++)
{
if (lowerBoundA[i] != 0)
isLowerBound = true;
}
}
if (isLowerBound)
indexMap = new int[rank];
bool isLoop = true;
while (isLoop)
{
isLoop = false;
if (isLowerBound)
{
for (int i=0; i<rank; i++)
{
indexMap[i] = currentA[i]+lowerBoundA[i];
}
WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(indexMap));
}
else
WriteArrayMember(objectInfo, arrayElemNameTypeInfo, array.GetValue(currentA));
for (int irank = rank-1; irank>-1; irank--)
{
// Find the current or lower dimension which can be incremented.
if (currentA[irank] < maxA[irank]-1)
{
// The current dimension is at maximum. Increase the next lower dimension by 1
currentA[irank]++;
if (irank < rank-1)
{
// The current dimension and higher dimensions are zeroed.
for (int i = irank+1; i<rank; i++)
currentA[i] = 0;
}
isLoop = true;
break;
}
}
}
SerTrace.Log( this, "WriteRectangle Exit ");
}
[System.Security.SecurityCritical] // auto-generated
private void WriteArray(WriteObjectInfo objectInfo, NameInfo memberNameInfo, WriteObjectInfo memberObjectInfo)
{
SerTrace.Log( this, "WriteArray Entry ",objectInfo.obj," ",objectInfo.objectId);
bool isAllocatedMemberNameInfo = false;
if (memberNameInfo == null)
{
memberNameInfo = TypeToNameInfo(objectInfo);
isAllocatedMemberNameInfo = true;
}
memberNameInfo.NIisArray = true;
long objectId = objectInfo.objectId;
memberNameInfo.NIobjectId = objectInfo.objectId;
// Get array type
System.Array array = (System.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)
{
arrayElemObjectInfo = WriteObjectInfo.Serialize(arrayElemType, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, m_binder);
arrayElemObjectInfo.assemId = GetAssemblyId(arrayElemObjectInfo);
}
NameInfo arrayElemTypeNameInfo = null;
if (arrayElemObjectInfo == null)
arrayElemTypeNameInfo = TypeToNameInfo(arrayElemType);
else
arrayElemTypeNameInfo = TypeToNameInfo(arrayElemObjectInfo);
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;
// 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.NIisArray)
{
if (rank == 1)
arrayEnum = InternalArrayTypeE.Jagged;
else
arrayEnum = InternalArrayTypeE.Rectangular;
}
else if (rank == 1)
arrayEnum = InternalArrayTypeE.Single;
else
arrayEnum = InternalArrayTypeE.Rectangular;
arrayElemTypeNameInfo.NIarrayEnum = arrayEnum;
SerTrace.Log( this, "WriteArray ArrayInfo type ",arrayType," rank ",rank);
// Byte array
if ((Object.ReferenceEquals(arrayElemType, Converter.typeofByte)) && (rank == 1) && (lowerBoundA[0] == 0))
{
serWriter.WriteObjectByteArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0], (byte[])array);
return;
}
if (Object.ReferenceEquals(arrayElemType, Converter.typeofObject) || (object)Nullable.GetUnderlyingType(arrayElemType) != null)
{
memberNameInfo.NItransmitTypeOnMember = true;
arrayElemTypeNameInfo.NItransmitTypeOnMember = true;
}
if (CheckTypeFormat(formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
memberNameInfo.NItransmitTypeOnObject = true;
arrayElemTypeNameInfo.NItransmitTypeOnObject = true;
}
if (arrayEnum == InternalArrayTypeE.Single)
{
// Single Dimensional array
SerTrace.Log( this, "WriteArray ARRAY_SINGLE ");
// 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.NIprimitiveTypeEnum) && (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
SerTrace.Log( this, "WriteArray ARRAY_JAGGED");
arrayNameInfo.NIobjectId = objectId;
serWriter.WriteJaggedArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0]);
Object[] objectA = (Object[])array;
for (int i = lowerBoundA[0]; i < upperBoundA[0]+1; i++)
{
WriteArrayMember(objectInfo, arrayElemTypeNameInfo, objectA[i]);
}
serWriter.WriteItemEnd();
}
else
{
// Rectangle Array
// Get the length for all the ranks
SerTrace.Log( this, "WriteArray ARRAY_RECTANGLE");
arrayNameInfo.NIobjectId = objectId;
serWriter.WriteRectangleArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, rank, lengthA, lowerBoundA);
IndexTraceMessage("WriteArray Rectangle ", lengthA);
// 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);
SerTrace.Log( this, "WriteArray Exit ");
}
[System.Security.SecurityCritical] // auto-generated
private void WriteMemberSetup(WriteObjectInfo objectInfo,
NameInfo memberNameInfo,
NameInfo typeNameInfo,
String memberName,
Type memberType,
Object memberData,
WriteObjectInfo memberObjectInfo
)
{
NameInfo newMemberNameInfo = MemberToNameInfo(memberName);
// newMemberNameInfo contains the member type
if (memberObjectInfo != null)
newMemberNameInfo.NIassemId = memberObjectInfo.assemId;
newMemberNameInfo.NItype = memberType;
// newTypeNameInfo contains the data type
NameInfo newTypeNameInfo = null;
if (memberObjectInfo == null)
{
newTypeNameInfo = TypeToNameInfo(memberType);
}
else
{
newTypeNameInfo = TypeToNameInfo(memberObjectInfo);
}
newMemberNameInfo.NItransmitTypeOnObject = memberNameInfo.NItransmitTypeOnObject;
newMemberNameInfo.NIisParentTypeOnObject = memberNameInfo.NIisParentTypeOnObject;
WriteMembers(newMemberNameInfo, newTypeNameInfo, memberData, objectInfo, typeNameInfo, memberObjectInfo);
PutNameInfo(newMemberNameInfo);
PutNameInfo(newTypeNameInfo);
}
[System.Security.SecurityCritical] // auto-generated
private void Write(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo)
{
#if _DEBUG
SerTrace.Log( this, "Write 1 Entry objectInfo ",objectInfo,", memberNameInfo ",memberNameInfo,", typeNameInfo ",typeNameInfo);
memberNameInfo.Dump("Write memberNameInfo");
typeNameInfo.Dump("Write typeNameInfo");
#endif
Object obj = objectInfo.obj;
if (obj==null)
throw new ArgumentNullException("objectInfo.obj", Environment.GetResourceString("ArgumentNull_Obj"));
SerTrace.Log( this, "Write 1 objectInfo obj ",objectInfo.obj," objectId ", objectInfo.objectId, " objectType ", objectInfo.objectType);
Type objType = objectInfo.objectType;
long objectId = objectInfo.objectId;
SerTrace.Log( this, "Write 1 ",obj," ObjectId ",objectId);
if (Object.ReferenceEquals(objType, Converter.typeofString))
{
// Top level String
memberNameInfo.NIobjectId = objectId;
serWriter.WriteObjectString((int)objectId, obj.ToString());
}
else
{
if (objectInfo.isArray)
{
WriteArray(objectInfo, memberNameInfo, null);
}
else
{
String[] memberNames;
Type[] memberTypes;
Object[] memberData;
objectInfo.GetMemberInfo(out memberNames, out memberTypes, out memberData);
// Only Binary needs to transmit types for ISerializable because the binary formatter transmits the types in URT format.
// Soap transmits all types as strings, so it is up to the ISerializable object to convert the string back to its URT type
if (objectInfo.isSi || CheckTypeFormat(formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
SerTrace.Log( this, "Write 1 TransmitOnObject ");
memberNameInfo.NItransmitTypeOnObject = true;
memberNameInfo.NIisParentTypeOnObject = true;
typeNameInfo.NItransmitTypeOnObject = true;
typeNameInfo.NIisParentTypeOnObject = true;
}
WriteObjectInfo[] memberObjectInfos = new WriteObjectInfo[memberNames.Length];
// Get assembly information
// Binary Serializer, assembly names need to be
// written before objects are referenced.
// GetAssemId here will write out the
// assemblyStrings at the right Binary
// Serialization object boundary.
for (int i=0; i<memberTypes.Length; i++)
{
Type type;
if ((object)memberTypes[i] != null)
type = memberTypes[i];
else if (memberData[i] != null)
type = GetType(memberData[i]);
else
type = Converter.typeofObject;
SerTrace.Log( this, "Write 1 member type ",type);
InternalPrimitiveTypeE code = ToCode(type);
if ((code == InternalPrimitiveTypeE.Invalid) &&
(!Object.ReferenceEquals(type, Converter.typeofString)))
{
SerTrace.Log( this, "Write 1 Create ObjectInfo ", memberTypes[i], " memberData ",memberData[i]);
if (memberData[i] != null)
{
memberObjectInfos[i] =
WriteObjectInfo.Serialize
(
memberData[i],
m_surrogates,
m_context,
serObjectInfoInit,
m_formatterConverter,
this,
m_binder);
memberObjectInfos[i].assemId = GetAssemblyId(memberObjectInfos[i]);
}
else
{
memberObjectInfos[i] =
WriteObjectInfo.Serialize
(
memberTypes[i],
m_surrogates,
m_context,
serObjectInfoInit,
m_formatterConverter,
m_binder
);
memberObjectInfos[i].assemId = GetAssemblyId(memberObjectInfos[i]);
}
}
}
Write(objectInfo, memberNameInfo, typeNameInfo, memberNames, memberTypes, memberData, memberObjectInfos);
SerTrace.Log( this, "Write 1 ",obj," type ",GetType(obj));
}
}
SerTrace.Log( this, "Write 1 Exit ",obj);
}
//internal BinaryCrossAppDomainMap crossAppDomainMap;
internal void WriteObject(NameInfo nameInfo, NameInfo typeNameInfo, int numMembers, String[] memberNames, Type[] memberTypes, WriteObjectInfo[] memberObjectInfos)
{
InternalWriteItemNull();
int assemId;
#if _DEBUG
nameInfo.Dump("WriteObject nameInfo");
typeNameInfo.Dump("WriteObject typeNameInfo");
#endif
int objectId = (int)nameInfo.NIobjectId;
//if (objectId < 0)
// objectId = --m_nestedObjectCount;
if (objectId > 0)
{
BCLDebug.Trace("BINARY", "-----Top Level Object-----");
}
String objectName = null;
if (objectId < 0)
{
// Nested Object
objectName = typeNameInfo.NIname;
}
else
{
// Non-Nested
objectName = nameInfo.NIname;
}
SerTrace.Log( this, "WriteObject objectName ",objectName);
if (objectMapTable == null)
{
objectMapTable = new Hashtable();
}
ObjectMapInfo objectMapInfo = (ObjectMapInfo)objectMapTable[objectName];
if (objectMapInfo != null && objectMapInfo.isCompatible(numMembers, memberNames, memberTypes))
{
// Object
if (binaryObject == null)
binaryObject = new BinaryObject();
binaryObject.Set(objectId, objectMapInfo.objectId);
#if _DEBUG
binaryObject.Dump();
#endif
binaryObject.Write(this);
}
else if (!typeNameInfo.NItransmitTypeOnObject)
{
// ObjectWithMap
if (binaryObjectWithMap == null)
binaryObjectWithMap = new BinaryObjectWithMap();
// BCL types are not placed into table
assemId = (int)typeNameInfo.NIassemId;
binaryObjectWithMap.Set(objectId, objectName, numMembers, memberNames, assemId);
binaryObjectWithMap.Dump();
binaryObjectWithMap.Write(this);
if (objectMapInfo == null)
objectMapTable.Add(objectName, new ObjectMapInfo(objectId, numMembers, memberNames, memberTypes));
}
else
{
// ObjectWithMapTyped
BinaryTypeEnum[] binaryTypeEnumA = new BinaryTypeEnum[numMembers];
Object[] typeInformationA = new Object[numMembers];
int[] assemIdA = new int[numMembers];
for (int i=0; i<numMembers; i++)
{
Object typeInformation = null;
binaryTypeEnumA[i] = BinaryConverter.GetBinaryTypeInfo(memberTypes[i], memberObjectInfos[i], null, objectWriter, out typeInformation, out assemId);
typeInformationA[i] = typeInformation;
assemIdA[i] = assemId;
SerTrace.Log( this, "WriteObject ObjectWithMapTyped memberNames "
,memberNames[i],", memberType ",memberTypes[i]," binaryTypeEnum ",((Enum)binaryTypeEnumA[i]).ToString()
,", typeInformation ",typeInformationA[i]," assemId ",assemIdA[i]);
}
if (binaryObjectWithMapTyped == null)
binaryObjectWithMapTyped = new BinaryObjectWithMapTyped();
// BCL types are not placed in table
assemId = (int)typeNameInfo.NIassemId;
binaryObjectWithMapTyped.Set(objectId, objectName, numMembers,memberNames, binaryTypeEnumA, typeInformationA, assemIdA, assemId);
#if _DEBUG
binaryObjectWithMapTyped.Dump();
#endif
binaryObjectWithMapTyped.Write(this);
if (objectMapInfo == null)
objectMapTable.Add(objectName, new ObjectMapInfo(objectId, numMembers, memberNames, memberTypes));
}
}
// From the type create the BinaryTypeEnum and typeInformation which describes the type on the wire
internal static BinaryTypeEnum GetBinaryTypeInfo(Type type, WriteObjectInfo objectInfo, String typeName, ObjectWriter objectWriter, out Object typeInformation, out int assemId)
{
SerTrace.Log("BinaryConverter", "GetBinaryTypeInfo Entry type ",type,", typeName ",typeName," objectInfo "+objectInfo);
BinaryTypeEnum binaryTypeEnum;
assemId = 0;
typeInformation = null;
if (Object.ReferenceEquals(type, Converter.typeofString))
binaryTypeEnum = BinaryTypeEnum.String;
else if (((objectInfo == null) || ((objectInfo != null) && !objectInfo.isSi))
&& (Object.ReferenceEquals(type, Converter.typeofObject)))
{
// If objectInfo.Si then can be a surrogate which will change the type
binaryTypeEnum = BinaryTypeEnum.Object;
}
else if (Object.ReferenceEquals(type, Converter.typeofStringArray))
binaryTypeEnum = BinaryTypeEnum.StringArray;
else if (Object.ReferenceEquals(type, Converter.typeofObjectArray))
binaryTypeEnum = BinaryTypeEnum.ObjectArray;
else if (Converter.IsPrimitiveArray(type, out typeInformation))
binaryTypeEnum = BinaryTypeEnum.PrimitiveArray;
else
{
InternalPrimitiveTypeE primitiveTypeEnum = objectWriter.ToCode(type);
switch (primitiveTypeEnum)
{
case InternalPrimitiveTypeE.Invalid:
String assembly = null;
if (objectInfo == null)
{
assembly = type.Assembly.FullName;
typeInformation = type.FullName;
}
else
{
assembly = objectInfo.GetAssemblyString();
typeInformation = objectInfo.GetTypeFullName();
}
if (assembly.Equals(Converter.urtAssemblyString))
{
binaryTypeEnum = BinaryTypeEnum.ObjectUrt;
assemId = 0;
}
else
{
binaryTypeEnum = BinaryTypeEnum.ObjectUser;
Contract.Assert(objectInfo!=null, "[BinaryConverter.GetBinaryTypeInfo]objectInfo null for user object");
assemId = (int)objectInfo.assemId;
if (assemId == 0)
throw new SerializationException(Environment.GetResourceString("Serialization_AssemblyId",typeInformation));
}
break;
default:
binaryTypeEnum = BinaryTypeEnum.Primitive;
typeInformation = primitiveTypeEnum;
break;
}
}
SerTrace.Log( "BinaryConverter", "GetBinaryTypeInfo Exit ",((Enum)binaryTypeEnum).ToString(),", typeInformation ",typeInformation," assemId ",assemId);
return binaryTypeEnum;
}
private static void PutObjectInfo(SerObjectInfoInit serObjectInfoInit, WriteObjectInfo objectInfo)
{
serObjectInfoInit.oiPool.Push(objectInfo);
//SerTrace.Log( "PutObjectInfo",objectInfo.objectInfoId," PutObjectInfo to pool");
}
private static WriteObjectInfo GetObjectInfo(SerObjectInfoInit serObjectInfoInit)
{
WriteObjectInfo objectInfo = null;
if (!serObjectInfoInit.oiPool.IsEmpty())
{
objectInfo = (WriteObjectInfo)serObjectInfoInit.oiPool.Pop();
objectInfo.InternalInit();
//SerTrace.Log( "GetObjectInfo",objectInfo.objectInfoId," GetObjectInfo from pool");
}
else
{
objectInfo = new WriteObjectInfo();
objectInfo.objectInfoId = serObjectInfoInit.objectInfoIdCount++;
//SerTrace.Log( "GetObjectInfo",objectInfo.objectInfoId," GetObjectInfo new not from pool");
}
return objectInfo;
}
internal void WriteSingleArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, Array array)
{
BinaryArrayTypeEnum single;
int num;
this.InternalWriteItemNull();
int[] lengthA = new int[] { length };
int[] lowerBoundA = null;
object typeInformation = null;
if (lowerBound == 0)
{
single = BinaryArrayTypeEnum.Single;
}
else
{
single = BinaryArrayTypeEnum.SingleOffset;
lowerBoundA = new int[] { lowerBound };
}
BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetBinaryTypeInfo(arrayElemTypeNameInfo.NItype, objectInfo, arrayElemTypeNameInfo.NIname, this.objectWriter, out typeInformation, out num);
if (this.binaryArray == null)
{
this.binaryArray = new BinaryArray();
}
this.binaryArray.Set((int) arrayNameInfo.NIobjectId, 1, lengthA, lowerBoundA, binaryTypeEnum, typeInformation, single, num);
long nIobjectId = arrayNameInfo.NIobjectId;
this.binaryArray.Write(this);
if (Converter.IsWriteAsByteArray(arrayElemTypeNameInfo.NIprimitiveTypeEnum) && (lowerBound == 0))
{
if (arrayElemTypeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.Byte)
{
this.WriteBytes((byte[]) array);
}
else if (arrayElemTypeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.Char)
{
this.WriteChars((char[]) array);
}
else
{
this.WriteArrayAsBytes(array, Converter.TypeLength(arrayElemTypeNameInfo.NIprimitiveTypeEnum));
}
}
}
internal void WriteRectangleArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int rank, int[] lengthA, int[] lowerBoundA)
{
this.InternalWriteItemNull();
BinaryArrayTypeEnum rectangular = BinaryArrayTypeEnum.Rectangular;
object typeInformation = null;
int assemId = 0;
BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetBinaryTypeInfo(arrayElemTypeNameInfo.NItype, objectInfo, arrayElemTypeNameInfo.NIname, this.objectWriter, out typeInformation, out assemId);
if (this.binaryArray == null)
{
this.binaryArray = new BinaryArray();
}
for (int i = 0; i < rank; i++)
{
if (lowerBoundA[i] != 0)
{
rectangular = BinaryArrayTypeEnum.RectangularOffset;
break;
}
}
this.binaryArray.Set((int) arrayNameInfo.NIobjectId, rank, lengthA, lowerBoundA, binaryTypeEnum, typeInformation, rectangular, assemId);
long nIobjectId = arrayNameInfo.NIobjectId;
this.binaryArray.Write(this);
}
internal void WriteObjectByteArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, byte[] byteA)
{
this.InternalWriteItemNull();
this.WriteSingleArray(memberNameInfo, arrayNameInfo, objectInfo, arrayElemTypeNameInfo, length, lowerBound, byteA);
}
private NameInfo TypeToNameInfo(WriteObjectInfo objectInfo, NameInfo nameInfo)
{
return TypeToNameInfo(objectInfo.objectType, objectInfo, ToCode(objectInfo.objectType), nameInfo);
}
private long GetAssemblyId(WriteObjectInfo objectInfo)
{
//use objectInfo to get assembly string with new criteria
SerTrace.Log( this, "GetAssemblyId Entry ",objectInfo.objectType," isSi ",objectInfo.isSi);
if (assemblyToIdTable == null)
assemblyToIdTable = new Hashtable(5);
long assemId = 0;
bool isNew = false;
String assemblyString = objectInfo.GetAssemblyString();
String serializedAssemblyString = assemblyString;
if (assemblyString.Length == 0)
{
assemId = 0;
}
else if (assemblyString.Equals(Converter.urtAssemblyString))
{
// Urt type is an assemId of 0. No assemblyString needs
// to be sent
SerTrace.Log( this, "GetAssemblyId urt Assembly String ");
assemId = 0;
}
else
{
// Assembly needs to be sent
// Need to prefix assembly string to separate the string names from the
// assemblyName string names. That is a string can have the same value
// as an assemblyNameString, but it is serialized differently
if (assemblyToIdTable.ContainsKey(assemblyString))
{
assemId = (long)assemblyToIdTable[assemblyString];
isNew = false;
}
else
{
assemId = InternalGetId("___AssemblyString___"+assemblyString, false, null, out isNew);
assemblyToIdTable[assemblyString] = assemId;
}
serWriter.WriteAssembly(objectInfo.objectType, serializedAssemblyString, (int)assemId, isNew);
}
SerTrace.Log( this, "GetAssemblyId Exit id ",assemId," isNew ",isNew," assemblyString ",serializedAssemblyString);
return assemId;
}
[System.Security.SecurityCritical] // auto-generated
internal void WriteSingleArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, Array array)
{
InternalWriteItemNull();
#if _DEBUG
arrayNameInfo.Dump("WriteSingleArray arrayNameInfo");
arrayElemTypeNameInfo.Dump("WriteSingleArray arrayElemTypeNameInfo");
#endif
BinaryArrayTypeEnum binaryArrayTypeEnum;
Int32[] lengthA = new Int32[1];
lengthA[0] = length;
Int32[] lowerBoundA = null;
Object typeInformation = null;
if (lowerBound == 0)
{
binaryArrayTypeEnum = BinaryArrayTypeEnum.Single;
}
else
{
binaryArrayTypeEnum = BinaryArrayTypeEnum.SingleOffset;
lowerBoundA = new Int32[1];
lowerBoundA[0] = lowerBound;
}
int assemId;
BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetBinaryTypeInfo(arrayElemTypeNameInfo.NItype, objectInfo, arrayElemTypeNameInfo.NIname, objectWriter, out typeInformation, out assemId);
if (binaryArray == null)
binaryArray = new BinaryArray();
binaryArray.Set((int)arrayNameInfo.NIobjectId, (int)1, lengthA, lowerBoundA, binaryTypeEnum, typeInformation, binaryArrayTypeEnum, assemId);
if (arrayNameInfo.NIobjectId >0)
{
BCLDebug.Trace("BINARY", "-----Top Level Object-----");
}
#if _DEBUG
binaryArray.Dump();
#endif
binaryArray.Write(this);
if (Converter.IsWriteAsByteArray(arrayElemTypeNameInfo.NIprimitiveTypeEnum) && (lowerBound == 0))
{
//array is written out as an array of bytes
if (arrayElemTypeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.Byte)
WriteBytes((Byte[])array);
else if (arrayElemTypeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.Char)
WriteChars((char[])array);
else
WriteArrayAsBytes(array, Converter.TypeLength(arrayElemTypeNameInfo.NIprimitiveTypeEnum));
}
}
[System.Security.SecurityCritical] // auto-generated
private void Write(WriteObjectInfo objectInfo,
NameInfo memberNameInfo,
NameInfo typeNameInfo,
String[] memberNames,
Type[] memberTypes,
Object[] memberData,
WriteObjectInfo[] memberObjectInfos)
{
SerTrace.Log( this, "Write 2 Entry obj ",objectInfo.obj,". objectId ",objectInfo.objectId,", objType ",typeNameInfo.NIname,", memberName ",memberNameInfo.NIname,", memberType ",typeNameInfo.NIname);
int numItems = memberNames.Length;
NameInfo topNameInfo = null;
if (memberNameInfo != null)
{
SerTrace.Log( this, "Write 2 ObjectBegin, memberName ",memberNameInfo.NIname);
memberNameInfo.NIobjectId = objectInfo.objectId;
serWriter.WriteObject(memberNameInfo, typeNameInfo, numItems, memberNames, memberTypes, memberObjectInfos);
}
else if ((objectInfo.objectId == topId) && (topName != null))
{
SerTrace.Log( this, "Write 2 ObjectBegin, topId method name ",topName);
topNameInfo = MemberToNameInfo(topName);
topNameInfo.NIobjectId = objectInfo.objectId;
serWriter.WriteObject(topNameInfo, typeNameInfo, numItems, memberNames, memberTypes, memberObjectInfos);
}
else
{
if (!Object.ReferenceEquals(objectInfo.objectType, Converter.typeofString))
{
SerTrace.Log( this, "Write 2 ObjectBegin, default ", typeNameInfo.NIname);
typeNameInfo.NIobjectId = objectInfo.objectId;
serWriter.WriteObject(typeNameInfo, null, numItems, memberNames, memberTypes, memberObjectInfos);
}
}
if (memberNameInfo.NIisParentTypeOnObject)
{
memberNameInfo.NItransmitTypeOnObject = true;
memberNameInfo.NIisParentTypeOnObject = false;
}
else
memberNameInfo.NItransmitTypeOnObject = false;
// Write members
for (int i=0; i<numItems; i++)
{
WriteMemberSetup(objectInfo, memberNameInfo, typeNameInfo, memberNames[i], memberTypes[i], memberData[i], memberObjectInfos[i]);
}
if (memberNameInfo != null)
{
memberNameInfo.NIobjectId = objectInfo.objectId;
serWriter.WriteObjectEnd(memberNameInfo, typeNameInfo);
}
else if ((objectInfo.objectId == topId) && (topName != null))
{
serWriter.WriteObjectEnd(topNameInfo, typeNameInfo);
PutNameInfo(topNameInfo);
}
else
{
if (!Object.ReferenceEquals(objectInfo.objectType, Converter.typeofString))
{
serWriter.WriteObjectEnd(typeNameInfo, typeNameInfo);
}
}
SerTrace.Log( this, "Write 2 Exit");
}
internal void WriteJaggedArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound)
{
#if _DEBUG
arrayNameInfo.Dump("WriteRectangleArray arrayNameInfo");
arrayElemTypeNameInfo.Dump("WriteRectangleArray arrayElemTypeNameInfo");
#endif
InternalWriteItemNull();
BinaryArrayTypeEnum binaryArrayTypeEnum;
Int32[] lengthA = new Int32[1];
lengthA[0] = length;
Int32[] lowerBoundA = null;
Object typeInformation = null;
int assemId = 0;
if (lowerBound == 0)
{
binaryArrayTypeEnum = BinaryArrayTypeEnum.Jagged;
}
else
{
binaryArrayTypeEnum = BinaryArrayTypeEnum.JaggedOffset;
lowerBoundA = new Int32[1];
lowerBoundA[0] = lowerBound;
}
BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetBinaryTypeInfo(arrayElemTypeNameInfo.NItype, objectInfo, arrayElemTypeNameInfo.NIname, objectWriter, out typeInformation, out assemId);
if (binaryArray == null)
binaryArray = new BinaryArray();
binaryArray.Set((int)arrayNameInfo.NIobjectId, (int)1, lengthA, lowerBoundA, binaryTypeEnum, typeInformation, binaryArrayTypeEnum, assemId);
if (arrayNameInfo.NIobjectId >0)
{
BCLDebug.Trace("BINARY", "-----Top Level Object-----");
}
#if _DEBUG
binaryArray.Dump();
#endif
binaryArray.Write(this);
}
[System.Security.SecurityCritical] // auto-generated
private void WriteMembers(NameInfo memberNameInfo,
NameInfo memberTypeNameInfo,
Object memberData,
WriteObjectInfo objectInfo,
NameInfo typeNameInfo,
WriteObjectInfo memberObjectInfo
)
{
SerTrace.Log( this, "WriteMembers Entry memberType: ",memberTypeNameInfo.NIname," memberName: ",memberNameInfo.NIname," data: ",memberData," objectId: ",objectInfo.objectId, " Container object ",objectInfo.obj, " memberObjectinfo ",memberObjectInfo);
Type memberType = memberNameInfo.NItype;
bool assignUniqueIdToValueType = false;
// Types are transmitted for a member as follows:
// The member is of type object
// The member object of type is ISerializable and
// Binary - Types always transmitted.
if (Object.ReferenceEquals(memberType, Converter.typeofObject) || (object)Nullable.GetUnderlyingType(memberType) != null)
{
memberTypeNameInfo.NItransmitTypeOnMember = true;
memberNameInfo.NItransmitTypeOnMember = true;
}
if (CheckTypeFormat(formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways) || (objectInfo.isSi) )
{
memberTypeNameInfo.NItransmitTypeOnObject = true;
memberNameInfo.NItransmitTypeOnObject = true;
memberNameInfo.NIisParentTypeOnObject = true;
}
if (CheckForNull(objectInfo, memberNameInfo, memberTypeNameInfo, memberData))
{
return;
}
Object outObj = memberData;
Type outType = null;
// If member type does not equal data type, transmit type on object.
if (memberTypeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.Invalid)
{
outType = GetType(outObj);
if (!Object.ReferenceEquals(memberType, outType))
{
memberTypeNameInfo.NItransmitTypeOnMember = true;
memberNameInfo.NItransmitTypeOnMember = true;
}
}
if (Object.ReferenceEquals(memberType, Converter.typeofObject))
{
assignUniqueIdToValueType = true;
memberType = GetType(memberData);
if (memberObjectInfo == null)
TypeToNameInfo(memberType, memberTypeNameInfo);
else
TypeToNameInfo(memberObjectInfo, memberTypeNameInfo);
SerTrace.Log( this, "WriteMembers memberType Object, actual memberType ",memberType);
}
if (memberObjectInfo != null && memberObjectInfo.isArray)
{
// Array
SerTrace.Log( this, "WriteMembers IsArray");
long arrayId = 0;
if ((object)outType == null)
outType = GetType(outObj);
// outObj is an array. It can never be a value type..
arrayId = Schedule(outObj, false, null, memberObjectInfo);
if (arrayId > 0)
{
// Array as object
SerTrace.Log( this, "WriteMembers Schedule 3");
memberNameInfo.NIobjectId = arrayId;
WriteObjectRef(memberNameInfo, arrayId);
}
else
{
// Nested Array
serWriter.WriteMemberNested(memberNameInfo);
memberObjectInfo.objectId = arrayId;
memberNameInfo.NIobjectId = arrayId;
WriteArray(memberObjectInfo, memberNameInfo, memberObjectInfo);
objectInfo.ObjectEnd();
}
SerTrace.Log( this, "WriteMembers Array Exit ");
return;
}
if (!WriteKnownValueClass(memberNameInfo, memberTypeNameInfo, memberData))
{
SerTrace.Log( this, "WriteMembers Object ",memberData);
#if false
// Value or NO_ID, need to explicitly check for IsValue because a top level
// value class has an objectId of 1
/*
if (memberType.IsValueType)
{
SerTrace.Log( this, "WriteMembers Value Type or NO_ID parameter");
bool isNew;
memberObjectInfo.objectId = InternalGetId(outObj, assignUniqueIdToValueType, memberType, out isNew) ;
NameInfo newTypeNameInfo = TypeToNameInfo(memberObjectInfo);
newTypeNameInfo.NIobjectId = memberObjectInfo.objectId;
Write( memberObjectInfo, memberNameInfo, newTypeNameInfo);
PutNameInfo(newTypeNameInfo);
memberObjectInfo.ObjectEnd();
}
else
*/
#endif
{
SerTrace.Log( this, "WriteMembers Schedule 4 ", outType, " memberInfo ",memberObjectInfo);
if ((object)outType == null)
outType = GetType(outObj);
long memberObjectId = Schedule(outObj, assignUniqueIdToValueType, outType, memberObjectInfo);
if (memberObjectId < 0)
{
// Nested object
SerTrace.Log( this, "WriteMembers Nesting");
memberObjectInfo.objectId = memberObjectId;
NameInfo newTypeNameInfo = TypeToNameInfo(memberObjectInfo);
newTypeNameInfo.NIobjectId = memberObjectId;
Write(memberObjectInfo, memberNameInfo, newTypeNameInfo);
PutNameInfo(newTypeNameInfo);
memberObjectInfo.ObjectEnd();
}
else
{
// Object reference
memberNameInfo.NIobjectId = memberObjectId;
WriteObjectRef(memberNameInfo, memberObjectId);
}
}
}
SerTrace.Log( this, "WriteMembers Exit ");
}
internal void WriteRectangleArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int rank, int[] lengthA, int[] lowerBoundA)
{
#if _DEBUG
arrayNameInfo.Dump("WriteRectangleArray arrayNameInfo");
arrayElemTypeNameInfo.Dump("WriteRectangleArray arrayElemTypeNameInfo");
#endif
InternalWriteItemNull();
BinaryArrayTypeEnum binaryArrayTypeEnum = BinaryArrayTypeEnum.Rectangular;
Object typeInformation = null;
int assemId = 0;
BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetBinaryTypeInfo(arrayElemTypeNameInfo.NItype, objectInfo, arrayElemTypeNameInfo.NIname, objectWriter, out typeInformation, out assemId);
if (binaryArray == null)
binaryArray = new BinaryArray();
for (int i=0; i<rank; i++)
{
if (lowerBoundA[i] != 0)
{
binaryArrayTypeEnum = BinaryArrayTypeEnum.RectangularOffset;
break;
}
}
binaryArray.Set((int)arrayNameInfo.NIobjectId, rank, lengthA, lowerBoundA, binaryTypeEnum, typeInformation, binaryArrayTypeEnum, assemId);
if (arrayNameInfo.NIobjectId >0)
{
BCLDebug.Trace("BINARY", "-----Top Level Object-----");
}
#if _DEBUG
binaryArray.Dump();
#endif
binaryArray.Write(this);
}
[System.Security.SecurityCritical] // auto-generated
private void WriteArrayMember(WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, Object data)
{
SerTrace.Log( this, "WriteArrayMember ",data," baseArrayName ",arrayElemTypeNameInfo.NIname);
arrayElemTypeNameInfo.NIisArrayItem = true;
if (CheckForNull(objectInfo, arrayElemTypeNameInfo, arrayElemTypeNameInfo, data))
return;
NameInfo actualTypeInfo = null;
Type dataType = null;
bool isObjectOnMember = false;
if (arrayElemTypeNameInfo.NItransmitTypeOnMember)
isObjectOnMember = true;
if (!isObjectOnMember && !arrayElemTypeNameInfo.IsSealed)
{
dataType = GetType(data);
if (!Object.ReferenceEquals(arrayElemTypeNameInfo.NItype, dataType))
isObjectOnMember = true;
}
if (isObjectOnMember)
{
// Object array, need type of member
if ((object)dataType == null)
dataType = GetType(data);
actualTypeInfo = TypeToNameInfo(dataType);
actualTypeInfo.NItransmitTypeOnMember = true;
actualTypeInfo.NIobjectId = arrayElemTypeNameInfo.NIobjectId;
actualTypeInfo.NIassemId = arrayElemTypeNameInfo.NIassemId;
actualTypeInfo.NIisArrayItem = true;
}
else
{
actualTypeInfo = arrayElemTypeNameInfo;
actualTypeInfo.NIisArrayItem = true;
}
if (!WriteKnownValueClass(arrayElemTypeNameInfo, actualTypeInfo, data))
{
Object obj = data;
bool assignUniqueIdForValueTypes = false;
if (Object.ReferenceEquals(arrayElemTypeNameInfo.NItype, Converter.typeofObject))
assignUniqueIdForValueTypes = true;
long arrayId = Schedule(obj, assignUniqueIdForValueTypes, actualTypeInfo.NItype);
arrayElemTypeNameInfo.NIobjectId = arrayId;
actualTypeInfo.NIobjectId = arrayId;
if (arrayId < 1)
{
WriteObjectInfo newObjectInfo = WriteObjectInfo.Serialize(obj, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, this, m_binder);
newObjectInfo.objectId = arrayId;
if (!Object.ReferenceEquals(arrayElemTypeNameInfo.NItype, Converter.typeofObject) && (object)Nullable.GetUnderlyingType(arrayElemTypeNameInfo.NItype) == null)
newObjectInfo.assemId = actualTypeInfo.NIassemId;
else
newObjectInfo.assemId = GetAssemblyId(newObjectInfo);
SerTrace.Log( this, "WriteArrayMembers nested");
NameInfo typeNameInfo = TypeToNameInfo(newObjectInfo);
typeNameInfo.NIobjectId = arrayId;
newObjectInfo.objectId = arrayId;
Write(newObjectInfo, actualTypeInfo, typeNameInfo);
newObjectInfo.ObjectEnd();
}
else
{
serWriter.WriteItemObjectRef(arrayElemTypeNameInfo, (int)arrayId);
}
}
if (arrayElemTypeNameInfo.NItransmitTypeOnMember)
PutNameInfo(actualTypeInfo);
}
[System.Security.SecurityCritical] // auto-generated
internal void WriteObjectByteArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, Byte[] byteA)
{
#if _DEBUG
arrayNameInfo.Dump("WriteObjectByteArray arrayNameInfo");
arrayElemTypeNameInfo.Dump("WriteObjectByteArray arrayElemTypeNameInfo");
#endif
InternalWriteItemNull();
WriteSingleArray(memberNameInfo, arrayNameInfo, objectInfo, arrayElemTypeNameInfo, length, lowerBound, byteA);
}
private long Schedule(Object obj, bool assignUniqueIdToValueType, Type type, WriteObjectInfo objectInfo)
{
SerTrace.Log( this, "Schedule Entry obj ",obj," type ", type, " objectInfo ",objectInfo);
bool isNew;
long id;
if (obj==null)
{
SerTrace.Log(this, "Schedule Obj Null, id = 0 ");
return 0;
}
id = InternalGetId(obj, assignUniqueIdToValueType, type, out isNew);
if (isNew && id > 0)
{
if (objectInfo == null)
m_objectQueue.Enqueue(obj);
else
m_objectQueue.Enqueue(objectInfo);
}
SerTrace.Log( this, "Schedule Exit, id: ",id," isNew: ",isNew);
return id;
}
// Writes a null member into the stream
private bool CheckForNull(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, Object data)
{
#if _DEBUG
SerTrace.Log( this, "CheckForNull Entry data ",Util.PString(data),", memberType ",Util.PString(typeNameInfo.NItype));
#endif
bool isNull = false;
if (data == null) // || Convert.IsDBNull(data)
isNull = true;
// Optimization, Null members are only written for Binary
if ((isNull) && (((formatterEnums.FEserializerTypeEnum == InternalSerializerTypeE.Binary)) ||
memberNameInfo.NIisArrayItem ||
memberNameInfo.NItransmitTypeOnObject ||
memberNameInfo.NItransmitTypeOnMember ||
objectInfo.isSi ||
(CheckTypeFormat(formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))))
{
SerTrace.Log( this, "CheckForNull Write");
if (typeNameInfo.NIisArrayItem)
{
if (typeNameInfo.NIarrayEnum == InternalArrayTypeE.Single)
serWriter.WriteDelayedNullItem();
else
serWriter.WriteNullItem(memberNameInfo, typeNameInfo);
}
else
serWriter.WriteNullMember(memberNameInfo, typeNameInfo);
}
SerTrace.Log( this, "CheckForNull Exit ",isNull);
return isNull;
}
internal static InternalNameSpaceE GetNameSpaceEnum(InternalPrimitiveTypeE code, Type type, WriteObjectInfo objectInfo, out string typeName)
{
InternalNameSpaceE nameSpaceEnum = InternalNameSpaceE.None;
typeName = null;
if (code != InternalPrimitiveTypeE.Invalid)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
case InternalPrimitiveTypeE.Char:
case InternalPrimitiveTypeE.Byte:
case InternalPrimitiveTypeE.Double:
case InternalPrimitiveTypeE.Int16:
case InternalPrimitiveTypeE.Int32:
case InternalPrimitiveTypeE.Int64:
case InternalPrimitiveTypeE.SByte:
case InternalPrimitiveTypeE.Single:
case InternalPrimitiveTypeE.UInt16:
case InternalPrimitiveTypeE.UInt32:
case InternalPrimitiveTypeE.UInt64:
case InternalPrimitiveTypeE.DateTime:
case InternalPrimitiveTypeE.TimeSpan:
nameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
typeName = "System." + ToComType(code);
break;
case InternalPrimitiveTypeE.Decimal:
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
typeName = "System." + ToComType(code);
break;
}
}
if ((nameSpaceEnum == InternalNameSpaceE.None) && type != null)
{
if (ReferenceEquals(type, s_typeofString))
{
nameSpaceEnum = InternalNameSpaceE.XdrString;
}
else
{
if (objectInfo == null)
{
typeName = type.FullName;
nameSpaceEnum = type.GetTypeInfo().Assembly == s_urtAssembly ? InternalNameSpaceE.UrtSystem : InternalNameSpaceE.UrtUser;
}
else
{
typeName = objectInfo.GetTypeFullName();
nameSpaceEnum = objectInfo.GetAssemblyString().Equals(s_urtAssemblyString) ? InternalNameSpaceE.UrtSystem : InternalNameSpaceE.UrtUser;
}
}
}
return nameSpaceEnum;
}
// Transforms a type to the serialized string form. URT Primitive types are converted to XMLData Types
private NameInfo TypeToNameInfo(Type type, WriteObjectInfo objectInfo, InternalPrimitiveTypeE code, NameInfo nameInfo)
{
SerTrace.Log( this, "TypeToNameInfo Entry type ",type,", objectInfo ",objectInfo,", code ", ((Enum)code).ToString());
if (nameInfo == null)
nameInfo = GetNameInfo();
else
nameInfo.Init();
if (code == InternalPrimitiveTypeE.Invalid)
{
if (objectInfo != null)
{
nameInfo.NIname = objectInfo.GetTypeFullName();
nameInfo.NIassemId = objectInfo.assemId;
}
}
nameInfo.NIprimitiveTypeEnum = code;
nameInfo.NItype = type;
SerTrace.Log( this, "TypeToNameInfo Exit ",type, " typeName "+nameInfo.NIname);
return nameInfo;
}
internal void WriteJaggedArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound)
{
BinaryArrayTypeEnum jagged;
this.InternalWriteItemNull();
int[] lengthA = new int[] { length };
int[] lowerBoundA = null;
object typeInformation = null;
int assemId = 0;
if (lowerBound == 0)
{
jagged = BinaryArrayTypeEnum.Jagged;
}
else
{
jagged = BinaryArrayTypeEnum.JaggedOffset;
lowerBoundA = new int[] { lowerBound };
}
BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetBinaryTypeInfo(arrayElemTypeNameInfo.NItype, objectInfo, arrayElemTypeNameInfo.NIname, this.objectWriter, out typeInformation, out assemId);
if (this.binaryArray == null)
{
this.binaryArray = new BinaryArray();
}
this.binaryArray.Set((int) arrayNameInfo.NIobjectId, 1, lengthA, lowerBoundA, binaryTypeEnum, typeInformation, jagged, assemId);
long nIobjectId = arrayNameInfo.NIobjectId;
this.binaryArray.Write(this);
}
internal static InternalNameSpaceE GetNameSpaceEnum(InternalPrimitiveTypeE code, Type type, WriteObjectInfo objectInfo, out String typeName)
{
SerTrace.Log("Converter", "GetNameSpaceEnum Entry ",((Enum)code).ToString()," type ",type);
InternalNameSpaceE nameSpaceEnum = InternalNameSpaceE.None;
typeName = null;
if (code != InternalPrimitiveTypeE.Invalid)
{
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
case InternalPrimitiveTypeE.Char:
case InternalPrimitiveTypeE.Byte:
case InternalPrimitiveTypeE.Double:
case InternalPrimitiveTypeE.Int16:
case InternalPrimitiveTypeE.Int32:
case InternalPrimitiveTypeE.Int64:
case InternalPrimitiveTypeE.SByte:
case InternalPrimitiveTypeE.Single:
case InternalPrimitiveTypeE.UInt16:
case InternalPrimitiveTypeE.UInt32:
case InternalPrimitiveTypeE.UInt64:
case InternalPrimitiveTypeE.DateTime:
case InternalPrimitiveTypeE.TimeSpan:
nameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
typeName = "System."+ToComType(code);
break;
case InternalPrimitiveTypeE.Decimal:
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
typeName = "System."+ToComType(code);
break;
}
}
if ((nameSpaceEnum == InternalNameSpaceE.None) && ((object)type != null))
{
if (Object.ReferenceEquals(type, typeofString))
nameSpaceEnum = InternalNameSpaceE.XdrString;
else
{
if (objectInfo == null)
{
typeName = type.FullName;
if (type.Assembly == urtAssembly)
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
else
nameSpaceEnum = InternalNameSpaceE.UrtUser;
}
else
{
typeName = objectInfo.GetTypeFullName();
if (objectInfo.GetAssemblyString().Equals(urtAssemblyString))
nameSpaceEnum = InternalNameSpaceE.UrtSystem;
else
nameSpaceEnum = InternalNameSpaceE.UrtUser;
}
}
}
SerTrace.Log("Converter", "GetNameSpaceEnum Exit ", ((Enum)nameSpaceEnum).ToString()," typeName ",typeName);
return nameSpaceEnum;
}
