The following code creates an integer array and initializes the values. The second element of the array is then modified, which confirms the read-write capability of the array. Array.AsReadOnly is then called to wrap the array in a read-only collection. The ReadOnlyCollection type is found in the System.Collections.ObjectModel namespace. After displaying the elements of the read-only collection, the program attempts to modify an element of the collection. Because the collection is read-only, a compiler error occurs:

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            int[] zArray = {1,2,3,4};
            zArray[1] = 10;
            ReadOnlyCollection<int> roArray = Array.AsReadOnly(zArray);
            foreach (int number in roArray) {
                Console.WriteLine(number);
            }
            roArray[1] = 2;   //  compiler error
        }
    }
}

In the following code, the CommissionedEmployee class inherits from the Employee class. An array of commissioned employees is defined and then cloned with the Clone method. The result is cast to an array of Employees. Because Clone returns an object array, which is unspecific, you should cast to a specific array type. The cast from System.Object[] is not type-safe, and an incorrect cast could cause an exception later in the application. Polymorphism is employed in the subsequent foreach loop to call the correct Pay method on the derived instance:

using System;
using System.Collections.Generic;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            CommissionedEmployee[] salespeople =
                { new CommissionedEmployee("Bob"),
                  new CommissionedEmployee("Ted"),
                  new CommissionedEmployee("Sally") };

            Employee[] employees =
                (Employee[])salespeople.Clone();

            foreach(Employee person in
                    employees) {
                person.Pay();
            }
        }
    }

    public class Employee {
        public Employee(string name) {
            m_Name = name;
        }

        public virtual void Pay() {
            Console.WriteLine("Paying {0}", m_Name);
        }

        private string m_Name;
    }

    public class CommissionedEmployee : Employee {
        public CommissionedEmployee(string name) :
            base(name) {
        }

        public override void Pay() {
            base.Pay();
            Console.WriteLine("Paying commissions");
        }
    }
}

The following code demonstrates both the CreateInstance and SetValue methods. CreateInstance creates a new array at run time. This requires a degree of reflection, which is discussed in Chapter 13. This code first creates an array at run time using Activator.CreateInstance. The type of array is input from the command line. In the for loop, values are assigned to each element of the array. The values also are input from the command line. Activator.CreateInstance creates the values, which are then assigned to elements of the array. In the subsequent foreach loop, the elements of the array are enumerated. A member function is then invoked on the element. The name of the method is read from the command line:

using System;
using System.Reflection;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main(string[] argv) {
            Assembly executing=Assembly.GetExecutingAssembly();
            Type t = executing.GetType(argv[0]);
            Array zArray = Array.CreateInstance(
                t, argv.Length - 2);
            for (int count = 2; count < argv.Length; ++count) {
                System.Object obj = Activator.CreateInstance(t, new object[] {
                    argv[count]});
                zArray.SetValue(obj, count - 2);
            }
            foreach (object item in zArray) {
                MethodInfo m = t.GetMethod(argv[1]);
                m.Invoke(item, null);
            }
        }
    }

    public class ZClass {
        public ZClass(string info) {
            m_Info = "ZClass " + info;
        }

        public void ShowInfo() {
            Console.WriteLine(m_Info);
        }

        private string m_Info;
    }

    public class YClass {
        public YClass(string info) {
            m_Info = "YClass " + info;
        }

        public void ShowInfo() {
            Console.WriteLine(m_Info);
        }

        private string m_Info;
    }

    public class XClass {
        public XClass(string info) {
            m_Info = "XClass " + info;
        }

        public void ShowInfo() {
            Console.WriteLine(m_Info);
        }

        private string m_Info;
    }
}

A typical command line and results of the application are shown in Figure 5-2.

Figure 5-2. A command line and the results from running the application

Several System.Array methods use predicates, including the Exists, Find, FindAll, and FindLastIndex methods. Predicates are essentially delegates. The predicate function is called for each element of the array. An array predicate performs a test on some condition. If the condition is met, true is returned. If not, false is returned.

This is the syntax of the Predicate delegate:

delegate bool Predicate<T>(T obj)

Predicate methods are generic methods. The type parameter indicates the element type. The return value is the result of the test.

The following code finds all elements equal to 3. MethodA is the predicate method, which compares each value to 3. The Boolean value true (result == 0) is returned in MethodA if the element equals 3:

public static void Main() {
    int[] zArray = {1,2,3,1,2,3,1,2,3};
    Predicate<int> match = new Predicate<int>(MethodA<int>);
    int[] answers = Array.FindAll(zArray, match);
    foreach (int answer in answers) {
        Console.WriteLine(answer);
    }
}

public static bool MethodA<T>(T number) where T : IComparable {
    int result = number.CompareTo(3);
    return result == 0;
}

The Resize method resizes a one-dimensional array.

Here is sample code for resizing an array. The elements added, if any, to the array are initialized to a default value:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            int[] zArray = {1,2,3,4};
            Array.Resize<int>(ref zArray, 8);
            foreach (int number in zArray) {
                Console.WriteLine(number);
            }
        }
    }
}

The purpose of the SyncRoot object is to synchronize access to an array. Arrays are not thread-safe. As documented in Table 5-3, the IsSynchronized property always returns false for an array. When accessed from multiple threads, arrays are easily synchronized with the lock statement, where the SyncRoot object is the parameter.

In the following code, the array is a field in the Starter class. The DisplayForward and DisplayReverse methods list array elements in forward and reverse order, respectively. The functions are invoked in separate threads, where DisplayForward and DisplayReverse might be called at the same time. This overlapping execution and access to the array could cause incorrect output. The SyncLock property of the array field is used to prevent simultaneous access by the concurrent threads:

using System;
using System.Threading;

namespace Donis.CSharpBook {
    public class Starter {

        public static void Main() {
            Array.Sort(zArray);
            Thread t1 = new Thread(
                new ThreadStart(DisplayForward));
            Thread t2 = new Thread(
                new ThreadStart(DisplayReverse));
            t1.Start();
            t2.Start();
        }

        private static int[] zArray = {1,5,4,2,4,2,9,8};

        public static void DisplayForward() {
            lock(zArray.SyncRoot) {
                Console.Write("
Forward: ");
                foreach (int number in zArray) {
                    Console.Write(number);
                }
            }
        }

        public static void DisplayReverse() {
            lock(zArray.SyncRoot) {
                Array.Reverse(zArray);
                Console.Write("
Reverse: ");
                foreach (int number in zArray) {
                    Console.Write(number);
                }
                Array.Reverse(zArray);
            }
        }
    }
}

The following System.Array methods compare elements to a value or another element:

As such, the elements must be instances of comparable types. Comparable types implement the IComparable interface, which requires the implementation of the CompareTo method.

The IComparable.CompareTo method returns zero when the current and target instances are equal. If the current instance is less than the target, a negative value is returned, and if the current instance is greater than the target, a positive value is returned. The previously listed System.Array methods call IComparable.CompareTo to perform the necessary comparisons for sorting, retrieving elements on value, or otherwise accessing the array in an ordered manner.

A run-time error occurs in the following code when Array.Sort is called. Why? The XClass instances, which are the array elements, do not implement the IComparable interface:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            XClass[] objs = {new XClass(5), new XClass(10),
                new XClass(1)};
            Array.Sort(objs);
        }
    }

    public class XClass {
        public XClass(int data) {
            propNumber = data;
        }

        private int propNumber;
        public int Number {
            get {
                return propNumber;
            }
        }
    }
}

Here is the proper code, where the XClass implements the IComparable interface. This program runs successfully:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            XClass[] objs = { new XClass(5), new XClass(10),
                new XClass(1) };
            Array.Sort(objs);
            foreach (XClass obj in objs) {
                Console.WriteLine(obj.Number);
            }
        }
    }

    public class XClass : IComparable {
        public XClass(int data) {
            propNumber = data;
        }

        private int propNumber;
        public int Number {
            get {
                return propNumber;
            }
        }

        public int CompareTo(object obj) {
            XClass comp = (XClass) obj;
            if (this.Number == comp.Number) {
                return 0;
            }
            if (this.Number < comp.Number) {
                return -1;
            }
            return 1;
        }
    }
}

Many of the methods and properties of System.Array are required from interfaces that System.Array inherits. The following section lists those interfaces and methods.

The ICollection interface defines behavior to return the count of elements, copy a collection, and provide synchronization support for collections. The members of the ICollection interface are as follows:

System.Array also implements the ICloneable interface. This is the interface for duplicating an object, including an array. The only member of this interface is the Clone method.

System.Array implements the IEnumerable interface to support enumeration. IEnumerable.GetEnumerator is the sole member of this interface. GetEnumerator returns an enumerator object that implements the IEnumerator interface. The enumerator provides a consistent interface for enumerating any collection. Enumerable objects are also convenient. For example, the foreach statement can enumerate the elements of an array easier than the more generic for statement can. Incorrectly iterating an array is a common error in programs. The foreach statement makes array iteration trivial.

Chapter 8, will focus more on enumerators.

Here is sample code that enumerates an array using an enumerator object:

using System;
using System.Collections;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            int[] numbers = { 1, 2, 3, 4, 5 };
            IEnumerator e = numbers.GetEnumerator();

            // first iteration
            while (e.MoveNext()) {
                Console.WriteLine(e.Current);
            }

            // second iteration
            foreach (int number in numbers) {
                Console.WriteLine(number);
            }
        }
    }
}

System.Array type implements the IList interface. However, only part of this implementation is publicly available. Some members of the IList interface are contrary to the array paradigm, such as the RemoveAt method. Arrays are immutable. You cannot remove elements from the middle of an array. For this reason, RemoveAt is implemented privately. Other methods of the IList interface are implemented privately for similar reasons.

Table 5-4 lists the IList interface and whether the implementation in System.Array is public or private.

Indexers are properties with the outward appearance of an array. They allow you to access an object as an array. For types that contain a collection as a member, indexers are helpful because they allow you to provide safe and convenient access to the internal collection. The backing data of an indexer is typically an array or a collection. The indexer defines a set and get method, which is common for all properties. However, the get and set method of an indexer are for the this reference. Indexers are considered a default property because the indexer is a nameless property. Internally, the compiler uses the get_Item and set_Item method to support indexers.

Here are some of the similarities and differences between indexers and standard properties:

Using an indexer is functionally similar to using an array. However, there are a couple of important differences:

Here is the syntax of an indexer:

Except for static accessibility, indexers have the same accessibility and modifiers as a normal property. Indexers cannot be static. At declaration, the parameters of an indexer are a comma-delimited list of indexes. The list includes the type and name of each parameter. Indexer indices can be nonintegral types, such as a string type or any reference type.

The following is example code for indexers. The Names type is a wrapper of an array of names and ages. The indexer for the Names type will provide access to this array. In this example, the indexer is read-only providing only read access to the internal array. The indexer in the example has a single parameter, which is an integer index. Flexibility is one of the benefits of indexers versus standard arrays. With a single indice, the indexer returns both the name and age of the employee. This task would be harder to accomplish with an array:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            Names obj = new Names();
            Console.WriteLine(obj[1]);
        }
    }

    public class Names {
        object[,] _names = {
             { "Valerie", 27 },
             { "Ben", 35 },
             { "Donis", 29 } };

        public object this[int index] {
            get {
                return _names[index,0] + " " + _names[index,1];
            }
        }
    }
}

Indexers can be overloaded based on the parameter list. Overloaded indexers should have a varying number of parameters, varying parameter types, or both. The following code overloads an indexer twice. The first indexer is read-only and returns the name and age information. The second indexer is a read-write property that sets and gets the age of a person. This indexer, which has a string parameter, demonstrates a non-numerical index:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            Names obj = new Names();
            obj["Donis"] = 42;
            Console.WriteLine(obj["Donis"]);
        }
    }

    public class Names {
        object [,] _names = {
             { "Valerie", 27 },
             { "Ben", 35 },
             { "Donis", 29 } };

        public object this[int index] {
            get {
                return _names[index,0] + " " + _names[index,1];
            }
        }

        public object this[string sIndex] {

            get {
                int index = FindName(sIndex);
                return _names[index, 1];
            }
            set {
                int index = FindName(sIndex);
                _names[index, 1] = value;
            }
        }

        private int FindName(string sIndex) {
            for (int index = 0; index < _names.GetLength(0);
                    ++index) {
                if ((string)(_names[index,0]) == sIndex) {
                    return index;
                }
            }
            throw new Exception("Name not found");
        }
    }
}

Arrays used as a function argument are passed by reference. This is more efficient than placing a potentially large number of elements on the stack. As a reference type, the array state can be changed in the called method. Arrays used as parameters are normal parameters and support the regular assortment of modifiers. Of course, the array instance must be convertible to the type of array parameter.

In the following code, ZClass has two static methods, which both have an array parameter. The ListArray method has a System.Array parameter, which accepts any array as an argument. This allows the ListArray method to be called in Main with different types of array arguments. The Total method also has an array argument, which is an integer array. This means the argument must be an integer array:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            int[] zArray = { 10,9,8,7,6,5,4,3,2,1 };
            string[] xArray = { "a", "b", "c", "d" };
            Console.WriteLine("List Numbers");
            ZClass.ListArray(zArray);
            Console.WriteLine("List Letters");
            ZClass.ListArray(xArray);
            Console.WriteLine("Total Numbers");
            ZClass.Total(zArray);
        }
    }

    public class ZClass {

        public static void ListArray(Array a) {
            foreach( object element in a) {
                Console.WriteLine(element);
            }
        }

        public static void Total(int[] iArray) {
            int total = 0;
            foreach (int number in iArray) {
                total += number;
            }
            Console.WriteLine(total);
        }
    }
}

Arrays also can be returned from functions, which is one way to return more than a single item from a function. You can return multiple items as elements of an array. Arrays are not returned on the stack. Returning an array gives the calling function a reference to the array, which provides direct access to the array values.