C#中实现Union Types（联合类型）的替代方案有哪些？

你需要的是类似TypeScript联合类型（boolean | Date）或F#可区分联合的特性，C#原生虽未直接支持，但有几种无需第三方库的替代方案，以下是常用实现方式：

1. 优化版可区分联合类（推荐） #

针对你之前尝试的隐式转换方案，添加类型标记解决多字段冗余问题，确保同一时间只有一个有效类型值，同时保留类型安全：

// 标记当前存储的类型
public enum MyFieldTypeKind
{
    Bool,
    DateTime
}

public class MyFieldType
{
    private readonly MyFieldTypeKind _typeKind;
    private readonly bool _boolValue;
    private readonly DateTime _dateTimeValue;

    // 私有构造函数，仅通过工厂方法创建实例
    private MyFieldType(MyFieldTypeKind typeKind, bool boolVal, DateTime dateVal)
    {
        _typeKind = typeKind;
        _boolValue = boolVal;
        _dateTimeValue = dateVal;
    }

    // 工厂方法：创建对应类型的实例
    public static MyFieldType FromBool(bool value) => 
        new MyFieldType(MyFieldTypeKind.Bool, value, default);

    public static MyFieldType FromDateTime(DateTime value) => 
        new MyFieldType(MyFieldTypeKind.DateTime, default, value);

    // 类型检查属性
    public bool IsBool => _typeKind == MyFieldTypeKind.Bool;
    public bool IsDateTime => _typeKind == MyFieldTypeKind.DateTime;

    // 安全转换方法，类型不匹配时抛出明确异常
    public bool AsBool()
    {
        if (!IsBool) throw new InvalidCastException("当前值为DateTime类型，无法转换为布尔值");
        return _boolValue;
    }

    public DateTime AsDateTime()
    {
        if (!IsDateTime) throw new InvalidCastException("当前值为布尔类型，无法转换为DateTime");
        return _dateTimeValue;
    }

    // 可选隐式转换，简化赋值操作
    public static implicit operator MyFieldType(bool value) => FromBool(value);
    public static implicit operator MyFieldType(DateTime value) => FromDateTime(value);
}

// 使用示例
public class MyClass
{
    public MyFieldType? MyField { get; set; }
}

// 调用代码
var obj = new MyClass();
obj.MyField = true;
obj.MyField = DateTime.Now;

// 访问值时先检查类型
if (obj.MyField?.IsBool == true)
{
    bool val = obj.MyField.AsBool();
}
else if (obj.MyField?.IsDateTime == true)
{
    DateTime val = obj.MyField.AsDateTime();
}

2. 接口+多态实现类 #

通过定义空接口，为每个允许的类型创建专属实现类，语义清晰且类型安全，适合后续需要扩展更多类型的场景：

// 定义标记接口
public interface IMyField { }

// 布尔类型实现
public class BoolField : IMyField
{
    public bool Value { get; }
    public BoolField(bool value) => Value = value;
}

// DateTime类型实现
public class DateTimeField : IMyField
{
    public DateTime Value { get; }
    public DateTimeField(DateTime value) => Value = value;
}

// 使用类
public class MyClass
{
    public IMyField? MyField { get; set; }
}

// 调用代码
var obj = new MyClass();
obj.MyField = new BoolField(true);
obj.MyField = new DateTimeField(DateTime.Now);

// 访问值时用模式匹配
if (obj.MyField is BoolField boolField)
{
    bool val = boolField.Value;
}
else if (obj.MyField is DateTimeField dateField)
{
    DateTime val = dateField.Value;
}

3. Nullable值元组（极简场景） #

用Nullable值组合存储，手动确保同一时间只有一个值不为null，适合快速原型或极简单场景：

public class MyClass
{
    // 第一个元素存布尔值，第二个存DateTime，仅一个可为非null
    public (bool? BoolValue, DateTime? DateTimeValue) MyField { get; set; }
}

// 调用代码
var obj = new MyClass();
obj.MyField = (true, null);
obj.MyField = (null, DateTime.Now);

// 访问值
if (obj.MyField.BoolValue.HasValue)
{
    bool val = obj.MyField.BoolValue.Value;
}
else if (obj.MyField.DateTimeValue.HasValue)
{
    DateTime val = obj.MyField.DateTimeValue.Value;
}

4. Dynamic类型（不推荐） #

使用dynamic跳过编译时类型检查，虽然赋值方便，但失去类型安全，运行时可能抛出异常，仅适合临时测试场景：

public class MyClass
{
    public dynamic? MyField { get; set; }
}

// 调用代码
var obj = new MyClass();
obj.MyField = true;
obj.MyField = DateTime.Now;

对你已考虑方案的补充 #

• object类型：确实缺乏编译时类型检查，强制转换容易出错，仅适合极端简单场景；
• 原隐式转换类：未添加类型标记会导致两个字段同时存储值，无法判断当前有效类型，优化后的可区分联合类解决了这个问题，同时保留了隐式转换的便利性。

内容的提问来源于stack exchange，提问作者Vitaly Kravtsov