Feature Request: Create an operator that represents String.IsNullOrEmpty()

[jnegron357]

In the same way that we have the null coalescing operator, I'd like to see one that can include an implicit check for empty strings.

Before

string result = String.IsNullOrEmpty(var1) ? var2 : var1;
//using an extension method:
string result = var1.IsNullOrEmpty() ? var2 : var1

After

string result = var1 ??! var2;

This would be a great way to clean up code!

[jnm2]

I use IsNullOrWhitespace or == null far more frequently than IsNullOrEmpty.

[jnegron357]

I suppose IsNullOrWhiteSpace makes more sense since it has better coverage. That one actually makes a better argument since it's more verbose than IsNullOrEmpty, so the new operator would make a bigger impact on code readability when replacing those calls.

[alrz]

HasValue on Nullable could be convention-based so you could define an extension property for string with that effect.

extension string {
  public bool HasValue => string.IsNullOrEmpty(this);
}

var x = str ?? "empty";

Related: #147

[Thaina]

I write extension method in my own basis

public static StringExt
{
    public static bool IsNullOrEmpty(this string str) => string.IsNullOrEmpty(str);
}

"abc".IsNullOrEmpty();
string s = null;
s.IsNullOrEmpty();

Should just have something like this in corefx

[iam3yal]

I almost never use string.IsNullOrEmpty but x == null and/or x.Length == 0.

Just as an example:

if (text == null)
{
	throw new ArgumentNullException(nameof(text));
}

if (text.Length == 0)
{
	yield return new TextChar(default(char));
}

[MovGP0]

Another way of doing this would be the ability to create custom operators:

public static class StringExtensions 
{
    public static string operator (??!) IsNullOrEmpty(this string left, string right) 
    {
        return string.IsNullOrEmpty(left) ? right : left;
    }
}

[JamesFaix]

I don't think this provides enough value to warrant language integration. The extension method call in the example is only a few characters longer than an expression with the new operator would be. I think it's fair that null checks have their own operators because of null's odd place in the type system, but looking for different string patterns is a much more business-rules decision, not something that should be in the language. The disagreement over OrWhitespace vs OrEmpty is proof of this.

[jamesqo]

If you use IsNullOrEmpty a lot in a file, adding a using static System.String at the top will help decrease verbosity. Better yet, you could create an extension method and write if (str.IsNullOrEmpty())... I don't think 1 function warrants language integration.

There's another way to do this I just thought of, too: if (str?.Length > 0)

[jnegron357]

The arguments against this feature are understandable but I still believe having the specialized operator or the ability for the developer to create it would be very useful and in the end would help us be more productive. I'm sticking to my guns despite the down votes.

@jamesqo I've already mentioned the use of extension methods in my initial post, that's the reason for my down vote on your comment. Your suggestion for the use of str?.Length >0 is an interesting workaround but it still doesn't beat the brevity of var1 ??! var2.

@eyalsk The fact that you almost never use IsNullOrEmpty is irrelevant, my argument is for a more efficient way of expressing the condition. You're comment actually helps my argument for less verbosity.

@Thaina Again, I've already mentioned the use of extension methods in my initial post, please read thoroughly before commenting.

@JamesFaix I strongly disagree with your opinion.

@alrz Your option is intriguing and I will try it out but for the record I'd prefer the specialized operator.