public void JsonConverter_CanConvert_Test() { var result = _jsonConverter.CanConvert(typeof(TaskQueueInfoDto)); result.ShouldBeFalse(); var result1 = _jsonConverter.CanConvert(typeof(Address)); result1.ShouldBeTrue(); }
private static JsonConverter GetRuntimeProvidedCustomConverter(System.Type type, JsonSerializerOptions options) { System.Collections.Generic.IList <JsonConverter> converters = options.Converters; for (int i = 0; i < converters.Count; i++) { JsonConverter converter = converters[i]; if (converter.CanConvert(type)) { if (converter is JsonConverterFactory factory) { converter = factory.CreateConverter(type, options); if (converter == null || converter is JsonConverterFactory) { throw new System.InvalidOperationException($"The converter '{factory.GetType()}' cannot return null or a JsonConverterFactory instance."); } } return(converter); } } return(null); }
protected override JsonConverter ResolveContractConverter(Type objectType) { //if (ErrorConverter.CanConvertStatic(objectType)) // return new ErrorConverter(); //if (ErrorListConverter.CanConvertStatic(objectType)) // return new ErrorListConverter(); if (ResourceObjectConverter.CanConvert(objectType)) { return(ResourceObjectConverter); } if (_resourceListConverter.CanConvert(objectType)) { return(_resourceListConverter); } if (DocumentRootConverter.CanConvertStatic(objectType)) { return(new DocumentRootConverter(_href)); } return(base.ResolveContractConverter(objectType)); }
private static void GenericConverterTestHelper <T>(string converterName, object objectValue, string stringValue, JsonSerializerOptions options, bool nullOptionOkay = true) { JsonConverter <T> converter = (JsonConverter <T>)options.GetConverter(typeof(T)); Assert.True(converter.CanConvert(typeof(T))); Assert.Equal(converterName, converter.GetType().Name); ReadOnlySpan <byte> data = Encoding.UTF8.GetBytes(stringValue); Utf8JsonReader reader = new Utf8JsonReader(data); reader.Read(); T valueRead = converter.Read(ref reader, typeof(T), nullOptionOkay ? null: options); Assert.Equal(objectValue, valueRead); if (reader.TokenType != JsonTokenType.EndObject) { valueRead = converter.Read(ref reader, typeof(T), options); // Test with given option if reader position haven't advanced. Assert.Equal(objectValue, valueRead); } using (var stream = new MemoryStream()) using (var writer = new Utf8JsonWriter(stream)) { converter.Write(writer, (T)objectValue, options); writer.Flush(); Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray())); writer.Reset(stream); converter.Write(writer, (T)objectValue, nullOptionOkay ? null : options); writer.Flush(); Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray())); } }
protected override JsonConverter ResolveContractConverter(Type objectType) { if (ErrorConverter.CanConvertStatic(objectType)) { return(new ErrorConverter()); } if (ErrorListConverter.CanConvertStatic(objectType)) { return(new ErrorListConverter()); } if (ResourceObjectConverter.CanConvert(objectType)) { return(ResourceObjectConverter); } if (_resourceObjectListConverter.CanConvert(objectType)) { return(_resourceObjectListConverter); } if (LinkConverter.CanConvertStatic(objectType)) { return(new LinkConverter()); } if (DocumentRootConverter.CanConvertStatic(objectType)) { return(new DocumentRootConverter()); } return(base.ResolveContractConverter(objectType)); }
private JsonConverter GetRuntimeProvidedCustomConverter(Type type) { IList <JsonConverter> converters = Options.Converters; for (int i = 0; i < converters.Count; i++) { JsonConverter converter = converters[i]; if (converter.CanConvert(type)) { if (converter is JsonConverterFactory factory) { converter = factory.CreateConverter(type, Options); if (converter == null || converter is JsonConverterFactory) { throw new InvalidOperationException($"The converter '{factory.GetType()}' cannot return null or a JsonConverterFactory instance."); } } return(converter); } } return(null); }
public static JsonConverter GetJsonConverter(ICustomAttributeProvider attributeProvider, Type targetConvertedType) { object provider = null; #if !NETFX_CORE provider = attributeProvider as MemberInfo; #else provider = attributeProvider.UnderlyingObject; #endif Type converterType = GetJsonConverterType(attributeProvider); if (converterType != null) { JsonConverter memberConverter = JsonConverterAttribute.CreateJsonConverterInstance(converterType); if (!memberConverter.CanConvert(targetConvertedType)) { throw new JsonSerializationException("JsonConverter {0} on {1} is not compatible with member type {2}.".FormatWith(CultureInfo.InvariantCulture, memberConverter.GetType().Name, provider, targetConvertedType.Name)); } return(memberConverter); } return(null); }
public override bool CanConvert(Type objectType) { if (MaskTypes.Contains(objectType)) { return(false); } return(_Inner.CanConvert(objectType)); }
protected T ReadBson <T>(String bson, JsonConverter converter) { if (!converter.CanConvert(typeof(T))) { throw new InvalidOperationException(); } using (var memoryStream = new MemoryStream(Convert.FromBase64String(RemovePreamble(bson)), writable: false)) using (var bsonReader = new BsonReader(memoryStream)) return((T)converter.ReadJson(bsonReader, typeof(T), null, NewtonsoftBsonSerializer.Default.Serializer)); }
protected T ReadJson <T>(String json, JsonConverter converter) { if (!converter.CanConvert(typeof(T))) { throw new InvalidOperationException(); } using (var stringReader = new StringReader(RemovePreamble(json))) using (var jsonReader = new JsonTextReader(stringReader)) return((T)converter.ReadJson(jsonReader, typeof(T), null, NewtonsoftBsonSerializer.Default.Serializer)); }
public override bool CanConvert(Type objectType) { if (objectType.IsGenericType && objectType.Name.Equals(typeof(List <>).Name)) { var genericArgument = objectType.GetGenericArguments().FirstOrDefault(); if (genericArgument != null) { return(_elementConverter.CanConvert(genericArgument)); } } return(false); }
private static void TestOptionsConverter <T>( JsonConverter converter, T some, T none = default) where T : IOption <Boxed <int> > { Assert.True(converter.CanRead); Assert.True(converter.CanWrite); Assert.True(converter.CanConvert(some.GetType())); Assert.False(converter.CanConvert(typeof(int))); var settings = new JsonSerializerSettings { ContractResolver = new CustomContractResolver(converter, some.GetType()) }; var someStr = JsonConvert.SerializeObject(some, settings); Assert.AreEqual(some, JsonConvert.DeserializeObject <T>(someStr, settings)); var strNone = JsonConvert.SerializeObject(none, settings); Assert.AreEqual(none, JsonConvert.DeserializeObject <T>(strNone, settings)); }
/// <inheritdoc /> protected override JsonContract CreateContract(Type objectType) { JsonContract contract = base.CreateContract(objectType); if (DateTimeConverter.CanConvert(objectType)) { contract.Converter = DateTimeConverter; } else if (ExplicitNullConverter.CanConvert(objectType)) { contract.Converter = ExplicitNullConverter; } return(contract); }
protected String WriteBson <T>(T value, JsonConverter converter) { if (!converter.CanConvert(typeof(T))) { throw new InvalidOperationException(); } using (var memoryStream = new MemoryStream()) using (var bsonWriter = new BsonWriter(memoryStream)) { converter.WriteJson(bsonWriter, value, NewtonsoftBsonSerializer.Default.Serializer); return(Convert.ToBase64String(memoryStream.ToArray())); } }
public static JsonConverter GetJsonConverter(ICustomAttributeProvider attributeProvider, Type targetConvertedType) { Type jsonConverterType = GetJsonConverterType(attributeProvider); if (jsonConverterType != null) { JsonConverter jsonConverter = JsonConverterAttribute.CreateJsonConverterInstance(jsonConverterType); if (!jsonConverter.CanConvert(targetConvertedType)) { throw new JsonSerializationException("JsonConverter {0} on {1} is not compatible with member type {2}.".FormatWith(CultureInfo.InvariantCulture, jsonConverter.GetType().Name, attributeProvider, targetConvertedType.Name)); } return(jsonConverter); } return(null); }
private void GenerateILForCallingConverter(Type valueType, Action pushValueOntoStack, JsonConverter converter) { if (!converter.CanConvert(valueType)) { throw new InvalidOperationException("Converter is not compatible."); } Type converterType = converter.GetType(); Type converterGenericTypeParameter = GetConverterGenericType(converterType); Type converterGenericType = typeof(JsonConverter <>).MakeGenericType(new Type[] { converterGenericTypeParameter }); // Save converter to a global variable FieldBuilder converterField; if (!_converterCache.TryGetValue(converter, out converterField)) { string fieldName = @"Converter" + (++_converterCounter); converterField = _tb.DefineField( fieldName: fieldName, // Default converters are internal classes so here the abstract generic type must be used. type: converterGenericType, attributes: FieldAttributes.Public | FieldAttributes.Static ); _converterCache.Add(converter, converterField); _followUp += type => { FieldInfo field = type.GetField(fieldName); field.SetValue(null, converter); }; } // converter.Write(writer, obj.Property, _options); _ilg.Emit(OpCodes.Ldsfld, converterField); _ilg.Emit(OpCodes.Ldarg_1); pushValueOntoStack(); _ilg.Emit(OpCodes.Ldsfld, _optionsField); _ilg.Emit(OpCodes.Callvirt, converterGenericType.GetMethod("Write", new Type[] { typeof(Utf8JsonWriter), converterGenericTypeParameter, typeof(JsonSerializerOptions) })); MarkNewJumpTableLabel(); }
public void CanConvert_IfObjectTypeIsInMapping_ReturnsTrue() { // Arrange Type typeInMapping = typeof(object); IDictionary <string, Type> typeMapping = new Dictionary <string, Type> { { "IgnoreTypeName", typeInMapping } }; JsonConverter product = CreateProductUnderTest(typeMapping); // Act bool canConvert = product.CanConvert(typeInMapping); // Assert Assert.True(canConvert); }
protected String WriteJson <T>(T value, JsonConverter converter) { if (!converter.CanConvert(typeof(T))) { throw new InvalidOperationException(); } NewtonsoftJsonSerializer.Default.Serializer.Formatting = Formatting.Indented; var sb = new StringBuilder(); using (var stringWriter = new StringWriter(sb)) using (var jsonWriter = new JsonTextWriter(stringWriter)) converter.WriteJson(jsonWriter, value, NewtonsoftJsonSerializer.Default.Serializer); return(sb.ToString()); }
// Taken from Newtonsoft's Json.NET JsonSerializer internal static JsonConverter GetMatchingConverter(IList <JsonConverter> converters, Type objectType) { ValidationUtils.ArgumentNotNull(objectType, "objectType"); if (converters != null) { for (int i = 0; i < converters.Count; i++) { JsonConverter converter = converters[i]; if (converter.CanConvert(objectType)) { return(converter); } } } return(null); }
// Taken from Newtonsoft's Json.NET JsonSerializer internal static JsonConverter GetMatchingConverter(IList <JsonConverter> converters, Type objectType) { if (objectType == null) { throw new ArgumentNullException("objectType"); } if (converters != null) { for (int i = 0; i < converters.Count; i++) { JsonConverter converter = converters[i]; if (converter.CanConvert(objectType)) { return(converter); } } } return(null); }
/// <inheritdoc /> public override bool CanConvert(Type objectType) => _instantTimeConverter.CanConvert(objectType) || _logicalTimeConverter.CanConvert(objectType);
/// <summary> /// Indicates if the <see cref="NullHandlingConverter"/> can be used with /// a given type. /// </summary> /// <param name="objectType"> /// The type under consideration. /// </param> /// <returns> /// <c>true</c> for value types and <c>false</c> otherwise. /// </returns> public override bool CanConvert(Type objectType) { return(objectType.GetTypeInfo().IsValueType || (inner != null && inner.CanConvert(objectType))); }
public override bool CanConvert(Type typeToConvert) { return(original.CanConvert(typeToConvert)); }
public override bool CanConvert(Type objectType) { return(_inner.CanConvert(objectType) || objectType == typeof(PropertyExceptionDescriptor)); }
public override bool CanConvert(Type objectType) => original.CanConvert(objectType);
public override bool CanConvert(Type objectType) => _converter.CanConvert(objectType);
public override bool CanConvert(Type objectType) { return(converter.CanConvert(objectType)); }
public static void AssertCanConvert(JsonConverter subject, object o) { subject.CanConvert(o.GetType()).Should().BeTrue(); }
public override bool CanConvert(Type objectType) { Type elementType; return(ListUtil.IsList(objectType, out elementType) && ResourceObjectConverter.CanConvert(elementType)); }
public static bool CanConvertStatic(Type objectType, JsonConverter elementConvertor) { return(ListUtil.IsList(objectType, out Type elementType) && elementConvertor.CanConvert(elementType)); }