无法使用隐式转换将字符串转换为类型 [英] Unable to cast string to type with implicit conversion

问题描述

我正在尝试使用 OneOf 库中的类型将JSON序列化为数据结构JSON.NET，使用自定义转换器.

I am trying to serialize JSON into a data structure with the types from the OneOf library, using JSON.NET, using a custom converter.

我遇到以下异常:

System.InvalidCastException::无法将类型为System.String的对象转换为类型为System.Nullable`1 [OneOf.OneOf`2 [OneOf.OneOf`2 [PandocFilters.TagContent] ，System.Int64] []，System.String]]'.'

System.InvalidCastException: 'Unable to cast object of type 'System.String' to type 'System.Nullable`1[OneOf.OneOf`2[OneOf.OneOf`2[PandocFilters.TagContent,System.Int64][],System.String]]'.'

这对我来说没有意义，因为以下C#代码可以编译并运行:

Which doesn't make sense to me, because the following C# code compiles and runs:

OneOf<OneOf<TagContent, long>[], string>? c = "abcd";

因为OneOf<...>类型定义了从每个子类型到OneOf类型的隐式转换(来源可以参见

because the OneOf<...> types define an implicit conversion from each of the subtypes to the OneOf type (source can be see here).

TagContent的定义如下:

TagContent is defined as follows:

internal record TagContent(string T, OneOf<OneOf<TagContent, long>[], string>? C);

我该如何调试呢?

为了完整起见，我在此处包括完整的转换器.这很重要，因为没有转换器我似乎无法复制.

For completeness, I'm including the full converter here. It's relevant, because I can't seem to reproduce without the converter.

public class OneOfJsonConverter : JsonConverter {
    public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer) {
        if (value is IOneOf of) {
            value = of.Value;
        }
        serializer.Serialize(writer, value);
    }

    public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer) {
        var dict = new Dictionary<JTokenType, Type>();
        if (objectType.IsNullable()) { dict[JTokenType.Null] = objectType; }

        var subtypes = objectType.OneOfTypes();
        
        foreach (var t in subtypes) {
            // TODO handle NRT -- if the type is defined as a non-nullable reference type, prefer something else
            if (!dict.ContainsKey(JTokenType.Null) && t.IsNullable(true)) {
                dict[JTokenType.Null] = t;
            }

            var u = t.UnderlyingIfNullable();
            JTokenType tokenType =
                t.IsArray ? JTokenType.Array :
                t == typeof(string) ? JTokenType.String :
                u == typeof(bool) ? JTokenType.Boolean :
                u == typeof(DateTime) ? JTokenType.Date :
                u == typeof(TimeSpan) ? JTokenType.TimeSpan :
                u.IsIntegral() ? JTokenType.Integer :
                u.IsNumeric() ? JTokenType.Float :
                t == typeof(Uri) ? JTokenType.Uri :
                JTokenType.Object;

            if (!dict.ContainsKey(tokenType)) {
                dict[tokenType] = t;
            }
        }

        var token = JToken.ReadFrom(reader);
        if (token.Type == JTokenType.Null && !dict.ContainsKey(JTokenType.Null)) {
            throw new InvalidOperationException($"Unable to find null-accepting subtype in '{objectType}");
        }

        var valueType = dict[token.Type];
        var conversion = objectType.UnderlyingIfNullable().GetMethod("op_Implicit", new[] { dict[token.Type] });
        if (conversion is null) {
            throw new InvalidOperationException($"Unable to find implicit conversion for token of type `{token.Type}` from '{valueType}' to '{objectType}");
        }

        return token.ToObject(valueType, serializer);
    }

    public override bool CanConvert(Type objectType) => objectType.OneOfTypes().Any();
}

和此处的相关扩展方法:

and the relevant extension methods here:

internal static Type UnderlyingIfNullable(this Type t) => Nullable.GetUnderlyingType(t) ?? t;

private static readonly Type[] OneOfDefinitions = new[] {
    typeof(OneOf<>),
    typeof(OneOf<,>),
    typeof(OneOf<,,>),
    typeof(OneOf<,,,>),
    typeof(OneOf<,,,,>),
    typeof(OneOf<,,,,,>),
    typeof(OneOf<,,,,,,>),
    typeof(OneOf<,,,,,,,>),
    typeof(OneOf<,,,,,,,,>),
    typeof(OneOfBase<>),
    typeof(OneOfBase<,>),
    typeof(OneOfBase<,,>),
    typeof(OneOfBase<,,,>),
    typeof(OneOfBase<,,,,>),
    typeof(OneOfBase<,,,,,>),
    typeof(OneOfBase<,,,,,,>),
    typeof(OneOfBase<,,,,,,,>),
    typeof(OneOfBase<,,,,,,,,>)
};

internal static Type[] OneOfTypes(this Type t) {
    t = t.UnderlyingIfNullable();
    var current = t;
    while (current is { }) {
        if (current.IsGenericType) {
            var def = current.GetGenericTypeDefinition();
            if (def.In(OneOfDefinitions)) {
                return current.GetGenericArguments();
            }
        }
        current = current.BaseType;
    }
    return Array.Empty<Type>();
}

// TODO return false for non-nullable reference type in a nullable-enabled context
internal static bool IsNullable(this Type t, bool orReferenceType = false) {
    if (orReferenceType && !t.IsValueType) { return true; }
    return t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>);
}

private static readonly Dictionary<Type, bool> numericTypes = new Dictionary<Type, bool> {
    [typeof(byte)] = true,
    [typeof(short)] = true,
    [typeof(int)] = true,
    [typeof(long)] = true,
    [typeof(sbyte)] = true,
    [typeof(ushort)] = true,
    [typeof(uint)] = true,
    [typeof(ulong)] = true,
    [typeof(BigInteger)] = true,
    [typeof(float)] = false,
    [typeof(double)] = false,
    [typeof(decimal)] = false
};

internal static bool IsNumeric(this Type type) => numericTypes.ContainsKey(type);
internal static bool IsIntegral(this Type type) => numericTypes.TryGetValue(type, out var isIntegeral) && isIntegeral;

推荐答案

原来，我必须实际调用转换:

It turns out I have to actually invoke the conversion:

return conversion.Invoke(null, new [] {token.ToObject(valueType, serializer)});

JSON.NET不会自行执行转换.

JSON.NET won't perform the conversion on its own.

这篇关于无法使用隐式转换将字符串转换为类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！