private Converter(object source, Type targetType, ref object targetInstance, bool includeNonPublic, JsonSerializerCase jsonSerializerCase) { _targetType = targetInstance != null?targetInstance.GetType() : targetType; _includeNonPublic = includeNonPublic; _jsonSerializerCase = jsonSerializerCase; if (source == null) { return; } var sourceType = source.GetType(); if (_targetType == null || _targetType == typeof(object)) { _targetType = sourceType; } if (sourceType == _targetType) { _target = source; return; } if (!TrySetInstance(targetInstance, source, ref _target)) { return; } ResolveObject(source, ref _target); }
/// <summary> /// Serializes the specified object into a JSON string. /// </summary> /// <param name="obj">The object.</param> /// <param name="format">if set to <c>true</c> it formats and indents the output.</param> /// <param name="typeSpecifier">The type specifier. Leave null or empty to avoid setting.</param> /// <param name="includeNonPublic">if set to <c>true</c> non-public getters will be also read.</param> /// <param name="includedNames">The included property names.</param> /// <param name="excludedNames">The excluded property names.</param> /// <param name="parentReferences">The parent references.</param> /// <param name="jsonSerializerCase">The json serializer case.</param> /// <returns> /// A <see cref="System.String" /> that represents the current object. /// </returns> public static string Serialize( object?obj, bool format, string?typeSpecifier, bool includeNonPublic, string[]?includedNames, string[]?excludedNames, List <WeakReference>?parentReferences, JsonSerializerCase jsonSerializerCase) { if (obj != null && (obj is string || Definitions.AllBasicValueTypes.Contains(obj.GetType()))) { return(SerializePrimitiveValue(obj)); } var options = new SerializerOptions( format, typeSpecifier, includedNames, GetExcludedNames(obj?.GetType(), excludedNames), includeNonPublic, parentReferences, jsonSerializerCase); return(Serialize(obj, options)); }
/// <summary> /// Initializes a new instance of the <see cref="SerializerOptions"/> class. /// </summary> /// <param name="format">if set to <c>true</c> [format].</param> /// <param name="typeSpecifier">The type specifier.</param> /// <param name="includeProperties">The include properties.</param> /// <param name="excludeProperties">The exclude properties.</param> /// <param name="includeNonPublic">if set to <c>true</c> [include non public].</param> /// <param name="parentReferences">The parent references.</param> /// <param name="jsonSerializerCase">The json serializer case.</param> public SerializerOptions( bool format, string?typeSpecifier, string[]?includeProperties, string[]?excludeProperties = null, bool includeNonPublic = true, IReadOnlyCollection <WeakReference>?parentReferences = null, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) { _includeProperties = includeProperties; ExcludeProperties = excludeProperties; IncludeNonPublic = includeNonPublic; Format = format; TypeSpecifier = typeSpecifier; JsonSerializerCase = jsonSerializerCase; if (parentReferences == null) { return; } foreach (var parentReference in parentReferences.Where(x => x.IsAlive)) { IsObjectPresent(parentReference.Target); } }
internal static object?FromJsonResult( object?source, JsonSerializerCase jsonSerializerCase, Type?targetType = null, bool includeNonPublic = false) { object?nullRef = null; return(new Converter(source, targetType ?? typeof(object), ref nullRef, includeNonPublic, jsonSerializerCase).GetResult()); }
internal static string GetNameWithCase(this string name, JsonSerializerCase jsonSerializerCase) { switch (jsonSerializerCase) { case JsonSerializerCase.PascalCase: return(char.ToUpperInvariant(name[0]) + name.Substring(1)); case JsonSerializerCase.CamelCase: return(char.ToLowerInvariant(name[0]) + name.Substring(1)); case JsonSerializerCase.None: return(name); default: throw new ArgumentOutOfRangeException(nameof(jsonSerializerCase), jsonSerializerCase, null); } }
private static async Task <TData> JsonInternal <TData>(IHttpContext context, JsonSerializerCase jsonSerializerCase) { string body; using (var reader = context.OpenRequestText()) { body = await reader.ReadToEndAsync().ConfigureAwait(false); } try { return(Swan.Formatters.Json.Deserialize <TData>(body, jsonSerializerCase)); } catch (FormatException) { $"[{context.Id}] Cannot convert JSON request body to {typeof(TData).Name}, sending 400 Bad Request..." .Warn($"{nameof(RequestDeserializer)}.{nameof(Json)}"); throw HttpException.BadRequest("Incorrect request data format."); } }
/// <summary> /// Deserializes the specified JSON string and converts it to the specified object type. /// </summary> /// <param name="json">The JSON string.</param> /// <param name="resultType">Type of the result.</param> /// <param name="includeNonPublic">if set to true, it also uses the non-public constructors and property setters.</param> /// <param name="jsonSerializerCase">The json serializer case.</param> /// <returns> /// Type of the current conversion from json result. /// </returns> public static object?Deserialize(string json, Type resultType, bool includeNonPublic = false, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) => Converter.FromJsonResult(Deserializer.DeserializeInternal(json), jsonSerializerCase, resultType, includeNonPublic);
/// <summary> /// Deserializes the specified JSON string and converts it to the specified object type. /// Non-public constructors and property setters are ignored. /// </summary> /// <typeparam name="T">The type of object to deserialize.</typeparam> /// <param name="json">The JSON string.</param> /// <param name="jsonSerializerCase">The JSON serializer case.</param> /// <returns> /// The deserialized specified type object. /// </returns> /// <example> /// The following code describes how to deserialize a JSON string into an object of type T. /// <code> /// using Swan.Formatters; /// class Example /// { /// static void Main() /// { /// // json type BasicJson to serialize /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}"; /// // deserializes the specified string in a new instance of the type BasicJson. /// var data = Json.Deserialize<BasicJson>(basicJson); /// } /// } /// </code></example> public static T Deserialize <T>(string json, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) => (T)Deserialize(json, typeof(T), jsonSerializerCase: jsonSerializerCase);
/// <summary> /// Deserializes the specified json string as either a Dictionary[string, object] or as a List[object] /// depending on the syntax of the JSON string. /// </summary> /// <param name="json">The JSON string.</param> /// <param name="jsonSerializerCase">The json serializer case.</param> /// <returns> /// Type of the current deserializes. /// </returns> /// <example> /// The following code shows how to deserialize a JSON string into a Dictionary. /// <code> /// using Swan.Formatters; /// class Example /// { /// static void Main() /// { /// // json to deserialize /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}"; /// // deserializes the specified json into a Dictionary<string, object>. /// var data = Json.Deserialize(basicJson, JsonSerializerCase.None); /// } /// } /// </code></example> public static object?Deserialize( string json, JsonSerializerCase jsonSerializerCase) => Converter.FromJsonResult(Deserializer.DeserializeInternal(json), jsonSerializerCase);
/// <summary> /// Serializes the specified object into a JSON string. /// </summary> /// <param name="obj">The object.</param> /// <param name="jsonSerializerCase">The json serializer case.</param> /// <param name="format">if set to <c>true</c> [format].</param> /// <param name="typeSpecifier">The type specifier.</param> /// <returns> /// A <see cref="System.String" /> that represents the current object. /// </returns> public static string Serialize( object?obj, JsonSerializerCase jsonSerializerCase, bool format = false, string?typeSpecifier = null) => Serialize(obj, format, typeSpecifier, false, null, null, null, jsonSerializerCase);
/// <summary> /// Serializes data in JSON format with the specified <paramref name="jsonSerializerCase"/> /// to a HTTP response, using the <see cref="Swan.Formatters.Json"/> utility class. /// </summary> /// <param name="jsonSerializerCase">The JSON serializer case.</param> /// <returns>A <see cref="ResponseSerializerCallback"/> that can be used to serialize /// data to a HTTP response.</returns> public static ResponseSerializerCallback Json(JsonSerializerCase jsonSerializerCase) => async(context, data) => {
internal static string GetNameWithCase(this string name, JsonSerializerCase jsonSerializerCase) => jsonSerializerCase switch {
/// <summary> /// Returns a <see cref="RequestDeserializerCallback{TData}">RequestDeserializerCallback</see> /// that will deserialize an HTTP request body in JSON format, using the specified property name casing. /// </summary> /// <typeparam name="TData">The expected type of the deserialized data.</typeparam> /// <param name="jsonSerializerCase">The <see cref="JsonSerializerCase"/> to use.</param> /// <returns>A <see cref="RequestDeserializerCallback{TData}"/> that can be used to deserialize /// a JSON request body.</returns> public static RequestDeserializerCallback <TData> Json <TData>(JsonSerializerCase jsonSerializerCase) => context => JsonInternal <TData>(context, jsonSerializerCase);
/// <summary> /// Deserializes the specified JSON string and converts it to the specified object type. /// </summary> /// <param name="json">The JSON string.</param> /// <param name="resultType">Type of the result.</param> /// <param name="includeNonPublic">if set to true, it also uses the non-public constructors and property setters.</param> /// <param name="jsonSerializerCase">The json serializer case.</param> /// <returns> /// Type of the current conversion from json result. /// </returns> public static object?Deserialize(string json, Type resultType, bool includeNonPublic = false, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) => json == null ? throw new ArgumentNullException(nameof(json)) : Converter.FromJsonResult( Deserializer.DeserializeInternal(json), jsonSerializerCase, resultType, includeNonPublic);
/// <summary> /// Deserializes the specified JSON string and converts it to the specified object type. /// Non-public constructors and property setters are ignored. /// </summary> /// <typeparam name="T">The type of object to deserialize.</typeparam> /// <param name="json">The JSON string.</param> /// <param name="jsonSerializerCase">The JSON serializer case.</param> /// <returns> /// The deserialized specified type object. /// </returns> /// <example> /// The following code describes how to deserialize a JSON string into an object of type T. /// <code> /// using Swan.Formatters; /// class Example /// { /// static void Main() /// { /// // json type BasicJson to serialize /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}"; /// // deserializes the specified string in a new instance of the type BasicJson. /// var data = Json.Deserialize<BasicJson>(basicJson); /// } /// } /// </code></example> public static T Deserialize <T>(string json, JsonSerializerCase jsonSerializerCase = JsonSerializerCase.None) => json == null ? throw new ArgumentNullException(nameof(json)) : (T)Deserialize(json, typeof(T), jsonSerializerCase: jsonSerializerCase);
/// <summary> /// Deserializes the specified json string as either a Dictionary[string, object] or as a List[object] /// depending on the syntax of the JSON string. /// </summary> /// <param name="json">The JSON string.</param> /// <param name="jsonSerializerCase">The json serializer case.</param> /// <returns> /// Type of the current deserializes. /// </returns> /// <example> /// The following code shows how to deserialize a JSON string into a Dictionary. /// <code> /// using Swan.Formatters; /// class Example /// { /// static void Main() /// { /// // json to deserialize /// var basicJson = "{\"One\":\"One\",\"Two\":\"Two\",\"Three\":\"Three\"}"; /// // deserializes the specified json into a Dictionary<string, object>. /// var data = Json.Deserialize(basicJson, JsonSerializerCase.None); /// } /// } /// </code></example> public static object?Deserialize(string json, JsonSerializerCase jsonSerializerCase) => json == null ? throw new ArgumentNullException(nameof(json)) : Converter.FromJsonResult(Deserializer.DeserializeInternal(json), jsonSerializerCase);