コード例 #1
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            object list;

            if (DocumentRootConverter.TryResolveAsRootData(reader, objectType, serializer, out list))
            {
                return(list);
            }

            //read into the 'Data' path
            var preDataPath = ReaderUtil.ReadUntilStart(reader, DataPathRegex);

            //we should be dealing with list types, but we also want the element type
            Type elementType;

            if (!ListUtil.IsList(objectType, out elementType))
            {
                throw new ArgumentException($"{typeof(ResourceObjectListConverter)} can only read json lists", nameof(objectType));
            }

            var itemsIterator = ReaderUtil.IterateList(reader).Select(x => serializer.Deserialize(reader, elementType));

            list = ListUtil.CreateList(objectType, itemsIterator);

            //read out of the 'Data' path
            ReaderUtil.ReadUntilEnd(reader, preDataPath);

            return(list);
        }
コード例 #2
0
        protected object PopulateProperties(JsonSerializer serializer, object obj, JsonReader reader, JsonObjectContract contract)
        {
            foreach (var propName in ReaderUtil.IterateProperties(reader))
            {
                if (propName == PropertyNames.Type)
                {
                    var type = reader.Value;
                    if (obj.GetType().Name.ToLower() != type.ToString().ToLower())
                    {
                        Assembly[] assembly = Utility.GetAssemblies();
                        var        tp       = assembly.SelectMany(s => s.GetTypes()).ToList().Where(t => t.Name.ToLower() == type.ToString().ToLower()).SingleOrDefault();
                        if (tp != null)
                        {
                            obj      = Activator.CreateInstance(tp);
                            contract = (JsonObjectContract)serializer.ContractResolver.ResolveContract(obj.GetType());
                        }
                    }
                    //retObj.id = obj;
                }
                var successfullyPopulateProperty = ReaderUtil.TryPopulateProperty(
                    serializer,
                    obj,
                    contract.Properties.GetClosestMatchProperty(propName),
                    reader);

                if (!successfullyPopulateProperty)
                {
                    //flatten out attributes onto the object
                    if (propName == "attributes")
                    {
                        foreach (var innerPropName in ReaderUtil.IterateProperties(reader))
                        {
                            ReaderUtil.TryPopulateProperty(
                                serializer,
                                obj,
                                contract.Properties.GetClosestMatchProperty(innerPropName),
                                reader);
                        }
                    }

                    //flatten out relationships onto the object
                    if (propName == "relationships")
                    {
                        foreach (var innerPropName in ReaderUtil.IterateProperties(reader))
                        {
                            //read into the 'Data' path
                            var preDataPath = ReaderUtil.ReadUntilStart(reader, DataPathRegex);

                            ReaderUtil.TryPopulateProperty(
                                serializer,
                                obj,
                                contract.Properties.GetClosestMatchProperty(innerPropName),
                                reader);
                            //read out of the 'Data' path
                            ReaderUtil.ReadUntilEnd(reader, preDataPath);
                        }
                    }
                }
            }
            return(obj);
        }