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.
Your suggested test is fine, so long as the array is intialised...
Martin.
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))
This is the best way. Please note Array is an object in NET so you need to check for null before.
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.
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 ....
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 == 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 != 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…
}
}
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 ;-).
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
You can use .Length == 0 if the length is empty and the array exists, but are you sure it's not null?
Yeah, for safety I would probably do:
if(array == null || array.Length == 0)
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)
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
}
Source: Stackoverflow.com