CODEWITHSUNDEEP
c#arrays
sooprise
sooprise

Reputation: 23187

If (Array.Length == 0)

If an array is empty, it looks like you can't check it's length using ".length". What's the best way to check if an array is empty?

Upvotes: 74

Views: 173690

Answers (14)

Artur Adam
Artur Adam

Reputation: 99

You can also use pattern matching in the newer versions if(array is null or [])

Upvotes: 0

poletaew
poletaew

Reputation: 196

Since .Net >= 5.0 the best way is to use Any:

if(!array.Any()) {
   //now you sure it's empty
}

For nullable arrays:

if(!(array?.Any() == true)) {
   //now you sure it's null or empty
}

Upvotes: 4

binki
binki

Reputation: 8316

If array is null, trying to derefrence array.Length will throw a NullReferenceException. If your code considers null to be an invalid value for array, you should reject it and blame the caller. One such pattern is to throw ArgumentNullException:

void MyMethod(string[] array)
{
    if (array is null) throw new ArgumentNullException(nameof(array));

    if (array.Length > 0)
    {
        // Do something with array…
    }
}

If you want to accept a null array as an indication to not do something or as an optional parameter, you may simply not access it if it is null:

void MyMethod(string[] array)
{
    if (array is not null)
    {
        // Do something with array here…
    }
}

If you want to avoid touching array when it is either null or has zero length, then you can check for both at the same time with C#-6’s null coalescing operator.

void MyMethod(string[] array)
{
    if (array?.Length > 0)
    {
        // Do something with array…
    }
}

Superfluous Length Check

It seems strange that you are treating the empty array as a special case. In many cases, if you, e.g., would just loop over the array anyway, there’s no need to treat the empty array as a special case. foreach (var elem in array) {«body»} will simply never execute «body» when array.Length is 0. If you are treating array == null || array.Length == 0 specially to, e.g., improve performance, you might consider leaving a comment for posterity. Otherwise, the check for Length == 0 appears superfluous.

Superfluous code makes understanding a program harder because people reading the code likely assume that each line is necessary to solve some problem or achieve correctness. If you include unnecessary code, the readers are going to spend forever trying to figure out why that line is or was necessary before deleting it ;-).

Upvotes: 3

Abdou
Abdou

Reputation: 1

// there is another method to check if the array contains items or not

if ( array.Count == 0) return;

Upvotes: -1

Waleed A.K.
Waleed A.K.

Reputation: 1656

You can use

if (array == null || array.Length == 0)

OR

if (!(array != null && array.Length != 0))

NOTE!!!!! To insure that c# will implement the short circuit correctly; you have to compare that the object with NULL before you go to the children compare of the object.

C# 7.0 and above

if(!(array?.Length != 0))

Upvotes: 15

Sylvain Perron
Sylvain Perron

Reputation: 413

Jon Skeet answered correctly. Just remember that the order of the test in the "IF" is important. Check for the null before the length. I also prefer to put the null on the left side of the equal which is a habit I got from Java that made the code more efficient and fast… I don't think it's important in a lot of application today, but it's a good practice! 

if (null == array || array.Length == 0)

Upvotes: 2

Saher Ahwal
Saher Ahwal

Reputation: 9237

check if the array is null first so you would avoid a null pointer exception

logic in any language: if array is null or is empty :do ....

Upvotes: 1

Brian Gideon
Brian Gideon

Reputation: 48959

As other have already suggested it is likely you are getting a NullReferenceException which can be avoided by first checking to see if the reference is null. However, you need to ask yourself whether that check is actually warranted. Would you be doing it because the reference really might be null and it being null has a special meaning in your code? Or would you be doing it to cover up a bug? The nature of the question leads me to believe it would be the latter. In which case you really need to examine the code in depth and figure out why that reference did not get initialized properly in the first place.

Upvotes: 3

Martin Milan
Martin Milan

Reputation: 6390

Your suggested test is fine, so long as the array is intialised...

Martin.

Upvotes: 0

Pharabus
Pharabus

Reputation: 6062

do you mean empty or null, two different things,

if the array is instantiated but empty, then length is correct, if it has not been instantiated then test vs null

Upvotes: 0

Arseny
Arseny

Reputation: 7361

This is the best way. Please note Array is an object in NET so you need to check for null before.

Upvotes: 2

Brian R. Bondy
Brian R. Bondy

Reputation: 347556

You can use .Length == 0 if the length is empty and the array exists, but are you sure it's not null?

Upvotes: 4

kemiller2002
kemiller2002

Reputation: 115538

Yeah, for safety I would probably do:

if(array == null || array.Length == 0)

Upvotes: 15

Jon Skeet
Jon Skeet

Reputation: 1503290

You can absolutely check an empty array's length. However, if you try to do that on a null reference you'll get an exception. I suspect that's what you're running into. You can cope with both though:

if (array == null || array.Length == 0)

If that isn't the cause, please give a short but complete program demonstrating the problem. If that was the cause, it's worth taking a moment to make sure you understand null references vs "empty" collections/strings/whatever.

Upvotes: 180

Related Questions