๊ทธ๋์ ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
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);
์, ๋ ๋์ ๊ธฐ๋ณธ ์ง๋ ฌ ๋ณํ๊ธฐ, ์ง๋ ฌ ๋ณํ๊ธฐ๋ฅผ ์ฌ์ ์ํ๋ ๋ฐฉ๋ฒ ๋๋ ๋ฌธ์์ด์ ๋ณธ๋ฌธ์ผ๋ก ์ค์ ํ๋ ๋ ์ฐ์ํ ๋ฐฉ๋ฒ์ ์ป์ ์ ์์ต๋๊น?
์ญ์ง๋ ฌํ๋ฅผ ์ํด Json.Net ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ๋ค์ ์ ํํ๊ฑฐ๋ ์ต์ํ ์ ๊ณตํ ๊ณํ์ด ์์ต๋๋ค. ์์ง ํด๊ฒฐํด์ผ ํ ๋ช ๊ฐ์ง ๊ณผ์ ๊ฐ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ ๋์ ์ด๋ฅผ ์ฌ์ฉํ๋ ์ฌ์ฉ์ ์ง์ ์ญ์ง๋ ฌ ๋ณํ๊ธฐ๋ฅผ ๊ตฌํํ ์ ์์ต๋๋ค. ๋ํ SimpleJson์ ์ฌ์ ๊ตฌํ์ ๋ํด ๋ด๊ฐ ๋ฌด์์ ํ ์ ์๋์ง ์์๋ณผ ๊ฒ์ ๋๋ค.
์ ๋ ์ด ๋ฌธ์ ์ ๋ถ๋ช์ณค๊ณ ํ์ฌ ์ ์๊ตฌ ์ฌํญ์ ๋ง๋ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ฐพ์์ต๋๋ค.
์ฌ๊ธฐ์ ์ค๋ช ๋ ์ฌ์ ์ ํ์ฅ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ต๋๋ค. http://theburningmonk.com/2011/05/idictionarystring-object-to-expandoobject-extension-method/
ExpandoObject eo = mydictionary.ToExpando();
์ด๊ฒ์ ์ฌ์ ์ ๋ณํํฉ๋๋ค
๊ทธ๋ฐ ๋ค์ 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
{
///
/// ๋์ ๋ฐ์ดํฐ๋ฅผ ๋ณด์ ํ๊ณ ์๋ ํค์
๋๋ค.
///
๊ณต๊ฐ ์ฌ์
์ ์ฌ์
/// <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์ ์ผ๋ถ๋ก ์ฒ๋ฆฌ๋ฉ๋๋ค.
๊ฐ์ฅ ์ ์ฉํ ๋๊ธ
body ๋งค๊ฐ๋ณ์๋ฅผ ์ง์ ์กฐ์ํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ต๋๋ค.