为什么myString.IsNullOrEmpty（）没有内置到.Net中？

Question

A bit of an academic question, but I'm trying to understand the framework design on a deeper level.

So we have String.IsNullOrEmpty(MyString)

and we could write an extension method to enable myString.IsNullOrEmpty() , though that's arguably not the greatest idea. See: Is extending String class with IsNullOrEmpty confusing? .

So my question is, why doesn't MS write this functionality as part of the .Net framework? Is there some performance consideration? And more generally, why would any method or property viewed as valuable enough to be built as accessible via the String object not be available as a member of any object of the string type?

Answer 1

The static method String.IsNullOrEmpty was introduced in the .NET Framework version 2.0. Extension methods were introduced in the .NET Framework version 3.5 together with LINQ. Therefore Microsoft did not have this option when introducing IsNullOrEmpty .

Of course, IsNullOrEmpty cannot be an instance method of String , since you cannot invoke a method on a reference which is null . However, you can invoke an extension method on such a reference, since the extension method syntax is just syntactic sugar for a static method invocation.

---

Let's assume that IsNullOrEmpty was an extension method. Then you could call it like this:

string s = null;
bool result = s.IsNullOrEmpty();

In a comment, someone pretends that this call would throw a NullReferenceException . The extension method would be declared like this:

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string s)
    {
        return s == null || s.Length == 0;
    }
}

... and be used like this ...

 string s = null;
 bool result = s.IsNullOrEmpty();

... which is just syntactic sugar for ...

 string s = null;
 bool result = StringExtensions.IsNullOrEmpty(s);

... and thus, would not throw an exception. Whether it is a good idea or not to do so is another question (see answer provided by usr below ).

Answer 2

It is generally considered bad-practice to have an extension method not fail when invoked on a null reference. This is because just from reading the code you cannot tell that an extension method is being called. Your intuition would be to see the call ((string)null).IsNullOrEmpty() fail.

Obviously, this kind of method would not be possible as an instance method. So we are violating intuition here.

That said, I have defined exactly this extension in all important projects of mine and it is outrageously useful in a lot of cases. I am willing to accept this small level of impurity and unintuitiveness.

The framework authors obviously disagreed. I also think that this method should not go into the .NET Framework because it is kind of "advanced" and impedes learnability. A beginner might ask "Huh? Sometimes I can invoke a method on a null reference safely, sometimes I can't? How to tell when?".

Answer 3

Because if you could use IsNullOrEmpty() on a null string, then you probably might want to rename the method to IsEmpty() .

Jokes aside, this is how the method is implemented:

public static bool IsNullOrEmpty(string value)
{
  if (value != null)
    return value.Length == 0;
  else
    return true;
}

It's clear that the condition would always be true in case of string instances.

Also, one little detail. Take, for instance, string.Concat which is a static method. It could've been reasonable, for example, wonder why there's no relative instance method; by looking at its implementation, I believe that they wanted to make those methods as fail-proof as possible. When passing the arguments to the method, in case of null references, they are replaced with empty strings instead of having exceptions thrown. This can be useful when you don't know in advance if your string(s) will actually contain a value or be null, and I guess that the framework's developers decided that it'd be better to contribute to code readability by treating null strings as empty ones and saving the end-user an additional check. Surely, if string.Concat was an instance method (or at least had an alternative), the user could still pass null arguments, but the instance which is being operated on will necessarily be not null.