CODEWITHSUNDEEP
c#.netarrays
Matias Cicero
Matias Cicero

Reputation: 26281

Array.Initialize - Why does this method exist?

I stumbled upon a method today. I'm talking about: Array.Initialize().

According to the documentation:

This method is designed to help compilers support value-type arrays; most users do not need this method.

How does this method is responsible for making the compiler support value types? As far as I'm concerned this method just:

Initializes every element of the value-type Array by calling the default constructor of the value type.

Also, why is it public? I don't see myself with the need of calling this method, compilers already initialize arrays when created, so manually calling this method will be redundant and useless.

Even when my intention would be resetting the values of an array, I would still not call it, I would create a new one. array = new int[].

So, it seems that this method exist just for the sake of the compiler. Why is this? Can anyone give me some more details?

Upvotes: 24

Views: 1468

Answers (4)

Jon Hanna
Jon Hanna

Reputation: 113292

It's worth noting that the rules of .NET are different to the rules of C#.

There are things we can do in .NET that we can't do in C#, generally either because the code is not verifiable (ref return types for example) or because they could introduce some confusion.

In C# structs cannot have a defined parameterless constructor, and calling new SomeValueType() works by creating a zero-filled portion of memory (all fields therefore being 0 for numeric types, null for reference types, and the result of this same rule again for other value-types).

In .NET you can have a parameterless constructor on a value type.

It's probably a bad idea to do so. For one thing the rules about just when it is called and just when the memory of the value is zero-filled, and what happens upon assignment in different cases aren't entirely simple (e.g. new SomeValueType() will call it but new T() in a generic method where T is SomeValueType will not!). Life is simpler if the result of new SomeValueType() will always be zero-filling. That no doubt influenced the design of C# not allowing this even though .NET does.

For this reason, Array.Initialize() will never make sense on new arrays of any type that was written in C#, because calling the constructor and zero-filling is the same thing.

But by the same token, it's possible for a type to be written in another .NET language (at the very least, you can do it in CIL) that does have a parameterless constructor that actually has an effect. And for that reason its possible that a compiler for such a language would want its equivalent to new SomeValueType[3] to call that constructor on all the types in the array. And therefore it's sensible to have a method in the framework that allows such a fill to be done, so that a compiler for such a language can make use of it.

Also, why is it public?

So it can be called by code produced by such a hypothetical constructor even in a context where security restrictions prevent it from calling private methods of another assembly.

Upvotes: 13

whoisj
whoisj

Reputation: 388

You can see the expected use in the test code:

https://github.com/dotnet/coreclr/blob/3015ff7afb4936a1c5c5856daa4e3482e6b390a9/tests/src/CoreMangLib/cti/system/array/arrayinitialize.cs

Basically, it sets an array of non-intrinsic value-types back to their default(T) state.

It does not seem like an amazingly useful tool, but I can see how it could be useful for zero'ing out arrays of non-intrinsic value data.

Upvotes: 0

IS4
IS4

Reputation: 13207

Based on the CLR source, the method traverses each index of the array and initializes the value type on that index by calling the default constructor, similar to initobj IL instruction (I wonder what happens when the constructor throws an exception, though). The method is public because calling a private method directly from IL would make it a bit unverifiable.

Today's C# compilers do not initialize each element of the array when creating it, simply "set" each index to the default value of the type. C# 6 introduces implementing default constructors for value types (which were already supported by CLR), so this is needed for languages with different array creation semantics.

Upvotes: 0

David
David

Reputation: 306

For me myself it looks like the Initialize() method runs through the array and recreates the Value Types within. So with a new array you get a new empty array and so you get with Array.Clear(), but with Array.Initialize() you get an Array full of fresh created Value Types (types and length based on the old array).

And that should be all of the difference.

Upvotes: 1

Related Questions