Array

In computer memory every byte is an array element. Abstractions translate these bytes into objects and give them meaning. Arrays are a foundational type. They are the basis of more usable collections. They use a special syntax form.
An array is a fixed collection of same-type data that are stored contiguously and that are accessible by an index
Arrays are the simplest and most common type of structured data.
Example
As an introduction, let's look at a program that allocates and initializes an integer array of three elements. Please notice how the elements can be assigned to or read from using the same syntax. The array is zero-based.
Program that uses an array [C#]
using System;
class Program
{
static void Main()
{
// Use an array. int[] values = new int[3]; values[0] = 5; values[1] = values[0] * 2; values[2] = values[1] * 2;
foreach (int value in values)
{
Console.WriteLine(value);
}
}
}
Output
5 10 20
Example 2
There is another way to allocate an array and fill it with values. You can use the curly brackets { } to assign element values in one line. The length of the array is automatically determined when you compile your program.
Program that uses another array syntax [C#]
using System;
class Program {
static void Main()
{
// Create an array of three ints.
int[] array = { 10, 30, 50 };
foreach (int value in array)
{
Console.WriteLine(value);
}
}
}
Output
10
30
50
For-loop Sometimes it is useful to use the for-loop construct instead of the foreach-loop on your arrays. This is because it allows you to access the index value (i) as well as the element value in the array.
For example, you could add logic that performs a different computation on the second element (where i == 1). The Length property is necessary here. The for-loop is also helpful for comparing adjacent elements.
Program that uses for loop on int array [C#]
using System;
class Program
{ static void Main()
{
// Create an array of three ints. int[] array = { 100, 300, 500 };
// Use for loop.
for (int i = 0; i < array.Length; i++) { Console.WriteLine(array[i]); } } }
Output
100 300 500
String array Arrays are not just for value types such as ints. They can be used for strings and other object references (classes). An interesting point here is that the strings themselves are not stored in the array.
Rather: Just a reference to the string data is in the array. The strings are typically stored in the managed heap. String Array
Program that creates string array [C#]
using System;
class Program
{ static void Main()
{
// Create string array of four references.
string[] array = new string[4]; array[0] = "DOT"; array[1] = "NET"; array[2] = "PERLS"; array[3] = 2010.ToString();
// Display. foreach (string value in array) { Console.WriteLine(value); } } }
Output
DOT NET PERLS 2010
Parameter How can you pass an array to another method to use there? This example program shows the correct syntax for passing an int array. Please note that the entire contents of the array are not copied.
Instead: Just a reference to the array is copied when the new method is put on the call stack.
Program that receives array parameter [C#]
using System;
class Program {
static void Main()
{ // Three-element array.
int[] array = { -5, -6, -7 };
// Pass array to Method. Console.WriteLine(Method(array)); }
/// <summary> /// Receive array parameter. /// </summary> static int Method(int[] array) {
return array[0] * 2;
}
}
Output
-10
Return array You can return arrays from methods. In this example program, we allocate a two-element array of strings in Method(). Then, after assigning its elements, we return it. In the Main method, the results are displayed.
Program that returns array reference [C#]
using System;
class Program {
static void Main()
{ // Write array from Method. Console.WriteLine(string.Join(" ", Method()));
}
/// <summary> /// Return an array. /// </summary>
static string[] Method() {
string[] array = new string[2]; array[0] = "THANK";
array[1] = "YOU"; return array;
}
}
Output
THANK YOU
2D arrays The C# language offers two-dimensional and multidimensional arrays. These articles provide examples of 2D arrays and also a three-dimensional array. You can loop over 2D arrays or even use them with enumerators. 2D Array 2D Array Loop Multidimensional Array Jagged arrays Jagged arrays are arrays of arrays. They can be faster or slower than 2D arrays based on how you use them. They can also require more or less memory, depending on the shape of your data. Jagged Array Jagged Array Memory First element The first element is at index 0. It can be accessed by using the indexer syntax, which has square brackets. We first ensure that it can be accessed in the array region. We usually test against null and often test the Length.
Program that gets first array element [C#]
using System;
class Program {
static void Main() {
int[] array = new int[2];
// Create an array.
array[0] = 10; array[1] = 20;
Test(array); Test(null); // No output Test(new int[0]); // No output }
static void Test(int[] array) {
if (array != null && array.Length > 0)
{
int first = array[0]; Console.WriteLine(first);
}
} }
Output
10
Last element Next, the last element's offset is equal to the array Length minus one. In many cases you need to remember to check against null and that the Length is greater than zero before accessing the last element.
Program that gets last array element [C#]
using System;
class Program {
static void Main()
{
string[] arr = new string[]
{
"cat", "dog", "panther", "tiger" }; // Get the last string element. Console.WriteLine(arr[arr.Length - 1]);
}
}
Output
tiger
Types We present examples of arrays used with different types available in the C# language. Additionally we see examples of arrays that are static or null. These examples illustrate specific types of arrays. Bool Array Byte Array Char Array Enum Array Int Array Null Array Static Array Array Property Random Byte Array Operations What should you do if you need to combine, flatten or initialize arrays in a certain way? These tutorials can help you out. They provide examples for these requirements. Please also see the Buffer type. Initialize Combine Flatten Initialize Array Methods The Array type introduces many different methods you can use to manipulate or test arrays and their elements. We cover specific methods and provide concrete examples for their usage. Array.AsReadOnly Array.BinarySearch Array.Clear Array.ConstrainedCopy Array.ConvertAll Array.Copy Array.CreateInstance Array.Exists Array.Find Array.FindIndex Array.ForEach Array.IndexOf Array.LastIndexOf Array.Resize Array.Reverse Array.Sort Array. TrueForAll Properties Continuing on, we examine properties on the Array type. The most commonly used property on arrays is the Length property, which is covered in detail here. We also describe the other boolean properties. Array Length Property Count Array Elements Array IsFixedSize, IsReadOnly and IsSynchronized ArraySegment When we use arrays, we often want to read or write into the elements with indexes. The ArraySegment type is an abstraction for a part of an array. With the properties of ArraySegment, we also access the original array. ArraySegment Buffer Buffer efficiently deals with bytes in large arrays. This program uses the Buffer.BlockCopy method. We copy the first 12 bytes (three integers of four bytes each) of the source array (src) into the destination array (dst). Buffer
Tip: You can see that the Buffer type acts upon bytes, not array elements. It is not helpful with object data.
Program that uses Buffer class [C#]
using System;
class Program {
static void Main() {
int[] src = { 1, 2, 3 };
int[] dst = { 0, 0, 0 }; Buffer.BlockCopy(src, 0, dst, 0, 3 * sizeof(int)); foreach (int val in dst) { Console.WriteLine(val); } } }
Output
1 2 3
Performance Arrays are one of the low-level managed types in the C# language and .NET Framework. This means they will be faster than other structures such as List in many cases. We analyze the array type's performance.
1. Avoid loops. You can sometimes avoid using a loop to store or load array elements. This sometimes improves performance. Optimization Tip
2. Use sentinels. A sentinel value in an array helps control the loop. It sometimes is used to reduce logical steps in a loop. Sentinel Element
3. Improve locality. Array elements that are nearer together are faster to access. This principle is called locality of reference. Locality of Reference Summary We reviewed arrays. A