Stack.CopyTo() Method in C#

The CopyTo() method in C# allows you to copy elements from one array to another or a specific position within an array. It provides a convenient way to duplicate the contents of an array and ensure that the target array contains the same values within a specified range. By specifying the target array and starting index, you can easily control the element copying process and facilitate efficient data and array operations.

Syntax:

It has the following syntax:

Parameters:

array: It is a one-dimensional array that is the destination for elements copied from the stack. Arrays must have zero-based indices.
arrIndex: It is the 0-based index within the array where the copy begins

Exception:

ArgumentNullException: If the array is null.
ArgumentOutOfRangeException: If the index is less than 0.
ArgumentException: If the array is multidimensional or the number of elements in the source stack is greater than the available space from the index to the end of the target array.
InvalidCastException: If the source stack type cannot be automatically cast to the target array type.

Example 1:

Let us take an example to implement the stack.CopyTo() method in C#.

using System;
using System.Collections;
public class StackCopy{
   public static void Main(){
      Stack st = new Stack();
      st.Push(115);
      st.Push(320);
      st.Push(560);
      st.Push(750);
      st.Push(1100);
      st.Push(1245);
      st.Push(1520);
      st.Push(2002);
      st.Push(2501);
      Console.WriteLine("The elements of the Stack are:");
      foreach(int value in st){
         Console.WriteLine(value);
      }
      Console.WriteLine("The total elements of the stack = "+st.Count);
      Console.WriteLine("Element 750 is the stack? = "+st.Contains(320));
      st.Push(3050);
      Console.WriteLine("The Updated Stack elements are");
      foreach(int value in st)
      {
         Console.WriteLine(value);
      }
      Console.WriteLine("Count of elements (updated) = "+st.Count);
      Console.WriteLine("Is 5050 is present in the stack? = "+st.Contains(5050));
      Stack st2 = (Stack)st.Clone();
      Console.WriteLine("The cloned stack elements");
      foreach(int value in st2){
         Console.WriteLine(value);
      }
      Console.WriteLine("The updated count of the stack elements= "+st2.Count);
      Console.WriteLine("The cloned elements are copied into the integer array");
      int[] intarray = new int[st2.Count];
      st2.CopyTo(intarray, 0);
      foreach(int j in intarray){
         Console.WriteLine(j);
      }
   }
}

Output:

The elements of the Stack are:
2501
2002
1520
1245
1100
750
560
320
115
The total elements of the stack = 9
Element 750 is the stack? = True
The Updated Stack elements are
3050
2501
2002
1520
1245
1100
750
560
320
115
Count of elements (updated) = 10
Is 5050 is present in the stack? = False
The cloned stack elements
3050
2501
2002
1520
1245
1100
750
560
320
115
The updated count of the stack elements = 10
The cloned elements are copied into the integer array
3050
2501
2002
1520
1245
1100
750
560
320
115

Example 2:

Let us take an example to implement the stack.CopyTo() method in C#.

using System;
using System.Collections;
public class StackCopy2{
   public static void Main(){
       //An empty stack created
      Stack st= new Stack();
      st.Push("Telugu");
      st.Push("Hindi");
      st.Push("English");
      st.Push("Maths");
      st.Push("Science");
      Console.WriteLine("The elements of the stack are......");
      foreach(string value in st){
         Console.WriteLine(value);
      }
      Console.WriteLine("The total count of elements= "+st.Count);
      Console.WriteLine("Is Maths is the stack? = "+st.Contains("Maths"));
      st.Push("Physics");
      Console.WriteLine("The updated.. elements of the stack are");
      foreach(string value in st){
         Console.WriteLine(value);
      }
      Console.WriteLine("Count of elements (updated) = "+st.Count);
      Console.WriteLine("Is the Physics element is in stack? = "+st.Contains("Physics"));
      Stack st2 = (Stack)st.Clone();
      Console.WriteLine("The cloned.. stack elements are");
      foreach(string value in st2){
         Console.WriteLine(value);
      }
      Console.WriteLine("The count of the updated stack = "+st2.Count);
      Console.WriteLine("The elements are cloned and copied in the string array.");
      string[] starray = new string[st2.Count];
      st2.CopyTo(starray, 0);
      foreach(string j in starray){
         Console.WriteLine(j);
      }
   }
}

Output:

The elements of the stack are......
Science
Maths
English
Hindi
Telugu
The total count of elements= 5
Is Maths is the stack? = True
The updated.. elements of the stack are
Physics
Science
Maths
English
Hindi
Telugu
Count of elements (updated) = 6
Is the Physics element is in stack? = True
The cloned.. stack elements are
Physics
Science
Maths
English
Hindi
Telugu
The count of the updated stack = 6
The elements are cloned and copied in the string array.
Physics
Science
Maths
English
Hindi
Telugu

Advantages of Stack.CopyTo() Method:

There are several advantages of the Stack.CopyTo() Method in C#. Some main advantages are as follows:

Productive cluster initialization:

In case you need to duplicate the substance of the Stack in a cluster, the CopyTo() method can be more proficient than physically erasing the substance from the Stack and assigning it to the cluster. It gives a brief and clear way to attain this.

Stack arrange capacity:

The CopyTo() strategy preserves the order of the elements within the Stack because it duplicates the cluster. It ensures that the arrangement of components within the resulting cluster is kept up, which may be necessary in a few cases.

Expand realistic plan:

The strategy can indicate a starting index within the goal cluster, permitting you to be adaptable in overseeing the duplicate operation. You'll be able to control where within the cluster the components are replicated.

Compatibility with Clusters:

Since the CopyTo() strategy could be a way to organize clusters in C#, it compares well to common programming hones. If you work with clusters and need to bring components from the Stack, utilizing this strategy could be a recognizable and steady strategy.

Next TopicTask Parallel Library (TPL) in C#

← prev next →