private void ArrayNameToDisplayName(WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo)
{
string nIname = arrayElemTypeNameInfo.NIname;
int index = nIname.IndexOf('[');
if (index <= 0)
{
if (nIname.Equals("System.Object"))
{
arrayElemTypeNameInfo.NIname = "anyType";
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
}
}
else
{
string str2 = nIname.Substring(0, index);
InternalPrimitiveTypeE code = Converter.ToCode(str2);
string str3 = null;
bool flag = false;
switch (code)
{
case InternalPrimitiveTypeE.Invalid:
if (!str2.Equals("String") && !str2.Equals("System.String"))
{
if (str2.Equals("System.Object"))
{
flag = true;
str3 = "anyType";
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
}
else
{
str3 = str2;
}
break;
}
flag = true;
str3 = "string";
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.XdrString;
break;
case InternalPrimitiveTypeE.Char:
str3 = str2;
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.UrtSystem;
break;
default:
{
flag = true;
str3 = Converter.ToXmlDataType(code);
string typeName = null;
arrayElemTypeNameInfo.NInameSpaceEnum = Converter.GetNameSpaceEnum(code, null, objectInfo, out typeName);
break;
}
}
if (flag)
{
arrayElemTypeNameInfo.NIname = str3 + nIname.Substring(index);
}
}
}
internal void WriteMemberString(NameInfo memberNameInfo, NameInfo typeNameInfo, string value)
{
int nIobjectId = (int) typeNameInfo.NIobjectId;
this.attrList.Clear();
if (nIobjectId > 0)
{
this.attrList.Put("id", this.IdToString((int) typeNameInfo.NIobjectId));
}
if ((typeNameInfo.NItype != null) && (memberNameInfo.NItransmitTypeOnMember || (memberNameInfo.NItransmitTypeOnObject && !memberNameInfo.NIisArrayItem)))
{
if (typeNameInfo.NIobjectId > 0L)
{
this.attrList.Put("xsi:type", "SOAP-ENC:string");
this.isUsedEnc = true;
}
else
{
this.attrList.Put("xsi:type", "xsd:string");
}
}
NameInfo info = null;
if (typeNameInfo.NInameSpaceEnum == InternalNameSpaceE.Interop)
{
info = typeNameInfo;
}
string name = this.MemberElementName(memberNameInfo, info);
this.NamespaceAttribute();
this.Write(InternalElementTypeE.Member, name, this.attrList, value, true, Converter.IsEscaped(typeNameInfo.NIprimitiveTypeEnum));
}
// Writes the members of an object
private void WriteMembers(NameInfo memberNameInfo,
NameInfo memberTypeNameInfo,
Object memberData,
WriteObjectInfo objectInfo,
NameInfo typeNameInfo,
WriteObjectInfo memberObjectInfo,
bool isAttribute)
{
InternalST.Soap( this, "WriteMembers Entry memberType: ",memberTypeNameInfo.NIname," memberName: ",memberNameInfo.NIname," data: ",memberData," objectId: ",objectInfo.objectId, " Container object ",objectInfo.obj, " isAttribute ", isAttribute);
Type memberType = memberNameInfo.NItype;
// Types are transmitted for a member as follows:
// The member is of type object
// The member object of type is ISerializable and
// Soap - the member is a non-primitive value type, or it is a primitive value type which needs types (TimeSpan, DateTime)
// TimeSpan and DateTime are transmitted as UInt64 to keep their precision.
// Binary - Types always transmitted.
if ((memberType == Converter.typeofObject) ||
(memberType.IsValueType && objectInfo.isSi &&
Converter.IsSiTransmitType(memberTypeNameInfo.NIprimitiveTypeEnum)))
{
memberTypeNameInfo.NItransmitTypeOnMember = true;
memberNameInfo.NItransmitTypeOnMember = true;
}
if (CheckTypeFormat(formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
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)
{
if (RemotingServices.IsTransparentProxy(outObj))
outType = Converter.typeofMarshalByRefObject;
else
{
outType = GetType(outObj);
if (memberType != outType)
{
memberTypeNameInfo.NItransmitTypeOnMember = true;
memberNameInfo.NItransmitTypeOnMember = true;
}
}
}
if (memberType == Converter.typeofObject)
{
memberType = GetType(memberData);
if (memberObjectInfo == null)
TypeToNameInfo(memberType, memberTypeNameInfo);
else
TypeToNameInfo(memberObjectInfo, memberTypeNameInfo);
InternalST.Soap( this, "WriteMembers memberType Object, actual memberType ",memberType);
}
if (memberObjectInfo != null && memberObjectInfo.isArray)
{
// Array
InternalST.Soap( this, "WriteMembers IsArray");
long arrayId = 0;
if (!(objectInfo.IsEmbeddedAttribute(memberNameInfo.NIname)|| IsEmbeddedAttribute(memberType)))
{
arrayId = Schedule(outObj, outType, memberObjectInfo);
}
if (arrayId > 0)
{
// Array as object
InternalST.Soap( this, "WriteMembers Schedule 3");
memberNameInfo.NIobjectId = arrayId;
WriteObjectRef(memberNameInfo, arrayId);
}
else
{
// Nested Array
serWriter.WriteMemberNested(memberNameInfo);
memberObjectInfo.objectId = arrayId;
memberNameInfo.NIobjectId = arrayId;
memberNameInfo.NIisNestedObject = true;
WriteArray(memberObjectInfo, memberNameInfo, memberObjectInfo);
}
InternalST.Soap( this, "WriteMembers Array Exit ");
return;
}
if (!WriteKnownValueClass(memberNameInfo, memberTypeNameInfo, memberData, isAttribute))
{
InternalST.Soap( this, "WriteMembers Object ",memberData);
// In soap an enum is written out as a string
if (memberTypeNameInfo.NItype.IsEnum)
WriteEnum(memberNameInfo, memberTypeNameInfo, memberData, isAttribute);
else
{
if (isAttribute)
{
// XmlAttribute must be a primitive type or string
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_NonPrimitive_XmlAttribute"), memberNameInfo.NIname));
}
// Value or NO_ID, need to explicitly check for IsValue because a top level
// value class has an objectId of 1
if ((memberType.IsValueType) || objectInfo.IsEmbeddedAttribute(memberNameInfo.NIname) || IsEmbeddedAttribute(outType))
{
InternalST.Soap( this, "WriteMembers Value Type or NO_ID parameter");
serWriter.WriteMemberNested(memberNameInfo);
memberObjectInfo.objectId = -1;
NameInfo newTypeNameInfo = TypeToNameInfo(memberObjectInfo);
newTypeNameInfo.NIobjectId = -1;
memberNameInfo.NIisNestedObject = true;
if (objectInfo.isSi)
{
memberTypeNameInfo.NItransmitTypeOnMember = true;
memberNameInfo.NItransmitTypeOnMember = true;
}
Write( memberObjectInfo, memberNameInfo, newTypeNameInfo);
PutNameInfo(newTypeNameInfo);
memberObjectInfo.ObjectEnd();
}
else
{
InternalST.Soap( this, "WriteMembers Schedule 4");
long memberObjectId = 0;
memberObjectId = Schedule(outObj, outType, memberObjectInfo);
if (memberObjectId < 0)
{
// Nested object
InternalST.Soap( this, "WriteMembers Nesting");
serWriter.WriteMemberNested(memberNameInfo);
memberObjectInfo.objectId = -1;
NameInfo newTypeNameInfo = TypeToNameInfo(memberObjectInfo);
newTypeNameInfo.NIobjectId = -1;
memberNameInfo.NIisNestedObject = true;
Write(memberObjectInfo, memberNameInfo, newTypeNameInfo);
PutNameInfo(newTypeNameInfo);
memberObjectInfo.ObjectEnd();
}
else
{
// Object reference
memberNameInfo.NIobjectId = memberObjectId;
WriteObjectRef(memberNameInfo, memberObjectId);
}
}
}
}
InternalST.Soap( this, "WriteMembers Exit ");
}
// Writes a given object to the stream.
private void Write(WriteObjectInfo objectInfo,
NameInfo memberNameInfo,
NameInfo typeNameInfo,
String[] memberNames,
Type[] memberTypes,
Object[] memberData,
WriteObjectInfo[] memberObjectInfos)
{
InternalST.Soap( this, "Write 2 Entry obj ",objectInfo.obj,". objectId ",objectInfo.objectId,", objType ",typeNameInfo.NIname,", memberName ",memberNameInfo.NIname,", memberType ",typeNameInfo.NIname,", isMustUnderstand ",memberNameInfo.NIisMustUnderstand);
int numItems = memberNames.Length;
NameInfo topNameInfo = null;
// Process members which will be written out as Soap attributes first
if (objectInfo.cache.memberAttributeInfos != null)
{
InternalST.Soap( this, "Write Attribute Members");
for (int i=0; i<objectInfo.cache.memberAttributeInfos.Length; i++)
{
InternalST.Soap( this, "Write Attribute Members name ", memberNames[i]);
if ((objectInfo.cache.memberAttributeInfos[i] != null) &&
(objectInfo.cache.memberAttributeInfos[i].IsXmlAttribute()))
WriteMemberSetup(objectInfo, memberNameInfo, typeNameInfo, memberNames[i], memberTypes[i], memberData[i], memberObjectInfos[i], true);
}
}
if (memberNameInfo != null)
{
InternalST.Soap( 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))
{
InternalST.Soap( 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 (objectInfo.objectType != Converter.typeofString)
{
InternalST.Soap( 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++)
{
if ((objectInfo.cache.memberAttributeInfos == null) ||
(objectInfo.cache.memberAttributeInfos[i] == null) ||
(!(objectInfo.cache.memberAttributeInfos[i].IsXmlAttribute())))
WriteMemberSetup(objectInfo, memberNameInfo, typeNameInfo, memberNames[i], memberTypes[i], memberData[i], memberObjectInfos[i], false);
}
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 (objectInfo.objectType != Converter.typeofString)
{
String objectName = objectInfo.GetTypeFullName();
serWriter.WriteObjectEnd(typeNameInfo, typeNameInfo);
}
}
InternalST.Soap( this, "Write 2 Exit");
}
private void HeaderNamespace(Header header, NameInfo nameInfo)
{
if (header.HeaderNamespace == null)
nameInfo.NInamespace = headerNamespace;
else
nameInfo.NInamespace = header.HeaderNamespace;
bool isNew = false;
nameInfo.NIheaderPrefix = "h"+InternalGetId(nameInfo.NInamespace, Converter.typeofString, out isNew);
}
private void PutNameInfo(NameInfo nameInfo)
{
niPool.Push(nameInfo);
}
private void WriteEnum(NameInfo memberNameInfo, NameInfo typeNameInfo, Object data, bool isAttribute)
{
InternalST.Soap( this, "WriteEnum ", memberNameInfo.NIname," type ", typeNameInfo.NItype," data ",((Enum)data).ToString());
// An enum is written out as a string
if (isAttribute)
serWriter.WriteAttributeValue(memberNameInfo, typeNameInfo, ((Enum)data).ToString());
else
serWriter.WriteMember(memberNameInfo, typeNameInfo, ((Enum)data).ToString());
}
// Transforms an Array to the serialized string form.
private NameInfo ArrayTypeToNameInfo(WriteObjectInfo objectInfo, out NameInfo arrayElemTypeNameInfo)
{
InternalST.Soap( this, "ArrayTypeToNameInfo Entry ",objectInfo.objectType);
NameInfo arrayNameInfo = TypeToNameInfo(objectInfo);
//arrayElemTypeNameInfo = TypeToNameInfo(objectInfo.objectType.GetElementType());
arrayElemTypeNameInfo = TypeToNameInfo(objectInfo.arrayElemObjectInfo);
// Need to substitute XDR type for URT type in array.
// E.g. Int32[] becomes I4[]
ArrayNameToDisplayName(objectInfo, arrayElemTypeNameInfo);
arrayNameInfo.NInameSpaceEnum = arrayElemTypeNameInfo.NInameSpaceEnum;
arrayElemTypeNameInfo.NIisArray = arrayElemTypeNameInfo.NItype.IsArray;
InternalST.Soap( this, "ArrayTypeToNameInfo Exit array ",arrayNameInfo.NIname," element ",arrayElemTypeNameInfo.NIname);
return arrayNameInfo;
}
internal void WriteRectangleArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int rank, int[] lengthA, int[] lowerBoundA)
{
this.sbOffset.Length = 0;
this.sbOffset.Append("[");
bool flag = true;
for (int i = 0; i < rank; i++)
{
if (lowerBoundA[i] != 0)
{
flag = false;
}
if (i > 0)
{
this.sbOffset.Append(",");
}
this.sbOffset.Append(lowerBoundA[i]);
}
this.sbOffset.Append("]");
this.attrList.Clear();
if (memberNameInfo.NIobjectId == this.topId)
{
this.Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", this.attrList, null, false, false);
}
if (arrayNameInfo.NIobjectId > 1L)
{
this.attrList.Put("id", this.IdToString((int) arrayNameInfo.NIobjectId));
}
arrayElemTypeNameInfo.NIitemName = this.NameTagResolver(arrayElemTypeNameInfo, true);
this.attrList.Put("SOAP-ENC:arrayType", this.TypeArrayNameTagResolver(memberNameInfo, arrayNameInfo, true));
this.isUsedEnc = true;
if (!flag)
{
this.attrList.Put("SOAP-ENC:offset", this.sbOffset.ToString());
}
string name = this.MemberElementName(memberNameInfo, null);
this.NamespaceAttribute();
this.Write(InternalElementTypeE.ObjectBegin, name, this.attrList, null, false, false);
}
internal void WriteObjectString(NameInfo nameInfo, string value)
{
this.attrList.Clear();
if (nameInfo.NIobjectId == this.topId)
{
this.Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", this.attrList, null, false, false);
}
if (nameInfo.NIobjectId > 0L)
{
this.attrList.Put("id", this.IdToString((int) nameInfo.NIobjectId));
}
string name = null;
if (nameInfo.NIobjectId > 0L)
{
name = "SOAP-ENC:string";
this.isUsedEnc = true;
}
else
{
name = "xsd:string";
}
this.Write(InternalElementTypeE.Member, name, this.attrList, value, false, Converter.IsEscaped(nameInfo.NIprimitiveTypeEnum));
}
internal void WriteObjectEnd(NameInfo memberNameInfo, NameInfo typeNameInfo)
{
this.attrList.Clear();
this.Write(InternalElementTypeE.ObjectEnd, this.MemberElementName(memberNameInfo, typeNameInfo), this.attrList, null, true, false);
this.assemblyInfoUsed.Clear();
}
internal void WriteObjectByteArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, byte[] byteA)
{
string str = Convert.ToBase64String(byteA);
this.attrList.Clear();
if (memberNameInfo.NIobjectId == this.topId)
{
this.Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", this.attrList, null, false, false);
}
if (arrayNameInfo.NIobjectId > 1L)
{
this.attrList.Put("id", this.IdToString((int) arrayNameInfo.NIobjectId));
}
this.attrList.Put("xsi:type", "SOAP-ENC:base64");
this.isUsedEnc = true;
string name = this.MemberElementName(memberNameInfo, null);
this.NamespaceAttribute();
this.Write(InternalElementTypeE.Member, name, this.attrList, str, true, false);
}
internal void WriteObject(NameInfo nameInfo, NameInfo typeNameInfo, int numMembers, string[] memberNames, Type[] memberTypes, WriteObjectInfo[] objectInfos)
{
int nIobjectId = (int) nameInfo.NIobjectId;
this.attrList.Clear();
if (nIobjectId == this.topId)
{
this.Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", this.attrList, null, false, false);
}
if (nIobjectId > 0)
{
this.attrList.Put("id", this.IdToString((int) nameInfo.NIobjectId));
}
if ((nameInfo.NItransmitTypeOnObject || nameInfo.NItransmitTypeOnMember) && (nameInfo.NIisNestedObject || nameInfo.NIisArrayItem))
{
this.attrList.Put("xsi:type", this.TypeNameTagResolver(typeNameInfo, true));
}
if (nameInfo.NIisMustUnderstand)
{
this.attrList.Put("SOAP-ENV:mustUnderstand", "1");
this.isUsedEnc = true;
}
if (nameInfo.NIisHeader)
{
this.attrList.Put("xmlns:" + nameInfo.NIheaderPrefix, nameInfo.NInamespace);
this.attrList.Put("SOAP-ENC:root", "1");
}
if (this.attrValueList.Count > 0)
{
for (int i = 0; i < this.attrValueList.Count; i++)
{
string str;
string str2;
this.attrValueList.Get(i, out str, out str2);
this.attrList.Put(str, str2);
}
this.attrValueList.Clear();
}
string name = this.MemberElementName(nameInfo, typeNameInfo);
this.NamespaceAttribute();
this.Write(InternalElementTypeE.ObjectBegin, name, this.attrList, null, true, false);
}
internal void WriteNullMember(NameInfo memberNameInfo, NameInfo typeNameInfo)
{
this.attrList.Clear();
if ((typeNameInfo.NItype != null) && (memberNameInfo.NItransmitTypeOnMember || (memberNameInfo.NItransmitTypeOnObject && !memberNameInfo.NIisArrayItem)))
{
this.attrList.Put("xsi:type", this.TypeNameTagResolver(typeNameInfo, true));
}
this.attrList.Put("xsi:null", "1");
string name = this.MemberElementName(memberNameInfo, null);
this.NamespaceAttribute();
this.Write(InternalElementTypeE.Member, name, this.attrList, null, true, false);
}
internal void WriteNullItem(NameInfo memberNameInfo, NameInfo typeNameInfo)
{
string nIname = typeNameInfo.NIname;
this.attrList.Clear();
if (((typeNameInfo.NItransmitTypeOnMember && !nIname.Equals("System.Object")) && (!nIname.Equals("Object") && !nIname.Equals("System.Empty"))) && (!nIname.Equals("ur-type") && !nIname.Equals("anyType")))
{
this.attrList.Put("xsi:type", this.TypeNameTagResolver(typeNameInfo, true));
}
this.attrList.Put("xsi:null", "1");
this.NamespaceAttribute();
this.Write(InternalElementTypeE.Member, "item", this.attrList, null, false, false);
}
private NameInfo TypeToNameInfo(WriteObjectInfo objectInfo, NameInfo nameInfo)
{
return TypeToNameInfo(objectInfo.objectType, objectInfo, Converter.ToCode(objectInfo.objectType), nameInfo);
}
private void TypeToNameInfo(Type type, NameInfo nameInfo)
{
TypeToNameInfo(type, null, Converter.ToCode(type), nameInfo);
}
// Writes out an array element
private void WriteArrayMember(WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, Object data)
{
InternalST.Soap( 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.NIisSealed)
{
dataType = GetType(data);
if (arrayElemTypeNameInfo.NItype != dataType)
isObjectOnMember = true;
}
if (isObjectOnMember)
{
// Object array, need type of member
if (dataType == null)
dataType = GetType(data);
actualTypeInfo = TypeToNameInfo(dataType);
actualTypeInfo.NItransmitTypeOnMember = true;
actualTypeInfo.NIobjectId = arrayElemTypeNameInfo.NIobjectId;
actualTypeInfo.NIassemId = arrayElemTypeNameInfo.NIassemId;
actualTypeInfo.NIisArrayItem = true;
actualTypeInfo.NIitemName = arrayElemTypeNameInfo.NIitemName;
}
else
{
actualTypeInfo = arrayElemTypeNameInfo;
actualTypeInfo.NIisArrayItem = true;
}
if (!WriteKnownValueClass(arrayElemTypeNameInfo, actualTypeInfo, data, false))
{
Object obj = data;
if (actualTypeInfo.NItype.IsEnum)
{
WriteObjectInfo newObjectInfo = WriteObjectInfo.Serialize(obj, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, null);
actualTypeInfo.NIassemId = GetAssemblyId(newObjectInfo);
WriteEnum(arrayElemTypeNameInfo, actualTypeInfo, data, false);
}
else
{
long arrayId = Schedule(obj, actualTypeInfo.NItype);
arrayElemTypeNameInfo.NIobjectId = arrayId;
actualTypeInfo.NIobjectId = arrayId;
if (arrayId < 1)
{
WriteObjectInfo newObjectInfo = WriteObjectInfo.Serialize(obj, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, null);
newObjectInfo.objectId = arrayId;
newObjectInfo.assemId = GetAssemblyId(newObjectInfo);
InternalST.Soap( this, "WriteArrayMembers nested");
if (dataType == null)
dataType = GetType(data);
if (data!=null && dataType.IsArray)
{
WriteArray(newObjectInfo, actualTypeInfo, null);
}
else
{
actualTypeInfo.NIisNestedObject = true;
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);
}
private void ArrayNameToDisplayName(WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo)
{
InternalST.Soap( this, "ArrayNameToDisplayName Entry ",arrayElemTypeNameInfo.NIname);
String arrayElemTypeName = arrayElemTypeNameInfo.NIname;
//String arrayElemTypeName = objectInfo.GetTypeFullName();;
InternalST.Soap( this, "ArrayNameToDisplayName Entry ",arrayElemTypeNameInfo.NIname, " Type full name ", arrayElemTypeName);
int arrayIndex = arrayElemTypeName.IndexOf('[');
if (arrayIndex > 0)
{
String elemBaseTypeString = arrayElemTypeName.Substring(0, arrayIndex);
InternalPrimitiveTypeE code = Converter.ToCode(elemBaseTypeString);
String convertedType = null;
bool isConverted = false;
if (code != InternalPrimitiveTypeE.Invalid)
{
if (code == InternalPrimitiveTypeE.Char)
{
convertedType = elemBaseTypeString;
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.UrtSystem;
}
else
{
isConverted = true;
convertedType = Converter.ToXmlDataType(code);
String typeName = null;
arrayElemTypeNameInfo.NInameSpaceEnum = Converter.GetNameSpaceEnum(code, null, objectInfo, out typeName);
}
}
else
{
InternalST.Soap( this, "ArrayNameToDisplayName elemBaseTypeString ",elemBaseTypeString);
if ((elemBaseTypeString.Equals("String")) || (elemBaseTypeString.Equals("System.String")))
{
isConverted = true;
convertedType = "string";
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.XdrString;
}
else if (elemBaseTypeString.Equals("System.Object"))
{
isConverted = true;
convertedType = "anyType";
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
}
else
{
convertedType = elemBaseTypeString;
}
}
if (isConverted)
{
arrayElemTypeNameInfo.NIname = convertedType+arrayElemTypeName.Substring(arrayIndex);
}
}
else if (arrayElemTypeName.Equals("System.Object"))
{
arrayElemTypeNameInfo.NIname = "anyType";
arrayElemTypeNameInfo.NInameSpaceEnum = InternalNameSpaceE.XdrPrimitive;
}
InternalST.Soap( this, "ArrayNameToDisplayName Exit ",arrayElemTypeNameInfo.NIname);
}
// Iterates over a Rectangle array, for each element of the array invokes WriteArrayMember
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;
}
}
}
InternalST.Soap( this, "WriteRectangle Exit ");
}
private NameInfo GetNameInfo()
{
NameInfo nameInfo = null;
if (!niPool.IsEmpty())
{
nameInfo = (NameInfo)niPool.Pop();
nameInfo.Init();
}
else
nameInfo = new NameInfo();
return nameInfo;
}
// Determines if a type is a primitive type, if it is it is written
private bool WriteKnownValueClass(NameInfo memberNameInfo, NameInfo typeNameInfo, Object data, bool isAttribute)
{
InternalST.Soap( this, "WriteKnownValueClass Entry ",typeNameInfo.NIname," ",data," ",memberNameInfo.NIname);
memberNameInfo.Dump("WriteKnownValueClass memberNameInfo");
typeNameInfo.Dump("WriteKnownValueClass typeNameInfo");
if (typeNameInfo.NItype == Converter.typeofString)
{
if (isAttribute)
serWriter.WriteAttributeValue(memberNameInfo, typeNameInfo, (String)data);
else
WriteString(memberNameInfo, typeNameInfo, data);
}
else
{
if (typeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.Invalid)
{
InternalST.Soap( this, "WriteKnownValueClass Exit false");
return false;
}
else
{
if (typeNameInfo.NIisArray) // null if an array
serWriter.WriteItem(memberNameInfo, typeNameInfo, data);
else
{
if (isAttribute)
serWriter.WriteAttributeValue(memberNameInfo, typeNameInfo, data);
else
serWriter.WriteMember(memberNameInfo, typeNameInfo, data);
}
}
}
InternalST.Soap( this, "WriteKnownValueClass Exit true");
return true;
}
private void ProcessHeaders(long headerId)
{
long objectId;
Object obj;
// XML Serializer
serWriter.WriteHeader((int)headerId, headers.Length);
for (int i=0; i<headers.Length; i++)
{
Type headerValueType = null;
if (headers[i].Value != null)
headerValueType = GetType(headers[i].Value);
if ((headerValueType != null) && (headerValueType == Converter.typeofString))
{
NameInfo nameInfo = GetNameInfo();
nameInfo.NInameSpaceEnum = InternalNameSpaceE.UserNameSpace;
nameInfo.NIname = headers[i].Name;
nameInfo.NIisMustUnderstand = headers[i].MustUnderstand;
nameInfo.NIobjectId = -1;
// Header will need to add a name space field which will if it doesn't the following
// is the default name space
HeaderNamespace(headers[i], nameInfo);
serWriter.WriteHeaderString(nameInfo, headers[i].Value.ToString());
PutNameInfo(nameInfo);
}
else if (headers[i].Name.Equals("__MethodSignature"))
{
InternalST.Soap( this, "Serialize Write Header __MethodSignature ");
// Process message signature
if (!(headers[i].Value is Type[]))
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MethodSignature"), headerValueType));
// Replace type array with an array of TypeToNameInfo's
Type[] types = (Type[])headers[i].Value;
NameInfo[] typeToNameInfos = new NameInfo[types.Length];
WriteObjectInfo[] objectInfos = new WriteObjectInfo[types.Length];
for (int j=0; j< types.Length; j++)
{
objectInfos[j] = WriteObjectInfo.Serialize(types[j], m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, null);
objectInfos[j].objectId = -1;
objectInfos[j].assemId = GetAssemblyId(objectInfos[j]);
typeToNameInfos[j] = TypeToNameInfo(objectInfos[j]);
}
// Create MemberNameInfo
NameInfo memberNameInfo = MemberToNameInfo(headers[i].Name);
memberNameInfo.NIisMustUnderstand = headers[i].MustUnderstand;
memberNameInfo.NItransmitTypeOnMember = true;
memberNameInfo.NIisNestedObject = true;
memberNameInfo.NIisHeader = true;
HeaderNamespace(headers[i], memberNameInfo);
serWriter.WriteHeaderMethodSignature(memberNameInfo, typeToNameInfos);
for (int j=0; j<types.Length; j++)
{
PutNameInfo(typeToNameInfos[j]);
objectInfos[j].ObjectEnd();
}
PutNameInfo(memberNameInfo);
}
else
{
InternalPrimitiveTypeE code = InternalPrimitiveTypeE.Invalid;
long valueId;
if (headerValueType != null)
code = Converter.ToCode(headerValueType);
if ((headerValueType != null) && (code == InternalPrimitiveTypeE.Invalid))
{
// Object reference
InternalST.Soap( this, "Serialize Schedule 2");
valueId = Schedule(headers[i].Value, headerValueType);
if (valueId == -1)
{
WriteObjectInfo objectInfo = WriteObjectInfo.Serialize(headers[i].Value, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, null);
objectInfo.objectId = -1;
objectInfo.assemId = GetAssemblyId(objectInfo);
NameInfo typeNameInfo = TypeToNameInfo(objectInfo);
NameInfo memberNameInfo = MemberToNameInfo(headers[i].Name);
memberNameInfo.NIisMustUnderstand = headers[i].MustUnderstand;
memberNameInfo.NItransmitTypeOnMember = true;
memberNameInfo.NIisNestedObject = true;
memberNameInfo.NIisHeader = true;
HeaderNamespace(headers[i], memberNameInfo);
Write(objectInfo, memberNameInfo, typeNameInfo);
PutNameInfo(typeNameInfo);
PutNameInfo(memberNameInfo);
objectInfo.ObjectEnd();
}
InternalST.Soap( this, "Serialize Write Header Object Reference ");
NameInfo refNameInfo = MemberToNameInfo(headers[i].Name);
refNameInfo.NIisMustUnderstand = headers[i].MustUnderstand;
refNameInfo.NIobjectId = valueId;
refNameInfo.NItransmitTypeOnMember = true;
refNameInfo.NIisNestedObject = true;
HeaderNamespace(headers[i], refNameInfo);
serWriter.WriteHeaderObjectRef(refNameInfo);
PutNameInfo(refNameInfo);
}
else
{
// Primitive type or null
InternalST.Soap( this, "Serialize Write Header primitive type ");
NameInfo nameInfo = GetNameInfo();
nameInfo.NInameSpaceEnum = InternalNameSpaceE.UserNameSpace;
nameInfo.NIname = headers[i].Name;
nameInfo.NIisMustUnderstand = headers[i].MustUnderstand;
nameInfo.NIprimitiveTypeEnum = code;
// Header will need to add a name space field which will if it doesn't the following
// is the default name space
HeaderNamespace(headers[i], nameInfo);
NameInfo typeNameInfo = null;
if (headerValueType != null)
{
typeNameInfo = TypeToNameInfo(headerValueType);
typeNameInfo.NItransmitTypeOnMember = true;
}
serWriter.WriteHeaderEntry(nameInfo, typeNameInfo, headers[i].Value);
PutNameInfo(nameInfo);
if (headerValueType != null)
PutNameInfo(typeNameInfo);
}
}
}
serWriter.WriteHeaderArrayEnd();
// Serialize headers ahead of top 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)
{
InternalST.Soap( this, "Serialize GetNext recognizes WriteObjectInfo");
objectInfo = (WriteObjectInfo)obj;
}
else
{
objectInfo = WriteObjectInfo.Serialize(obj, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, null);
objectInfo.assemId = GetAssemblyId(objectInfo);
}
objectInfo.objectId = objectId;
NameInfo typeNameInfo = TypeToNameInfo(objectInfo);
Write(objectInfo, typeNameInfo, typeNameInfo);
PutNameInfo(typeNameInfo);
objectInfo.ObjectEnd();
}
serWriter.WriteHeaderSectionEnd();
}
// Writes an object reference to the stream.
private void WriteObjectRef(NameInfo nameInfo, long objectId)
{
InternalST.Soap( this, "WriteObjectRef Entry ",nameInfo.NIname," ",objectId);
serWriter.WriteMemberObjectRef(nameInfo, (int)objectId);
InternalST.Soap( this, "WriteObjectRef Exit ");
}
// Writes a given object to the stream.
private void Write(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo)
{
InternalST.Soap( this, "Write 1 Entry objectInfo ",objectInfo,", memberNameInfo ",memberNameInfo,", typeNameInfo ",typeNameInfo);
memberNameInfo.Dump("Write memberNameInfo");
typeNameInfo.Dump("Write typeNameInfo");
Object obj = objectInfo.obj;
if (obj==null)
throw new ArgumentNullException("objectInfo.obj", String.Format(SoapUtil.GetResourceString("Serialization_ArgumentNull_Obj"), objectInfo.objectType));
Type objType = objectInfo.objectType;
long objectId = objectInfo.objectId;
InternalST.Soap( this, "Write 1 ",obj," ObjectId ",objectId);
if (objType == Converter.typeofString)
{
// Top level String
memberNameInfo.NIobjectId = objectId;
serWriter.WriteObjectString(memberNameInfo, obj.ToString());
}
else if (objType == Converter.typeofTimeSpan)
{
// Top level TimeSpan
serWriter.WriteTopPrimitive(memberNameInfo, obj);
}
else
{
if (objType.IsArray)
{
WriteArray(objectInfo, null, null);
}
else
{
String[] memberNames;
Type[] memberTypes;
Object[] memberData;
SoapAttributeInfo[] memberAttributeInfo;
objectInfo.GetMemberInfo(out memberNames, out memberTypes, out memberData, out memberAttributeInfo);
// 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 (CheckTypeFormat(formatterEnums.FEtypeFormat, FormatterTypeStyle.TypesAlways))
{
InternalST.Soap( 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 = null;
if (memberData[i] != null)
type = GetType(memberData[i]);
else
type = typeof(Object);
InternalPrimitiveTypeE code = Converter.ToCode(type);
if ((code == InternalPrimitiveTypeE.Invalid && type != Converter.typeofString) ||
((objectInfo.cache.memberAttributeInfos != null) &&
(objectInfo.cache.memberAttributeInfos[i] != null) &&
((objectInfo.cache.memberAttributeInfos[i].IsXmlAttribute()) ||
(objectInfo.cache.memberAttributeInfos[i].IsXmlElement()))))
{
if (memberData[i] != null)
{
memberObjectInfos[i] =
WriteObjectInfo.Serialize
(
memberData[i],
m_surrogates,
m_context,
serObjectInfoInit,
m_formatterConverter,
(memberAttributeInfo == null)? null : memberAttributeInfo[i]
);
memberObjectInfos[i].assemId = GetAssemblyId(memberObjectInfos[i]);
}
else
{
memberObjectInfos[i] =
WriteObjectInfo.Serialize
(
memberTypes[i],
m_surrogates,
m_context,
serObjectInfoInit,
m_formatterConverter,
((memberAttributeInfo == null) ? null : memberAttributeInfo[i])
);
memberObjectInfos[i].assemId = GetAssemblyId(memberObjectInfos[i]);
}
}
}
Write(objectInfo, memberNameInfo, typeNameInfo, memberNames, memberTypes, memberData, memberObjectInfos);
}
InternalST.Soap( this, "Write 1 ",obj," type ",GetType(obj));
// After first time null members do not have to be written
if (!(m_serializedTypeTable.ContainsKey(objType)))
{
InternalST.Soap( this, "Serialize SerializedTypeTable Add ",objType," obj ",obj);
m_serializedTypeTable.Add(objType, objType);
}
}
InternalST.Soap( this, "Write 1 Exit ",obj);
}
// Writes a string into the XML stream
private void WriteString(NameInfo memberNameInfo, NameInfo typeNameInfo, Object stringObject)
{
InternalST.Soap( this, "WriteString stringObject ",stringObject," memberName ",memberNameInfo.NIname);
bool isFirstTime = true;
long stringId = -1;
if (!CheckTypeFormat(formatterEnums.FEtypeFormat, FormatterTypeStyle.XsdString))
stringId= InternalGetId(stringObject, typeNameInfo.NItype, out isFirstTime);
typeNameInfo.NIobjectId = stringId;
InternalST.Soap( this, "WriteString stringId ",stringId," isFirstTime ",isFirstTime);
if ((isFirstTime) || (stringId < 0))
{
if (typeNameInfo.NIisArray) // null if array
serWriter.WriteItemString(memberNameInfo, typeNameInfo, (String)stringObject);
else
serWriter.WriteMemberString(memberNameInfo, typeNameInfo, (String)stringObject);
}
else
{
WriteObjectRef(memberNameInfo, stringId);
}
}
private void WriteMemberSetup(WriteObjectInfo objectInfo,
NameInfo memberNameInfo,
NameInfo typeNameInfo,
String memberName,
Type memberType,
Object memberData,
WriteObjectInfo memberObjectInfo,
bool isAttribute
)
{
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.NIisRemoteRecord = typeNameInfo.NIisRemoteRecord;
newMemberNameInfo.NItransmitTypeOnObject = memberNameInfo.NItransmitTypeOnObject;
newMemberNameInfo.NIisParentTypeOnObject = memberNameInfo.NIisParentTypeOnObject;
WriteMembers(newMemberNameInfo, newTypeNameInfo, memberData, objectInfo, typeNameInfo, memberObjectInfo, isAttribute);
PutNameInfo(newMemberNameInfo);
PutNameInfo(newTypeNameInfo);
}
// Writes a null member into the stream
private bool CheckForNull(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo, Object data)
{
InternalST.Soap( this, "CheckForNull Entry data ",Util.PString(data),", memberType ",Util.PString(typeNameInfo.NItype));
bool isNull = false;
if (data == null) // || Convert.IsDBNull(data)
isNull = true;
// Optimization, Null members are only written for Binary
if (isNull)
{
InternalST.Soap( this, "CheckForNull Write");
if (typeNameInfo.NItype.IsArray)
{
// Call can occur before typeNameInfo.NIisArray is set
ArrayNameToDisplayName(objectInfo, typeNameInfo);
}
if (typeNameInfo.NIisArrayItem)
serWriter.WriteNullItem(memberNameInfo, typeNameInfo);
else
serWriter.WriteNullMember(memberNameInfo, typeNameInfo);
}
InternalST.Soap( this, "CheckForNull Exit ",isNull);
return isNull;
}
// Writes out an array
private void WriteArray(WriteObjectInfo objectInfo, NameInfo memberNameInfo, WriteObjectInfo memberObjectInfo)
{
InternalST.Soap( this, "WriteArray Entry ",objectInfo.obj," ",objectInfo.objectId);
bool isAllocatedMemberNameInfo = false;
if (memberNameInfo == null)
{
memberNameInfo = TypeToNameInfo(objectInfo);
memberNameInfo.NIisTopLevelObject = true;
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 = WriteObjectInfo.Serialize(arrayElemType, m_surrogates, m_context, serObjectInfoInit, m_formatterConverter, (memberObjectInfo == null) ? null : memberObjectInfo.typeAttributeInfo);
arrayElemObjectInfo.assemId = GetAssemblyId(arrayElemObjectInfo);
NameInfo arrayElemTypeNameInfo = null;
NameInfo arrayNameInfo = ArrayTypeToNameInfo(objectInfo, out arrayElemTypeNameInfo);
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 (arrayElemType.IsArray)
{
if (rank == 1)
arrayEnum = InternalArrayTypeE.Jagged;
else
arrayEnum = InternalArrayTypeE.Rectangular;
}
else if (rank == 1)
arrayEnum = InternalArrayTypeE.Single;
else
arrayEnum = InternalArrayTypeE.Rectangular;
InternalST.Soap( this, "WriteArray ArrayInfo type ",arrayType," rank ",rank);
// Byte array
if ((arrayElemType == Converter.typeofByte) && (rank == 1) && (lowerBoundA[0] == 0))
{
serWriter.WriteObjectByteArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, lengthA[0], lowerBoundA[0], (byte[])array);
return;
}
if (arrayElemType == Converter.typeofObject)
{
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
InternalST.Soap( this, "WriteArray ARRAY_SINGLE ");
arrayNameInfo.NIname = arrayElemTypeNameInfo.NIname+"["+lengthA[0]+"]";
// 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))
{
// If binaryformatter and array is of appopriate primitive type the array is
// written out as a buffer of bytes. The array was transmitted in WriteSingleArray
// If soap the index directly by array
arrayElemTypeNameInfo.NIobjectId = 0;
if (primitiveArray == null)
primitiveArray = new PrimitiveArray(arrayElemTypeNameInfo.NIprimitiveTypeEnum, array);
else
primitiveArray.Init(arrayElemTypeNameInfo.NIprimitiveTypeEnum, array);
int upperBound = upperBoundA[0]+1;
for (int i = lowerBoundA[0]; i < upperBound; i++)
{
serWriter.WriteItemString(arrayElemTypeNameInfo, arrayElemTypeNameInfo, primitiveArray.GetValue(i));
}
}
else
{
// Non-primitive type array
Object[] objectA = null;
if (!arrayElemType.IsValueType)
objectA = (Object[])array;
int upperBound = upperBoundA[0]+1;
// Soap does not write out trailing nulls. lastValue is set to the last null value. This becomes the array's upperbound
// Note: value classes can't be null
if (objectA != null)
{
int lastValue = lowerBoundA[0]-1;
for (int i = lowerBoundA[0]; i< upperBound; i++)
{
if (objectA[i] != null)
lastValue = i;
}
upperBound = lastValue+1;
}
for (int i = lowerBoundA[0]; i < upperBound; i++)
{
if (objectA == null)
WriteArrayMember(objectInfo, arrayElemTypeNameInfo, array.GetValue(i));
else
WriteArrayMember(objectInfo, arrayElemTypeNameInfo, objectA[i]);
}
}
}
else if (arrayEnum == InternalArrayTypeE.Jagged)
{
// Jagged Array
InternalST.Soap( this, "WriteArray ARRAY_JAGGED");
int index;
String arrayElemTypeDimension = null;
index = arrayNameInfo.NIname.IndexOf('[');
if (index < 0)
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_Dimensions"),arrayElemTypeNameInfo.NIname));
arrayElemTypeDimension = arrayNameInfo.NIname.Substring(index);
InternalST.Soap( this, "WriteArray arrayNameInfo.NIname ",arrayNameInfo.NIname," arrayElemTypeNameInfo.NIname ",arrayElemTypeNameInfo.NIname," arrayElemTypeDimension ",arrayElemTypeDimension);
arrayNameInfo.NIname = arrayElemTypeNameInfo.NIname+"["+lengthA[0]+"]";
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]);
}
}
else
{
// Rectangle Array
// Get the length for all the ranks
InternalST.Soap( this, "WriteArray ARRAY_RECTANGLE");
// Express array Type using XmlData Name
int index;
index = arrayNameInfo.NIname.IndexOf('[');
// Create length dimension string in form [3,4,2]
StringBuilder sb = new StringBuilder(10);
sb.Append(arrayElemTypeNameInfo.NIname);
sb.Append('[');
for (int i=0; i<rank; i++)
{
sb.Append(lengthA[i]);
if (i < rank-1)
sb.Append(',');
}
sb.Append(']');
arrayNameInfo.NIname = sb.ToString();
arrayNameInfo.NIobjectId = objectId;
serWriter.WriteRectangleArray(memberNameInfo, arrayNameInfo, arrayElemObjectInfo, arrayElemTypeNameInfo, rank, lengthA, lowerBoundA);
IndexTraceMessage("WriteArray Rectangle ", lengthA);
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.WriteObjectEnd(memberNameInfo, arrayNameInfo);
PutNameInfo(arrayElemTypeNameInfo);
PutNameInfo(arrayNameInfo);
if (isAllocatedMemberNameInfo)
PutNameInfo(memberNameInfo);
InternalST.Soap( this, "WriteArray Exit ");
}
// 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)
{
InternalST.Soap( this, "TypeToNameInfo Entry type ",type,", objectInfo ",objectInfo,", code ", ((Enum)code).ToString());
if (nameInfo == null)
nameInfo = GetNameInfo();
else
nameInfo.Init();
nameInfo.NIisSealed = type.IsSealed;
String typeName = null;
nameInfo.NInameSpaceEnum = Converter.GetNameSpaceEnum(code, type, objectInfo, out typeName);
nameInfo.NIprimitiveTypeEnum = code;
nameInfo.NItype = type;
nameInfo.NIname = typeName;
if (objectInfo != null)
{
nameInfo.NIattributeInfo = objectInfo.typeAttributeInfo;
nameInfo.NIassemId = objectInfo.assemId;
}
switch (nameInfo.NInameSpaceEnum)
{
case InternalNameSpaceE.XdrPrimitive:
break;
case InternalNameSpaceE.XdrString:
nameInfo.NIname = "string";
break;
case InternalNameSpaceE.UrtSystem:
break;
case InternalNameSpaceE.UrtUser:
//if (type.FullName.StartsWith("System."))
if (type.Module.Assembly == Converter.urtAssembly)
{
// The type name could be an ISerializable
// But the type returned (typeName) could be a fake
// type
}
else
{
if (objectInfo == null)
{
InternalST.Soap( this, "TypeToNameInfo ObjectInfo is null 2 ",type);
}
}
break;
}
InternalST.Soap( this, "TypeToNameInfo Exit ",type, " typeName "+nameInfo.NIname);
return nameInfo;
}