// Pop the object from the stack
internal Object Pop()
{
if (top < 0)
{
return(null);
}
Object obj = objects[top];
objects[top--] = null;
InternalST.Soap(this, "Pop ", stackId, " ", ((obj is ITrace)?((ITrace)obj).Trace():""));
return(obj);
}
internal Type GetType(int position)
{
InternalST.Soap(this, objectInfoId, " ", objectType, " GetType Entry ByPosition ", position);
Type type = null;
if (isTyped)
{
if (position >= cache.memberTypes.Length)
{
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ISerializableTypes"), objectType + " " + position));
}
type = cache.memberTypes[position];
InternalST.Soap(this, objectInfoId, " ", objectType, " GetType Exit ByPosition ", type);
}
return(type);
}
internal virtual void Fixup(ParseRecord record, ParseRecord parent)
{
Object obj = record.PRnewObj;
InternalST.Soap(this, "Fixup ", obj, " ", ((Enum)valueFixupEnum).ToString());
switch (valueFixupEnum)
{
case ValueFixupEnum.Array:
arrayObj.SetValue(obj, indexMap);
break;
case ValueFixupEnum.Header:
Type type = typeof(Header);
if (valueInfo == null)
{
MemberInfo[] valueInfos = type.GetMember("Value");
if (valueInfos.Length != 1)
{
throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_HeaderReflection"), valueInfos.Length));
}
valueInfo = valueInfos[0];
}
InternalST.SerializationSetValue((FieldInfo)valueInfo, header, obj);
break;
case ValueFixupEnum.Member:
InternalST.Soap(this, "Fixup Member new object value ", obj, " memberObject ", memberObject);
if (objectInfo.isSi)
{
InternalST.Soap(this, "Recording a fixup on member: ", memberName,
" in object id", parent.PRobjectId, " Required Object ", record.PRobjectId);
objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, memberName, record.PRobjectId);
}
else
{
MemberInfo memberInfo = objectInfo.GetMemberInfo(memberName);
InternalST.Soap(this, "Recording a fixup on member:", memberInfo, " in object id ",
parent.PRobjectId, " Required Object", record.PRobjectId);
objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
}
break;
}
}
private void InitSiWrite(ObjectWriter objectWriter)
{
InternalST.Soap(this, objectInfoId, " InitSiWrite Entry ");
// FormatterWrapper instructs the Formatters to use the
// __WrappedObject has the real object. This is a way
// to get Surrogates to return a real object.
if (si.FullTypeName.Equals("FormatterWrapper"))
{
obj = si.GetValue("__WrappedObject", Converter.typeofObject);
InitSerialize(obj, surrogateSelector, context, serObjectInfoInit, converter, null, objectWriter);
}
else
{
SerializationInfoEnumerator siEnum = null;
isSi = true;
siEnum = si.GetEnumerator();
int infoLength = 0;
infoLength = si.MemberCount;
int count = infoLength;
// For ISerializable cache cannot be saved because each object instance can have different values
// BinaryWriter only puts the map on the wire if the ISerializable map cannot be reused.
cache = new SerObjectInfoCache();
cache.memberNames = new String[count];
cache.memberTypes = new Type[count];
memberData = new Object[count];
cache.fullTypeName = si.FullTypeName;
cache.assemblyString = si.AssemblyName;
siEnum = si.GetEnumerator();
for (int i = 0; siEnum.MoveNext(); i++)
{
cache.memberNames[i] = siEnum.Name;
cache.memberTypes[i] = siEnum.ObjectType;
memberData[i] = siEnum.Value;
InternalST.Soap(this, objectInfoId + " ", objectType, " InitSiWrite ", cache.memberNames[i], " Type ", cache.memberTypes[i], " data ", memberData[i]);
}
isNamed = true;
isTyped = false;
}
InternalST.Soap(this, objectInfoId, " InitSiWrite Exit ");
}
// Specifies whether the embedded attribute is set for a member.
internal bool IsEmbeddedAttribute(String name)
{
InternalST.Soap(this, objectInfoId, " ", objectType, " IsEmbedded Entry ", name);
if (arrayElemObjectInfo != null)
{
return(arrayElemObjectInfo.IsEmbeddedAttribute(name));
}
bool isEmbedded = false;
if (cache.memberAttributeInfos != null && cache.memberAttributeInfos.Length > 0)
{
SoapAttributeInfo attributeInfo = cache.memberAttributeInfos[Position(name)];
isEmbedded = attributeInfo.IsEmbedded();
}
InternalST.Soap(this, objectInfoId, " ", objectType, " IsEmbedded Exit ", isEmbedded);
return(isEmbedded);
}
private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, String assemblyName)
{
InternalST.Soap(this, objectInfoId, " ", objectType, " InitReadConstructor Entry ", objectType);
if (objectType.IsArray)
{
arrayElemObjectInfo = Create(objectType.GetElementType(), surrogateSelector, context, objectManager, serObjectInfoInit, formatterConverter, assemblyName);
typeAttributeInfo = GetTypeAttributeInfo();
InitNoMembers();
return;
}
ISurrogateSelector surrogateSelectorTemp = null;
if (surrogateSelector != null)
{
serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);
}
if (serializationSurrogate != null)
{
isSi = true;
}
else if (objectType == Converter.typeofObject)
{
}
else if (Converter.typeofISerializable.IsAssignableFrom(objectType))
{
isSi = true;
}
if (isSi)
{
si = new SerializationInfo(objectType, formatterConverter);
InitSiRead(assemblyName);
}
else
{
InitMemberInfo();
}
InternalST.Soap(this, objectInfoId, " ", objectType, " InitReadConstructor Exit ", isSi);
}
private void InitMemberInfo()
{
InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo Entry");
cache = (SerObjectInfoCache)serObjectInfoInit.seenBeforeTable[objectType];
if (cache == null)
{
InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
cache = new SerObjectInfoCache();
int count = 0;
if (!objectType.IsByRef) // byref will only occur for MethodSignature
{
cache.memberInfos = FormatterServices.GetSerializableMembers(objectType, context);
count = cache.memberInfos.Length;
}
cache.memberNames = new String[count];
cache.memberTypes = new Type[count];
cache.memberAttributeInfos = new SoapAttributeInfo[count];
// Calculate new arrays
for (int i = 0; i < count; i++)
{
cache.memberNames[i] = cache.memberInfos[i].Name;
cache.memberTypes[i] = GetMemberType(cache.memberInfos[i]);
cache.memberAttributeInfos[i] = Attr.GetMemberAttributeInfo(cache.memberInfos[i], cache.memberNames[i], cache.memberTypes[i]);
InternalST.Soap(this, objectInfoId, " InitMemberInfo name ", cache.memberNames[i], ", type ", cache.memberTypes[i], ", memberInfoType ", cache.memberInfos[i].GetType());
}
cache.fullTypeName = objectType.FullName;
cache.assemblyString = objectType.Module.Assembly.FullName;
serObjectInfoInit.seenBeforeTable.Add(objectType, cache);
}
if (obj != null)
{
memberData = FormatterServices.GetObjectData(obj, cache.memberInfos);
DumpMemberInfo();
}
isTyped = true;
isNamed = true;
InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo Exit");
}
// Commences the process of serializing the entire graph. All of the data (in the appropriate format)
// is emitted onto the stream.
public void Serialize(Stream serializationStream, Object graph, Header[] headers)
{
InternalST.InfoSoap("Enter SoapFormatter.Serialize ");
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
InternalST.Soap(this, "Serialize Entry");
InternalFE formatterEnums = new InternalFE();
formatterEnums.FEtypeFormat = m_typeFormat;
formatterEnums.FEtopObject = m_topObject;
formatterEnums.FEserializerTypeEnum = InternalSerializerTypeE.Soap;
formatterEnums.FEassemblyFormat = m_assemblyFormat;
ObjectWriter sow = new ObjectWriter(serializationStream, m_surrogates, m_context, formatterEnums);
sow.Serialize(graph, headers, new SoapWriter(serializationStream));
InternalST.InfoSoap("Leave SoapFormatter.Serialize ");
}
// Adds the value for a memberName
internal void AddValue(String name, Object value)
{
InternalST.Soap(this, objectInfoId, " ", objectType, " AddValue ", name, " ", value, " isSi ", isSi);
if (isSi)
{
if (bfake)
{
AddParamName(name);
}
si.AddValue(name, value);
}
else
{
// Console.WriteLine("Calling add value for " + name + " with value " + value);
int position = Position(name);
memberData[position] = value;
memberNames[position] = name;
}
}
// Read Constructor
internal void Init(Type objectType, String[] memberNames, Type[] memberTypes, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, String assemblyName)
{
InternalST.Soap(this, objectInfoId, " Constructor 5 ", objectType);
this.objectType = objectType;
this.objectManager = objectManager;
this.wireMemberNames = memberNames;
this.wireMemberTypes = memberTypes;
this.context = context;
this.serObjectInfoInit = serObjectInfoInit;
this.formatterConverter = converter;
if (memberNames != null)
{
isNamed = true;
}
if (memberTypes != null)
{
isTyped = true;
}
InitReadConstructor(objectType, surrogateSelector, context, assemblyName);
}
internal Type GetMemberType(MemberInfo objMember)
{
Type objectType = null;
if (objMember is FieldInfo)
{
objectType = ((FieldInfo)objMember).FieldType;
InternalST.Soap(this, objectInfoId, " ", "GetMemberType FieldInfo ", objectType);
}
else if (objMember is PropertyInfo)
{
objectType = ((PropertyInfo)objMember).PropertyType;
InternalST.Soap(this, objectInfoId, " ", "GetMemberType PropertyInfo ", objectType);
}
else
{
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_SerMemberInfo"), objMember.GetType()));
}
return(objectType);
}
// Get the ObjectType for a memberName
internal Type GetType(String name)
{
InternalST.Soap(this, objectInfoId, " ", objectType, " GetType Entry ", name);
Type type = null;
if (isTyped)
{
type = cache.memberTypes[Position(name)];
}
else
{
type = (Type)memberTypesList[Position(name)];
}
if (type == null)
{
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ISerializableTypes"), objectType + " " + name));
}
InternalST.Soap(this, objectInfoId, " ", objectType, " GetType Exit ", type);
return(type);
}
internal void AddParamName(String name)
{
if (!bfake)
{
return;
}
if (name[0] == '_' && name[1] == '_')
{
if (name == "__fault")
{
bSoapFault = true;
return;
}
else if (name == "__methodName" || name == "__keyToNamespaceTable" || name == "__paramNameList" || name == "__xmlNameSpace")
{
return;
}
}
InternalST.Soap(this, objectInfoId, " ", objectType, " AddParamName Add " + name);
paramNameList.Add(name);
}
internal String GetAssemblyString()
{
String assemblyString = null;
InternalST.Soap(this, objectInfoId, " ", objectType, " GetAssemblyString Entry isSi ", isSi);
if (arrayElemObjectInfo != null)
{
assemblyString = arrayElemObjectInfo.GetAssemblyString();
}
else if (IsAttributeNameSpace())
{
assemblyString = typeAttributeInfo.m_nameSpace;
}
else
{
assemblyString = cache.assemblyString;
}
InternalST.Soap(this, objectInfoId, " ", objectType, " GetAssemblyString Exit ", assemblyString);
return(assemblyString);
}
// Deserialize the stream into an object graph.
public Object Deserialize(Stream serializationStream, HeaderHandler handler)
{
InternalST.InfoSoap("Enter SoapFormatter.Deserialize ");
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream");
}
if (serializationStream.CanSeek && (serializationStream.Length == 0))
{
throw new SerializationException(SoapUtil.GetResourceString("Serialization_Stream"));
}
InternalST.Soap(this, "Deserialize Entry");
InternalFE formatterEnums = new InternalFE();
formatterEnums.FEtypeFormat = m_typeFormat;
formatterEnums.FEtopObject = m_topObject;
formatterEnums.FEserializerTypeEnum = InternalSerializerTypeE.Soap;
formatterEnums.FEassemblyFormat = m_assemblyFormat;
formatterEnums.FEsecurityLevel = m_securityLevel;
ObjectReader sor = new ObjectReader(serializationStream, m_surrogates, m_context, formatterEnums, m_binder);
// If this is the first call, or a new stream is being used a new Soap parser is created.
// If this is a continuing call, then the existing SoapParser is used.
// One stream can contains multiple Soap XML documents. The XMLParser buffers the XML so
// that the same XMLParser has to be used to continue a stream.
if ((soapParser == null) || (serializationStream != currentStream))
{
soapParser = new SoapParser(serializationStream);
currentStream = serializationStream;
}
soapParser.Init(sor);
Object obj = sor.Deserialize(handler, soapParser);
InternalST.InfoSoap("Leave SoapFormatter.Deserialize ");
return(obj);
}
private void InternalInit()
{
InternalST.Soap(this, objectInfoId, " InternalInit");
obj = null;
objectType = null;
isSi = false;
isNamed = false;
isTyped = false;
si = null;
cache = null;
memberData = null;
isArray = false;
// Writing and Parsing information
objectId = 0;
assemId = 0;
// Added for Soap
lastPosition = 0;
typeAttributeInfo = null;
parentMemberAttributeInfo = null;
arrayElemObjectInfo = null;
}
internal void Dump(String id)
{
InternalST.Soap("Dump SoapAttributeInfo ", id);
if (IsXmlType())
{
InternalST.Soap(" SchemaType");
}
if (IsEmbedded())
{
InternalST.Soap(" Embedded");
}
if (IsXmlElement())
{
InternalST.Soap(" XmlElement");
}
if (IsXmlAttribute())
{
InternalST.Soap(" XmlAttribute");
}
Util.NVTrace("_nameSpace", m_nameSpace);
Util.NVTrace("_elementName", m_elementName);
Util.NVTrace("_type", m_typeName);
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
int numberOfMembers = 0;
if (paramValues != null)
{
numberOfMembers = paramValues.Length;
}
InternalST.Soap(this, "GetObjectData ", methodName, " " + numberOfMembers);
info.FullTypeName = methodName;
if (xmlNameSpace != null)
{
info.AssemblyName = xmlNameSpace;
}
String paramName = null;
if (paramValues != null)
{
for (int i = 0; i < paramValues.Length; i++)
{
InternalST.Soap(this, "GetObjectData AddValue ", paramNames[i], " ", paramValues[i]);
if ((paramNames != null) && (paramNames[i] == null))
{
paramName = "param" + i;
}
else
{
paramName = paramNames[i];
}
info.AddValue(paramName, paramValues[i], typeof(Object));
}
}
}
internal void SetValue(String value, int index)
{
InternalST.Soap("PrimitiveArray value ", value, " index ", index, " code ", ((Enum)code).ToString());
switch (code)
{
case InternalPrimitiveTypeE.Boolean:
booleanA[index] = Boolean.Parse(value);
break;
case InternalPrimitiveTypeE.Char:
if ((value[0] == '_') && (value.Equals("_0x00_")))
{
charA[index] = Char.MinValue;
}
else
{
charA[index] = Char.Parse(value);
}
break;
case InternalPrimitiveTypeE.Double:
if (value == "INF")
{
doubleA[index] = Double.PositiveInfinity;
}
else if (value == "-INF")
{
doubleA[index] = Double.NegativeInfinity;
}
else
{
doubleA[index] = Double.Parse(value, CultureInfo.InvariantCulture);
}
break;
case InternalPrimitiveTypeE.Int16:
int16A[index] = Int16.Parse(value, CultureInfo.InvariantCulture);
break;
case InternalPrimitiveTypeE.Int32:
int32A[index] = Int32.Parse(value, CultureInfo.InvariantCulture);
break;
case InternalPrimitiveTypeE.Int64:
int64A[index] = Int64.Parse(value, CultureInfo.InvariantCulture);
break;
case InternalPrimitiveTypeE.SByte:
sbyteA[index] = SByte.Parse(value, CultureInfo.InvariantCulture);
break;
case InternalPrimitiveTypeE.Single:
if (value == "INF")
{
singleA[index] = Single.PositiveInfinity;
}
else if (value == "-INF")
{
singleA[index] = Single.NegativeInfinity;
}
else
{
singleA[index] = Single.Parse(value, CultureInfo.InvariantCulture);
}
break;
case InternalPrimitiveTypeE.UInt16:
uint16A[index] = UInt16.Parse(value, CultureInfo.InvariantCulture);
break;
case InternalPrimitiveTypeE.UInt32:
uint32A[index] = UInt32.Parse(value, CultureInfo.InvariantCulture);
break;
case InternalPrimitiveTypeE.UInt64:
uint64A[index] = UInt64.Parse(value, CultureInfo.InvariantCulture);
break;
}
}
internal void ObjectEnd()
{
InternalST.Soap(this, objectInfoId, " objectType ", objectType, " ObjectEnd");
PutObjectInfo(serObjectInfoInit, this);
}
internal static void NVTraceI(String name, String value)
{
InternalST.Soap(" " + name + ((value == null)?" = null":" = " + value));
}
internal void AddMemberSeen()
{
InternalST.Soap(this, objectInfoId, " ", objectType, " AddMemberSeen ");
numberMembersSeen++;
}
// Return type name for the object.
internal String GetTypeFullName()
{
InternalST.Soap(this, objectInfoId, " ", objectType, " GetTypeFullName isSi ", isSi, " " + cache.fullTypeName);
return(cache.fullTypeName);
}
internal ValueFixup(Object header)
{
InternalST.Soap(this, "Header Constructor ", header);
valueFixupEnum = ValueFixupEnum.Header;
this.header = header;
}
// Write constructor
internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SoapAttributeInfo attributeInfo, ObjectWriter objectWriter)
{
InternalST.Soap(this, objectInfoId, " Constructor 1 ", obj);
this.context = context;
this.obj = obj;
this.serObjectInfoInit = serObjectInfoInit;
this.parentMemberAttributeInfo = attributeInfo;
this.surrogateSelector = surrogateSelector;
this.converter = converter;
ISurrogateSelector surrogateSelectorTemp;
if (RemotingServices.IsTransparentProxy(obj))
{
objectType = Converter.typeofMarshalByRefObject;
}
else
{
objectType = obj.GetType();
}
if (objectType.IsArray)
{
arrayElemObjectInfo = Serialize(objectType.GetElementType(), surrogateSelector, context, serObjectInfoInit, converter, null);
typeAttributeInfo = GetTypeAttributeInfo();
isArray = true;
InitNoMembers();
return;
}
InternalST.Soap(this, objectInfoId, " Constructor 1 trace 2");
typeAttributeInfo = GetTypeAttributeInfo();
objectWriter.ObjectManager.RegisterObject(obj);
if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
{
InternalST.Soap(this, objectInfoId, " Constructor 1 trace 3");
si = new SerializationInfo(objectType, converter);
if (!objectType.IsPrimitive)
{
serializationSurrogate.GetObjectData(obj, si, context);
}
InitSiWrite(objectWriter);
}
else if (obj is ISerializable)
{
if (!objectType.IsSerializable)
{
throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_NonSerType"),
objectType.FullName, objectType.Module.Assembly.FullName));
}
si = new SerializationInfo(objectType, converter);
((ISerializable)obj).GetObjectData(si, context);
InternalST.Soap(this, objectInfoId, " Constructor 1 trace 4 ISerializable " + objectType);
InitSiWrite(objectWriter);
}
else
{
InternalST.Soap(this, objectInfoId, " Constructor 1 trace 5");
InitMemberInfo();
}
}
internal static void NVTraceI(String name, Object value)
{
InternalST.Soap(" " + name + ((value == null)?" = null":" = " + value.ToString()));
}
internal InternalSoapMessage(SerializationInfo info, StreamingContext context)
{
InternalST.Soap(this, "Constructor Write SetObjectData ");
SetObjectData(info, context);
}
internal void Dump()
{
#if _DEBUG
InternalST.Soap("ParseRecord Dump ", PRparseRecordId);
InternalST.Soap("Enums");
Util.NVTrace("ParseType", ((Enum)PRparseTypeEnum).ToString());
Util.NVTrace("ObjectType", ((Enum)PRobjectTypeEnum).ToString());
Util.NVTrace("ArrayType", ((Enum)PRarrayTypeEnum).ToString());
Util.NVTrace("MemberType", ((Enum)PRmemberTypeEnum).ToString());
Util.NVTrace("MemberValue", ((Enum)PRmemberValueEnum).ToString());
Util.NVTrace("ObjectPosition", ((Enum)PRobjectPositionEnum).ToString());
Util.NVTrace("ParseState", ((Enum)PRparseStateEnum).ToString());
InternalST.Soap("Basics");
Util.NVTrace("Name", PRname);
Util.NVTrace("PRisParsed", PRisParsed);
Util.NVTrace("PRisProcessAttributes", PRisParsed);
Util.NVTrace("PRnameXmlKey", PRnameXmlKey);
Util.NVTrace("PRxmlNameSpace", PRxmlNameSpace);
Util.NVTrace("Value ", PRvalue);
Util.NVTrace("varValue ", PRvarValue);
if (PRvarValue != null)
{
Util.NVTrace("varValue type", PRvarValue.GetType());
}
Util.NVTrace("keyDt", PRkeyDt);
Util.NVTrace("dtType", PRdtType);
Util.NVTrace("assemblyName", PRassemblyName);
Util.NVTrace("code", ((Enum)PRdtTypeCode).ToString());
Util.NVTrace("objectID", PRobjectId);
Util.NVTrace("idRef", PRidRef);
Util.NVTrace("isEnum", PRisEnum);
InternalST.Soap("Array ");
Util.NVTrace("arrayElementTypeString", PRarrayElementTypeString);
Util.NVTrace("arrayElementType", PRarrayElementType);
Util.NVTrace("arrayElementTypeCode", ((Enum)PRarrayElementTypeCode).ToString());
Util.NVTrace("isArrayVariant", PRisArrayVariant);
Util.NVTrace("primitiveArrayTypeString", PRprimitiveArrayTypeString);
Util.NVTrace("rank", PRrank);
Util.NVTrace("dimensions", Util.PArray(PRlengthA));
Util.NVTrace("position", Util.PArray(PRpositionA));
Util.NVTrace("lowerBoundA", Util.PArray(PRlowerBoundA));
Util.NVTrace("upperBoundA", Util.PArray(PRupperBoundA));
InternalST.Soap("Header ");
Util.NVTrace("isMustUnderstand", PRisMustUnderstand);
Util.NVTrace("isHeaderRoot", PRisHeaderRoot);
Util.NVTrace("isAttributesProcessed", PRisAttributesProcessed);
Util.NVTrace("isXmlAttribute", PRisXmlAttribute);
InternalST.Soap("New Object");
if (PRnewObj != null)
{
Util.NVTrace("newObj", PRnewObj);
}
/*
* if ((objectInfo != null) && (objectInfo.objectType != null))
* Util.NVTrace("objectInfo", objectInfo.objectType.ToString());
*/
#endif
}
// Read Constructor
internal InternalSoapMessage()
{
InternalST.Soap(this, "Constructor Read Unitialized ");
}
