Explanation of ArrayList

The concept is a bit foggy because this loop is being done in a non-standard way. The idiomatic way of looping through an array / list in C# is to do so with a 0 starting index

for (int i = 0; i < items.Conut; i++) {
  String current = (String)items[i];
  Console.WriteLine("{0}. {1}", i + 1, current);
}

It seems a bit untrue for the code to be printing out the index of the item + 1 though (which is what the code does). The original author of this code seems to be more familiar with arrays which are indexed starting at 1 vs. the CLR / C# way of starting at 0.

1. (String) << this I believe is casting the value in the current ArrayList index to a String type?

(String) is casting, that is correct. As per this casting, yes ArrayList should contain any object of type String, otherwise there will be classcastexception.

1. What is the type of an ArrayList item? Is it just an object type?

Type of arraylist should be object of String.

Unlike a List where we define the Type of the objects in the List, ArrayLists are not generics.

It turns out that internally the ArrayList uses an array of type object to store its values. In our code, we must treat its values as if we declared a List<object>.

So, since the type is not defined past object, we must cast our values if we want to define them as a subclass of object (i.e. String in this case) because otherwise the compiler will treat it as the type object and we will not be able to perform String operations.

Note: In this case the cast may not be necessary because the object's ToString() method will implicitly be called, but if we want to perform other String operations (i.e. Substring) we will in fact need the cast.

Your analysis is correct.

The .NET frameworks 1.0 and 1.1 did not have generics. Because of this ArrayList dating from this time has items of object type. Since .NET 2.0 the generic List<T> is available, which made the old ArrayList obsolete in most cases.

Define your list as

var items = new List<string>();

Then you can drop the casting.

1. yes, it's a cast to string of the individual element in the arraylist reference by the i-1. this is assuming each element in the arraylist is a string. if any are not, an invalidcastexception will be thrown. if any elements are null, a nullreferenceexception will be thrown. i think you are asking the question because of uncertainty about the precedence of operations. without knowledge of precedence, you can be confused about whether you are casting an element in the arraylist to string or the arraylist itself (which would throw an invalidcastexception, were you to try to do that). as mentioned before, in this case it is unnecessary because tostring will be called by console.writeline.

2. yes, arraylist is a list of objects. as mentioned before, generics provide the ability to have lists of more specifically types items.

also worth nothing, starting the loop with an index of 1 is inconvenience. life is usually better if you start with 0 and use < for the loop continue condition rather than <=. better still if you don't need to use the index itself is to use a foreach loop.

I'll try to give strict explanation

1. a for loop is executed for each item in the ArrayList.

Loop continues to execute as long as condition i<=items.Count remains true.

1. the code executed is a method call to the Console's WriteLine method with a formal parameter.

Formal parameter is the one, that you declare in the signature of the method. The parameter that you pass to the method is called actual paramter.

1. {0} will be replaced with the current value of i in the for loop and {1} will be replaced 4. with the value in the ArrayList index of [i - 1].

{0} and {1} will be replaced with a value of ToString() call of parameters that are passed at the second and third position of the Console.Writeline

the reason for [i - 1] is because the index of an ArrayList begins at 0 and not 1.

Right

Here is what I am unsure about. 1. (String) << this I believe is casting the value in the current ArrayList index to a String type?

You are right. This is casting. Also, this cast is not necessary (Console.Writeline calls ToString() on its arguments). It will cause InvalidCastException, if the item in the arraylist is of type other than String.

1. What is the type of an ArrayList item? Is it just an object type?

Right