C#中如何高效初始化可能为两种类型的局部变量？

你需要的是根据条件让局部变量仅初始化对应类型的实例（避免提前初始化两个高成本对象），以下是几种可行的高效方案：

方案1：使用 object 类型 #

将变量声明为object，在分支中仅初始化对应类型，使用时通过类型检查转换：

bool myCase = GetCase();
object myVar;

if (myCase)
{
    myVar = GetFloat(); // 仅执行此分支的初始化逻辑
}
else
{
    myVar = GetBool(); // 仅执行此分支的初始化逻辑
}

// 使用时做类型判断
if (myVar is float floatVal)
{
    // 处理float类型的业务逻辑
}
else if (myVar is bool boolVal)
{
    // 处理bool类型的业务逻辑
}

方案2：使用 dynamic 类型 #

如果不想每次使用都写类型检查，可以用dynamic，但注意这会跳过编译时类型检查，运行时才会验证类型：

bool myCase = GetCase();
dynamic myVar;

if (myCase)
{
    myVar = GetFloat();
}
else
{
    myVar = GetBool();
}

// 直接使用myVar，编译器不会做类型校验
// 示例：Console.WriteLine(myVar);

方案3：自定义可区分联合类型（C# 8+） #

适合需要严格类型安全的复杂场景，通过自定义类封装不同类型，用switch表达式处理：

// 定义基础联合类型
public abstract class ValueUnion { }

// 封装float类型的实现
public sealed class FloatValue : ValueUnion
{
    public float Value { get; }
    public FloatValue(float value) => Value = value;
}

// 封装bool类型的实现
public sealed class BoolValue : ValueUnion
{
    public bool Value { get; }
    public BoolValue(bool value) => Value = value;
}

// 使用示例
bool myCase = GetCase();
ValueUnion myVar = myCase ? new FloatValue(GetFloat()) : new BoolValue(GetBool());

// 用switch表达式处理不同类型
var output = myVar switch
{
    FloatValue f => $"处理浮点值：{f.Value}",
    BoolValue b => $"处理布尔值：{b.Value}",
    _ => throw new InvalidOperationException("未知类型")
};

方案4：泛型方法封装逻辑 #

如果处理逻辑可以抽象，把初始化和业务逻辑封装到泛型方法中，主逻辑更简洁：

T HandleValue<T>(bool isFloat)
{
    if (isFloat)
    {
        float val = GetFloat();
        // 在这里编写float类型的处理逻辑
        return (T)(object)val;
    }
    else
    {
        bool val = GetBool();
        // 在这里编写bool类型的处理逻辑
        return (T)(object)val;
    }
}

// 使用时
bool myCase = GetCase();
if (myCase)
{
    float result = HandleValue<float>(myCase);
}
else
{
    bool result = HandleValue<bool>(myCase);
}

各方案对比 #

• object：兼容所有C#版本，缺点是使用时必须手动做类型检查，代码稍显繁琐。
• dynamic：使用简单，但失去编译时类型安全，适合逻辑简单的场景。
• 自定义可区分联合：类型安全、结构清晰，适合复杂业务场景，代码易维护。
• 泛型方法：适合处理逻辑可复用的场景，把类型分支隐藏在方法内部。

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