C# Arrays: A Getting Started Guide (2023)

You have now started your C# development journey. Learning any new language or framework can be a challenging journey. However, you don't have to despair. May those who have gone before guide you and lead you on your way. Today's tour is C# arrays.

In this article we will discuss what an array is. We'll see how to use it in your code, discuss how best to use it, and what pitfalls can hurt code quality.

C# Arrays: Under the Hood

If you want to use arrays in C#, you need to understand what they are and how they work. So what is an array?

A simple definition is that an array is an indexed list.This means that the field contains a collection of elements in an ordered list. Each array element must be of the same type.

In other words, you can have an array of integers or an array of strings, but not an array of integers and strings.

When initializing a C# array, the .NET runtime reserves enough memory blocks to hold the elements. It then stores the elements of the array in that memory block in order.

Declare Arrays in C#

To understand how array declarations work in C#, it's important to keep in mind the role of angle brackets in the syntax. Consider the following line of code:

string with; int n; today's date and time;

In the example above, we declared three type variablesseries,whole number, itime to get to know each other, that is. Now consider another example:

string[] name; int[] number; DateTime[] date;

In the above line of code, we declare three variables again. But this time, their guy didseries[],whole number[], iappointment time[], that is. look? "DateTime" is one type, "DateTime[]" is another (we read it as "DateTime array", "Integer array", etc.).

I've seen many younger developers struggle to understand what square brackets are for. Well done,AndA bit confusing.

Remember this when declaring an arrayThe square brackets are part of the type nameyou will be fine.

Initialize a C# field

In the previous section, we described how to declare variables that can contain strings.

But we didn't initialize the variable itself, so we'll do that now. The following code declares and initializes a variable with a five-element array of integers:

int[] my array = 新 int[5];

You can also use type inference on the left side of the declaration, making the following line equivalent to the one above:

var myArray = new int[5];

The blue blocks above represent the memory available to your computer. When the above code is executed, the runtime reserves memory and places the elements in order in the reserved memory.

Angle brackets behind each element?my stringContains the index of this element. Indexing starts at zero, so an array of five elements has indices 0, 1, 2, 3, and 4. You can access a specific array element by index, as follows:

// Get the third element of the array and store it in another variable var someElement = myArray[2]

However, you haven't actually set any values ​​to the array at this point. Let's do it next.

Assigning values ​​to strings in C#

There are two ways to put a value in a C# field. You can access each element of the array and set the value or you can useCollection initializersSyntax provided by C#. Let's look at both.

// access each individual element int[] myArray = new int[5];myArray[0] = 1;myArray[1] = 4;myArray[2] = 9;myArray[3] = 16;myArray[4 ] = 25 ;// Use collection initializerint[] myArray = new int[5] {1, 4, 9, 16, 25};// Another way to use collection initializerint[] myArray = {1, 4, 9 , 16 , 25 };

Which one do you think is better? I'll give you a hint: it's all about readability. The C# compiler converts the second and third examples into the first, so they are effectively equivalent from a clean code standpoint.

Best Mode #1: Creates an array using the collection initializer. It's more readable and, frankly, easier to type.

Lock #1: Filling strings manually can lead to hard-to-find errors and performance errors due to incorrectly entered indices. Your application will throw a runtime exception if you try to access an element that doesn't exist.

Using C# fields

C# arrays have some key characteristics that make them useful and efficient. In fact, when you dig deeper into more advanced collectionskindLists, for example, you'll see are actually array wrappers.

The array's versatility and efficiency comes from two main factors. First, they are implemented at runtime. That's why they have a special syntax that other types don't have.

For example, the List class is a C# class written by Microsoft to expose some functions. You must create a new listPurposebefore you use it.

Arrays are implemented internally at runtime, using a language closer to the metal. So you can create an array by simply adding square brackets to the type, which is unique within the type.seriesare the key building blocks of language.

Another factor in their performance advantage is the way they are stored and accessed in memory.

C# arrays are stored by reserving a block of memory equal to the number needed to hold the elements.

If you store 5 integers, each occupying 4 bytes of memory, the runtime allocates 20 bytes of memory (4 x 5) to store the values. It then puts the values ​​into the array in order, one next to the other.

So if we take our previous example, we'll initialize the array with the first five squares.

int[] my array = {1, 4, 9, 16, 25};

In memory it will look like this:

The beauty of this data structure is that the values ​​are next to each other. When you want to access an array element, just start from the beginning and jump to the number of bytes needed for the next element.

The diagram below illustrates this concept. Once you know the memory location of the first element, the rest is just a matter of adding. This is why arrays are so fast at retrieving data.

However, this efficiency comes at a price.

Once an array is created, no more elements can be added to it. This is a fixed size. There is no guarantee that the memory behind the field will be available for use. Therefore, you should not use arrays for lists of things that may change with the use of the application.

Best Mode #2: use an array when you have an immutable list. A good example is an array containing the days of the week.

Lock #2: If you need to dynamically add things to a collection, then using an array won't work for you (at least not without a lot of extra code). Use a different type of collection.

The way arrays work also means that you have to be careful about the amount of space allocated to the array. Make sure you only use the space you need.

Best Mode #3: For large lists of data, create only the array size you need. Use what you seek to keep.

Lock #3😕 If you create a large field and don't use it all, that memory will not be available to you or other applications.

C# arrays: when you need to get elements

When you want to perform an operation on all the elements of an array, you have to go through all the elements in turn and process them. This is called?repetitionon a string. There are two ways to iterate over an array in C#,forLoop ifor everyonestatement.

On the surface, the two look very similar. However, there are some important differences that you should be aware of. Let's look at the code for both and discuss the differences.

int[] myArray = {1, 4, 9, 16, 25 };for (int i = 0; i < myArray.Length; i++) { Console.WriteLine(myArray[i]); } }foreach (var broj u myArray) { Console.WriteLine(number); }

this one?for?The loop function directly accesses each element of the array and performs some operations on it using square brackets. this one?for everyoneThe loop in turn assigns the value variable of each element, and the element can then be read.

There is an important difference here:for everyoneit's a cycleread only. You cannot change the value of the elements as they pass through the loop.

return,?for everyoneThe whole sequence repeats itself anyway. If you want to iterate over only part of the array, you have to use ?for?a ring.

Best Mode #4: use?for?You need a loop if you need to iterate over part of an array, or if you need to somehow change elements of the array during iteration. use?for everyoneWhen you don't want to change anything in an array and need to iterate over all elements.

Lock #4: Do you understand the difference between them?for?i?for everyonecycle. It's not just grammar. When to use it?forWhen looping, be very careful with indexing so you don't get runtime exceptions by iterating too far and accessing elements that don't exist.

Learn more about C# arrays: Multidimensional arrays

So far we've covered one-dimensional arrays. But arrays in C# can have multiple dimensions. What does this mean in practice?

One-dimensional arrays can be used to represent data expressed in such a way that each value is associated with a single index.

For example, suppose you need to store the average temperature for the last 30 days. You can create a double field with 30 items and be done with it.

You just have to be careful not to forget that arrays are indexed from zero? So to access the first value you have to use index 0 and so on.

But what if you need to store the average daily temperature for the whole year?

Of course, you could use an array of 365 (or 366) items, but that would make it difficult to retrieve results for a specific date. A better approach might be to use a multidimensional array.

An example of a multidimensional field

See the following example:

double [,] temperature = new double [12, 31];

The above line creates a multidimensional array of dimensions 12 and 31. Visually, think of it as a table (or matrix) with 12 rows and 31 columns.

In order to assign values ​​to our multidimensional array, we need to use two indices.

In the following example, we list the average temperature for January 15:

temperature[0, 14] = 15;

You can also omit the rank of the array when you declare it, and then infer the rank from the right side of the declaration:

int[,] many = { { 1, 1 }, { 2, 3 }, { 5, 8 }, { 13, 21 } };

Note that although we use two-dimensional arrays in our examples, you are not limited to this number of dimensions. You can easily work with arrays of three, four or more dimensions.

Finally, how do we loop through a multidimensional array?

We cross one dimension in the same way: usingfororfor everyone. The only difference is what you need for multidimensional arraysnnestedfor/for everyonestructure, of whichnis the dimension of the array.

C# field as IEnumerable

This is another important feature of arrays in C#: they all implementIE countableiIEbrolive interface. In other words, if you havewhole number[], then you also have aIEbrolive.

So what is the use of this?

• You can move through the array items usingfor everyonea ring.
• You can use the LINQ extension method (such as selection, position and aggregation) on the string.

See the example below and notice that we need to include "System.Linq":

使用 System;using System.Linq;class MainClass { public static void Main (string[] args) { int[] 数字 = { 1, 2, 3, 4, 5 }; var squares = Numbers.Select(x => x * x); var GreaterThanFour = squares.Where(x => x > 4); var sum = GreaterThanFour.Sum(); Console.WriteLine("结果：{0}", zbroj); }}

What's next?

An array is one of the basic data structures in the C# language. Nevertheless, they are fascinating when you explore why they are special and super useful in your application. Use arrays efficiently and you will be able to build anything.

Spend some time practicing arrays and using them where they make sense in everyday coding. A solid understanding of how arrays work will help you along your journey as a software engineer.

You may also be interested in further reading about other C# language concepts:

• list
• Wires
• description
• dictionary
• interface
• statement switch
• operator

Learn more about how CodeIt.Right can help you automate code review and improve code quality.

related