// 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 "); }