コード例 #1
0
        /// <summary>
        /// Populates a list with items.
        /// </summary>
        /// <param name="state">The loader state.</param>
        /// <param name="list">The list to populate.</param>
        /// <param name="listElemType">The type of elements in the list.</param>
        /// <param name="element">The element that defines the list.</param>
        private void PopulateListItems(ObjectLoaderState state, Object list, Type listElemType, XElement element)
        {
            // Make sure that the list is properly defined.
            var itemsRoot = element.Element("Items");

            if (itemsRoot != null && itemsRoot.Elements().Where(x => x.Name != "Item").Any())
            {
                throw new InvalidOperationException(NucleusStrings.NonItemElementsInListDef);
            }

            // Populate the list's items.
            if (itemsRoot != null)
            {
                var add   = list.GetType().GetMethod("Add", new[] { listElemType });
                var items = itemsRoot.Elements("Item").ToList();

                for (int i = 0; i < items.Count; i++)
                {
                    var value = default(Object);
                    var type  = GetTypeFromElement(state, listElemType, items[i]);
                    if (items[i].Elements().Any())
                    {
                        value = CreateObject(state, type, null, GetSpecifiedConstructorArguments(items[i]));
                        value = PopulateObjectFromElements(state, value, items[i]);
                    }
                    else
                    {
                        value = ObjectResolver.FromString(items[i].Value, type);
                    }
                    add.Invoke(list, new[] { value });
                }
            }
        }
コード例 #2
0
        /// <summary>
        /// Populates an array value.
        /// </summary>
        /// <param name="state">The loader state.</param>
        /// <param name="member">The member to populate.</param>
        /// <param name="element">The element that defines the member's value.</param>
        private void PopulateArray(ObjectLoaderState state, ObjectLoaderMember member, XElement element)
        {
            // Make sure that the array is properly defined.
            var itemsRoot = element.Element("Items");

            if (itemsRoot != null && itemsRoot.Elements().Where(x => x.Name != "Item").Any())
            {
                throw new InvalidOperationException(NucleusStrings.NonItemElementsInArrayDef);
            }

            // Create the array.
            var items            = (itemsRoot == null) ? new List <XElement>() : itemsRoot.Elements("Item").ToList();
            var arrayElementType = member.MemberType.GetElementType();
            var array            = Array.CreateInstance(arrayElementType, items.Count);

            member.SetValueFromData(array, element);

            // Populate the array's items.
            for (int i = 0; i < items.Count; i++)
            {
                var value = default(Object);
                var type  = GetTypeFromElement(state, arrayElementType, items[i]);
                if (items[i].Elements().Any())
                {
                    value = CreateObject(state, type, null, GetSpecifiedConstructorArguments(items[i]));
                    value = PopulateObjectFromElements(state, value, items[i]);
                }
                else
                {
                    value = ObjectResolver.FromString(items[i].Value, type);
                }
                array.SetValue(value, i);
            }
        }
コード例 #3
0
        /// <inheritdoc/>
        public override Object ReadJson(JsonReader reader, Type objectType, Object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType != JsonToken.String)
            {
                throw new JsonReaderException(NucleusStrings.JsonObjectResolverRequiresString.Format(reader.TokenType));
            }

            return(ObjectResolver.FromString((String)reader.Value, objectType));
        }
コード例 #4
0
        /// <summary>
        /// Converts the given object to the type of this converter, using the specified context and culture information.
        /// </summary>
        /// <param name="context">An <see cref="ITypeDescriptorContext"/> that provides a format context.</param>
        /// <param name="culture">The <see cref="CultureInfo"/> to use as the current culture.</param>
        /// <param name="value">The <see cref="Object"/> to convert.</param>
        /// <returns>An <see cref="Object"/> that represents the converted value.</returns>
        public override Object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, Object value)
        {
            if (value is String)
            {
                if (String.IsNullOrEmpty((String)value))
                {
                    return(default(T));
                }

                var type = (context == null) ? typeof(T) : context.PropertyDescriptor.PropertyType;
                return(ObjectResolver.FromString((String)value, type));
            }
            return(base.ConvertFrom(context, culture, value));
        }
コード例 #5
0
        /// <summary>
        /// Populates an object from the attributes defined on the specified data element.
        /// </summary>
        /// <param name="state">The loader state.</param>
        /// <param name="objectInstance">The object instance.</param>
        /// <param name="objectElement">The object element.</param>
        /// <returns>The object instance.</returns>
        private Object PopulateObjectFromAttributes(ObjectLoaderState state, Object objectInstance, XElement objectElement)
        {
            foreach (var attr in objectElement.Attributes())
            {
                if (IsReservedKeyword(attr.Name.LocalName))
                {
                    continue;
                }

                var attrMember = ObjectLoaderMember.Find(objectInstance, attr.Name.LocalName, state.IgnoreMissingMembers);
                if (attrMember != null)
                {
                    if (state.Resolver != null && state.Resolver(objectInstance, attr.Name.LocalName, attr.Value))
                    {
                        continue;
                    }

                    var attrValue = ObjectResolver.FromString(attr.Value, attrMember.MemberType);
                    attrMember.SetValue(attrValue, null);
                }
            }

            return(objectInstance);
        }
コード例 #6
0
        /// <summary>
        /// Gets a set of index parameters from the specified data element.
        /// </summary>
        /// <param name="element">The data element from which to retrieve index parameters.</param>
        /// <returns>The index parameters that were retrieved.</returns>
        private Object[] GetIndexParameters(XElement element)
        {
            var indexParameterValues = new Object[indexParameters.Length];

            for (int i = 0; i < indexParameters.Length; i++)
            {
                var indexParameter = indexParameters[i];

                var attr = element.Attribute(indexParameter.Name);
                if (attr == null)
                {
                    throw new InvalidOperationException(NucleusStrings.DataObjectMissingIndexParam.Format(indexParameter.Name));
                }

                indexParameterValues[i] = ObjectResolver.FromString(attr.Value, indexParameter.ParameterType);
            }

            if (element.Attributes().Where(x => !ObjectLoaderXmlSerializer.IsReservedKeyword(x.Name.LocalName)).Count() > indexParameterValues.Length)
            {
                throw new InvalidOperationException(NucleusStrings.DataObjectHasTooManyIndexParams);
            }

            return(indexParameterValues);
        }
コード例 #7
0
 /// <summary>
 /// Attempts to parse a string into a simple value.
 /// </summary>
 /// <param name="str">The string to parse.</param>
 /// <param name="type">The type into which to parse the string.</param>
 /// <param name="provider">An object that provides culture-specific formatting information.</param>
 /// <returns>The value that was parsed.</returns>
 private Object ParseValue(String str, Type type, IFormatProvider provider)
 {
     return(ObjectResolver.FromString(str, type, provider));
 }