How to test a null value variable if it's a string?

Question

Is it possible to test if a variable is defined as a string if the value inside it is null?

If I write:

string b = null;
bool c = b is string;

Then c will be false because is looks at the content, which is null and not a string.

If I write:

string b = null;
bool c = (b.GetType() == typeof(string)); 

Then it crashes because s is null and you can't call GetType() on a null value.

So, how can I check b to find out what type it is? Some kind of reflection maybe? Or is there any simpler way?

Edit 1: Clarification of the question!

I was a bit unclear in my question and that was my fault. In the example it looks like I'm trying to test the content of the variable. But I want to test the variable itself without looking at the content. In the code examples given I can see that b is a string, but what if I don't know if b is a string and just want to test the variable s to see if it is a string or not.

So, how can I know what type the variable is defined as? As in this example, but x is an unknown variable that might be defined as a string and it might be null as well (since it might be null this example won't work).

bool c = (x.GetType() == typeof(string)); 

Edit 2: The working solution!

Thanks to all the answers given I was able to solve it. This is how the working solution became. I first created a help function to test the defined type of a variable that works even if the value is null and it doesn't point to anything.

public static Type GetParameterType<T>(T destination)
{
    return typeof(T);
}

Then I can just call this function and test my "suspected string" and find out if it really is a string or not.

// We define s as string just for this examples sake but in my "definition" we wouldn't be sure about whether s is a string or not.
string s = null; 

// Now we want to test to see if s is a string
Type t = GetParameterType(s);
b = t == typeof(string);  // Returns TRUE because s has the type of a string
b = t is string;  // Returns FALSE because the content isn't a string

This is just what I wanted to find out!!! Thank you all for squeezing your brains...

Answer 1

So you want to know if there is a direct method to check of an object type whose value is set to NULL

In The simple word the answer is NO.

A null reference does not point to any Storage Location, so there is no metadata from which it can make that determination.

Although if you already know it is of type String , you can use following two functions for checking null values

String.IsNullOrWhiteSpace(stringObject);

and

String.IsNullOrEmpty(stringObject)

The best that you could do to set a value to unknown type is use

Convert.ChangeType 

e.g. as given in .NET : How do you get the Type of a null object?

public void GetObjectValue<T>(out T destination)
{
    object paramVal = "Blah.Blah.";
    destination = default(T);
    destination = Convert.ChangeType(paramVal, typeof(T).GetType());
}

The type of T can be inferred, so you shouldn't need to give a type parameter to the method explicitly.

Answer 2

You cannot check the type of null because null has no type. It doesn't reference anything at all, therefore there is nothing that C# can look at to find out the actual type.

(Everyone else seems to be answering the question "How can I tell if a string reference is null or empty - but I think the question is "how can I tell if the underlying type of a null reference is string...)

There might be a way to fiddle it though - you might be able to use a generic method as mentioned here:

.NET : How do you get the Type of a null object?

(That link was posted by someone else - not me - as a comment to your original post!)

Answer 3

If you want to tell whether the actual value is a string, you can't do that with null, as null doesn't have a type.

So it seems you want to determine the actual type of the variable (the one it was declared as):

If the variable is of type string, then you know it at compile time (you declared it as string, after all).
If the variable is generic (like in generic types or a generic method), you can test it via typeof(T), assuming T is your type parameter.
If you got the variable as object though (e.g. as argument of a method), then there is no way to determine its original type if its value is null.

Answer 4

1. IsNullOrWhiteSpace(variableName)

2. string.IsNullOrEmpty()

3. var.Trim().Length < 1

The third one is the one I personally use, as it is version-independent.

Answer 5

Use the String.IsNullOrEmpty method to check it.

string b = null;
bool c = String.IsNullOrEmpty(b);

See this MSDN link for further details.

Answer 6

Here it is

String.IsNullOrEmpty(s);