具有泛型的可空基元

Question

I'm trying to find the right thing to do with a non-null validation on a nullable boolean. I also want to be able to do the same thing with some other fields, including strings, ints, etc., so I want to use generics for the method. Here's an example of the kind of thing which can happen.

bool? myValue = null;
bool valid = ValidateNotNull(myValue);

And here's some validation code:

public bool ValidateNotNull<T>(T nullableField)
{
    return nullableField != null;
}

All the answers I've found to this kind of problem suggest adding a where T : struct or where T: class to the method signature, or using default(T) in the comparison, none of which will work for a bool where false is a valid value.

Any other suggestions? The code compiles, but Resharper isn't happy about that null comparison on a value which it thinks might be a primitive, and I'd love to know what I should be doing to cheer it up.

NB: This isn't the complete code. I'm still interested in maintaining the type. This is also not the only place I've run into the problem.

NB2: Yes, it compiles and works fine. What I really want to know is whether there is a code solution for stopping Resharper from complaining, or an idiomatic way to do this which I don't know about.

Answer 1

The code below will validate nullable types and reference types:

 public bool ValidateNotNull<T>(Nullable<T> nullableField) where T:struct
 {
  return nullableField.HasValue;
 }

 public bool ValidateNotNull<T>(T nullableField) where T:class
 {
  return nullableField!=null;
 }

Answer 2

Would comparing to default work?

  public bool ValidateNotNull<T>(T nullableField) { return Equals(nullableField, default(T)); } 

Updated:

Either its a primitive , and all is well, or its not null:

    public bool ValidateNotNull<T>(T nullableField)
    {
        return typeof(T).IsPrimitive || !Equals(nullableField, null);
    }

Answer 3

I also want to be able to do the same thing with some other fields, including strings, ints, etc

OK, so you want a method that can be passed either a Nullable<> (which is a struct ), or a reference type, and will return true iff the argument is null (note that your name appears to be the wrong way round, but there you go).

The thing is, if that's all this method has to do, then you don't need generics because you don't need type-safety. This example works and does what you want, I think:

class Program
{
    static void Main(string[] args)
    {
        int? x = null;
        int? y = 5;
        string s = null;
        string r = "moo";

        Console.WriteLine(ValidateNotNull(x));
        Console.WriteLine(ValidateNotNull(y));
        Console.WriteLine(ValidateNotNull(s));
        Console.WriteLine(ValidateNotNull(r));

        Console.ReadLine();

    }

    private static bool ValidateNotNull(object o)
    {
        return o == null;
    }
}

This outputs

True
False
True
False

which is I believe your required output.

Answer 4

I don't know why you thing your method doesn't work (apart from using != rather than == ), because as far as I can tell, it already works! You can compare any value of type T with null (when T is a generic type parameter). If a non-nullable value type is used for T, the result will be treated as a constant ( false for == null , true for != null ).

So, this should be fine.

public bool ValidateNotNull<T>(T nullableField)
{
    return nullableField != null;
}

But this would also work without generics:

public bool ValidateNotNull(object nullableField)
{
    return nullableField != null;
}

(Because boxing a Nullable<T> null value returns a null reference.)

Answer 5

You need to use

public bool ValidateNotNull<T>(T nullableField)
{
    return nullableField.HasValue;
}