C# 用通用T检验布尔值

我有一个通用方法，我想传入一个引用类型或bool

private void Test<T>(T value)
{
    if(typeof(T)) == typeof(bool))
    {
        if(value == false)
            // do something
        else if (value == null)
            // do something else
    }
}

---

即使已验证类型，您仍然需要强制转换，并且您的

else

语句将永远不会激发：

private void Test<T>(T value)
{
    if(typeof(T)) == typeof(bool))
    {
        if((bool)value == false)
            // do something
        else if (value == null) // this will never be true for a bool!
            // do something else
    }
}

private void Test（T值）
{
if（typeof（T））==typeof（bool））
{
如果（（bool）值==false）
//做点什么
else if（value==null）//对于bool，这永远不会是真的！
//做点别的
}
}

即使验证了类型，您仍然需要强制转换，并且您的

else

语句将永远不会触发：

private void Test<T>(T value)
{
    if(typeof(T)) == typeof(bool))
    {
        if((bool)value == false)
            // do something
        else if (value == null) // this will never be true for a bool!
            // do something else
    }
}

private void Test（T值）
{
if（typeof（T））==typeof（bool））
{
如果（（bool）值==false）
//做点什么
else if（value==null）//对于bool，这永远不会是真的！
//做点别的
}
}

您需要一个丑陋的双重演员阵容，如下所示：

private void Test<T>(T value)
{
    if(typeof(T) == typeof(bool))
    {
        if((bool)(object)value)
            // do something
        else if (!(bool)(object)value)
            // do something else
    }
}

---

然而，应该注意的是，在泛型方法中测试类型，并对不同的类型参数使用不同的策略，这是非常糟糕的代码味道。您最好为

bool

或任何其他需要提供特殊处理的参数类型提供不同的重载。

您需要一个丑陋的双重强制转换，如下所示：

private void Test<T>(T value)
{
    if(typeof(T) == typeof(bool))
    {
        if((bool)(object)value)
            // do something
        else if (!(bool)(object)value)
            // do something else
    }
}

---

然而，应该注意的是，在泛型方法中测试类型，并对不同的类型参数使用不同的策略，这是非常糟糕的代码味道。您最好为

bool

或需要提供特殊处理的任何其他参数类型提供不同的重载。

使用

is

操作符：

private void Test<T>(T value)
{
    if(value is bool)
    {
        ...
    }
}

private void Test<T>(T value)
{
    bool? boolValue = value as bool;
    if (boolValue != null) {
        // do something with boolValue, which can never be null if value is of type bool
    }
    else {
        // do something with value, which is not a boolean
    }
}

---

使用

is

运算符：

private void Test<T>(T value)
{
    if(value is bool)
    {
        ...
    }
}

private void Test<T>(T value)
{
    bool? boolValue = value as bool;
    if (boolValue != null) {
        // do something with boolValue, which can never be null if value is of type bool
    }
    else {
        // do something with value, which is not a boolean
    }
}

---

根据调用此方法的方式，您可以使用

bool

创建重载：

private void Test(bool b)
{
    if(! b)
    {
        //do something
    }
}

private void Test<T>(T value) where T : class
{
    if(value == null)
    {
        //do something else
    }
}

专用无效测试（bool b）
{
如果（！b）
{
//做点什么
}
}
专用无效测试（T值），其中T:等级
{
如果（值==null）
{
//做点别的
}
}

根据调用此方法的方式，您可以使用

bool创建重载：

private void Test(bool b)
{
    if(! b)
    {
        //do something
    }
}

private void Test<T>(T value) where T : class
{
    if(value == null)
    {
        //do something else
    }
}

专用无效测试（bool b）
{
如果（！b）
{
//做点什么
}
}
专用无效测试（T值），其中T:等级
{
如果（值==null）
{
//做点别的
}
}
T是一个类型参数，可以是类或结构，因此编译器不允许您执行类和结构中不存在的操作。（旁注：
value==false
->
！value
）我更倾向于问您为什么需要这样做？这里有些错误。T是一个类型参数，可以是类或结构，因此编译器不允许您执行类和结构中不存在的操作。（旁注：
value==false
->
！value
）我更倾向于问您为什么需要这样做？这里有点不对劲。说得好，但并不能解决OP所指的问题。感谢您指出这一点，已更新为包含
as
运算符变体，它将解决使用该值进行操作的问题。@mayabelle as运算符必须与引用类型或可为null的类型一起使用（'bool'是一种不可为null的值类型）谢谢，尽管我收到了一个错误“运算符不能与不可为null的值类型一起使用”

bool“使用as.Sorry，我有一个输入错误，没有找到问号，它应该是

bool？

，可以为空。这一点很好，但并不能解决OP所指的问题。感谢您指出这一点，更新为包含

as

操作符变体，它将解决使用该值执行操作的问题。@mayabelle as操作符m必须与引用类型或可空类型一起使用（“bool”是不可空的值类型）谢谢，尽管我收到了一个错误“运算符不能与不可空的值类型一起使用”bool“使用as.Sorry，我有一个输入错误，没有找到问号，它应该是

bool？

，可以为空。谢谢，但是我在强制转换时遇到以下错误：“无法将type

T'转换为
bool'”@user2994682我们使用的是我的代码的最新版本吗（使用双强制转换--
（bool）（object）值
）？您不应该看到该错误。谢谢，但我在强制转换时遇到以下错误：“无法将类型
t'转换为
bool'”@user2994682我们是否使用我的代码的最新版本（使用双强制转换--
（bool）（object）值
）？您不应该看到该错误。