Null() public static method

Get a null JSON value (that when serialized will stay null rather than not being written out).
public static Null ( ) : JToken
return JToken
Esempio n. 1
0
        /// <summary>
        /// Get an element from a table by its ID.
        /// </summary>
        /// <param name="id">The ID of the element.</param>
        /// <param name="parameters">A dictionary of user-defined parameters and values to include in the request URI query string.</param>
        /// <returns>The desired element as JSON object.</returns>
        private Task <JsonObject> GetSingleValueAsync(object id, IDictionary <string, string> parameters)
        {
            // Create a query for just this item
            string query = string.Format(
                CultureInfo.InvariantCulture,
                "$filter={0} eq {1}",
                MobileServiceTableUrlBuilder.IdPropertyName,
                TypeExtensions.ToODataConstant(id));

            return(ReadAsync(query, parameters).ContinueWith(t =>
            {
                // Get the first element in the response
                JsonObject obj = t.Result.AsObject();
                if (obj == null)
                {
                    JsonArray array = t.Result.AsArray();
                    if (array != null && array.Count > 0)
                    {
                        obj = array.FirstOrDefault().AsObject();
                    }
                }

                if (obj == null)
                {
                    throw new InvalidOperationException(
                        string.Format(
                            CultureInfo.InvariantCulture,
                            Resources.MobileServiceTables_GetSingleValueAsync_NotSingleObject,
                            (t.Result ?? JsonExtensions.Null()).Stringify()));
                }

                return obj;
            }));
        }
Esempio n. 2
0
        /// <summary>
        /// Parse a JSON response into a sequence of elements and also return
        /// the count of objects.  This method abstracts out the differences
        /// between a raw array response and an inline count response.
        /// </summary>
        /// <param name="response">The JSON response.</param>
        /// <param name="totalCount">
        /// The total count as requested via the IncludeTotalCount method.
        /// </param>
        /// <returns>The response as a JSON array.</returns>
        internal static JsonArray GetResponseSequence(IJsonValue response, out long totalCount)
        {
            double?inlineCount = null;

            // Try and get the values as an array
            JsonArray values = response.AsArray();

            if (values == null)
            {
                // Otherwise try and get the values from the results property
                // (which is the case when we retrieve the count inline)
                values      = response.Get(InlineCountResultsKey).AsArray();
                inlineCount = response.Get(InlineCountCountKey).AsNumber();
                if (values == null)
                {
                    throw new InvalidOperationException(
                              string.Format(
                                  CultureInfo.InvariantCulture,
                                  Resources.MobileServiceTables_GetResponseSequence_ExpectedArray,
                                  (response ?? JsonExtensions.Null()).Stringify()));
                }
            }

            // Get the count via the inline count or default an unspecified
            // count to -1
            totalCount = inlineCount != null ?
                         (long)inlineCount.Value :
                         -1L;

            return(values);
        }
Esempio n. 3
0
        /// <summary>
        /// Get an element from a table by its ID.
        /// </summary>
        /// <param name="id">The ID of the element.</param>
        /// <returns>The desired element as JSON object.</returns>
        private async Task <JObject> GetSingleValueAsync(object id)
        {
            // Create a query for just this item
            string query = string.Format(
                CultureInfo.InvariantCulture,
                "$filter={0} eq {1}",
                IdPropertyName,
                TypeExtensions.ToODataConstant(id));

            // Send the query
            JToken response = await this.ReadAsync(query);

            // Get the first element in the response
            JObject obj = response.AsObject();

            if (obj == null)
            {
                JArray array = response.AsArray();
                if (array != null && array.Count > 0)
                {
                    obj = array.FirstOrDefault().AsObject();
                }
            }

            if (obj == null)
            {
                throw new InvalidOperationException(
                          string.Format(
                              CultureInfo.InvariantCulture,
                              Resources.MobileServiceTables_GetSingleValueAsync_NotSingleObject,
                              (response ?? JsonExtensions.Null()).ToString()));
            }

            return(obj);
        }
Esempio n. 4
0
        /// <summary>
        /// Set a named value on an object of any type.  Unlike the other set
        /// overloads, this will attempt to convert arbitrary CLR values into
        /// the correct JSON types.
        /// </summary>
        /// <param name="obj">The object to set the value on.</param>
        /// <param name="name">The name of the value to set.</param>
        /// <param name="value">The value to set.</param>
        /// <returns>Whether we were able to set the value.</returns>
        public static bool TrySet(this JContainer obj, string name, object value)
        {
            Debug.Assert(obj != null, "obj should probably not be null!");
            Debug.Assert(!string.IsNullOrEmpty(name), "name cannot be null or empty.");

            if (obj == null)
            {
                return(false);
            }
            if (value == null)
            {
                obj.Set(name, JsonExtensions.Null());
            }
            else
            {
                // If the type is nullable, strip off the Nullable<> which will
                // allow the comparisons below to convert correctly (since
                // we've already checked the value isn't null)
                Type memberType = value.GetType();
                memberType = Nullable.GetUnderlyingType(memberType) ?? memberType;
                RuntimeTypeHandle handle = memberType.TypeHandle;

                // Set the value based on the type for known primitives
                if (handle.Equals(typeof(bool).TypeHandle))
                {
                    obj.Set(name, Convert.ToBoolean(value, CultureInfo.InvariantCulture));
                }
                else if (handle.Equals(typeof(int).TypeHandle) ||
                         handle.Equals(typeof(uint).TypeHandle) ||
                         handle.Equals(typeof(sbyte).TypeHandle) ||
                         handle.Equals(typeof(byte).TypeHandle) ||
                         handle.Equals(typeof(short).TypeHandle) ||
                         handle.Equals(typeof(ushort).TypeHandle) ||
                         handle.Equals(typeof(double).TypeHandle) ||
                         handle.Equals(typeof(float).TypeHandle) ||
                         handle.Equals(typeof(Decimal).TypeHandle) ||
                         handle.Equals(typeof(uint).TypeHandle))
                {
                    // Convert all numeric types into doubles
                    obj.Set(name, Convert.ToDouble(value, CultureInfo.InvariantCulture));
                }
                else if (handle.Equals(typeof(long).TypeHandle) ||
                         handle.Equals(typeof(ulong).TypeHandle))
                {
                    if (!NumericCanRoundtrip(value, memberType))
                    {
                        throw new ArgumentOutOfRangeException(
                                  name,
                                  value,
                                  string.Format(
                                      Resources.JsonExtensions_TrySetValue_CannotRoundtripNumericValue,
                                      value,
                                      name,
                                      CultureInfo.InvariantCulture));
                    }

                    obj.Set(name, Convert.ToDouble(value, CultureInfo.InvariantCulture));
                }
                else if (handle.Equals(typeof(char).TypeHandle))
                {
                    // Convert characters to strings
                    obj.Set(name, value.ToString());
                }
                else if (handle.Equals(typeof(string).TypeHandle))
                {
                    obj.Set(name, value as string);
                }
                else if (handle.Equals(typeof(DateTime).TypeHandle))
                {
                    // Serialize DateTime as an ISO 8061 date/time
                    obj.Set(name, ((DateTime)value).ToRoundtripDateString());
                }
                else if (handle.Equals(typeof(DateTimeOffset).TypeHandle))
                {
                    // Serialize DateTimeOffset as an ISO 8061 date/time
                    obj.Set(name, ((DateTimeOffset)value).DateTime.ToRoundtripDateString());
                }
                else
                {
                    return(false);
                }
            }

            return(true);
        }