Is there a function in the .NET library that will return true or false as to whether an array is null or empty? (Similar to string.IsNullOrEmpty).
I had a look in the Array class for a function such as this but couldn't see anything.
i.e.
var a = new string[]{};
string[] b = null;
var c = new string[]{"hello"};
IsNullOrEmpty(a); //returns true
IsNullOrEmpty(b); //returns true
IsNullOrEmpty(c); //returns false
There isn't an existing one, but you could use this extension method:
/// <summary>Indicates whether the specified array is null or has a length of zero.</summary>
/// <param name="array">The array to test.</param>
/// <returns>true if the array parameter is null or has a length of zero; otherwise, false.</returns>
public static bool IsNullOrEmpty(this Array array)
{
return (array == null || array.Length == 0);
}
Just place this in an extensions class somewhere and it'll extend Array to have an IsNullOrEmpty method.
Update for 2025: These days you can use the null conditional operator and null coalescing operator to simplify the check inline, e.g. (array?.Length ?? 0) == 0 - the array?.Length part evaluates to the length of the array if it is not null, or null otherwise. The (...) ?? 0 part evaluates to the left hand expression if its value is not null, otherwise zero. By combining the two, you get the length of the array if it is not null, or zero if the array is null. The brackets are required due to operator precedence (?? has lower precedence than ==).
Naturally, you could still wrap this in an extension method:
/// <summary>Indicates whether the specified array is null or has a length of zero.</summary>
/// <param name="array">The array to test.</param>
/// <returns>true if the array parameter is null or has a length of zero; otherwise, false.</returns>
public static bool IsNullOrEmpty(this Array array)
{
return (array?.Length ?? 0) == 0;
}
For correct behaviour with very large arrays, one should use LongLength instead of Length.
Since it came up in the comments, it is important to note that calling an extension method on a null object is 100% valid and will not throw a NullReferenceException in the same way that calling an instance method on a null object would. This is because extension methods are implemented as static methods, so when you type array.IsNullOrEmpty() what you're really getting under the hood is MyExtensionMethods.IsNullOrEmpty(array), which operates in exactly the same way as the String.IsNullOrEmpty() static method.
ExtensionClass.IsNullOrEmpty(arr) (which is what the compiler is effectively doing), but that's not the normal way of using an extension method.var empty = a.IsNullOrEmpty(); what you're really using is syntactic sugar that gets turned into bool empty = MyArrayExtensions.IsNullOrEmpty(a); under the hood. This answer was written in 2011 so it came long before null conditional or null coalescing operators. These days you'd just do (array?.Length ?? 0) == 0 and do away with the need for an extension method.With Null-conditional Operator introduced in VS 2015, the opposite IsNotNullOrEmpty can be:
if (array?.Length > 0) { // similar to if (array != null && array.Length > 0) {
but the IsNullOrEmpty version looks a bit ugly because of the operator precedence:
if (!(array?.Length > 0)) {
You could create your own extension method:
public static bool IsNullOrEmpty<T>(this T[] array)
{
return array == null || array.Length == 0;
}
new int[0].IsNullOrEmpty<int>() throws an exception for me. But that works with yours. Now if you declare it any other way, it works fine.<int> or let the compiler infer the type.
(new int[0]).IsNullOrEmpty<int>();
error CS0121: The call is ambiguous between the following methods or properties: 'System.ExtensionMethods.IsNullOrEmpty(System.Array)' and 'System.Collections.Generic.ExtensionMethods.IsNullOrEmpty<T>(System.Collections.Generic.IEnumerable<T>)' - so I like this answer better.More generic if you use ICollection<T>:
public static bool IsNullOrEmpty<T> (this ICollection<T> collection)
{
return collection == null || collection.Count == 0;
}
This is an updated C# 8 version of the (currently) up-voted answer
public static bool IsNullOrEmpty<T>([NotNullWhen(false)] this T[]? array) =>
array == null || array.Length == 0;
if (array?.Any() != true) { ... }
using System.Linq;true since the underlying type is bool?In case you initialized you array like
string[] myEmpytArray = new string[4];
Then to check if your array elements are empty use
myEmpytArray .All(item => item == null)
Try
public static bool IsNullOrEmpty<T> (this ICollection<T> collection)
{
if (collection == null || collection.Count == 0)
return true;
else
return collection.All(item => item == null);
}
You can also use Any on creating your extension method:
public static bool IsNullOrEmpty<T>(this T[] array) where T : class
{
return (array == null || !array.Any());
}
Don't forget to add using System.Linq; on your using statements.
Since C# 6.0, the null-propagation operator may be used to express concise like this:
if (array?.Count.Equals(0) ?? true)
Note 1:
?? falseis necessary, because of the following reasonNote 2: as a bonus, the statement is also "thread-safe"
Checking for null or empty or Length has been simplified with C# Linq. With null coalesce operator, one can simply do this:
if (array?.Any())
return true;
else return false;
if (arr != null && arr.Length != 0)? Or create an extension method if you need to use this repeatedly.if (arr != null && arr.Length != 0)in its entirety.IsNullOrEmptymethod—it's just there for convenience reasons. Early versions of the JITer actually had problems getting the optimization right.