Exemplo n.º 1
0
 private void ReflectionReadMembers(object obj, XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces)
 {
     int memberCount = _classContract.MemberNames.Length;
     context.IncrementItemCount(memberCount);
     int memberIndex = -1;
     int firstRequiredMember;
     bool[] requiredMembers = GetRequiredMembers(_classContract, out firstRequiredMember);
     bool hasRequiredMembers = (firstRequiredMember < memberCount);
     int requiredIndex = hasRequiredMembers ? firstRequiredMember : -1;
     int index = -1;
     while (true)
     {
         if (!XmlObjectSerializerReadContext.MoveToNextElement(xmlReader))
         {
             return;
         }
         if (hasRequiredMembers)
         {
             index = context.GetMemberIndexWithRequiredMembers(xmlReader, memberNames, memberNamespaces, memberIndex, requiredIndex, null);
         }
         else
         {
             index = context.GetMemberIndex(xmlReader, memberNames, memberNamespaces, memberIndex, null);
         }
         ReflectionReadMember(obj, index, xmlReader, context, memberNames, memberNamespaces);
         memberIndex = index;
         requiredIndex = index + 1;
     }
 }
Exemplo n.º 2
0
 private void ReflectionInitArgs(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces)
 {
     _arg0XmlReader = xmlReader;
     _arg1Context = context;
     _arg2MemberNames = memberNames;
     _arg3MemberNamespaces = memberNamespaces;
 }
 public override object ReadXmlValue(XmlReaderDelegator reader, XmlObjectSerializerReadContext context)
 {
     object obj2;
     if (reader.IsEmptyElement)
     {
         reader.Skip();
         obj2 = new object();
     }
     else
     {
         string localName = reader.LocalName;
         string namespaceURI = reader.NamespaceURI;
         reader.Read();
         try
         {
             reader.ReadEndElement();
             obj2 = new object();
         }
         catch (XmlException exception)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(System.Runtime.Serialization.SR.GetString("XmlForObjectCannotHaveContent", new object[] { localName, namespaceURI }), exception));
         }
     }
     if (context != null)
     {
         return base.HandleReadValue(obj2, context);
     }
     return obj2;
 }
 public override object ReadXmlValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context)
 {
     xmlReader.Read();
     Type underlyingType = base.UnderlyingType;
     object obj2 = underlyingType.IsArray ? Array.CreateInstance(underlyingType.GetElementType(), 0) : this.GetUninitializedObject(underlyingType);
     context.AddNewObject(obj2);
     string objectId = context.GetObjectId();
     SerializationInfo serInfo = context.ReadSerializationInfo(xmlReader, underlyingType);
     object newObj = this.SerializationSurrogateSetObjectData(obj2, serInfo, context.GetStreamingContext());
     if (newObj == null)
     {
         newObj = obj2;
     }
     if (newObj is IDeserializationCallback)
     {
         ((IDeserializationCallback) newObj).OnDeserialization(null);
     }
     if (newObj is IObjectReference)
     {
         newObj = GetRealObject((IObjectReference) newObj, context.GetStreamingContext());
     }
     context.ReplaceDeserializedObject(objectId, obj2, newObj);
     xmlReader.ReadEndElement();
     return newObj;
 }
 public override object ReadXmlValue(XmlReaderDelegator reader, XmlObjectSerializerReadContext context)
 {
     if (context != null)
     {
         return base.HandleReadValue(reader.ReadElementContentAsChar(), context);
     }
     return reader.ReadElementContentAsChar();
 }
 protected int GetArrayLengthQuota(XmlObjectSerializerReadContext context)
 {
     if (this.dictionaryReader.Quotas == null)
     {
         return context.RemainingItemCount;
     }
     return Math.Min(context.RemainingItemCount, this.dictionaryReader.Quotas.MaxArrayLength);
 }
 public override object ReadXmlValue(XmlReaderDelegator reader, XmlObjectSerializerReadContext context)
 {
     if (context != null)
     {
         return base.HandleReadValue(reader.ReadElementContentAsQName(), context);
     }
     if (!base.TryReadNullAtTopLevel(reader))
     {
         return reader.ReadElementContentAsQName();
     }
     return null;
 }
Exemplo n.º 8
0
        internal object ReflectionReadClass(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces)
        {
            ReflectionInitArgs(xmlReader, context, memberNames, memberNamespaces);
            object obj = ReflectionCreateObject(_classContract);
            context.AddNewObject(obj);
            ReflectionReadMembers(obj, xmlReader, context, memberNames, memberNamespaces);

            if (obj.GetType() == typeof(DateTimeOffsetAdapter))
            {
                obj = DateTimeOffsetAdapter.GetDateTimeOffset((DateTimeOffsetAdapter)obj);
            }
            else if (obj.GetType().GetTypeInfo().IsGenericType && obj.GetType().GetGenericTypeDefinition() == typeof(KeyValuePairAdapter<,>))
            {
                obj = _classContract.GetKeyValuePairMethodInfo.Invoke(obj, Array.Empty<object>());
            }

            return obj;
        }
		public object ReadFromXml (XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces)
		{
			// InitArgs()
			this.xmlReader = xmlReader;
			this.context = context;
			this.memberNames = memberNames;
			this.memberNamespaces = memberNamespaces;
			
			//DemandSerializationFormatterPermission(classContract);
			//DemandMemberAccessPermission(memberAccessFlag);
			CreateObject (classContract);
			
			context.AddNewObject (objectLocal);
			InvokeOnDeserializing (classContract);
            
            string objectId = null;
            
			if (HasFactoryMethod (classContract))
				objectId = context.GetObjectId ();
			if (classContract.IsISerializable)
				ReadISerializable (classContract);
			else
				ReadClass (classContract);
			bool isFactoryType = InvokeFactoryMethod (classContract, objectId);
			if (Globals.TypeOfIDeserializationCallback.IsAssignableFrom (classContract.UnderlyingType))
				((IDeserializationCallback) objectLocal).OnDeserialization (null);
			InvokeOnDeserialized(classContract);
			if (objectId == null || !isFactoryType) {

				// Do a conversion back from DateTimeOffsetAdapter to DateTimeOffset after deserialization.
				// DateTimeOffsetAdapter is used here for deserialization purposes to bypass the ISerializable implementation
				// on DateTimeOffset; which does not work in partial trust.

				if (classContract.UnderlyingType == Globals.TypeOfDateTimeOffsetAdapter)
					objectLocal = DateTimeOffsetAdapter.GetDateTimeOffset ((DateTimeOffsetAdapter) objectLocal);
				// else - do we have to call CodeInterpreter.ConvertValue()? I guess not...
			}
			return objectLocal;
		}
Exemplo n.º 10
0
        protected override void ReflectionReadMembers(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces, ClassDataContract classContract, ref object obj)
        {
            int memberCount = classContract.MemberNames.Length;
            context.IncrementItemCount(memberCount);
            int memberIndex = -1;
            int firstRequiredMember;
            bool[] requiredMembers = GetRequiredMembers(classContract, out firstRequiredMember);
            bool hasRequiredMembers = (firstRequiredMember < memberCount);
            int requiredIndex = hasRequiredMembers ? firstRequiredMember : -1;
            DataMember[] members = new DataMember[memberCount];
            int reflectedMemberCount = ReflectionGetMembers(classContract, members);
            Debug.Assert(reflectedMemberCount == memberCount, "The value returned by ReflectionGetMembers() should equal to memberCount.");

            while (true)
            {
                if (!XmlObjectSerializerReadContext.MoveToNextElement(xmlReader))
                {
                    return;
                }
                if (hasRequiredMembers)
                {
                    memberIndex = context.GetMemberIndexWithRequiredMembers(xmlReader, memberNames, memberNamespaces, memberIndex, requiredIndex, null);
                }
                else
                {
                    memberIndex = context.GetMemberIndex(xmlReader, memberNames, memberNamespaces, memberIndex, null);
                }

                // GetMemberIndex returns memberNames.Length if member not found
                if (memberIndex < members.Length)
                {
                    ReflectionReadMember(xmlReader, context, classContract, ref obj, memberIndex, members);
                    requiredIndex = memberIndex + 1;
                }
            }
        }
Exemplo n.º 11
0
 private void CheckExpectedArrayLength(XmlObjectSerializerReadContext context, int arrayLength)
 {
     context.IncrementItemCount(arrayLength);
 }
 internal bool TryReadDecimalArray(XmlObjectSerializerReadContext context, XmlDictionaryString itemName, XmlDictionaryString itemNamespace, int arrayLength, out decimal[] array)
 {
     if (this.dictionaryReader == null)
     {
         array = null;
         return false;
     }
     if (arrayLength != -1)
     {
         this.CheckExpectedArrayLength(context, arrayLength);
         array = new decimal[arrayLength];
         int num = 0;
         int offset = 0;
         while ((num = this.dictionaryReader.ReadArray(itemName, itemNamespace, array, offset, arrayLength - offset)) > 0)
         {
             offset += num;
         }
         this.CheckActualArrayLength(arrayLength, offset, itemName, itemNamespace);
     }
     else
     {
         array = DecimalArrayHelperWithDictionaryString.Instance.ReadArray(this.dictionaryReader, itemName, itemNamespace, this.GetArrayLengthQuota(context));
         context.IncrementItemCount(array.Length);
     }
     return true;
 }
 public override bool TryReadDateTimeArray(XmlObjectSerializerReadContext context,
Exemplo n.º 14
0
 protected static object HandleReadValue(object obj, XmlObjectSerializerReadContext context)
 {
     context.AddNewObject(obj);
     return obj;
 }
Exemplo n.º 15
0
 public override object ReadXmlValue(XmlReaderDelegator reader, XmlObjectSerializerReadContext context)
 {
     return (context == null) ? reader.ReadElementContentAsGuid()
         : HandleReadValue(reader.ReadElementContentAsGuid(), context);
 }
Exemplo n.º 16
0
 public override object ReadXmlValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context)
 {
     object obj = ReadEnumValue(xmlReader);
     if (context != null)
         context.AddNewObject(obj);
     return obj;
 }
Exemplo n.º 17
0
 public bool TryReadDecimalArray(XmlObjectSerializerReadContext context,
Exemplo n.º 18
0
        private int ReflectionReadMember(object obj, int memberIndex, XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString[] memberNames, XmlDictionaryString[] memberNamespaces)
        {
            int memberCount = 0;

            Type classType = _classContract.UnadaptedClassType;
            int i = memberIndex + memberCount;
            DataMember dataMember = _classContract.Members[i];
            Type memberType = dataMember.MemberType;

            var value = ReflectionReadValue(memberType, dataMember.Name, _classContract.StableName.Namespace);
            MemberInfo memberInfo = dataMember.MemberInfo;
            if (memberInfo != null)
            {
                ReflectionSetMemberValue(obj, value, memberInfo);
            }
            else
            {
                throw new NotImplementedException("PropertyInfo incorrect");
            }

            return memberCount;
        }
Exemplo n.º 19
0
        protected override bool ReflectionReadSpecialCollection(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, CollectionDataContract collectionContract, object resultCollection)
        {
            var jsonContext = context as XmlObjectSerializerReadContextComplexJson;

            Debug.Assert(jsonContext != null);

            bool canReadSimpleDictionary = collectionContract.Kind == CollectionKind.Dictionary ||
                                           collectionContract.Kind == CollectionKind.GenericDictionary;

            if (canReadSimpleDictionary && jsonContext.UseSimpleDictionaryFormat)
            {
                ReadSimpleDictionary(xmlReader, context, collectionContract, collectionContract.ItemType, resultCollection);
            }

            return(false);
        }
Exemplo n.º 20
0
        private void ReadSimpleDictionary(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, CollectionDataContract collectionContract, Type keyValueType, object dictionary)
        {
            Type[] keyValueTypes = keyValueType.GetGenericArguments();
            Type   keyType       = keyValueTypes[0];
            Type   valueType     = keyValueTypes[1];

            int keyTypeNullableDepth = 0;

            while (keyType.IsGenericType && keyType.GetGenericTypeDefinition() == Globals.TypeOfNullable)
            {
                keyTypeNullableDepth++;
                keyType = keyType.GetGenericArguments()[0];
            }

            ClassDataContract keyValueDataContract = (ClassDataContract)collectionContract.ItemContract;
            DataContract      keyDataContract      = keyValueDataContract.Members[0].MemberTypeContract;

            KeyParseMode keyParseMode = KeyParseMode.Fail;

            if (keyType == Globals.TypeOfString || keyType == Globals.TypeOfObject)
            {
                keyParseMode = KeyParseMode.AsString;
            }
            else if (keyType.IsEnum)
            {
                keyParseMode = KeyParseMode.UsingParseEnum;
            }
            else if (keyDataContract.ParseMethod != null)
            {
                keyParseMode = KeyParseMode.UsingCustomParse;
            }

            if (keyParseMode == KeyParseMode.Fail)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                          new InvalidOperationException(
                              SR.Format(SR.KeyTypeCannotBeParsedInSimpleDictionary,
                                        DataContract.GetClrTypeFullName(collectionContract.UnderlyingType),
                                        DataContract.GetClrTypeFullName(keyType))
                              ));
            }

            while (true)
            {
                XmlNodeType nodeType = xmlReader.MoveToContent();
                if (nodeType == XmlNodeType.EndElement)
                {
                    return;
                }
                if (nodeType != XmlNodeType.Element)
                {
                    throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.Element, xmlReader);
                }

                context.IncrementItemCount(1);
                string keyString = XmlObjectSerializerReadContextComplexJson.GetJsonMemberName(xmlReader);
                object pairKey;

                if (keyParseMode == KeyParseMode.UsingParseEnum)
                {
                    pairKey = Enum.Parse(keyType, keyString);
                }
                else if (keyParseMode == KeyParseMode.UsingCustomParse)
                {
                    TypeCode typeCode = Type.GetTypeCode(keyDataContract.UnderlyingType);
                    switch (typeCode)
                    {
                    case TypeCode.Boolean:
                        pairKey = bool.Parse(keyString);
                        break;

                    case TypeCode.Int16:
                        pairKey = short.Parse(keyString);
                        break;

                    case TypeCode.Int32:
                        pairKey = int.Parse(keyString);
                        break;

                    case TypeCode.Int64:
                        pairKey = long.Parse(keyString);
                        break;

                    case TypeCode.Char:
                        pairKey = char.Parse(keyString);
                        break;

                    case TypeCode.Byte:
                        pairKey = byte.Parse(keyString);
                        break;

                    case TypeCode.SByte:
                        pairKey = sbyte.Parse(keyString);
                        break;

                    case TypeCode.Double:
                        pairKey = double.Parse(keyString);
                        break;

                    case TypeCode.Decimal:
                        pairKey = decimal.Parse(keyString);
                        break;

                    case TypeCode.Single:
                        pairKey = float.Parse(keyString);
                        break;

                    case TypeCode.UInt16:
                        pairKey = ushort.Parse(keyString);
                        break;

                    case TypeCode.UInt32:
                        pairKey = uint.Parse(keyString);
                        break;

                    case TypeCode.UInt64:
                        pairKey = ulong.Parse(keyString);
                        break;

                    default:
                        pairKey = keyDataContract.ParseMethod.Invoke(null, new object[] { keyString });
                        break;
                    }
                }
                else
                {
                    pairKey = keyString;
                }

                if (keyTypeNullableDepth > 0)
                {
                    throw new NotImplementedException("keyTypeNullableDepth > 0");
                }

                object pairValue = ReflectionReadValue(xmlReader, context, valueType, string.Empty, string.Empty);


                ((IDictionary)dictionary).Add(pairKey, pairValue);
            }
        }
Exemplo n.º 21
0
 internal void ReflectionReadGetOnlyCollection(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString itemName, XmlDictionaryString itemNamespace, CollectionDataContract collectionContract)
 {
     throw new NotImplementedException();
 }
Exemplo n.º 22
0
        internal object ReflectionReadCollection(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, XmlDictionaryString itemName, XmlDictionaryString itemNamespace, CollectionDataContract collectionContract)
        {
            ReflectionInitArgs(xmlReader, context, null, null);
            _arg2CollectionItemName = itemName;
            _arg3CollectionItemNamespace = itemNamespace;

            return ReflectionReadCollectionCore(collectionContract);
        }
Exemplo n.º 23
0
 protected int GetArrayLengthQuota(XmlObjectSerializerReadContext context)
 {
     return Math.Min(context.RemainingItemCount, int.MaxValue);
 }
Exemplo n.º 24
0
 public bool TryReadBooleanArray(XmlObjectSerializerReadContext context,
Exemplo n.º 25
0
 public bool TryReadDoubleArray(XmlObjectSerializerReadContext context,
Exemplo n.º 26
0
 public bool TryReadInt64Array(XmlObjectSerializerReadContext context,
Exemplo n.º 27
0
        protected override object ReflectionReadDictionaryItem(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context, CollectionDataContract collectionContract)
        {
            var jsonContext = context as XmlObjectSerializerReadContextComplexJson;

            Debug.Assert(jsonContext != null);
            Debug.Assert(collectionContract.Kind == CollectionKind.Dictionary || collectionContract.Kind == CollectionKind.GenericDictionary);
            context.ReadAttributes(xmlReader);

            var itemContract = XmlObjectSerializerWriteContextComplexJson.GetRevisedItemContract(collectionContract.ItemContract);

            return(DataContractJsonSerializer.ReadJsonValue(itemContract, xmlReader, jsonContext));
        }
Exemplo n.º 28
0
        internal bool TryReadDoubleArray(XmlObjectSerializerReadContext context,
#endif   
            XmlDictionaryString itemName, XmlDictionaryString itemNamespace,
            int arrayLength, out double[] array)
        {
            if (dictionaryReader == null)
            {
                array = null;
                return false;
            }

            if (arrayLength != -1)
            {
                CheckExpectedArrayLength(context, arrayLength);
                array = new double[arrayLength];
                int read = 0, offset = 0;
                while ((read = dictionaryReader.ReadArray(itemName, itemNamespace, array, offset, arrayLength - offset)) > 0)
                {
                    offset += read;
                }
                CheckActualArrayLength(arrayLength, offset, itemName, itemNamespace);
            }
            else
            {
                array = DoubleArrayHelperWithDictionaryString.Instance.ReadArray(
                    dictionaryReader, itemName, itemNamespace, GetArrayLengthQuota(context));
                context.IncrementItemCount(array.Length);
            }
            return true;
        }
Exemplo n.º 29
0
        public override object ReadXmlValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context)
        {
            XmlReaderDelegator xmlDelegator = ParseReaderString(xmlReader);

            ClassDataContract cdc = new ClassDataContract(this.UnderlyingType);

            // The Class Data Contract created from the underlying exception type uses custom imported members that are 
            // created in this classes constructor. Here we clear out the Class Data Contract's default members and insert our own.
            cdc.Members.Clear();
            foreach (DataMember dm in this.Members)
            {
                cdc.Members.Add(dm);
            }

            cdc.MemberNames = _memberNames;
            cdc.ContractNamespaces = _contractNamespaces;
            cdc.MemberNamespaces = _memberNamespaces;

            object obj = cdc.ReadXmlValue(xmlDelegator, context);

            if (context != null)
                context.AddNewObject(obj);
            return obj;
        }
Exemplo n.º 30
0
 public override object ReadXmlValue(XmlReaderDelegator reader, XmlObjectSerializerReadContext context)
 {
     object obj;
     if (reader.IsEmptyElement)
     {
         reader.Skip();
         obj = new object();
     }
     else
     {
         string localName = reader.LocalName;
         string ns = reader.NamespaceURI;
         reader.Read();
         try
         {
             reader.ReadEndElement();
             obj = new object();
         }
         catch (XmlException xes)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.XmlForObjectCannotHaveContent, localName, ns), xes));
         }
     }
     return (context == null) ? obj : HandleReadValue(obj, context);
 }
Exemplo n.º 31
0
 protected static object HandleReadValue(object obj, XmlObjectSerializerReadContext context)
 {
     context.AddNewObject(obj);
     return(obj);
 }
Exemplo n.º 32
0
 public override object ReadXmlValue(XmlReaderDelegator reader, XmlObjectSerializerReadContext context)
 {
     if (context == null)
     {
         return TryReadNullAtTopLevel(reader) ? null : reader.ReadElementContentAsQName();
     }
     else
     {
         return HandleReadValue(reader.ReadElementContentAsQName(), context);
     }
 }
Exemplo n.º 33
0
 public override object ReadXmlValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context)
 {
     throw CreateInvalidDataContractException();
 }
 internal ExtensionDataReader(XmlObjectSerializerReadContext context)
 {
     this.attributeIndex = -1;
     this.context = context;
 }
Exemplo n.º 35
0
 internal override bool TryReadDateTimeArray(XmlObjectSerializerReadContext context,
                                             XmlDictionaryString itemName, XmlDictionaryString itemNamespace,
                                             int arrayLength, [NotNullWhen(true)] out DateTime[]?array)
 {
     return(TryReadJsonDateTimeArray(context, itemName, itemNamespace, arrayLength, out array));
 }
Exemplo n.º 36
0
 public override object ReadXmlValue(XmlReaderDelegator xmlReader, XmlObjectSerializerReadContext context)
 {
     object o;
     if (context == null)
     {
         o = XmlObjectSerializerReadContext.ReadRootIXmlSerializable(xmlReader, this, true /*isMemberType*/);
     }
     else
     {
         o = context.ReadIXmlSerializable(xmlReader, this, true /*isMemberType*/);
         context.AddNewObject(o);
     }
     xmlReader.ReadEndElement();
     return o;
 }
 internal ExtensionDataReader(XmlObjectSerializerReadContext context)
 {
     attributeIndex = -1;
     this.context   = context;
 }