Copying the queue elements to 1-D Array in C#
In this article, we will discuss the Queue<T>.CopyTo(T[], Int32) method in C# with its syntax, parameters, exceptions, and examples.
What is the Queue<T>.CopyTo(T[], Int32) Method?
Queue<T> is used to copy queue elements to an existing 1-D array, starting at a specified array index, using the CopyTo(T[], Int32) method. This copyto() method is O(n) in nature, where n is the count, and the elements are transferred to the Array in the same order that the enumerator proceeds via the Queue. This method is located in the System.Collections.Generic namespace.
Syntax:
It has the following syntax:
public void CopyTo (T[] array, int arrayIndex);
Parameters:
- array: The elements that have been copied from Queue<T> end up in this one-dimensional array. The array has to be indexable using zeros.
- arrayIndex: It is the point in the array where copying starts based on a zero basis.
Exceptions:
- ArgumentNullException: If occurs when an array is empty.
- ArgumentOutOfRangeException: It occurs when the index is not zero.
- ArgumentException: When there are more elements in the source Queue<T>, there is space available from arrayIndex to the destination array's end.
Example:
Let us take an example to illustrate the Queue<T>.CopyTo(T[], Int32) method in C#.
using System;
using System.Collections;
class Program
{
static void Main()
{
// Creating a queue
Queue myQueue = new Queue();
// Adding elements to the queue
myQueue.Enqueue("Apple");
myQueue.Enqueue("Banana");
myQueue.Enqueue("Orange");
myQueue.Enqueue("Grapes");
// Copying queue elements to a 1-D array
string[] array = new string[myQueue.Count];
myQueue.CopyTo(array, 0);
// Displaying the original queue
Console.WriteLine("Original Queue:");
foreach (var item in myQueue)
{
Console.Write(item + " ");
}
// Displaying the copied array
Console.WriteLine("\nCopied 1-D Array:");
foreach (var item in array)
{
Console.Write(item + " ");
}
}
}
Output:
Original Queue:
Apple Banana Orange Grapes
Copied 1-D Array:
Apple Banana Orange Grapes
Explanation:
In this example, the steps involve creating a queue of strings and using the CopyTo method to copy the elements to a 1-D array of strings. The CopyTo function copies the queue's elements to the designated array utilizing an index as a starting point. After that, the copied array is shown, along with the original queue.
Example 2:
Let us take another example to illustrate the queue.CopyTo() method in C#.
using System;
using System.Collections.Generic;
class Program
{
// Driver code for the program
public static void Main()
{
// Creating a Queue of integers
Queue<int> myQueue = new Queue<int>();
// Adding elements to Queue
myQueue.Enqueue(10);
myQueue.Enqueue(20);
myQueue.Enqueue(30);
myQueue.Enqueue(40);
// Creates and initializes the
// one-dimensional target Array.
int[] targetArray = new int[8];
// Adding elements to targetArray
targetArray[0] = 5;
targetArray[1] = 15;
targetArray[2] = 25;
targetArray[3] = 35;
targetArray[4] = 45;
targetArray[5] = 55;
targetArray[6] = 65;
targetArray[7] = 75;
Console.WriteLine("Before Method:");
Console.WriteLine("\nQueue Contains:");
foreach (var item in myQueue)
{
Console.WriteLine(item);
}
Console.WriteLine("\nArray Contains:");
for (int i = 0; i < targetArray.Length; i++)
{
Console.WriteLine($"targetArray[{i}] : {targetArray[i]}");
}
Console.WriteLine("After Method:");
// Copying the entire source Queue to the target Array starting at index 3.
myQueue.CopyTo(targetArray, 3);
Console.WriteLine("\nQueue Contains:");
foreach (var item in myQueue)
{
Console.WriteLine(item);
}
Console.WriteLine("\nArray Contains:");
for (int i = 0; i < targetArray.Length; i++)
{
Console.WriteLine($"targetArray[{i}] : {targetArray[i]}");
}
}
}
Output:
Before Method:
Queue Contains:
10
20
30
40
Array Contains:
targetArray[0] : 5
targetArray[1] : 15
targetArray[2] : 25
targetArray[3] : 35
targetArray[4] : 45
targetArray[5] : 55
targetArray[6] : 65
targetArray[7] : 75
After Method:
Queue Contains:
10
20
30
40
Array Contains:
targetArray[0] : 5
targetArray[1] : 15
targetArray[2] : 25
targetArray[3] : 10
targetArray[4] : 20
targetArray[5] : 30
targetArray[6] : 40
targetArray[7] : 75
Example 3:
Let us take another example to illustrate the queue.CopyTo() method in C#.
using System;
using System.Collections.Generic;
public class Demo
{
public static void Main()
{
// Creating a Queue of integers
Queue<int> myQueue = new Queue<int>();
myQueue.Enqueue(42);
myQueue.Enqueue(99);
// Creating an array of integers
int[] intArray = new int[5];
intArray[0] = 10;
intArray[1] = 20;
intArray[2] = 30;
intArray[3] = 40;
intArray[4] = 50;
Console.WriteLine("Original Array Elements:");
for (int i = 0; i < intArray.Length; i++)
{
Console.WriteLine(intArray[i]);
}
// Copying queue elements to the array starting at index 1
myQueue.CopyTo(intArray, 1);
Console.WriteLine("\nAfter Copying, Array Contains:");
for (int i = 0; i < intArray.Length; i++)
{
Console.WriteLine("intArray[{0}] : {1}", i, intArray[i]);
}
}
}
Output:
Original Array Elements:
10
20
30
40
50
After Copying, Array Contains:
intArray[0] : 10
intArray[1] : 42
intArray[2] : 99
intArray[3] : 40
intArray[4] : 50
Conclusion:
In conclusion, copying elements from a C# Queue to a 1-D array is a useful and efficient way to combine data from both structures. Using the CopyTo method, we can easily transfer data and specify the starting index in the target array. This operation preserves the initial elements in the array by inserting the queue elements at the specified location. The output array is a well-balanced selection of elements from both the queue and the original array, offering a practical way to organize and modify data in C# applications.