Question

我有一个通用的方法，我想通过引用类型或bool传递。

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

但是我得到了这个编译时错误“Operator ==' cannot be applied to operands of type T'和`bool'”。是否有一个简单的解决方案（最好不使用反射）？

更新：如果它包含在foreach循环中，是否会有隐式转换？我仍然收到相同的编译错误。

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

Answer 1

使用is运算符：

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

或as运营商：

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
    }
}

Answer 2

即使您已经验证了类型，仍然需要进行投射，并且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
    }
}

Answer 3

根据您调用此方法的方式，您可以创建一个带有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
    }
}

Answer 4

你需要一个丑陋的双重演员，如下：

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
    }
}

同样适用于循环：

private void Test<T>(T[] values)
{
    foreach(T value in values)
    {
        if(typeof(T) == typeof(bool))
        {
            if (!(bool)(object)value)
                // do something
        }
        else if (value == null)
                // do something else
    }
}

虽然，这比您需要的更多比较。这会更有效：

private void Test<T>(params T[] values)
{
    if(typeof(T) == typeof(bool))
    {
        foreach(bool b in values.Cast<bool>())
        {
            if (!b)
                // do something
        }
    }
    else
    {
        foreach(T value in values)
        {
            if (value == null)
            // do something else
        }
    }
}

另外，如果do something和do something else相同，您可以将其简化为：

private void Test<T>(params T[] values)
{
    foreach(T value in values)
    {
        if (value == default(T))
            // do something
    }
}

然而，应该注意的是，在泛型方法中测试类型，并对不同类型参数使用不同的策略是非常糟糕的代码味道。您可能最好为bool或您需要提供特殊处理的任何其他参数类型提供不同的重载。

使用通用T测试bool值

4 个答案: