Arrays in C#

long[ ] secondArray;
 	where: 
 	the rank specifiers = 1 (i.e. the blank in "[ ]") 
 	the array type is long 

int[,,]   firstArray;   // Array type: 3-D array of int
 	int[,]    arr1;         // Array type: 2-D array of int
 	long[,,]  arr3;         // Array type: 3-D array of long 
 	where: 
 	Rank specifiers = ",," and "," and ",," 

 	long[3,2,6] SecondArray; // Wrong!  Compile error 

int[] arr2 = new int[4];
 		MyClass[] mcArr = new MyClass[4];
 		where: 
 		no. elements = 4 (i.e. "[4]") 
 		Array creation expression = "new MyClass[4]" 

int[,,] arr3 = new int[3,6,2] ;
where: 
Lengths of the dimensions = "3,6,2" 

int[]intArr1 = new int[15];  // 1-D example
   	intArr1[2] = 10;             // Write to element 2 of the array.
   	int var1 = intArr1[2];       // Read from element 2 of the array.
 
   
  int[,] intArr2 = new int[5,10];  // 2-D example
   	intArr2[2,3]   = 7;              // Write to the array.
   	int var2 = intArr2[2,3];   	  // Read from the array. 

int[] myIntArray;          // Declare the array.
 
   	myIntArray = new int[4];   // Instantiate the array.
 
   	for( int i=0; i<4; i++ )   // Set the values.
      		myIntArray[i] = i*10;
 
   // Read and display the values of each element.
   for( int i=0; i<4; i++ )  
      Console.WriteLine("Value of element {0} = {1}", i, myIntArray[i]);
This code produces the following output: 
Value of element 0 is 0
Value of element 1 is 10
Value of element 2 is 20
Value of element 3 is 30 

int[] intArr = new int[4] { 10, 20, 30, 40 };
where: 
Initialization list = "10, 20, 30, 40" 
No connecting operator (i.e. the space in "[4] {") 

int[,] intArray2 = new int[3,2]
   { {10, 1}, {2, 10}, {11, 9} } ;
where: 
Initialization lists separated by commas 

(i.e. the commas outside the brackets "{10, 1}, {2, 10}, {11, 9}") 

int[,,] intArray = new int[4,3,2]
   {
    	{ {8, 6},  {5,  2}, {12, 9} },
    	{ {6, 4},  {13, 9}, {18, 4} },
    	{ {7, 2},  {1, 13}, {9,  3} },
    	{ {4, 6},  {3,  2}, {23, 8} }
   };
where: 
Initialization lists, nested and separated by commas 

int [] arr1 = new int[3] (10, 20, 30);
int [] arr1 =		 (10, 20, 30);
Both the above codes are equivalent.

int [,] arr = new int[2,3]  ({0,1,2},{10,11,12});
int [,] arr =		  ({0,1,2},{10,11,12});
Both the above codes are equivalent.

// Declare, create, and initialize the array.
int[,] arr = new int[2,3] {{0, 1, 2}, {10, 11, 12}};
 
// Print the values.
for( int i=0; i<2; i++ )
   for( int j=0; j<3; j++ )
      Console.WriteLine
         ("Element [{0}, {1}] is {2}", i, j, arr[i,j]);

Element [0, 0] is 0
Element [0, 1] is 1
Element [0, 2] is 2
Element [1, 0] is 10
Element [1, 1] is 11
Element [1, 2] is 12 

// Declare and create top-level array.
int[][] jagArr = new int[3][];
 
// Declare and create sub-arrays. 
...

int[][]   SomeArr;   // Rank = 2
int[][][] OtherArr;  // Rank = 3 
where: 
Rank specifiers = "[][]" and "[][][]" 
Array types = "int[][]" and "int[][][]" 
Array names = "SomeArr" and "OtherArr" 

int[][] jagArr = new int[3][];
where: 
Three sub-arrays (i.e. "[3]") 

int[][] jagArr = new int[3][4];   // Wrong! Compile error 
where: 
Allowed: "[3]" 
Not allowed: "[4]" 

// 1. Instantiate top level
int[][] Arr = new int[3][];                  
 
// 2. Instantiate sub-arrays
Arr[0] = new int[] {10, 20, 30};             
Arr[1] = new int[] {40, 50, 60, 70};         
Arr[2] = new int[] {80, 90, 100, 110, 120};

// An array of 2-D arrays
int[][,] Arr; 
 
// Instantiate an array of three 2-D arrays.        
Arr = new int[3][,];  
 
Arr[0] = new int[,] 
   { { 10, 20 }, { 100, 200 } };
Arr[1] = new int[,] 
   { { 30, 40, 50 }, { 300, 400, 500 } };
Arr[2] = new int[,] 
   { { 60, 70, 80, 90 }, { 600, 700, 800, 900 } };
 
       //Get length of dimension 0 of Arr
for (int i = 0; i < Arr.GetLength(0); i++)
{         //Get length of dimension 0 of Arr[ i ] 
   for (int j = 0; j < Arr[i].GetLength(0); j++)
   {         //Get length of dimension 1 of Arr[ i ] 
      for (int k = 0; k < Arr[i].GetLength(1); k++) {
          Console.WriteLine
                     ("[{0}][{1},{2}] = {3}", i, j, k, Arr[i][j, k]);
      }
      Console.WriteLine("");
   }
   Console.WriteLine("");
}

foreach( Type Identifier in ArrayName )
where: 
Iteration variable declaration = "Type Identifier" 
Statement is the entire line 

int[] arr1 = {10, 11, 12, 13};
 
foreach( int item in arr1 )
   Console.WriteLine("Item Value: {0}", item);
where: 
Iteration variable declaration = "int item" 
Iteration variable use = "item);" 

int[] arr1 = {10, 11, 12, 13};	
 
   foreach( int item in arr1 )
      item++;   // Wrong... 
      //Changing variable value is not allowed 

   class MyClass
   {
      public int MyField = 0;
   }
 
   class Program 
   {
      static void Main() 
      {
         MyClass[] mcArray = new MyClass[4];            // Create array
         for (int i = 0; i < 4; i++)
         {
            mcArray[i] = new MyClass();                 // Create class objects
            mcArray[i].MyField = i;                     // Set field
         }
         foreach (MyClass item in mcArray)
            item.MyField += 10;                         // Change the data.
 
         foreach (MyClass item in mcArray)
            Console.WriteLine("{0}", item.MyField);     // Read the changed data.
      }
   }

class Sample
   {
      static void Main()
      {
         int nTotal = 0;
         int[,] arr1 = { {10, 11}, {12, 13} };
 
         foreach( int element in arr1 )
         {
            nTotal += element;
            Console.WriteLine
               ("Element: {0}, Current Total: {1}", 
                  element, nTotal);
         }
      }
   }

Element: 10, Current Total: 10
Element: 11, Current Total: 21
Element: 12, Current Total: 33
Element: 13, Current Total: 46 

static void Main()
   {
      int nTotal = 0;
      int[][] arr1 = new int[2][];
      arr1[0] = new int[] { 10, 11 };
      arr1[1] = new int[] { 12, 13, 14 };
 
      // Process the top level.
      foreach (int[] array in arr1)       
      {
         Console.WriteLine("Starting new array\n");
         // Process the second level.
         foreach (int item in array)      
         {
            nTotal += item;
            Console.WriteLine
               (" Item: {0}, Current Total: {1}", 
                  item, nTotal);
         }
      }
   }

Starting new array Item: 10, Current Total: 10
Item: 11, Current Total: 21
Starting new array
Item: 12, Current Total: 33
Item: 13, Current Total: 46
Item: 14, Current Total: 60 

class A { ... }      // Base class
   class B : A { ... }  // Derived class
 
   class Program {
      static void Main() {
         // Two arrays of type A[]
         A[] AArray1 = new A[3];
         A[] AArray2 = new A[3];
 
         // Normal--assigning objects of type A 
         // to an array of type A
         AArray1[0] = new A(); AArray1[1] = 
           new A(); AArray1[2] = new A();
 
         // Covariant--assigning objects of type B 
         // to an array of type A
         AArray2[0] = new B(); AArray2[1] 
            = new B(); AArray2[2] = new B();
      }
   }

public static void PrintArray(int[] a)
   {
      foreach (int x in a) 
         Console.Write("{0}  ", x);
      Console.WriteLine("");
   }
 
   static void Main()
   {
      int[] arr = new int[] { 15, 20, 5, 25, 10 };
      PrintArray(arr);
      Array.Sort(arr);
      PrintArray(arr);
      Array.Reverse(arr);
      PrintArray(arr);
      
      Console.WriteLine
         ("Rank = {0}, Length = {1}",arr.Rank, arr.Length);
      Console.WriteLine("GetLength(0) = {0}",arr.GetLength(0));
      Console.WriteLine("GetType()    = {0}",arr.GetType());
   }

  int[] intArr1 = { 1, 2, 3 };
  int[] intArr2 = ( int[] ) intArr1.Clone();
where: 
Array type = "int[]" 
Returns object "intArr1.Clone()" 

  static void Main()
  {
     // Step 1
     int[] intArr1 = { 1, 2, 3 };                             
     // Step 2
     int[] intArr2 = (int[]) intArr1.Clone();
     // Step 3
     intArr2[0] = 100; intArr2[1] = 200; intArr2[2] = 300;
  }

class A
   {
      public int Value = 5;
   }
 
   class Program
   {
      static void Main()
      {
         A[] AArray1 = new A[3] { new A(), new A(), new A() }; //Step 1
         A[] AArray2 = (A[]) AArray1.Clone();                  //Step 2
 
         AArray2[0].Value = 100;
         AArray2[1].Value = 200;
         AArray2[2].Value = 300;                               //Step 3
      }
   }

int [] intArray;
 	// fixed array with 3 items
 	intArray = new int[3] {0, 1, 2};
 	// 2x2 varialbe length array
 	string[,] names = new string[,] { {"Rosy","Amy"}, {"Peter","Albert"} };
 	if(intArray.IsFixedSize)
 	{
 		Console.WriteLine("Array is fixed size");
 		Console.WriteLine("Size :" + intArray.Length.ToString());
 	}
 	if(names.IsFixedSize)
 	{
 		Console.WriteLine("Array is varialbe.");
 		Console.WriteLine("Size :" + names.Length.ToString());
 		Console.WriteLine("Rank :" + names.Rank.ToString());
 	} 

int [] intArray = new int[3] {0, 1, 2};
 	string[] names = new string[] {"Rosy", "Amy", "Peter", "Albert" };
 	object obj1 = "Peter";
 	object obj2 = 1;
 	int retVal = Array.BinarySearch(names, obj1);
 	if(retVal >=0)
 		Console.WriteLine("Item index " +retVal.ToString() );
 	else 
 		Console.WriteLine("Item not found");
 	retVal = Array.BinarySearch(intArray, obj2);
 	if(retVal >=0)
 		Console.WriteLine("Item index " +retVal.ToString() );
 	else
 		Console.WriteLine("Item not found"); 

string[] names = new string[] {"Rosy", "Amy", "Peter", "Albert" };
 	Console.WriteLine("Original Array:");
 	foreach (string str in names)
 	{
 		Console.WriteLine(str);
 	}
 	Console.WriteLine("Sorted Array:");
 	Array.Sort(names);
 	foreach (string str in names)
 	{
 		Console.WriteLine(str);
 	} 

Array names = Array.CreateInstance( typeof(String), 2, 4 );
 	names.SetValue( "Rosy", 0, 0 );
 	names.SetValue( "Amy", 0, 1 );
 	names.SetValue( "Peter", 0, 2 );
 	names.SetValue( "Albert", 0, 3 );
 	names.SetValue( "Mel", 1, 0 );
 	names.SetValue( "Mongee", 1, 1 );
 	names.SetValue( "Luma", 1, 2 );
 	names.SetValue( "Lara", 1, 3 );
 	int items1 = names.GetLength(0); 
 	int items2 = names.GetLength(1);
 	for ( int i =0; i < items1; i++ )
 		for ( int j = 0; j < items2; j++ )
 			Console.WriteLine(i.ToString() +"
,"+ j.ToString() +": " +names.GetValue( i, j ) ); 

string[] names = new string[] { "Rosy", "Amy", "Peter", "Albert" };
 	Console.WriteLine(names.GetLength (0).ToString());
 	Console.WriteLine(names.GetLowerBound (0).ToString());
 	Console.WriteLine(names.GetUpperBound (0).ToString()); 

	// Creates and initializes a new Array of type Int32.
 	Array oddArray = Array.CreateInsta
nce( Type.GetType("System.Int32"), 5 );
 	oddArray.SetValue (1, 0);
 	oddArray.SetValue (3, 1);
 	oddArray.SetValue (5, 2);
 	oddArray.SetValue (7, 3);
 	oddArray.SetValue (9, 4); 
 		// Creates and initializes a new Array of type Object.
 	Array objArray = Array.CreateInsta
nce( Type.GetType("System.Object"), 5 );
 	Array.Copy ( oddArray, oddArray.GetLowerBound(0), objArray, 
 	bjArray.GetLowerBound(0), 4 );
 	int items1 = objArray.GetUpperBound(0);
 	for ( int i =0; i < items1; i++ )
 		Console.WriteLine(objArray.GetValue(i).ToString());