C# ArrayList Examples, Usage and Tips
You need to use the ArrayList class in an older C# program to fix or improve the dynamic arrays. ArrayList is still useful, even when newer classes are more durable and popular. Here we see examples and tips using the ArrayList class in the C# programming language, moving from the simpler tasks to the more advanced usages of ArrayList.
Add elements
The Add method on ArrayList is used in almost every program. It appends a new element object to the very end of the ArrayList. You can keep adding elements to your collection until memory runs out. The objects are stored in the managed heap.
Program that uses ArrayList [C#]
using System.Collections;
class Program
{
static void Main()
{
//
// Create an ArrayList and add three elements.
//
ArrayList list = new ArrayList();
list.Add("Two");
list.Add("Three");
}
}
Result
An ArrayList with three elements is created.
What the example shows. First, this is a complete console program that you can run in the Visual Studio IDE. When you run this example, there will be three elements added to the ArrayList. The first element is a string containing "One". The last element is "Three".
Use ArrayList in methods
Structural programming with ArrayList is easy, as you can simply pass the object with the ArrayList type. However, in the receiving function, you have to know (or find out) what the type of each element is. Here we pass the ArrayList as a parameter.
Program that uses ArrayList parameter [C#]
using System;
using System.Collections;
class Program
{
static void Main()
{
//
// Create an ArrayList and add two ints.
//
ArrayList list = new ArrayList();
list.Add(5);
list.Add(7);
//
// Use ArrayList with method.
//
Example(list);
}
static void Example(ArrayList list)
{
foreach (int i in list)
{
Console.WriteLine(i);
}
}
}
Output
5
7
Note on using ArrayList as return value. You can also use the ArrayList as a return value. Use the ArrayList type as the return keyword at the start of your method. Note that generally it is best to reuse the same ArrayList instead of combining more than one.
Add one ArrayList to second one
There are different ways to add one ArrayList to another, but the best way is using AddRange. Internally, AddRange uses the Array.Copy or CopyTo methods, which have better performance than some loops.
Program that uses Add and AddRange [C#]
using System;
using System.Collections;
class Program
{
static void Main()
{
//
// Create an ArrayList with two values.
//
ArrayList list = new ArrayList();
list.Add(5);
list.Add(7);
//
// Second ArrayList.
//
ArrayList list2 = new ArrayList();
list2.Add(10);
list2.Add(13);
//
// Add second ArrayList to first.
//
list.AddRange(list2);
//
// Display the values.
//
foreach (int i in list)
{
Console.WriteLine(i);
}
}
}
Output
5
7
10
13
Description of the two ArrayLists. The first ArrayList has two elements added to it. Next, the second ArrayList has two elements added to it. The second ArrayList is then appended to the first using the AddRange method. The example finally shows the output.
Use Count and Clear
The ArrayList class provides the Count property, which is a virtual property. When you use Count, no counting is actually done; instead, a cached field value is returned. This means that Count is fairly fast. The example also shows Clear.
Program that uses Count [C#]
using System;
using System.Collections;
class Program
{
static void Main()
{
//
// Create an ArrayList with two values.
//
ArrayList list = new ArrayList();
list.Add(9);
list.Add(10);
//
// Show number of elements in ArrayList.
//
Console.WriteLine(list.Count);
//
// Clear the ArrayList.
//
list.Clear();
//
// Show count again.
//
Console.WriteLine(list.Count);
}
}
Output
2
0
Usage of Count. The Count property returns an int, and you can assume this will always be a positive value. Sometimes, you can store the count in a local variable for better performance, but this isn't usually needed because no calculation takes place in the property itself.
Usage of Clear method. You can call the instance method Clear on your ArrayList. Internally, this calls the Array.Clear method. Sometimes, your code is clearer if you create a new ArrayList instead.
Sort and reverse
Many dynamic arrays such as ArrayList must be sorted frequently, before insertion into the output web page or Windows program. This greatly improves the functionality and usability in programs. You can call the instance Sort method on an ArrayList, and then we call Reverse on that sorted collection. These methods work in-place.
Sorting ranges in your ArrayList. You can sort subsets (ranges) of elements in your ArrayList using the third overload. This can be useful for rare situations, but isn't likely to be needed. Additionally, you can Reverse only a range of your ArrayList.
Insert and remove elements
Here we see how you can insert and remove elements with the Insert and Remove family of methods. Specifically, we see the RemoveAt method for erasing a single element, then the Insert method and RemoveRange methods.
Program that uses Insert and Remove [C#]
using System;
using System.Collections;
class Program
{
static void Main()
{
//
// Create an ArrayList with three strings.
//
ArrayList list = new ArrayList();
list.Add("Dot");
list.Add("Net");
list.Add("Perls");
//
// Remove middle element in ArrayList.
//
list.RemoveAt(1); // It becomes [Dot, Perls]
//
// Insert word at beginning of ArrayList.
//
list.Insert(0, "Carrot"); // It becomes [Carrot, Dot, Perls]
//
// Remove first two words from ArrayList.
//
list.RemoveRange(0, 2);
//
// Display the result ArrayList.
//
foreach (string value in list)
{
Console.WriteLine(value); // <-- "Perls"
}
}
}
Output
Perls
Loop with for
In C# programming, the for loop is a very popular and useful loop construct. However, when using for on an ArrayList, you will need to cast the element after using its index. The [i] part in the example below demonstrates how to use the indexer on the ArrayList. You can find more separate information on indexers here.
Program that uses ArrayList and for [C#]
using System;
using System.Collections;
class Program
{
static void Main()
{
//
// Create an ArrayList with three strings.
//
ArrayList list = new ArrayList();
list.Add("man");
list.Add("woman");
list.Add("plant");
//
// Loop over ArrayList with for.
//
for (int i = 0; i < list.Count; i++)
{
string value = list[i] as string;
Console.WriteLine(value);
}
}
}
Output
man
woman
plant
Using "as" cast with ArrayList elements. The "as" cast in C# is probably the best way to cast reference types such as string. After you cast, you can check the result for null before using the variable, to see if the cast succeeded. This is not always needed.
Get range of values
Another interesting method you can use is the GetRange method, which will return to you a subset of the original ArrayList in a new ArrayList. This is ideal when you know a certain part of your ArrayList has a different purpose or behavior.
Program that uses GetRange [C#]
using System;
using System.Collections;
class Program
{
static void Main()
{
//
// Create an ArrayList with 4 strings.
//
ArrayList list = new ArrayList();
list.Add("fish");
list.Add("amphibian");
list.Add("bird");
list.Add("plant");
//
// Get last two elements in ArrayList.
//
ArrayList range = list.GetRange(2, 2);
//
// Display the elements.
//
foreach (string value in range)
{
Console.WriteLine(value); // bird, plant
}
}
}
Output
bird
plant
Note on SetRange and RemoveRange. The SetRange method on ArrayList is also useful when you need to replace a range. However, I have not found SetRange to be useful, as often you will just want to replace elements in a for loop.
IndexOf and LastIndexOf
The IndexOf and LastIndexOf methods on ArrayList are similar to those on strings. You pass in the value you are looking for, the start index, the number of elements to search. IndexOf will return -1 if the element could not be located.
Convert ArrayList to array
Arrays in C# offer more performance and compatibility, so you will want to convert ArrayLists to arrays. Due to the boxing and unboxing requirements with the ArrayList, you need to specify more complex casts than with the List constructed type. This site has more details on converting ArrayLists.
BinarySearch method
The BinarySearch method on ArrayList implements the binary searching algorithm. This uses a "divide and conquer" approach to finding the correct element, and only works on a pre-sorted array. For this reason, never use BinarySearch if your ArrayList might not be sorted.
Performance and memory usage
There is a significant performance penalty in using ArrayList, particularly on value types. This is because boxing occurs, which is a way the runtime turns a value type into an object. This site has some material on the cost of unboxing.
Should I use List<T> instead?
Yes, assuming the project you are working on is compatible. Older .NET deployed applications may be using ArrayList, and it is often best not to have to rewrite them. Lists not only avoid boxing or unboxing, but they also lead to clearer and less bug-prone code. This is because the compiler can check your code for type integrity before runtime.
C# Array.Copy Method Usage
You want to copy your typed array to another array using the C# language. The Array.Copy method is ideal for this purpose, but has some complexities. The Array type is an abstract base type from which all arrays are derived. Here we look at how you can copy one array to another, taking a close look at declaration syntax and the internals of Array.Copy, in the C# programming language.
Copy complete arrays
Here we look at the Array.Copy method overload that copies one source array to a target array. Both arrays must have at least the length specified in the third parameter. Array.Copy allows you to copy the arrays without a for loop, which avoids some complexity.
Example program for Array.Copy method [C#]
using System;
class Program
{
static void Main()
{
//
// Instantiate the source array.
//
int[] source = new int[5];
source[0] = 1;
source[1] = 2;
source[2] = 3;
source[3] = 4;
source[4] = 5;
//
// Instantiate and allocate the target array.
//
int[] target = new int[5];
//
// Copy the source to the target.
//
Array.Copy(source, target, 5);
//
// Display the target array.
//
Console.WriteLine("--- Target array ---");
foreach (int value in target)
{
Console.WriteLine(value);
}
}
}
Output
-- Target array ---
1
2
3
4
5
Notes on the example. The code first creates a new int array with five elements. Then, it allocates an empty array of five int elements. The Array.Copy method is called with the first parameter as the source array, the second parameter as the target array, and then the length we want to copy. Finally, the target array is written to the Console. It has the same contents as the source array.
Copy sections of arrays
Here we copy one range in an array to another range in the second array. This style of code is fraught with exceptions and you have to be very careful with checking the array bounds. Further on, we see all the exceptions you can get with Array.Copy. The example copies the first 3 elements from the source array to a smaller target array.
Example for copying array section [C#]
using System;
class Program
{
static void Main()
{
//
// Instantiate the source array.
//
int[] source = new int[5];
source[0] = 5;
source[1] = 4;
source[2] = 3;
source[3] = 2;
source[4] = 1;
//
// Instantiate the target.
//
int[] target = new int[3];
//
// Copy first three elements in source to target.
//
Array.Copy(source, 0, target, 0, 3);
//
// Display the result
//
Console.WriteLine("--- Destination array ---");
foreach (int value in target)
{
Console.WriteLine(value);
}
}
}
Output of the example
--- Destination array ---
5
4
3
Exceptions
Here we look at some exceptions you will get when using Array.Copy. First, you cannot copy from or to a null reference array. This raises the ArgumentNullException. Second, each array must have adequate length for the complete copy operation. If either array is too short, there will be an ArgumentException.
Unhandled Exception: System.ArgumentNullException: Value cannot be null.
Parameter name: sourceArray
Unhandled Exception: System.ArgumentNullException: Value cannot be null.
Parameter name: destinationArray
Unhandled Exception: System.ArgumentException: Source array was not long enough.
Check src Index and length, and the array's lower bounds.
Unhandled Exception: System.ArgumentException: Destination array was not long enough.
Check destIndex and length, and the array's lower bounds.
Internal implementation
Looking into IL Disassembler, you will see that the Array.Copy overloads all call into the internal method Copy. This method is implemented in unmanaged code, and is not visible in the intermediate language.
Array copying benchmarks
The Array.Copy method is fast for most uses, and it is also simpler than manually copying all the elements. However, you can use the Buffer class to improve performance. The downside to the Buffer class is that you must specify byte sizes, which complicates your code. The Buffer.BlockCopy article benchmarks the Array.Copy method.
Alternatives
You can use the List generic class instead of Array to copy collections of elements. With the List class, you can copy into a new List simply by using the constructor. This site has more information on using Lists with arrays.
No comments:
Post a Comment
Your comment is pending for approval