Method 1: Using the ToArray() Method

To convert a list to an array in C# is to use the built-in ToArray() method provided by the System.Linq namespace. This method can be called on any list object and returns an array containing the elements of the list. 

using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> myList = new List<int>() { 1, 2, 3, 4, 5 };
        int[] myArray = myList.ToArray();
        Console.WriteLine("Array elements: " + string.Join(", ", myArray));
    }
}

Output:

Array elements: 1, 2, 3, 4, 5

In the above example, we create a list myList containing integers from 1 to 5. We then call the ToArray() method on myList to convert it to an array myArray. Finally, we print the elements of myArray using string.Join() method to concatenate array elements with comma-separated values.

Method 2: Using the ToArray() Method with Predicate

To convert a list to an array is by using the ToArray() method with a predicate. The predicate is a delegate that represents a method that takes an element from the list and returns a boolean value indicating whether the element should be included in the array or not.

using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> myList = new List<int>() { 1, 2, 3, 4, 5 };
        int[] myArray = myList.ToArray(x => x % 2 == 0);
        Console.WriteLine("Array elements: " + string.Join(", ", myArray));
    }
}

Output:

Array elements: 2, 4

In the above example, we create a list myList containing integers from 1 to 5. We then call the ToArray() method on myList with a predicate that checks if an element is even or not. The predicate x => x % 2 == 0 returns true for even numbers and false for odd numbers. As a result, only the even numbers are included in the array myArray.

Method 3: Using the ToArray() Method with LINQ Query

C# provides a powerful language-integrated query (LINQ) feature that allows you to perform queries on collections of data. You can use the from keyword along with various LINQ operators to filter, project, and sort data. 

using System;
using System.Linq;
using System.Collections.Generic;

class Program {
  static void Main() {
    List<int> myList = new List<int>() { 1, 2, 3, 4, 5 };
    int[] myArray = (from num in myList where num > 2 select num).ToArray();
    Console.WriteLine("Array elements: " + string.Join(", ", myArray));
  }
}

Output:

Array elements: 3, 4, 5

In the above example, we create a list `myList` containing integers from 1 to 5. We then use a LINQ query to select only the numbers greater than 2 from the list using the `where` clause, and project the selected numbers into an array using the `ToArray()` method. Finally, we print the elements of the resulting array `myArray`.

Method 4: Using the CopyTo() Method

You can also convert a list to an array in C# using the `CopyTo()` method provided by the `List<T>` class. This method allows you to copy the elements of the list to an array at a specified index. 

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> myList = new List<int>() { 1, 2, 3, 4, 5 };
        int[] myArray = new int[myList.Count];
        myList.CopyTo(myArray);
        Console.WriteLine("Array elements: " + string.Join(", ", myArray));
    }
}

Output:

Array elements: 1, 2, 3, 4, 5

In the above example, we create a list myList containing integers from 1 to 5. We then create an array myArray with the same size as myList using the new keyword. Finally, we use the CopyTo() method to copy the elements of myList to myArray, and print the elements of myArray.

Method 5: Using the ToArray() Method with Custom Classes

If you have a list of custom objects and you want to convert it to an array, you can use the ToArray() method as well. However, you need to ensure that the custom class implements the IEquatable<T> interface, which defines the equality comparison method. 

using System;
using System.Linq;
using System.Collections.Generic;

class Student : IEquatable<Student>
{
    public string Name { get; set; }
    public int Age { get; set; }

    public bool Equals(Student other)
    {
        if (other == null) return false;
        return (this.Name == other.Name && this.Age == other.Age);
    }
}

class Program
{
    static void Main()
    {
        List<Student> studentList = new List<Student>()
        {
            new Student { Name = "John", Age = 20 },
            new Student { Name = "Jane", Age = 22 },
            new Student { Name = "Tom", Age = 21 }
        };

        Student[] studentArray = studentList.ToArray();
        Console.WriteLine("Array elements: ");
        foreach (var student in studentArray)
        {
            Console.WriteLine("Name: " + student.Name + ", Age: " + student.Age);
        }
    }
}

Output:

Array elements:
Name: John, Age: 20
Name: Jane, Age: 22
Name: Tom, Age: 21

In the above example, we create a list studentList containing objects of the custom class Student, which implements the IEquatable<Student> interface. We then call the ToArray() method on studentList to convert it to an array studentArray. Finally, we iterate through the elements of studentArray using a foreach loop to print the properties Name and Age of each Student object.