| static private FromString ( string value, InternalPrimitiveTypeE code ) : object | ||
| value | string | |
| code | InternalPrimitiveTypeE | |
| return | object | |
private void ParseMember(ParseRecord pr)
{
ParseRecord parseRecord = (ParseRecord)this.stack.Peek();
if (parseRecord != null)
{
string str = parseRecord.PRname;
}
switch (pr.PRmemberTypeEnum)
{
case InternalMemberTypeE.Item:
this.ParseArrayMember(pr);
break;
default:
if (pr.PRdtType == null && parseRecord.PRobjectInfo.isTyped)
{
pr.PRdtType = parseRecord.PRobjectInfo.GetType(pr.PRname);
if (pr.PRdtType != null)
{
pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
}
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)null, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
this.ParseObject(pr);
this.stack.Push((object)pr);
if (pr.PRobjectInfo != null && pr.PRobjectInfo.objectType != null && pr.PRobjectInfo.objectType.IsValueType)
{
pr.PRisValueTypeFixup = true;
this.ValueFixupStack.Push((object)new ValueFixup(parseRecord.PRnewObj, pr.PRname, parseRecord.PRobjectInfo));
break;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object @object = this.m_objectManager.GetObject(pr.PRidRef);
if (@object == null)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)null, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
parseRecord.PRobjectInfo.RecordFixup(parseRecord.PRobjectId, pr.PRname, pr.PRidRef);
break;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, @object, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parseRecord);
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)pr.PRvalue, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid)
{
if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)Convert.FromBase64String(pr.PRvalue), ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (pr.PRdtType == Converter.typeofObject)
{
throw new SerializationException(Environment.GetResourceString("Serialization_TypeMissing", (object)pr.PRname));
}
this.ParseString(pr, parseRecord);
if (pr.PRdtType == Converter.typeofSystemVoid)
{
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)pr.PRdtType, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
if (!parseRecord.PRobjectInfo.isSi)
{
break;
}
parseRecord.PRobjectInfo.AddValue(pr.PRname, (object)pr.PRvalue, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
object obj = pr.PRvarValue == null?Converter.FromString(pr.PRvalue, pr.PRdtTypeCode) : pr.PRvarValue;
parseRecord.PRobjectInfo.AddValue(pr.PRname, obj, ref parseRecord.PRsi, ref parseRecord.PRmemberData);
break;
}
this.ParseError(pr, parseRecord);
break;
}
}
// Object member encountered in stream
private void ParseMember(ParseRecord pr)
{
ParseRecord objectPr = (ParseRecord)_stack.Peek();
string objName = objectPr?._name;
switch (pr._memberTypeEnum)
{
case InternalMemberTypeE.Item:
ParseArrayMember(pr);
return;
case InternalMemberTypeE.Field:
break;
}
//if ((pr.PRdtType == null) && !objectPr.PRobjectInfo.isSi)
if (pr._dtType == null && objectPr._objectInfo._isTyped)
{
pr._dtType = objectPr._objectInfo.GetType(pr._name);
if (pr._dtType != null)
{
pr._dtTypeCode = Converter.ToCode(pr._dtType);
}
}
if (pr._memberValueEnum == InternalMemberValueE.Null)
{
// Value is Null
objectPr._objectInfo.AddValue(pr._name, null, ref objectPr._si, ref objectPr._memberData);
}
else if (pr._memberValueEnum == InternalMemberValueE.Nested)
{
ParseObject(pr);
_stack.Push(pr);
if ((pr._objectInfo != null) && pr._objectInfo._objectType != null && (pr._objectInfo._objectType.IsValueType))
{
pr._isValueTypeFixup = true; //Valuefixup
ValueFixupStack.Push(new ValueFixup(objectPr._newObj, pr._name, objectPr._objectInfo)); //valuefixup
}
else
{
objectPr._objectInfo.AddValue(pr._name, pr._newObj, ref objectPr._si, ref objectPr._memberData);
}
}
else if (pr._memberValueEnum == InternalMemberValueE.Reference)
{
// See if object has already been instantiated
object refObj = _objectManager.GetObject(pr._idRef);
if (refObj == null)
{
objectPr._objectInfo.AddValue(pr._name, null, ref objectPr._si, ref objectPr._memberData);
objectPr._objectInfo.RecordFixup(objectPr._objectId, pr._name, pr._idRef); // Object not instantiated
}
else
{
objectPr._objectInfo.AddValue(pr._name, refObj, ref objectPr._si, ref objectPr._memberData);
}
}
else if (pr._memberValueEnum == InternalMemberValueE.InlineValue)
{
// Primitive type or String
if (ReferenceEquals(pr._dtType, Converter.s_typeofString))
{
ParseString(pr, objectPr);
objectPr._objectInfo.AddValue(pr._name, pr._value, ref objectPr._si, ref objectPr._memberData);
}
else if (pr._dtTypeCode == InternalPrimitiveTypeE.Invalid)
{
// The member field was an object put the value is Inline either bin.Base64 or invalid
if (pr._arrayTypeEnum == InternalArrayTypeE.Base64)
{
objectPr._objectInfo.AddValue(pr._name, Convert.FromBase64String(pr._value), ref objectPr._si, ref objectPr._memberData);
}
else if (ReferenceEquals(pr._dtType, Converter.s_typeofObject))
{
throw new SerializationException(SR.Format(SR.Serialization_TypeMissing, pr._name));
}
else
{
ParseString(pr, objectPr); // Register the object if it has an objectId
// Object Class with no memberInfo data
// only special case where AddValue is needed?
if (ReferenceEquals(pr._dtType, Converter.s_typeofSystemVoid))
{
objectPr._objectInfo.AddValue(pr._name, pr._dtType, ref objectPr._si, ref objectPr._memberData);
}
else if (objectPr._objectInfo._isSi)
{
// ISerializable are added as strings, the conversion to type is done by the
// ISerializable object
objectPr._objectInfo.AddValue(pr._name, pr._value, ref objectPr._si, ref objectPr._memberData);
}
}
}
else
{
object var = pr._varValue != null ?
pr._varValue :
Converter.FromString(pr._value, pr._dtTypeCode);
objectPr._objectInfo.AddValue(pr._name, var, ref objectPr._si, ref objectPr._memberData);
}
}
else
{
ParseError(pr, objectPr);
}
}
private void ParseArrayMember(ParseRecord pr)
{
ParseRecord parseRecord = (ParseRecord)this.stack.Peek();
if (parseRecord.PRarrayTypeEnum == InternalArrayTypeE.Rectangular)
{
if (parseRecord.PRmemberIndex > 0)
{
this.NextRectangleMap(parseRecord);
}
if (parseRecord.PRisLowerBound)
{
for (int index = 0; index < parseRecord.PRrank; ++index)
{
parseRecord.PRindexMap[index] = parseRecord.PRrectangularMap[index] + parseRecord.PRlowerBoundA[index];
}
}
}
else
{
parseRecord.PRindexMap[0] = parseRecord.PRisLowerBound ? parseRecord.PRlowerBoundA[0] + parseRecord.PRmemberIndex : parseRecord.PRmemberIndex;
}
if (pr.PRmemberValueEnum == InternalMemberValueE.Reference)
{
object @object = this.m_objectManager.GetObject(pr.PRidRef);
if (@object == null)
{
int[] indices = new int[parseRecord.PRrank];
Array.Copy((Array)parseRecord.PRindexMap, 0, (Array)indices, 0, parseRecord.PRrank);
this.m_objectManager.RecordArrayElementFixup(parseRecord.PRobjectId, indices, pr.PRidRef);
}
else if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = @object;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(@object, parseRecord.PRindexMap);
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
{
if (pr.PRdtType == null)
{
pr.PRdtType = parseRecord.PRarrayElementType;
}
this.ParseObject(pr);
this.stack.Push((object)pr);
if (parseRecord.PRarrayElementType != null)
{
if (parseRecord.PRarrayElementType.IsValueType && pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Invalid)
{
pr.PRisValueTypeFixup = true;
this.ValueFixupStack.Push((object)new ValueFixup((Array)parseRecord.PRnewObj, parseRecord.PRindexMap));
}
else if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = pr.PRnewObj;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(pr.PRnewObj, parseRecord.PRindexMap);
}
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue)
{
if (parseRecord.PRarrayElementType == Converter.typeofString || pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parseRecord);
if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = (object)pr.PRvalue;
}
else
{
((Array)parseRecord.PRnewObj).SetValue((object)pr.PRvalue, parseRecord.PRindexMap);
}
}
else if (parseRecord.PRisArrayVariant)
{
if (pr.PRkeyDt == null)
{
throw new SerializationException(Environment.GetResourceString("Serialization_ArrayTypeObject"));
}
object obj;
if (pr.PRdtType == Converter.typeofString)
{
this.ParseString(pr, parseRecord);
obj = (object)pr.PRvalue;
}
else if ((Enum)pr.PRdtTypeCode == (Enum)InternalPrimitiveTypeE.Invalid)
{
this.CheckSerializable(pr.PRdtType);
obj = !this.IsRemoting || this.formatterEnums.FEsecurityLevel == TypeFilterLevel.Full ? FormatterServices.GetUninitializedObject(pr.PRdtType) : FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
}
else
{
obj = pr.PRvarValue == null?Converter.FromString(pr.PRvalue, pr.PRdtTypeCode) : pr.PRvarValue;
}
if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = obj;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(obj, parseRecord.PRindexMap);
}
}
else if (parseRecord.PRprimitiveArray != null)
{
parseRecord.PRprimitiveArray.SetValue(pr.PRvalue, parseRecord.PRindexMap[0]);
}
else
{
object obj = pr.PRvarValue == null?Converter.FromString(pr.PRvalue, parseRecord.PRarrayElementTypeCode) : pr.PRvarValue;
if (parseRecord.PRobjectA != null)
{
parseRecord.PRobjectA[parseRecord.PRindexMap[0]] = obj;
}
else
{
((Array)parseRecord.PRnewObj).SetValue(obj, parseRecord.PRindexMap);
}
}
}
else if (pr.PRmemberValueEnum == InternalMemberValueE.Null)
{
parseRecord.PRmemberIndex += pr.PRnullCount - 1;
}
else
{
this.ParseError(pr, parseRecord);
}
++parseRecord.PRmemberIndex;
}
// Array object item encountered in stream
private void ParseArrayMember(ParseRecord pr)
{
ParseRecord objectPr = (ParseRecord)_stack.Peek();
// Set up for inserting value into correct array position
if (objectPr._arrayTypeEnum == InternalArrayTypeE.Rectangular)
{
if (objectPr._memberIndex > 0)
{
NextRectangleMap(objectPr); // Rectangle array, calculate position in array
}
if (objectPr._isLowerBound)
{
for (int i = 0; i < objectPr._rank; i++)
{
objectPr._indexMap[i] = objectPr._rectangularMap[i] + objectPr._lowerBoundA[i];
}
}
}
else
{
objectPr._indexMap[0] = !objectPr._isLowerBound ?
objectPr._memberIndex : // Zero based array
objectPr._lowerBoundA[0] + objectPr._memberIndex; // Lower Bound based array
}
// Set Array element according to type of element
if (pr._memberValueEnum == InternalMemberValueE.Reference)
{
// Object Reference
// See if object has already been instantiated
object refObj = _objectManager.GetObject(pr._idRef);
if (refObj == null)
{
// Object not instantiated
// Array fixup manager
int[] fixupIndex = new int[objectPr._rank];
Array.Copy(objectPr._indexMap, 0, fixupIndex, 0, objectPr._rank);
_objectManager.RecordArrayElementFixup(objectPr._objectId, fixupIndex, pr._idRef);
}
else
{
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = refObj;
}
else
{
((Array)objectPr._newObj).SetValue(refObj, objectPr._indexMap); // Object has been instantiated
}
}
}
else if (pr._memberValueEnum == InternalMemberValueE.Nested)
{
//Set up dtType for ParseObject
if (pr._dtType == null)
{
pr._dtType = objectPr._arrayElementType;
}
ParseObject(pr);
_stack.Push(pr);
if (objectPr._arrayElementType != null)
{
if ((objectPr._arrayElementType.IsValueType) && (pr._arrayElementTypeCode == InternalPrimitiveTypeE.Invalid))
{
pr._isValueTypeFixup = true; //Valuefixup
ValueFixupStack.Push(new ValueFixup((Array)objectPr._newObj, objectPr._indexMap)); //valuefixup
}
else
{
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = pr._newObj;
}
else
{
((Array)objectPr._newObj).SetValue(pr._newObj, objectPr._indexMap);
}
}
}
}
else if (pr._memberValueEnum == InternalMemberValueE.InlineValue)
{
if ((ReferenceEquals(objectPr._arrayElementType, Converter.s_typeofString)) || (ReferenceEquals(pr._dtType, Converter.s_typeofString)))
{
// String in either a string array, or a string element of an object array
ParseString(pr, objectPr);
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = pr._value;
}
else
{
((Array)objectPr._newObj).SetValue(pr._value, objectPr._indexMap);
}
}
else if (objectPr._isArrayVariant)
{
// Array of type object
if (pr._keyDt == null)
{
throw new SerializationException(SR.Serialization_ArrayTypeObject);
}
object var = null;
if (ReferenceEquals(pr._dtType, Converter.s_typeofString))
{
ParseString(pr, objectPr);
var = pr._value;
}
else if (ReferenceEquals(pr._dtTypeCode, InternalPrimitiveTypeE.Invalid))
{
CheckSerializable(pr._dtType);
// Not nested and invalid, so it is an empty object
var = FormatterServices.GetUninitializedObject(pr._dtType);
}
else
{
var = pr._varValue != null ?
pr._varValue :
Converter.FromString(pr._value, pr._dtTypeCode);
}
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = var;
}
else
{
((Array)objectPr._newObj).SetValue(var, objectPr._indexMap); // Primitive type
}
}
else
{
// Primitive type
if (objectPr._primitiveArray != null)
{
// Fast path for Soap primitive arrays. Binary was handled in the BinaryParser
objectPr._primitiveArray.SetValue(pr._value, objectPr._indexMap[0]);
}
else
{
object var = pr._varValue != null ?
pr._varValue :
Converter.FromString(pr._value, objectPr._arrayElementTypeCode);
if (objectPr._objectA != null)
{
objectPr._objectA[objectPr._indexMap[0]] = var;
}
else
{
((Array)objectPr._newObj).SetValue(var, objectPr._indexMap); // Primitive type
}
}
}
}
else if (pr._memberValueEnum == InternalMemberValueE.Null)
{
objectPr._memberIndex += pr._consecutiveNullArrayEntryCount - 1; //also incremented again below
}
else
{
ParseError(pr, objectPr);
}
objectPr._memberIndex++;
}
