How To Copy An Array In C#

int[] myArray = new int[5];

public class ArrayDemo {
    public static void Main() {
        int[] n = new int[10]; /* n is an array of 10 integers */
        int[] m = new int[5]; /* m is an array of 5 integers */
        for (int i = 0; i < 10; i++) {
            n[i] = i + 200;
        }
        Console.WriteLine("Original Array...");
        foreach(int j in n) {
            int i = j - 200;
            Console.WriteLine("Element[{0}] = {1}", i, j);
        }
        Array.Copy(n, 0, m, 0, 5);
        Console.WriteLine("New Array...");
        foreach(int res in m) {
            Console.WriteLine(res);
        }
        Console.ReadKey();
    }
}

   public static void Main()
            {
            int[] originalArray = { 1, 2, 3, 4, 5 };

            // create a new array using the Clone method
            int[] clonedArray = (int[])originalArray.Clone();

            // print the original array
            Console.WriteLine("Original array:");
            PrintArray(originalArray);

            // print the cloned array
            Console.WriteLine("Cloned array:");
            PrintArray(clonedArray);

            // modify an element in the original array
            originalArray[0] = 100;

            // print the original array again
            Console.WriteLine("Modified original array:");
            PrintArray(originalArray);

            // print the cloned array again
            Console.WriteLine("Cloned array after modifying original array:");
            PrintArray(clonedArray);

            Console.ReadLine();
        }

        // helper method to print an array
        static void PrintArray(int[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                Console.Write(arr[i] + " ");
            }
            Console.WriteLine();
        }
    }
}

This program creates an array of integers called originalArray, then a new array called clonedArray using the Clone method. It then prints both arrays to the console using a helper method called PrintArray.

After that, it modifies an element in the original Array and prints both arrays again to demonstrate that changing the original Array does not affect the cloned Array.

Output

Method 3. Using the CopyTo()

This method arranges Demo class copies of all the Array data to an existing array. It performs a shallow copy in C#. This is used to copy a one-dimensional array in C#. This statement copies the complete content of the Array to the new Array starting from the index passed in the parameter to C#.

This statement is the CopyTo method of the Array class name.

Array.CopyTo(destArray, index);

• The Array is the Array we want to copy the contents
• destArray is the Name of the Array of the same data type as the Array where the content will be copied to
• the index is the integer from where you want to start copying on destArray

The following example is copying array data to a new array using the CopyTo() method in C#.

public class ArrayDemo {
    public static void Main() {
        var array1 = new [] {
            "Ravi",
            "Rahul",
            "Nitin",
            "Welcomes",
            "You"
        };
        var array2 = new string[10];
        array2[0] = "Narveer";
        // cloning arr and storing it in new array
        array1.CopyTo(array2, 1);
        // Printing array using loop
        foreach(var element in array2) {
            System.Console.WriteLine(element);
        }
    }
}

This statement is that demonstrates the use of arrays in C#. The program creates two arrays, array1 and array2. The first Array, array1, is initialized with string values. The second Array, array2, is declared with a size of 10 but is not initialized with any values except for the first element, which is assigned the "Narveer."

The program then uses the CopyTo method to copy the elements from array1 to array2 starting from the second index (index 1). This method takes two arguments: the destination array and the starting index.

Finally, the program prints the elements of array2 using a foreach loop. The loop iterates through each element in the Array and prints it to the console.

When executed, the output of this program will be

Narveer Ravi Rahul Nitin Welcomes You

Note that the elements of array1 are copied to array2 starting from index 1, so the first element of array2 ("Narveer") is not overwritten.

Output

Conclusion

In this article, you will learn how to copy an array in C#. We have discussed different ways to copy arrays in C#. Understanding these methods will help you to write efficient and error-free code. Working with Arrays in C# (code included) check out- Working with Arrays in C# (code included)

FAQs

Q: Can you explain the difference between shallow and deep copies of an array in C#?

A: When you copy an array in C#, you can make two types of copies: shallow and deep.

A shallow copy of an array creates a new array with the same elements as the original Array. Still, the elements in the new Array reference the same objects as those in the original Array. In other words, a shallow copy creates a new array that points to the same objects as the original Array.

On the other hand, a deep copy of an array creates a new array with the same elements as the original Array, but the elements in the new Array are copies of the objects in the original Array. In other words, a deep copy creates a new array with its copies of the objects in the original Array.

To make a shallow copy of an array in C#, you can use the Array.Clone() method. To make a deep copy, you must manually create a new array and copy each element from the original Array to the new Array, starting new instances of each object.

Understanding the difference between shallow and deep copies is essential when working with arrays and objects in C#. Depending on your needs, you may want to use a shallow or deep copy to avoid unintended consequences.

Q: How do you copy an array in C#?

A: You can copy an array using the Array.Copy() method or assign the source array to a new destination array.