我有一个自定义类型：

[TypeConverter(typeof(FriendlyUrlTypeConverter))]
public class FriendlyUrl : IEquatable<FriendlyUrl>, IConvertible
{
    public FriendlyUrl()
    {
        _friendlyUrl = string.Empty;
    }

    public FriendlyUrl(string value)
    {
        value = value.Trim();
        if (!FriednlyUrlValidator.Validate(value))
            throw new FriendlyUrlValidationException("Invalid value for FrienlyUrl");
        _friendlyUrl = value;
    }

    public static implicit operator FriendlyUrl(string friendlyUrlValue)
    {
        if (friendlyUrlValue != "" && !FriednlyUrlValidator.Validate(friendlyUrlValue))
            throw new FriendlyUrlValidationException($"Invalid value for FrienlyUrl: {friendlyUrlValue}");
        return new FriendlyUrl { _friendlyUrl = friendlyUrlValue };
    }

    public static implicit operator string(FriendlyUrl furl)
    {
        return furl._friendlyUrl;
    }

    public override string ToString()
    {
        return _friendlyUrl;
    }

    private string _friendlyUrl;

//[...skip IEquatable implementation...]

    TypeCode IConvertible.GetTypeCode()
    {
        return _friendlyUrl.GetTypeCode();
    }

    bool IConvertible.ToBoolean(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToBoolean(provider);
    }

    byte IConvertible.ToByte(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToByte(provider);
    }

    char IConvertible.ToChar(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToChar(provider);
    }

    DateTime IConvertible.ToDateTime(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToDateTime(provider);
    }

    decimal IConvertible.ToDecimal(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToDecimal(provider);
    }

    double IConvertible.ToDouble(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToDouble(provider);
    }

    short IConvertible.ToInt16(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToInt16(provider);
    }

    int IConvertible.ToInt32(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToInt32(provider);
    }

    long IConvertible.ToInt64(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToInt64(provider);
    }

    sbyte IConvertible.ToSByte(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToSByte(provider);
    }

    float IConvertible.ToSingle(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToSingle(provider);
    }

    string IConvertible.ToString(IFormatProvider provider)
    {
        return _friendlyUrl.ToString(provider);
    }

    object IConvertible.ToType(Type conversionType, IFormatProvider provider)
    {
        if (conversionType == typeof(FriendlyUrl))
            return this;
        return ((IConvertible) _friendlyUrl).ToType(conversionType, provider);
    }

    ushort IConvertible.ToUInt16(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToUInt16(provider);
    }

    uint IConvertible.ToUInt32(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToUInt32(provider);
    }

    ulong IConvertible.ToUInt64(IFormatProvider provider)
    {
        return ((IConvertible) _friendlyUrl).ToUInt64(provider);
    }
}

这是Json序列化/反序列化（xUnit）的测试：

    [Fact]
    public void ConvertToJsonAndBack()
    {
        FriendlyUrl friendlyUrl = "some-friendly-url-1";
        string friendlyUrlJson = JsonConvert.SerializeObject(friendlyUrl);
        Assert.Equal($"\"{friendlyUrl}\"", friendlyUrlJson);

        // ******** Throws the next line: ********
        FriendlyUrl deserialized = JsonConvert.DeserializeObject<FriendlyUrl>(friendlyUrlJson);
        Assert.Equal(friendlyUrl, deserialized);
    }

它抛出以下异常：

Newtonsoft.Json.JsonSerializationException：将值“ some-friendly-url-1”转换为“ BlahBlah.Entities.FriendlyUrl”类型时出错。路径”，第1行，位置21。---- System.InvalidCastException：从'System.String'到'BlahBlah.Entities.FriendlyUrl'的无效转换。

堆栈跟踪：

堆栈跟踪：JsonSerializerInternalReader.EnsureType（JsonReader阅读器，对象值，CultureInfo文化，JsonContract合同，类型targetType）JsonSerializerInternalReader.CreateValueInternal（JsonReader阅读器，类型objectType，JsonContract合同，JsonProperty成员，JsonContainerContractContainerContracterInnerReader。 （JsonReader阅读器，类型objectType，布尔值checkAdditionalContent）JsonSerializer.DeserializeInternal（JsonReader阅读器，类型objectType）JsonSerializer.Deserialize（JsonReader阅读器，类型objectType）JsonConvert.DeserializeObject（字符串值，类型类型，JsonSerializerSettings []设置）[]字符串值，JsonSerializerSettings设置）JsonConvert.DeserializeObject [T]（字符串值）

现在，如果我删除实现并仅保留它，它确实可以工作IConvertible：

• 显式和隐式“ FriendlyUrl <=>字符串”转换运算符。
• TypeConverter 实施-请参阅第一行。

但是当类实现时，IConvertible我得到了那个错误。我怎样才能解决这个问题？

（我确实需要IConvertible实施。我也尝试使用JsonObject它，但没有帮助）。

小提琴

这是repro- https: //dotnetfiddle.net/YPfr60 。

类型转换器

public class FriendlyUrlTypeConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);
    }

    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        return value is string sValue ? new FriendlyUrl(sValue) : base.ConvertFrom(context, culture, value);
    }

    public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
    {
        return destinationType == typeof(string) ? value.ToString() : base.ConvertTo(context, culture, value, destinationType);
    }
}