C# 0 The Complete Reference

var

with

[ ]

. Furthermore, the array must be initialized because it is the type of the initializers 

that determine the element type of the array. All of the initializers must be of the same or 

compatible type. Here is an example of an implicitly typed array:

var vals = new[] { 1, 2, 3, 4, 5 };

This creates an array of 

int

 that is five elements long. A reference to that array is assigned to 

vals

. Thus, the type of 

vals

 is “array of 

int”

 and it has five elements. Again, notice that 

var

 is 

not followed by 

[ ]

. Also, even though the array is being initialized, you must include 

new[ ]

.

It’s not optional in this context.

Here is another example. It creates a two-dimensional array of 

double

:

var vals = new[,] { {1.1, 2.2}, {3.3, 4.4},{ 5.5, 6.6} };

In this case, 

vals

 has the dimensions 2×3.

www.freepdf-books.com

---

152

 

P a r t   I :  

T h e   C #   L a n g u a g e

You can also declare implicitly typed jagged arrays. For example, consider the following 

program:

// Demonstrate an implicitly typed jagged array.

using System;

class Jagged {

  static void Main() {

    var jagged = new[] {

       new[] { 1, 2, 3, 4 },

       new[] { 9, 8, 7 },

       new[] { 11, 12, 13, 14, 15 }

    };

    for(int j = 0; j < jagged.Length; j++) {

      for(int i=0; i < jagged[j].Length; i++)

        Console.Write(jagged[j][i] + " ");

      Console.WriteLine();

    }

  }

}

The program produces the following output:

1 2 3 4

9 8 7

11 12 13 14 15

Pay special attention to the declaration of 

jagged

:

var jagged = new[] {

   new[] { 1, 2, 3, 4 },

   new[] { 9, 8, 7 },

   new[] { 11, 12, 13, 14, 15 }

};

Notice how 

new[ ]

 is used in two ways. First, it creates the array of arrays. Second, it creates 

each individual array, based on the number and type of initializers. As you would expect, 

all of the initializers in the individual arrays must be of the same type. The same general 

approach used to declare 

jagged

 can be used to declare any implicitly typed jagged array.

As mentioned, implicitly typed arrays are most applicable to LINQ-based queries. They 

are not meant for general use. In most cases, you should use explicitly typed arrays.

The foreach Loop

In Chapter 5, it was mentioned that C# defines a loop called 

foreach

, but a discussion of 

that statement was deferred until later. The time for that discussion has now come.

The

foreach

 loop is used to cycle through the elements of a 

collection.

 A collection is a 

group of objects. C# defines several types of collections, of which one is an array. The general 

form of 

foreach

 is shown here:

www.freepdf-books.com

---