Restsharp: JSON ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ๊ฐ€ ์˜ˆ์ƒ๋Œ€๋กœ C# ์‚ฌ์ „์„ JSON ๊ฐœ์ฒด๋กœ ๋ณ€ํ™˜ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

์— ๋งŒ๋“  2015๋…„ 05์›” 27์ผ  ยท  6์ฝ”๋ฉ˜ํŠธ  ยท  ์ถœ์ฒ˜: restsharp/RestSharp

๊ทธ๋ž˜์„œ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ๋ฐฉ๋ฒ•์ด ์žˆ์Šต๋‹ˆ๋‹ค.

public static void SomeApiCall(string foo, string bar, Dictionary<String, Dictionary<String, int[]>> list, ...)
{
  var request = new RestRequest("some/endpoint", Method.PUT);
  request.AddJsonBody(new { foo = foo, bar = bar, list = list });
  ...
}

list ์œ ํ˜•์€ ์‚ฌ์ „์ž…๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ {"key1": ..., "key2": ...} ์™€ ๊ฐ™์€ ๊ฐ์ฒด๋กœ JSON์œผ๋กœ ์ง์ ‘ ๋ณ€ํ™˜๋˜์–ด์•ผ ํ•˜์ง€๋งŒ ๋‹ค๋ฅธ ์ชฝ ๋์— ์žˆ๋Š” ๊ฒƒ์€ ์‹ค์ œ๋กœ [{"Key":"key1","Value": ...}, {"Key":"key2","Value": ...}] ์ด๋ฉฐ, ์ด๋Š” ๋ฌผ๋ก  ๋‹ค๋ฅธ ํด๋ผ์ด์–ธํŠธ๊ฐ€ ๋ณด๋‚ด๋Š” ๊ฒƒ๊ณผ ํ˜ธํ™˜๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ๊ทธ ์•ˆ์— ์žˆ๋Š” ์‚ฌ์ „์—๋„ ๊ฐ™์€ ๋ฌธ์ œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

๋‚ด๊ฐ€ ๋ณผ ์ˆ˜ ์žˆ๋“ฏ์ด RestSharp๋Š” SimpleJson์„ ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ๋กœ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ์ƒ๋˜๋Š” JSON ๋ฌธ์ž์—ด์„ ์ƒ์„ฑํ•˜๋Š” Newtonsoft๋กœ ์ง๋ ฌํ™”๋ฅผ ์‹œ๋„ํ–ˆ์Šต๋‹ˆ๋‹ค. ๋ณธ๋ฌธ์— ๋ฌธ์ž์—ด์„ ๋ณด๋‚ด๋Š” ํ•ดํ‚น ๋ฐฉ๋ฒ•์„ ์ฐพ์€ ํ›„์—๋Š” ์ž˜ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฐฉ๋ฒ•์€ RestSharp์—์„œ ๋‚ด๋ถ€์ ์œผ๋กœ ๋ณธ๋ฌธ์„ ์ง๋ ฌํ™”ํ•˜์ง€ ์•Š๋Š” ์œ ์ผํ•œ ๋ฐฉ๋ฒ•์ธ ๊ฒƒ ๊ฐ™์Šต๋‹ˆ๋‹ค.

var jout = JObject.FromObject(new { foo = foo, bar = bar, list = list });
request.AddParameter("application/json; charset=utf-8", jout.ToString(Formatting.None), ParameterType.RequestBody);

์˜ˆ, ๋” ๋‚˜์€ ๊ธฐ๋ณธ ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ, ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ๋ฅผ ์žฌ์ •์˜ํ•˜๋Š” ๋ฐฉ๋ฒ• ๋˜๋Š” ๋ฌธ์ž์—ด์„ ๋ณธ๋ฌธ์œผ๋กœ ์„ค์ •ํ•˜๋Š” ๋” ์šฐ์•„ํ•œ ๋ฐฉ๋ฒ•์„ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๊นŒ?

feature-request

๊ฐ€์žฅ ์œ ์šฉํ•œ ๋Œ“๊ธ€

body ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ์ง์ ‘ ์กฐ์ž‘ํ•˜์—ฌ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ–ˆ์Šต๋‹ˆ๋‹ค.

restRequest.AddJsonBody(toBeSerializedContainingDictionary);
var bodyParameter = restRequest.Parameters.First(p => p.Type == ParameterType.RequestBody);
restRequest.Parameters.Remove(bodyParameter);
bodyParameter.Value = JsonConvert.SerializeObject(toBeSerializedContainingDictionary);
restRequest.Parameters.Add(bodyParameter);

๋ชจ๋“  6 ๋Œ“๊ธ€

์—ญ์ง๋ ฌํ™”๋ฅผ ์œ„ํ•ด Json.Net ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋กœ ๋‹ค์‹œ ์ „ํ™˜ํ•˜๊ฑฐ๋‚˜ ์ตœ์†Œํ•œ ์ œ๊ณตํ•  ๊ณ„ํš์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์•„์ง ํ•ด๊ฒฐํ•ด์•ผ ํ•  ๋ช‡ ๊ฐ€์ง€ ๊ณผ์ œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ๊ทธ ๋™์•ˆ ์ด๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ์‚ฌ์šฉ์ž ์ง€์ • ์—ญ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ๋ฅผ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋˜ํ•œ SimpleJson์˜ ์‚ฌ์ „ ๊ตฌํ˜„์— ๋Œ€ํ•ด ๋‚ด๊ฐ€ ๋ฌด์—‡์„ ํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ์•Œ์•„๋ณผ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ €๋„ ์ด ๋ฌธ์ œ์— ๋ถ€๋”ช์ณค๊ณ  ํ˜„์žฌ ์ œ ์š”๊ตฌ ์‚ฌํ•ญ์— ๋งž๋Š” ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์„ ์ฐพ์•˜์Šต๋‹ˆ๋‹ค.

์—ฌ๊ธฐ์— ์„ค๋ช…๋œ ์‚ฌ์ „์˜ ํ™•์žฅ ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ–ˆ์Šต๋‹ˆ๋‹ค. http://theburningmonk.com/2011/05/idictionarystring-object-to-expandoobject-extension-method/

ExpandoObject eo = mydictionary.ToExpando();

์ด๊ฒƒ์€ ์‚ฌ์ „์„ ๋ณ€ํ™˜ํ•ฉ๋‹ˆ๋‹ค(๋™์ ) ExpandoObject์—.
๊ทธ๋Ÿฐ ๋‹ค์Œ ExpandoObject๋Š” {"key1": ..., "key2": ...} ํ˜•์‹์œผ๋กœ ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ์ง๋ ฌํ™”๋ฉ๋‹ˆ๋‹ค.

์ œ ๊ฒฝ์šฐ์—๋Š” ์‚ฌ์ „์ด ์žˆ์—ˆ์Šต๋‹ˆ๋‹ค.> ๊ทธ๋ž˜์„œ ๋จผ์ € ์‚ฌ์ „์œผ๋กœ ๋ณ€ํ™˜ํ•ด์•ผํ–ˆ์Šต๋‹ˆ๋‹ค

์ด ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•˜๋Š” ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค์—๊ฒŒ ์œ ์šฉํ•  ์ˆ˜ ์žˆ๊ธฐ๋ฅผ ๋ฐ”๋ž๋‹ˆ๋‹ค.

body ๋งค๊ฐœ๋ณ€์ˆ˜๋ฅผ ์ง์ ‘ ์กฐ์ž‘ํ•˜์—ฌ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ–ˆ์Šต๋‹ˆ๋‹ค.

restRequest.AddJsonBody(toBeSerializedContainingDictionary);
var bodyParameter = restRequest.Parameters.First(p => p.Type == ParameterType.RequestBody);
restRequest.Parameters.Remove(bodyParameter);
bodyParameter.Value = JsonConvert.SerializeObject(toBeSerializedContainingDictionary);
restRequest.Parameters.Add(bodyParameter);

@mathume ๊ฐ์‚ฌํ•ฉ๋‹ˆ๋‹ค ... ํŠธ๋ฆญ์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค

๋˜ ๋‹ค๋ฅธ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์€ ์ด๋ฅผ ์ฒ˜๋ฆฌํ•˜๊ธฐ ์œ„ํ•ด ISerializer ๋ฅผ ๋งŒ๋“œ๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ž„์˜์˜ DTO๋„ ์ง€์›ํ•  ์ˆ˜ ์žˆ์„ ๋งŒํผ ์ถฉ๋ถ„ํžˆ ์ผ๋ฐ˜ํ™”ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

```C#
///


/// ๊ฐ’์ด JSON ๊ฐ์ฒด์ธ ์ตœ์ƒ์œ„ ํ‚ค๊ฐ€ ์žˆ๋Š” ์˜ˆ์ œ DTO
/// ๋™์  ํ‚ค๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ํ•ด๋‹น ํ‚ค์˜ ๊ฐ’์€ ์ผ๋ถ€ ๊ฐœ์ฒด์ž…๋‹ˆ๋‹ค.
///

๊ณต๊ฐœ ํด๋ž˜์Šค MyDto
{
///
/// ๋™์  ๋ฐ์ดํ„ฐ๋ฅผ ๋ณด์œ ํ•˜๊ณ  ์žˆ๋Š” ํ‚ค์ž…๋‹ˆ๋‹ค.
///

๊ณต๊ฐœ ์‚ฌ์ „SomeKey { ๊ฐ€์ ธ์˜ค๊ธฐ; ์„ธํŠธ; } =
์ƒˆ ์‚ฌ์ „();

/// <summary>
/// Helper method to easily add new objects.
/// </summary>
public MyDto AddDynamicObject(string dynamicKey, object obj)
{
    SomeKey[dynamicKey] = obj;
    return this;
}

}

///


/// DTO์—์„œ JSON ๋ฌธ์ž์—ด์„ ์ƒ์„ฑํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๋Š” ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ.
///

๊ณต์šฉ ํด๋ž˜์Šค MyDtoSerializer : ISerializer
{
๊ณต๊ฐœ ๋ฌธ์ž์—ด RootElement { ๊ฐ€์ ธ์˜ค๊ธฐ; ์„ธํŠธ; }
๊ณต๊ฐœ ๋ฌธ์ž์—ด ๋„ค์ž„์ŠคํŽ˜์ด์Šค { get; ์„ธํŠธ; }
๊ณต๊ฐœ ๋ฌธ์ž์—ด DateFormat { ๊ฐ€์ ธ์˜ค๊ธฐ; ์„ธํŠธ; }
๊ณต๊ฐœ ๋ฌธ์ž์—ด ContentType { ๊ฐ€์ ธ์˜ค๊ธฐ; ์„ธํŠธ; }

/// <summary>
/// Serialize the object, where obj is assumed to be a MyDto instance.
/// </summary>
public string Serialize(object obj)
{
    return JsonConvert.SerializeObject(obj);
}

}

///


/// ์š”์ฒญ์— ๋ฐ์ดํ„ฐ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ๋ณด์—ฌ์ฃผ๋Š” ๊ฐ„๋‹จํ•œ ํ™•์žฅ์ž…๋‹ˆ๋‹ค.
///

๊ณต๊ฐœ ์ •์  IRestRequest AddMyDto(IRestRequest restRequest, MyDto dto)
{
// ์ƒˆ ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ๋ฅผ ์‚ฌ์šฉํ•˜๋„๋ก ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ๋ฅผ ๋ณ€๊ฒฝํ•ฉ๋‹ˆ๋‹ค.
// ์ง๋ ฌ ๋ณ€ํ™˜๊ธฐ์˜ ContentType์„ "application/json"์œผ๋กœ ์„ค์ •ํ•ด์•ผ ํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.
request.JsonSerializer = ์ƒˆ๋กœ์šด MyDtoSerializer();

// Add the DTO - behind the scenes it is serialized to a JSON string using our serializer
request.AddJsonBody(dto);
return request;

}

The output JSON will then look something like the following (note - the values are simply placeholders):

```JSON
{
    "SomeKey": {
        "dynamicKey-1": "value-1",
        "dynamicKey-2": "value-2",
        "dyanmicKey-n": "value-n"
    }
}

์ด๊ฒƒ์€ #1018์˜ ์ผ๋ถ€๋กœ ์ฒ˜๋ฆฌ๋ฉ๋‹ˆ๋‹ค.

์ด ํŽ˜์ด์ง€๊ฐ€ ๋„์›€์ด ๋˜์—ˆ๋‚˜์š”?
0 / 5 - 0 ๋“ฑ๊ธ‰