如何用接口实现类属性兼容bool与自定义FooClass类型？

当然可以用接口来处理，这样既能避免object类型的类型不安全问题，又能保证向前兼容旧的bool值。下面是具体的实现方案：

1. 定义接口与自定义类 #

首先定义一个接口来规范Foo的行为，让你的自定义类实现这个接口：

public interface IFoo
{
    string Value { get; set; } // 根据你的FooClass实际属性调整
}

public class FooClass : IFoo
{
    public string Value { get; set; }
}

2. 主类中使用接口类型属性+私有字段 #

在业务类里，用IFoo作为公开属性的类型，同时用私有字段存储实际值，避免直接访问属性导致的递归问题：

public class YourBusinessClass
{
    private IFoo _foo;

    [JsonProperty("foo")]
    [JsonConverter(typeof(FooConverter))] // 关键：用自定义转换器处理旧bool值
    public IFoo Foo
    {
        get => _foo ?? new FooClass { Value = "example" }; // 处理未初始化的情况
        set
        {
            if (value is null)
                throw new InvalidPropertyException("Foo cannot be null");
            
            if (value is not IFoo)
                throw new InvalidPropertyException($"Foo must implement IFoo");
            
            _foo = value;
        }
    }
}

3. 自定义Json转换器处理兼容 #

核心是通过JsonConverter来处理旧的bool类型Json值，自动转换为FooClass实例：

public class FooConverter : JsonConverter<IFoo>
{
    public override IFoo ReadJson(JsonReader reader, Type objectType, IFoo existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        // 处理旧的bool类型值
        if (reader.TokenType == JsonToken.Boolean)
        {
            bool oldValue = (bool)reader.Value;
            return new FooClass { Value = oldValue ? "example_true" : "example_false" };
        }
        // 处理新的FooClass对象
        else if (reader.TokenType == JsonToken.StartObject)
        {
            return serializer.Deserialize<FooClass>(reader);
        }

        throw new JsonSerializationException($"Unexpected token type for Foo: {reader.TokenType}");
    }

    public override void WriteJson(JsonWriter writer, IFoo value, JsonSerializer serializer)
    {
        // 序列化时输出新的FooClass格式，保持新数据结构
        serializer.Serialize(writer, value);
    }
}

方案优势 #

• 避免了object类型的类型不安全问题，编译器会帮你做类型检查
• 通过Json转换器自动兼容旧的bool格式，无需手动在属性get/set里处理递归和类型判断
• 接口定义了Foo的行为规范，后续如果需要扩展其他实现类也很方便

额外优化：如果不想暴露接口 #

如果你不需要对外暴露IFoo接口，也可以用隐式转换+具体类的方式实现，代码更简洁：

public class FooClass
{
    public string Value { get; set; }

    // 定义bool到FooClass的隐式转换，支持直接赋值bool值
    public static implicit operator FooClass(bool value)
    {
        return new FooClass { Value = value ? "example_true" : "example_false" };
    }
}

public class YourBusinessClass
{
    private FooClass _foo;

    [JsonProperty("foo")]
    [JsonConverter(typeof(FooConverter))]
    public FooClass Foo
    {
        get => _foo ?? new FooClass { Value = "example" };
        set => _foo = value ?? throw new InvalidPropertyException("Foo cannot be null");
    }
}

// 对应调整转换器为FooClass类型
public class FooConverter : JsonConverter<FooClass>
{
    public override FooClass ReadJson(JsonReader reader, Type objectType, FooClass existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.Boolean)
        {
            return (bool)reader.Value; // 利用隐式转换
        }
        else if (reader.TokenType == JsonToken.StartObject)
        {
            return serializer.Deserialize<FooClass>(reader);
        }

        throw new JsonSerializationException($"Unexpected token type for Foo: {reader.TokenType}");
    }

    public override void WriteJson(JsonWriter writer, FooClass value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

内容的提问来源于stack exchange，提问作者Emme Developer