public override KeyValuePair <Type, object> ReadJson(JsonReader reader, Type objectType, KeyValuePair <Type, object> existingValue, bool hasExistingValue,
JsonSerializer serializer)
{
var kvpConv = new KeyValuePairConverter();
var obj = kvpConv.ReadJson(reader, objectType, existingValue, serializer);
if (obj is null)
{
return(default(KeyValuePair <Type, object>));
}
var(key, value) = (KeyValuePair <Type, object>)obj;
if (value is IConvertible)
{
return(new KeyValuePair <Type, object>(key, Convert.ChangeType(value, key)));
}
else if (value is JArray jarr)
{
var arr = jarr.Select(jv => Convert.ChangeType(jv, key.GetElementType())).ToArray();
return(new KeyValuePair <Type, object>(key, arr));
}
return(new KeyValuePair <Type, object>(key, value));
}
public void CannotConvertNotKvpToKvp()
{
var converterChooserMock = new Mock <ISettingsConverterChooser>();
var converter = new KeyValuePairConverter(converterChooserMock.Object);
var canConvert = converter.CanConvert(typeof(object), typeof(KeyValuePair <string, object>));
Assert.IsFalse(canConvert);
}
public void CanConvertKvpToKvp()
{
var converterChooserMock = new Mock <ISettingsConverterChooser>();
var converter = new KeyValuePairConverter(converterChooserMock.Object);
var canConvert = converter.CanConvert(typeof(KeyValuePair <int, double>), typeof(KeyValuePair <string, object>));
Assert.IsTrue(canConvert);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var converter = new KeyValuePairConverter();
var dict = (ConcurrentDictionarySafe <TKey, TValue>)value;
var enumerator = dict.GetEnumerator();
writer.WriteStartArray();
while (enumerator.MoveNext())
{
var entry = enumerator.Current;
converter.WriteJson(writer, entry, serializer);
}
writer.WriteEndArray();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var result = existingValue as ConcurrentDictionarySafe <TKey, TValue> ?? (objectType == _targetType ? new ConcurrentDictionarySafe <TKey, TValue>() : (ConcurrentDictionarySafe <TKey, TValue>)Activator.CreateInstance(objectType));
var entryType = typeof(KeyValuePair <TKey, TValue>);
var converter = new KeyValuePairConverter();
reader.Read();
while (reader.TokenType == JsonToken.StartObject)
{
var entry = (KeyValuePair <TKey, TValue>)converter.ReadJson(reader, entryType, null, serializer);
result.AddOrUpdate(entry.Key, entry.Value, (key, value) => default(TValue));
reader.Read();
}
return(result);
}
public void ShouldCallConverterChooserWithKeyAndValueAndReturnCreatedKvp()
{
var obj = new object();
var converterChooserMock = new Mock <ISettingsConverterChooser>();
converterChooserMock.Setup(x => x.ChooseAndConvert <string, object>(It.IsAny <string>())).Returns(obj);
converterChooserMock.Setup(x => x.ChooseAndConvert <int, double>(It.IsAny <int>())).Returns(-1.1);
var exprectedKvp = new KeyValuePair <object, double>(obj, -1.1);
var converter = new KeyValuePairConverter(converterChooserMock.Object);
var rawValue = new KeyValuePair <string, int>("test", 1);
var convertedKvp = converter.Convert <KeyValuePair <string, int>, KeyValuePair <object, double> >(rawValue);
converterChooserMock.Verify(x => x.ChooseAndConvert <string, object>(rawValue.Key), Times.Once);
converterChooserMock.Verify(x => x.ChooseAndConvert <int, double>(rawValue.Value), Times.Once);
Assert.AreEqual(exprectedKvp, convertedKvp);
}
/// <summary>
/// Converts the given object into a query parameter string
/// </summary>
/// <param name="parameters">A list of parameters to convert to a query string.
/// All objects must be of types that are supported by the JsonQueryStringConverter class.</param>
/// <returns>The query string</returns>
private static string ConvertQueryParametersToQueryString(Dictionary <string, object> parameters)
{
if (parameters == null)
{
return(String.Empty);
}
// Build the query parameter string
var converter = new KeyValuePairConverter();
var queryString = new StringBuilder();
bool isFirstItem = true;
foreach (KeyValuePair <string, object> parameter in parameters)
{
if (isFirstItem == true)
{
queryString.Append("?");
isFirstItem = false;
}
else
{
queryString.Append("&");
}
queryString.Append(parameter.Key);
queryString.Append("=");
// Handle the "esp_type" parameter separately as it must be sent without quotations "" around the value
if (parameter.Key == "esp_type")
{
queryString.Append(parameter.Value.ToString());
}
else if (converter.CanConvert(parameter.GetType()))
{
queryString.Append(JsonConvert.ToString(parameter.Value));
}
}
return(queryString.ToString());
}
public override void WriteJson(JsonWriter writer, KeyValuePair <Type, object> value, JsonSerializer serializer)
{
var kvpConv = new KeyValuePairConverter();
kvpConv.WriteJson(writer, value, serializer);
}
