Exercise - Explore Clear() and Resize()

15 minutes

As you continue to develop a pallet tracker for the logistics company, it's likely that you need to track new pallets and remove old ones from the tracking system. So, how can you create a tracking functionality that allows for the addition and removal of pallets?

Use array methods to clear and resize an array

The Array.Clear() method enables you to eliminate the contents of specific elements in your array, replacing them with the array's default value. For instance, if you clear an element in a string array, the cleared value is replaced with null. Similarly, when you clear an element in an int array, the replacement is 0 (zero).

The Array.Resize() method, on the other hand, allows you to add or remove elements from your array.

Delete or use the line comment operator // to comment out all of the code from the previous exercises.

Update your code in the Visual Studio Code Editor as follows:

string[] pallets = [ "B14", "A11", "B12", "A13" ];
Console.WriteLine("");

Array.Clear(pallets, 0, 2);
Console.WriteLine($"Clearing 2 ... count: {pallets.Length}");
foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Note

This example uses Collection expression syntax, introduced in C# 12.

Take a minute to focus on the line of code Array.Clear(pallets, 0, 2);.

Here you're using the Array.Clear() method to clear the values stored in the elements of the pallets array starting at index 0 and clearing 2 elements.
On the Visual Studio Code File menu, select Save.

The Program.cs file must be saved before building or running the code.
In the EXPLORER panel, to open a Terminal at your TestProject folder location, right-click TestProject, and then select Open in Integrated Terminal.

A Terminal panel should open, and should include a command prompt showing that the Terminal is open to your TestProject folder location.
At the Terminal command prompt, to run your code, type dotnet run and then press Enter.

Note

If you see a message saying "Couldn't find a project to run", ensure that the Terminal command prompt displays the expected TestProject folder location. For example: C:\Users\someuser\Desktop\csharpprojects\TestProject>

When you run the code, you see that the values stored in the first two elements of the array are cleared out. In the Length property and the foreach statement, the elements still exist, but they're now empty.
```
Clearing 2 ... count: 4
-- 
-- 
-- B12
-- A13
```

Empty string versus null

When you use Array.Clear(), the elements that were cleared no longer reference a string in memory. In fact, the element points to nothing at all. Pointing to nothing is an important concept that can be difficult to grasp at first.

What if you attempt to retrieve the value of an element affected by the Array.Clear() method, could you do it?

Access the value of a cleared element

Two approaches are needed to determine the value of a cleared element to see how the C# compiler works with a null value.

Insert new code lines around the Array.Clear(pallets, 0, 2); code line as follows:

Console.WriteLine($"Before: {pallets[0]}");
Array.Clear(pallets, 0, 2);
Console.WriteLine($"After: {pallets[0]}");

Verify your code should match the following code listing:

string[] pallets = [ "B14", "A11", "B12", "A13" ];
Console.WriteLine("");

Console.WriteLine($"Before: {pallets[0]}");
Array.Clear(pallets, 0, 2);
Console.WriteLine($"After: {pallets[0]}");

Console.WriteLine($"Clearing 2 ... count: {pallets.Length}");
foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Save your code file, and then use Visual Studio Code to run your code.

You should see the following output:
```
Before: B14
After:
Clearing 2 ... count: 4
--
--
-- B12
-- A13
```

If you focus on the line of output After: , you might think that the value stored in pallets[0] is an empty string. However, the C# Compiler implicitly converts the null value to an empty string for presentation.

Call a string helper method on a cleared element

To prove that the value stored in pallets[0] after being cleared is null, you'll modify the code example to call the ToLower() method on pallets[0]. If it's a string, it should work fine. But if it's null, it should cause the code to throw an exception.

To call the ToLower() method each time you attempt to write pallets[0] to the console, update your code as follows::

Console.WriteLine($"Before: {pallets[0].ToLower()}");
Array.Clear(pallets, 0, 2);
Console.WriteLine($"After: {pallets[0].ToLower()}");

Make sure your code matches the following code listing:

string[] pallets = [ "B14", "A11", "B12", "A13" ];
Console.WriteLine("");

Console.WriteLine($"Before: {pallets[0].ToLower()}");
Array.Clear(pallets, 0, 2);
Console.WriteLine($"After: {pallets[0].ToLower()}");

Console.WriteLine($"Clearing 2 ... count: {pallets.Length}");
foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Save your code file, and then use Visual Studio Code to run your code. This time, when you run the code, you see a large error message. If you parse through the text, you see the following message:
```
System.NullReferenceException: Object reference not set to an instance of an object.
```
This exception is thrown because the attempt to call the method on the contents of the pallets[0] element happens before the C# Compiler has a chance to implicitly convert null to an empty string.

The moral of the story is that Array.Clear() removes an array element's reference to a value if one exists. To fix this, you might check for null before attempt to print the value.

To avoid the error, add an if statement before accessing an array element that is potentially null.

if (pallets[0] != null)
    Console.WriteLine($"After: {pallets[0].ToLower()}");

Resize the array to add more elements

Next, rework the code listing from Step 1 to include code to resize the array. When complete, your code should match the following code listing:

string[] pallets =  ["B14", "A11", "B12", "A13" ];
Console.WriteLine("");

Array.Clear(pallets, 0, 2);
Console.WriteLine($"Clearing 2 ... count: {pallets.Length}");
foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Console.WriteLine("");
Array.Resize(ref pallets, 6);
Console.WriteLine($"Resizing 6 ... count: {pallets.Length}");

pallets[4] = "C01";
pallets[5] = "C02";

foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Take a few minutes to focus on the line Array.Resize(ref pallets, 6);.

Here, you're calling the Resize() method passing in the pallets array by reference, using the ref keyword. In some cases, methods require you pass arguments by value (the default) or by reference (using the ref keyword). The reasons why this is necessary requires a long and complicated explanation about of how objects are managed in .NET. Unfortunately, that is beyond the scope of this module. When in doubt, you're recommended to look at Intellisense or Microsoft Docs for examples on how to properly call a given method.

In this case, you're resizing the pallets array from four elements to 6. The new elements are added at the end of the current elements. The two new elements are null until you assign a value to them.
Save your code file, and then use Visual Studio Code to run your code. When you run the code, you should see the following output.
```
Clearing 2 ... count: 4
-- 
-- 
-- B12
-- A13

Resizing 6 ... count: 6
-- 
-- 
-- B12
-- A13
-- C01
-- C02
```

Resize the array to remove elements

Conversely, you can remove array elements using Array.Resize().

Update your code in the Visual Studio Code Editor as follows:

string[] pallets = [ "B14", "A11", "B12", "A13" ];
Console.WriteLine("");

Array.Clear(pallets, 0, 2);
Console.WriteLine($"Clearing 2 ... count: {pallets.Length}");
foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Console.WriteLine("");
Array.Resize(ref pallets, 6);
Console.WriteLine($"Resizing 6 ... count: {pallets.Length}");

pallets[4] = "C01";
pallets[5] = "C02";

foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Console.WriteLine("");
Array.Resize(ref pallets, 3);
Console.WriteLine($"Resizing 3 ... count: {pallets.Length}");

foreach (var pallet in pallets)
{
    Console.WriteLine($"-- {pallet}");
}

Save your code file, and then use Visual Studio Code to run your code. When you run the code, you should see the following output:
```
Clearing 2 ... count: 4
--
--
-- B12
-- A13

Resizing 6 ... count: 6
--
--
-- B12
-- A13
-- C01
-- C02

Resizing 3 ... count: 3
--
--
-- B12
```
Notice that calling Array.Resize() didn't eliminate the first two null elements. Rather, it removed the last three elements. Notably, last three elements were removed even though they contained string values.

Can you remove null elements from an array?

If the Array.Resize() method doesn't remove empty elements from an array, is there another helper method that does the job automatically? No. The best way to empty elements from an array would be to count the number of non-null elements by iterating through each item and increment a variable (a counter). Next, you would create a second array that is the size of the counter variable. Finally, you would loop through each element in the original array and copy non-null values into the new array.

Recap

Here's a few important ideas that you covered in this unit:

Use the Clear() method to empty the values out of elements in the array.
Use the Resize() method to change the number of elements in the array, removing or adding elements from the end of the array.
New array elements and cleared elements are null, meaning they don't point to a value in memory.