noam's blog.a.lish

spanish french italian german 12/11/2007 10:38:47 PM

Array.ForEach on Primitives

Java has a cute little static method built into the java.util.Arrays class called fill. As you might imagine it takes two parameters, namely the array that you want to fill, and the value you want to fill it with.

C# (2.0) does NOT have a fill method in it's static System.Array class, but the nifty world of generics provides us with an System.Array.ForEach method that, as described by MSDN:

Performs the specified action on each element of the specified array.

Well, I was wondering at first why I would use Array.ForEach (on either Arrays or generic Lists) at all. It turns out that using Array.ForEach (which is apparently always generic) is much faster that using a regular foreach statement.

From diditwith.net

while the ForEach method is much faster at iterating a List, this is not the case with arrays. An Array.ForEach method does exist for single-dimension arrays (or vectors) and it is actually slower than using foreach. The reason is that the compiler doesn't generate code that uses IEnumerator for foreach-loops over vectors. Instead, it generates special IL instructions that are designed for working with vectors. Thus, using foreach on a vector results in no method calls while Array.ForEach still requires one call to the supplied delegate per iteration.

Anyway, the reason I looked at using Array.ForEach was simply to set the value of a single dimensional boolean array to true (preset the values to true rather than false) without a for-loop or a standard foreach. The reason was not to optimize the speed of my application but simply to type less... Armed with anonymous delegates and the need for speed I wrote the following code:


bool[] array = new bool[10]; // will default all values to true

Array.ForEach(array, delegate( bool val ){ val = true; }); // should set all values to true

According to MSFT the action specified by the delegate should be applied to each element in the array. Can you guess what the outcome was?

It seems to me (and I might be wrong) that the Array.ForEach method actually creates a brand new array "under the sheets" and assigns it the values produced by performing the action. Since bool is a primitive and a struct (which happens to be immutable) it looks like the values of the newly created array (which should be a copy of the array passed to the ForEach method including the changes performed by the action delegate) are reset to the default value of the primitive type, namely false.

So, what does all this mean? It means that you can't use primitive arrays with the Array.ForEach method (which turns out to be slower than a regular foreach anyway...) which sucks.

One interesting discovery I had was that if you have a member in a reference type (class) that is a value type (struct, bool for example) and you use the Array.ForEach on that specific value type member, the changes do get applied and the newly created array stores actually shows the actions performed. Consider the following code:


class SomeClass

 {

        private bool _someMember;



        public bool SomeProperty

        {

            get { return _someMember; }

            set { _someMember = value; }

        }



        public SomeClass() { }

}



SomeClass[] sArray = new SomeClass[3];
sArray[0] = new SomeClass();

sArray[1] = new SomeClass();

sArray[2] = new SomeClass();



Array.ForEach(sArray, delegate(SomeClass s) { s.SomeProperty = true; });

The value of sArray[0].SomeProperty will be true after the Array.ForEach operates.
Maybe it's because it's too late or maybe it's because value type members get auto boxed in the context of a reference type... either way this is interesting stuff.

Post View

noam's blog.a.lish

Array.ForEach on Primitives

Search blog.a.lish

Step 1: Full Text Indexing

Step 2: Writing your SQL

Step 3: Writing your WebService

Step 4: Javascript and JSON

MIX 08 - Reviewed

Highs

Lows

My Favorite C# Features - Part 1: Generics

Introduction

Side Note

Favorite #1 - Generics

Short Comings

Boxing, Shadowing, Overriding and Overloading

Boxing

Shadowing

Overriding vs. Overloading

Overriding

Overloading

Syndication .NET 3.5 Style

Post Your Comment

Thanks for contacting me. I will get back to you as soon as I can.

Latest blog entries.

Shared Items

YUI

shirt.woot.com

Powered by Reditus Catalog | YUI