Array ExamplesCreate and loop over a string array. Access array Length and get elements at indexes.
This page was last reviewed on Dec 3, 2022.
Array. Consider a C# program that stores the names of animals. Each name is a string—the animals can be stored in an array, and looped over and handled together.
Shows a string arrayShows an arrayShows a loopShows an array
Arrays are inside many things. An array has elements: these all have the same type. In .NET, arrays are a low-level way to hold objects together.
Initialize Array
String arrays. We begin with string arrays. Square brackets are used for all arrays. With the Length property, we get a cached value that is the element count.
Array Length
Version 1 This code creates a string array of 3 elements, and then assign strings to the array indexes (starting at 0).
Version 2 This string array is created with an array initializer expression. It is shorter and easier to type.
Version 3 Here we do not even declare the type of the array—the compiler can figure out the best type.
Version 4 Here we use the new keyword alone to create a string array. The string type is inferred.
Shows a string array
using System; class Program { static void Main() { // Version 1: create empty string array. // ... Assign into the array. string[] animals = new string[3]; animals[0] = "deer"; animals[1] = "moose"; animals[2] = "boars"; Console.WriteLine("ARRAY 1: " + animals.Length); // Version 2: use array initializer. string[] animals2 = new string[] { "deer", "moose", "boars" }; Console.WriteLine("ARRAY 2: " + animals2.Length); // Version 3: a shorter array initializer. string[] animals3 = { "deer", "moose", "boars" }; Console.WriteLine("ARRAY 3: " + animals3.Length); // Version 4: use new with no type name. string[] animals4 = new[] { "deer", "moose", "boars" }; Console.WriteLine("ARRAY 4: " + animals4.Length); } }
ARRAY 1: 3 ARRAY 2: 3 ARRAY 3: 3 ARRAY 4: 3
First and last. The first element is at index 0. And the last element is always at the array's length minus one. These elements can be accessed by using the indexer syntax.
Here We create a 4-element int array and populate it with a for-loop. Then we access element 0 and the last element.
Shows an array
using System; class Program { static void Main() { // Create an array. int[] array = new int[4]; // Populate the array. int value = 10; for (int i = 0; i < array.Length; i++) { array[i] = value++ * 10; } // Access first and last elements. int first = array[0]; int last = array[array.Length - 1]; Console.WriteLine($"FIRST: {first}"); Console.WriteLine($"LAST: {last}"); } }
FIRST: 100 LAST: 130
Foreach-loop. With this loop, no indexes are needed—the loop itself handles the indexes. This makes some code simpler. We use string interpolation to display the colors.
Tip For many programs, a foreach-loop is the clearest loop. If the logic does complicated things with indexes, use for.
Shows a loop
class Program { static void Main() { string[] array = { "red", "blue", "green" }; // Loop with foreach and write colors with string interpolation. foreach (string color in array) { System.Console.WriteLine($"Color = {color}"); } } }
Color = red Color = blue Color = green
For-loop. With this loop we use indexes. We have a start, and end, and increment expression. We must then access the element from the array in an expression within the loop.
Here We use a for-loop to iterate over a string array. The length of this array is 2, so the valid indexes are 0 and 1.
Info The variable "i" is set to each array index. We can access multiple array elements if needed in a for-loop.
Shows an array
using System; class Program { static void Main() { string[] array = new string[2]; array[0] = "Socrates"; array[1] = "Plato"; // Use for-loop on array. for (int i = 0; i < array.Length; i++) { // Get element, and print index and element value. string element = array[i]; Console.WriteLine("INDEX: {0}, VALUE: {1}", i, element); } } }
INDEX: 0, VALUE: Socrates INDEX: 1, VALUE: Plato
Int array, parameter. In structural programming we pass arrays as arguments to methods. The entire contents of the array are not copied—just the small reference.
Step 1 We create an int array of 3 integer elements—these are 3 negative integers.
Step 2 We pass a reference to the array (this is like an integer itself) to the method. Only the small reference itself is copied.
Step 3 This method receives a reference to the int array. It accesses the array and returns a value based on the first element.
using System; class Program { static void Main() { // Step 1: create 3-element array. int[] array = { -5, -6, -7 }; // Step 2: pass array reference to method. int result = MultiplyFirstElement(array); Console.WriteLine("FIRST ELEMENT MULTIPLIED: {0}", result); } static int MultiplyFirstElement(int[] array) { // Step 3: multiply the first element by 2 and return it. return array[0] * 2; } }
Return. We can return arrays from methods. A method might need to generate data for the array beforehand. Even random data could be returned this way.
GetTreeNameArray This method creates an array of 3 strings. More strings could be added. Any array initializer could be used.
Result The GetTreeNameArray() method is called, then joined into a string with string.Join. Then we write it to the screen.
using System; class Program { static void Main() { // Get tree array, and merge its results into a single string. string result = string.Join("; ", GetTreeNameArray()); // Write the tree names. Console.WriteLine("TREES: {0}", result); } static string[] GetTreeNameArray() { // Put 3 tree names in the array and return it. string[] array = { "Elm", "Oak", "Palm" }; return array; } }
TREES: Elm; Oak; Palm
Empty. Here is another syntax example. To create an empty string array, we can use an empty initializer expression. Or we can specify a 0 length.
using System; class Program { static void Main() { // Create string array with no elements. var empty1 = new string[] { }; Console.WriteLine(empty1.Length == 0); // This syntax has the same result. var empty2 = new string[0]; Console.WriteLine(empty2.Length == 0); } }
True True
IndexOf. Sometimes we want to search for a value in an array without using a for-loop. Consider the Array.IndexOf method. We can use this to search an array by value.
Argument 1 The first argument to Array.IndexOf is the array we are trying to search.
Argument 2 Here we specify the value we are trying to find in the array. We try find the index of the string "dog."
Warning IndexOf methods return -1 when no element is found. This value often must be checked in an if-statement.
using System; class Program { static void Main() { string[] array = { "cat", "dog", "bird", "fish" }; // The dog string is at index 1. int dogIndex = Array.IndexOf(array, "dog"); Console.WriteLine(dogIndex); // There is no monkey string in the array. // ... So IndexOf returns -1. int monkeyIndex = Array.IndexOf(array, "monkey"); Console.WriteLine(monkeyIndex); } }
1 -1
Class, indexer. We use arrays as fields (or properties) in classes. This is useful for storing values. In the Test class here, we have a string array field.
Elements The second part of the Test class is a property accessor. It provides a clean way for external code to access the internal array.
Indexer The final part of the Test class is called an Indexer. An indexer uses the this-keyword.
Note The indexer shown receives one parameter, an integer, and returns a value based on it.
class Program { static void Main() { // Create new instance with string array. Test test = new Test(); // Loop over elements with property. foreach (string element in test.Elements) { System.Console.WriteLine(element); } // Get first string element. System.Console.WriteLine(test[0]); } } public class Test { /// <summary> /// String array field instance. /// </summary> string[] _elements = { "one", "two", "three" }; /// <summary> /// String array property getter. /// </summary> public string[] Elements { get { return _elements; } } /// <summary> /// String array indexer. /// </summary> public string this[int index] { get { return _elements[index]; } } }
one two three one
Convert string arrays. It is possible to use built-in methods like Join and Split to convert a string array into a string, and back again. We can also use loops and StringBuilder.
Part A This example uses the Join method to combine the 3 string literals within the "elements" array.
Part B Finally we invoke Split to change our joined string back into a string array. The 2 string arrays are separate in memory.
Info For converting a string array into a string, we can use methods based on StringBuilder as well.
Convert Array, String
using System; class Program { static void Main() { string[] elements = { "cat", "dog", "fish" }; Console.WriteLine(elements[0]); // Part A: join strings into a single string. string joined = string.Join("|", elements); Console.WriteLine(joined); // Part B: separate joined strings with Split. string[] separated = joined.Split('|'); Console.WriteLine(separated[0]); } }
cat cat|dog|fish cat
String args. When a C# program is started, an optional string array is received from the operating system. This array, args, contains string arguments.
Main args
Start Try creating a shortcut in Windows to your C# executable. The args array is empty when no arguments are passed.
Here I added the argument string "hello world" to the command in the Windows shortcut. The two strings are received into the args array.
using System; class Program { static void Main(string[] args) { // ... Loop over arguments passed to this program. foreach (string value in args) { Console.WriteLine("Argument: {0}", value); } } }
Argument: hello Argument: world
Return ref, array element. With the ref keyword, we can return a reference to an array element. Here we have an int array. FirstElement returns a ref to the element at index 0.
Then We can assign the result of FirstElement to modify the array. The "codes" array is modified.
class Program { static ref int FirstElement(int[] array) { // Return ref to first element in array. return ref array[0]; } static void Main() { int[] codes = { 10, 20, 30 }; // Change first element to a new value. FirstElement(codes) = 60; // Display modified array. for (int i = 0; i < codes.Length; i++) { System.Console.WriteLine(codes[i]); } } }
60 20 30
Random array. We can use the Random NextBytes method to fill a byte array with random values. This does not require much custom code.
Part 1 We allocate an array of 4 bytes. We create a Random object, and then call NextBytes to fill up the array.
Part 2 We loop over the array of 4 random bytes, and print each value to the console.
using System; class Program { static void Main() { // Part 1: fill up a random byte array. byte[] array = new byte[4]; Random random = new Random(); random.NextBytes(array); // Part 2: display random array elements. foreach (byte value in array) { Console.WriteLine("RANDOM ELEMENT: {0}", value); } } }
IEnumerable. Arrays implement the IEnumerable interface for us automatically. This allows us to use arrays with LINQ extension methods, or pass arrays to methods that receive IEnumerable.
Tip IEnumerable is an important part of using the C# language—it makes developing programs much easier.
using System; using System.Collections.Generic; class Program { static void Display(IEnumerable<int> values) { // This method can be used with arrays or Lists. foreach (int value in values) { Console.WriteLine("IENUMERABLE: " + value); } } static void Main() { int[] ids = { 10400, 20800, 40100 }; // Pass the int array to the Display method, which accepts it as an IEnumerable. Display(ids); } }
Count extension. It is usually best to use the Length property for an element count. But the Count() extension method can be also used—here we use a lambda to only count certain elements.
Count Array Elements
using System; using System.Linq; class Program { static void Main() { var array = new int[] { 10, 20, 30 }; // Count elements greater than or equal to 20. int c = array.Count(x => x >= 20); Console.WriteLine(c); } }
Exceptions. We must only access elements in an array that are present in the array. The values can be anything, but the accesses must occur within the length of the array.
Tip To make array usage easier, you can add helper methods that prevent out-of-range accesses, but this will reduce performance.
using System; class Program { static void Main() { int[] test = { 10, 20, 30 }; Console.WriteLine(test[4]); } }
Unhandled Exception: System.IndexOutOfRangeException: Index was outside the bounds of the array. at Program.Main() in ...Program.cs:line 7
Array initializer error. When initializing an array with the var keyword, we must somewhere specify the type. Here we fix the error by using the "new" keyword with the int array type.
class Program { static void Main() { var array = { 5, 10 }; } }
error CS0820: Cannot initialize an implicitly-typed variable with an array initializer
class Program { static void Main() { var array = new int[] { 5, 10 }; } }
Benchmark, array caching. Creating an array has some cost—memory needs to be allocated, and it will need to be garbage-collected. We can optimize by caching arrays of the required sizes.
Version 1 This code reuses a static array of 0 elements each time, so less burden is placed on the runtime.
Version 2 Here we create a new 0-element array each time—the costs add up so this version is several times slower.
Result In 2021 (on .NET 5 for Linux) the cached array is many times faster—it helps to avoid creating arrays.
using System; using System.Diagnostics; class Program { const int _max = 1000000; static void Main() { // Version 1: use an empty array cache to avoid creating more than 1 array. var s1 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { if (Method1().Length != 0) { return; } } s1.Stop(); // Version 2: use a new array on each method call. var s2 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { if (Method2().Length != 0) { return; } } s2.Stop(); Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns")); Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns")); } static int[] _emptyArrayCache = new int[0]; static int[] Method1() { return _emptyArrayCache; // Return the cached array. } static int[] Method2() { return new int[0]; // Return a new array. } }
0.44 ns Cached array 11.11 ns New array
Multidimensional arrays. If your program is too simple, the C# language offers two-dimensional and multidimensional arrays. We also loop over 2D arrays. We use them with enumerators.
2D Array
Multidimensional Array
Jagged Arrays
Types. Arrays can be of any type. We can have (for example) bool, byte, int or char arrays. And all these arrays can also be used as static fields or properties. They can be null.
Bool Array
Byte Array
Char Array
Enum Array
Int Array
Object Array
Types, null. An array is a reference type (like a string) so it can be null. An array property often benefits from special-casing. We avoid returning null.
Null Array
Array Property
Combine. Suppose two arrays exist. We can combine them. Suppose a 2D array is present. We can flatten it into a single array. An array can operated upon in nearly any way imaginable.
Combine Arrays
Flatten Array
Methods. The Array type has many methods. To find things we use Array.Find with a predicate argument—FindAll finds many elements at once. And we can use BinarySearch on a sorted array.
Array Find
Array.IndexOf, LastIndexOf
A summary. Arrays in C# are memory regions that contain elements. They store string references, ints, bytes (or any type). Even if not used directly, they are a core part of all programs.
Dot Net Perls is a collection of tested code examples. Pages are continually updated to stay current, with code correctness a top priority.
Sam Allen is passionate about computer languages. In the past, his work has been recommended by Apple and Microsoft and he has studied computers at a selective university in the United States.
This page was last updated on Dec 3, 2022 (new example).
© 2007-2022 sam allen.
see site info on the changelog.