This time around, I’ll start explaining how to create and handle arrays in C#. It has some similarities to RPG, which will allow you to learn new and interesting C# concepts!

C# arrays are somewhat similar to their RPG counterparts, at least in concept. You’ll see that these similarities will allow you to get a grasp on some new concepts, namely the FOR loop.

Let’s start by creating a new console application, following the steps I described on a previous TechTip of this series. Let’s name this new console application “IntroducingArrays.” Inside the curly braces that delimit the Main method, let’s create your very first C# array, in this particular case an array of integers, and name it myFirstIntArray. Type, or copy and paste, the following line of code:

int[] myFirstIntArray = new int[10];

Note that the left side of the variable definition—int[] myFirstIntArray—is very similar to a “regular” integer variable definition, as discussed here. However, there’s a pair of square brackets right after the data type identifier—int in this case—which is what tells the compiler that I’m defining an array.

Now let’s look at the right side of the definition: new int[10]. An array, in most programming languages, is defined with a fixed length. For instance, when defining an RPG array, you use the DIM keyword, followed by the dimension (or length) of the array. That definition is “final” in the sense that you can’t change it, neither after the original definition nor at run-time. C# arrays are similar, and that’s why the right side of the variable definition contains the int[10]: I have to specify the data type and length of the array. In this case, I’m creating a 10-position array, just like I would use DIM(10) to do the same on RPG. There’s an important difference: Just like the string data type I explained in the previous TechTip, arrays use a zero-based index, meaning that the first position of the array has an index of zero, not one. Here’s an example to make this clear. Let’s say I want to assign 1 to the first position of the myFirstIntArray array. Here’s how it’s done:

// assigning 1 to the first position of the array

myFirstIntArray[0] = 1;

Introducing the FOR Loop

Naturally, I could repeat the line of code above nine more times to assign the digits 2 to 10 to the remaining positions of the array. But, being the seasoned programmer I suspect you are, you know there’s a better way: using a loop. Specifically, using a FOR loop, because we know the length of the array, which is the same as saying that the number of iterations necessary to perform the task at hand is known in advance.

In RPG, I’d write something like FOR index = 1 TO 9 to define the loop and assign the values using the index variable to indicate the position to fill, assuming that the variable was defined somewhere on the code, before the looping operation. In C#, the syntax is a bit different because it contains three things:

• The variable definition, which includes the initial value
• The stop condition, which keeps the loop going until the condition evaluates to False
• And finally, the increment value, because unlike its RPG counterpart, there’s no default value

These three things have nice, formal names and characteristics that I’ll discuss in a moment, but first let’s see where these three components fit on the C# FOR loop syntax by creating a loop that starts in 1 and stops when it reaches 9:

// looping through the array, starting on position 1

for (int index = 1; index <= 9; index++)

{

      myFirstIntArray[index] = index + 1;

}

Note that the three components of the loop definition are contained between parentheses and separated by a semicolon. What’s going on inside? Well, the first instruction—int index = 1—formally known as the initializer, is defining a local variable named index and assigning it an initial value of 1. Note that index only “exists” inside the loop. I’ll discuss variable scope later, but this is roughly the concept of a local variable. Then comes the condition (yup, no funny/formal name here, just condition)—index <= 9—which states that the loop will go on until index reaches 9. Finally, the iterator—index++—simply increases the index value by 1 on each loop (or iteration).

Even though the syntax is different from its RPG counterpart, C#’s FOR loop is conceptually similar: It executes a block of code a certain number of times.

It should be obvious by now, but I’ll mention it anyway: after the closing parenthesis come the curly braces that delimit the block of code that will be executed while the loop lasts. In this case, I’m assigning the index value plus 1 to the index position of the array. With the previous assignment operation and this simple FOR loop, I’ve assigned the numbers from 1 to 10 to the 10 positions of the array.

Now I have a question for you: If I want to access the value of the third position, I just have to write myFirstIntArray[3], right?

Wrong, because C# arrays (like C# strings) use zero-based indexes, which means that the third position is represented by the number 2. The following code outputs the content of the third position of the array, which, as you’d expect, contains the number 3:

// displaying the value of the array's third position

Console.WriteLine(myFirstIntArray[2]);

// ReadKey is used to "pause" the display until a key is pressed

Console.ReadKey();

If I want to display the contents of the whole array instead of a single element, I can use a FOR loop again, slightly tweaked to start of the first position of the array and stop at the last. As you probably know from previous TechTips, I’m not a big fan of hardcoding. Representing the last position of the array with the digit 9 makes my skin crawl, so let’s use softcoding instead. The Length array property contains the actual length of the array (10 in this case) and is very useful to avoid hardcoding and indexOutOfBound errors. In the next TechTip, I’ll talk about other array properties and methods. For now, here’s how to use the Length property in our tweaked FOR loop:

// looping through the array, to output the value of each element

for (int index = 0; index < myFirstIntArray.Length; index++)

{

Console.WriteLine(myFirstIntArray[index]);

}

Arrays have more interesting properties and methods that I’ll continue to discuss in the next TechTip. Until then, here’s the complete code of this program for your analysis and enjoyment:

using System;

namespace IntroducingArrays

{

    class Program

    {

        static void Main(string[] args)

        {

            int[] myFirstIntArray = new int[10];

            // assigining 1 to the first position of the array

            myFirstIntArray[0] = 1;

            // looping through the array,

// starting on position 1

            for (int index = 1; index <= 9; index++)

            {

                myFirstIntArray[index] = index + 1;

            }

            // displaying the value of the array's third position

            Console.WriteLine(myFirstIntArray[2]);

            // ReadKey is used to "pause" the display

            // until a key is pressed

            Console.ReadKey();

            // looping through the array,

// to output the value of each element

            for (int index = 0; index < myFirstIntArray.Length; index++)

            {

                Console.WriteLine(myFirstIntArray[index]);

            }

            // ReadKey is used to "pause" the display

            // until a key is pressed

            Console.ReadKey();

        }

    }

}

Rafael Victória-Pereira has more than 20 years of IBM i experience as a programmer, analyst, and manager. Over that period, he has been an active voice in the IBM i community, encouraging and helping programmers transition to ILE and free-format RPG. Rafael has written more than 100 technical articles about topics ranging from interfaces (the topic for his first book, Flexible Input, Dazzling Output with IBM i) to modern RPG and SQL in his popular RPG Academy and SQL 101 series on mcpressonline.com and in his books Evolve Your RPG Coding and SQL for IBM i: A Database Modernization Guide. Rafael writes in an easy-to-read, practical style that is highly popular with his audience of IBM technology professionals.

Rafael is the Deputy IT Director - Infrastructures and Services at the Luis Simões Group in Portugal. His areas of expertise include programming in the IBM i native languages (RPG, CL, and DB2 SQL) and in "modern" programming languages, such as Java, C#, and Python, as well as project management and consultancy.

---

MC Press books written by Rafael Victória-Pereira available now on the MC Press Bookstore.

		Evolve Your RPG Coding: Move from OPM to ILE...and Beyond Transition to modern RPG programming with this step-by-step guide through ILE and free-format RPG, SQL, and modernization techniques. List Price $79.95 Now On Sale
		Flexible Input, Dazzling Output with IBM i Uncover easier, more flexible ways to get data into your system, plus some methods for exporting and presenting the vital business data it contains. List Price $79.95 Now On Sale
		SQL for IBM i: A Database Modernization Guide Learn how to use SQL’s capabilities to modernize and enhance your IBM i database. List Price $79.95 Now On Sale

Also Read

The Power of Writing Code in a Low-Code Solution

TechTip: Let’s Have a Date, Part 2

Going off the Rails