Does .NET have a way of resolving a null string to String.Empty?

Question

I've got a one line method that resolves a null string to string.Empty which I thought might be useful as an extension method - but I can't find a useful way of making it so.

The only way I could see it being useful is as a static method on the string class because obviously it can't be attributed to an instance as the instance is null and this causes a compiler error. [Edit: Compiler error was due to uninitialized variable, which I misinterpreted]

I thought about adding it to a helper class but that just adds unnecessary complexity from a discoverability standpoint.

So this question is in two parts I suppose:

1. Does the .NET framework have a built in way of resolving a null string to string.Empty that is common knowledge that I have missed somewhere along the way?
2. If it doesn't - does anyone know of a way to add this method as a static extension of the string class?

Cheers in advance

Edit:

Okay, I guess I should've been a little more clear - I'm already well aware of null coallescing and I was using this in a place where I've got a dozen or so strings being inspected for calculation of a hash code.

As you can imagine, 12 lines of code closely following each other all containing the null coallescing syntax is an eyesore, so I moved the null coallescing operation out to a method to make things easier easier on the eyes. Which is perfect, however, it would be a perfect extension to the string object:

int hashcode =
FirstValue.ResolveNull().GetHashCode() ^
SecondValue.ResolveNull().GetHashCode() ^
...

over a dozen lines is a lot easier to read than:

int hashcode =
(FirstValue ?? String.Empty).GetHashCode() ^
(SecondValue ?? String.Empty).GetHashCode() ^
...

I was running into compiler problems when I didn't explicitly declare my string values as null but relied on the implicit:

 string s;

If however, you explicitly define:

string s = null;

You can quite easily call:

s.ResolveNull();

Thanks all for your input.

Answer 1

The only way I could see it being useful is as a static method on the string class because obviously it can't be attributed to an instance as the instance is null and this would cause a runtime error.

C# 3.0 extension methods can be called on null receivers (since they are static in practice), but behave as instance methods. So just make it an extension method.

Answer 2

I don't think there's anything built in for this. My first thought, and what I do often, is use the coalesce operator:

string s = null;
string x = s ?? string.Empty;

Answer 3

someExpressionInvolving(s ?? "");

There is no point getting excited about string.Empty vs "" - there is negligible difference:

Console.WriteLine(ReferenceEquals(string.Empty, "")); // true

Answer 4

Extension method:

public static class StringExtensions
{
    public static String EmptyIfNull(this String instance)
    {
        return instance ?? String.Empty;
    }
}

of course, you can just as easily write instance ?? String.Empty in places where you need to use String.Empty instead of null.

Answer 5

string test = CouldReturnNull() ?? string.Empty;

Answer 6

You can use the ?? Operator (null-coalescing operator) in C# - is that what you mean? Or have I misunderstood?

eg.

string n = null;
string y = n ?? String.Empty;

y would = String.Empty;

Answer 7

string abc = s ?? string.Empty;

Answer 8

I would say that implementing this as an extension method would feel a bit like what we in Sweden call "to travel to the other side of the creek to fetch water". When I need to ensure I get an empty string instead of null I often just concatenate with string.Empty:

public void SomeMethod(string param)
{
    string notNull = param + string.Empty;
}

Sure, this may lead to an extra string instance being created, but in most real-world situations I have been in this has not been a problem.

Answer 9

There is no build in function for that. But you can write a little extension method (or a static menthod) for the string type with a statement like:

return s ?? string.Emtpy;

Answer 10

Just add string.Empty to any string variable and you'll be guaranteed to never get null

string a = null;
string b = null + string.Empty;
string c = "a" + string.Empty;

(a == string.Empty).Dump(); // False
(b == string.Empty).Dump(); // True
(c == "a").Dump(); // True

I threw this in LinqPad, hence the .Dump()'s

Looking at your options...

This technique

string b = null + string.Empty;

generates

IL_0001:  ldsfld      System.String.Empty
IL_0006:  dup         
IL_0007:  brtrue.s    IL_000F
IL_0009:  pop         
IL_000A:  ldstr       ""
IL_000F:  stloc.0     

The other popular option:

string b = null ?? string.empty

generates

IL_0001:  ldsfld      System.String.Empty
IL_0006:  stloc.0     

and this

string b = null + "";

generates this

IL_0001:  ldstr       ""
IL_0006:  stloc.0     

I still favor

string b = null + "";

But really, IMO, you should just be prepared to handle null when you digest the string