When I type the following code:
object[] objects = new object[] { };
Visual Studio tells me:
Avoid unnecessary zero-length allocations. Use
Array.Empty<object>()instead.
Are there any actual implications of using one over the other?
What is the reason for the warning?
You're creating an empty array. Which will always be empty, as you cannot change the capacity of the array instance (it just sounds weird to say you can't change its length, I don't know, why). Every time you do this, you create another instance of an array that can never be used. Doing this a lot may result in wasted GC and memory pressure, thus the warning.
Instead of creating empty arrays, just use Array.Empty<T>() as it suggests. This method returns an array using this static class
internal static class EmptyArray<T>
{
public readonly static T[] Value;
static EmptyArray()
{
EmptyArray<T>.Value = new T[0];
}
}
Since it's static and readonly, there's only ever one instance of this empty array in the entire app domain. An empty array is essentially immutable, so caching the instance isn't a problem. And it allows you to forego special-casing empty array creation in your algorithms if you find yourself eyeballing an elegant code path that is creating tons of empty arrays.
Enumerable.Empty<T>() is the Linq to Objects equivalent and is also useful for not wasting allocations for empty stuff.
static and readonly and it will only create one instance of the empty array...made me think about the disaster under the hood in the huge application my team has been working on. its a shame that visual studio does not provide a reason for its fix...!Using Array.Empty is useful to avoid unnecessary memory allocation. Refer the code from .NET Library itself below:
[Pure]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public static T[] Empty<T>()
{
Contract.Ensures(Contract.Result<T[]>() != null);
Contract.Ensures(Contract.Result<T[]>().Length == 0);
Contract.EndContractBlock();
return EmptyArray<T>.Value;
}
...
// Useful in number of places that return an empty byte array to avoid unnecessary memory allocation.
internal static class EmptyArray<T>
{
public static readonly T[] Value = new T[0];
}
Source: https://referencesource.microsoft.com/#mscorlib/system/array.cs,bc9fd1be0e4f4e70
Array.Empty()returns the same array, whereas your code will create multiple arrays. It might be to avoid unnecessary overhead.