Evaluate my helper please

Question

I have some static helper class:

public static class Helper
{
    public static bool IsNull<T>(this T value) where T : class
    {
        return (value == null);
    }

    public static bool NotNull<T>(this T value) where T : class
    {
        return (!value.IsNull<T>());
    }

    public static bool IsNullOrEmpty(this string value)
    {
        return string.IsNullOrEmpty(value);
    }

    public static bool NotNullAndNotEmpty(this string value)
    {
        return (!value.IsNullOrEmpty());
    }

    public static bool NotNullAndNotEmpty(this ICollection value)
    {
        return (value.NotNull<ICollection>() && (value.Count > 0));
    }

    public static bool IsNullOrEmpty(this ICollection value)
    {
        return (!value.NotNullAndNotEmpty());
    }
}

It is comfortable (habit) for me to use this helper, but I am not sure, that it is correctly (worth it), how about performance? probably there are any other reasons don't use it?

Thanks.

Answer 1

This gets to be a sticky point. There are those who will argue fervently that an extension method should never work on a null reference, and there are those who are fine with that.

Personally, I don't mind extension methods on null if the name is a clear indicator that null is a possibility (like IsNullOrEmpty) but as I said, that's my opinion and may not match others.

Don't worry about the performance, method calls are not a serious impact and check methods like this eliminate some of the readability concerns over compound expressions when maintaining the code. After all, that's what string.IsNullOrEmpty() does, but it does it through a static method instead of an extension method.

So the only concern, really, you may get push back that these are extension methods as opposed to ordinary static methods, but you'll get differing opinions on whether calling an extension method on null is bad/okay.

One could argue Microsoft disallows LINQ extension methods on null sequences, but then again Microsoft also doesn't disallow extension method calls on a null source in general.

So, the choice is yours, I don't have an issue with them since the names clearly indicate null is an accepted possibility, but I can see both sides of the argument.

On a side note, I'd keep your naming consistent:

• NotNull -> IsNotNull
• NotNullAndNotEmpty -> IsNotNullAndNotEmpty

Answer 2

I don't see exactly what's the win for you with this helper class. Most of the methods you have shown seem like some overhead. For example:

public static bool IsNullOrEmpty(this string value) 
{ 
    return string.IsNullOrEmpty(value); 
} 

Although it will provide you a fluent syntax in your code. Performance will not bite you, your not doing very heavy things inside your extension methods.

Answer 3

• IsNull: What does this buy you? Just say if (whatever == null)
• NotNull: Same as above. What's so bulky about if (whatever != null)?
• IsNullOrEmpty: What does this buy you? You're just putting existing logic into a helper method without any special supporting logic.
• NotNullAndNotEmpty: Same as previous. What's wrong with !string.IsNullOrEmpty(value)?
• NotNullAndNotEmpty(this ICollection value): Why would you name it like this? Call it IsNullOrEmpty so you can test for a positive.
• IsNullOrEmpty: Why on Earth are you convoluting your code with this? All you're doing is creating a method that calls NotNullAndNotEmpty with a !. Ditch this method, rename the previous like I suggested, and just go like !IsNullOrEmpty when you need to check for a false value.

Not to be rude or anything, but I think your helper methods really don't help at all since they're only encapsulating existing logic. The only one that has merit is the logic within NotNullAndNotEmpty for ICollection (although you need to rename it like I suggested).