Skip to footer content
.NET HELP

C# Initialize List (How It Works For Developers)

Lists are part of the System.Collections.Generic namespace and are versatile for handling collections of data. Lists in C# are dynamic, meaning their size can change at runtime. This flexibility is very helpful in many software engineering scenarios where the number of elements isn't known upfront. Let's dive into different ways to initialize a list in C#. We’ll cover basic techniques, object initializer syntax, collection initializers, and the IronPDF library.

Basic List Initialization

To initialize a list, start by creating an instance of the List<T> class, where T is the type of elements in the list. The most common type is string, but you can use any type.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Initialize an empty list
        List<string> fruits = new List<string>();

        // Adding elements to the list
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Cherry");

        // Display the list
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Initialize an empty list
        List<string> fruits = new List<string>();

        // Adding elements to the list
        fruits.Add("Apple");
        fruits.Add("Banana");
        fruits.Add("Cherry");

        // Display the list
        foreach (var fruit in fruits)
        {
            Console.WriteLine(fruit);
        }
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		' Initialize an empty list
		Dim fruits As New List(Of String)()

		' Adding elements to the list
		fruits.Add("Apple")
		fruits.Add("Banana")
		fruits.Add("Cherry")

		' Display the list
		For Each fruit In fruits
			Console.WriteLine(fruit)
		Next fruit
	End Sub
End Class
$vbLabelText   $csharpLabel

In the example above, we created an empty list and added elements using the Add method. The List<string> represents a list of strings, and we used the Add method to populate it with values.

Using Collection Initializer Syntax

C# offers a more concise way to initialize a list using collection initializer syntax. This allows you to populate the list directly when it is created without repeatedly calling the Add method.

public void InitializeList()
{
    List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
}
public void InitializeList()
{
    List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };
}
Public Sub InitializeList()
	Dim fruits As New List(Of String) From {"Apple", "Banana", "Cherry"}
End Sub
$vbLabelText   $csharpLabel

This code achieves the same result as the previous example but in a more compact form. Collection initializers allow you to initialize a list with values in a single statement, making your code more readable.

Object Initializers and List Initialization

Object initializer syntax is another way to initialize lists, mainly when working with custom objects. Here’s an example of how object initializers work with lists:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

List<Person> people = new List<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 25 },
    new Person { Name = "Jack", Age = 35 }
};
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

List<Person> people = new List<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 25 },
    new Person { Name = "Jack", Age = 35 }
};
Friend Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Private people As New List(Of Person) From {
	New Person With {
		.Name = "John",
		.Age = 30
	},
	New Person With {
		.Name = "Jane",
		.Age = 25
	},
	New Person With {
		.Name = "Jack",
		.Age = 35
	}
}
$vbLabelText   $csharpLabel

In this example, we create a list of Person objects using object initializers. The Person class has two properties: Name and Age, which are explicitly assigned values when the list is created.

Creating a List with an Initial Size

While lists are dynamic in size, you can specify an initial capacity if you know approximately how many elements the list will hold. This can improve performance by reducing the number of memory reallocations.

List<string> fruits = new List<string>(10); // Initial size of 10
List<string> fruits = new List<string>(10); // Initial size of 10
Dim fruits As New List(Of String)(10) ' Initial size of 10
$vbLabelText   $csharpLabel

This creates an empty list with an initial capacity of 10. Although it doesn't add elements, it allocates enough memory to hold up to 10 elements without resizing the internal array.

Initializing a List from an Array

You can also initialize a list from an existing array using the list constructor that takes an IEnumerable<T> argument. This is useful when you have an array and want to convert it into a list for flexibility.

// New String array of fruit
string[] fruitArray = { "Apple", "Banana", "Cherry" };
List<string> fruits = new List<string>(fruitArray);
// New String array of fruit
string[] fruitArray = { "Apple", "Banana", "Cherry" };
List<string> fruits = new List<string>(fruitArray);
' New String array of fruit
Dim fruitArray() As String = { "Apple", "Banana", "Cherry" }
Dim fruits As New List(Of String)(fruitArray)
$vbLabelText   $csharpLabel

Here, a new array is created and then used to initialize a list. This converts the fruitArray array into a list. Any IEnumerable<T>, including arrays, can be passed to the list constructor for initialization.

Using the AddRange Method

If you have an existing collection of items, you can use the AddRange method to add multiple elements to a list together.

List<string> fruits = new List<string> { "Apple", "Banana" };
string[] moreFruits = { "Cherry", "Date", "Elderberry" };
fruits.AddRange(moreFruits);
List<string> fruits = new List<string> { "Apple", "Banana" };
string[] moreFruits = { "Cherry", "Date", "Elderberry" };
fruits.AddRange(moreFruits);
Dim fruits As New List(Of String) From {"Apple", "Banana"}
Dim moreFruits() As String = { "Cherry", "Date", "Elderberry" }
fruits.AddRange(moreFruits)
$vbLabelText   $csharpLabel

In this example, we start with a list containing two elements and add multiple new items from an array using AddRange. This method can improve performance by adding elements in bulk, as it minimizes the need for multiple reallocations.

Initializing a List with Custom Objects

When initializing a list of custom objects, you can combine object initializers with collection initializers to create complex data structures in a single expression.

List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 28 },
    new Person { Name = "Bob", Age = 32 },
    new Person { Name = "Charlie", Age = 40 }
};
List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 28 },
    new Person { Name = "Bob", Age = 32 },
    new Person { Name = "Charlie", Age = 40 }
};
Dim people As New List(Of Person) From {
	New Person With {
		.Name = "Alice",
		.Age = 28
	},
	New Person With {
		.Name = "Bob",
		.Age = 32
	},
	New Person With {
		.Name = "Charlie",
		.Age = 40
	}
}
$vbLabelText   $csharpLabel

This technique allows for creating and initializing a list of objects in a single statement, making the code concise and easy to read.

List Initialization with Extension Methods

You can also implement an extension method to initialize a list in a custom way. Extension methods provide a mechanism to improve existing types with new capabilities without altering their original structure.

public static class ListExtensions
{
    public static List<T> InitializeWith<T>(this List<T> list, params T[] elements)
    {
        list.AddRange(elements);
        return list;
    }
}

// Usage
List<string> fruits = new List<string>().InitializeWith("Apple", "Banana", "Cherry");
public static class ListExtensions
{
    public static List<T> InitializeWith<T>(this List<T> list, params T[] elements)
    {
        list.AddRange(elements);
        return list;
    }
}

// Usage
List<string> fruits = new List<string>().InitializeWith("Apple", "Banana", "Cherry");
Public Module ListExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function InitializeWith(Of T)(ByVal list As List(Of T), ParamArray ByVal elements() As T) As List(Of T)
		list.AddRange(elements)
		Return list
	End Function
End Module

' Usage
Private fruits As List(Of String) = (New List(Of String)()).InitializeWith("Apple", "Banana", "Cherry")
$vbLabelText   $csharpLabel

Here, we define an extension method, InitializeWith, which adds elements to the list and returns the list itself. This allows you to chain the list's initialization and population.

IronPDF: C# PDF Library

C# Initialize List (How It Works For Developers): Figure 1 - IronPDF: The C# PDF Library

If you have a list, like a list of fruits, you can quickly turn it into an HTML table and render it as a PDF using IronPDF, all in just a few lines of code. The process is straightforward: initialize your list, convert it to HTML, and let IronPDF generate the PDF. Here’s an example:

using IronPdf;
using System;
using System.Collections.Generic;
using System.Text;

class Program
{
    static void Main()
    {
        // Initialize a list of strings representing data
        List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };

        // Convert the list to an HTML table
        StringBuilder htmlContent = new StringBuilder();
        htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>");
        foreach (var fruit in fruits)
        {
            htmlContent.Append($"<tr><td>{fruit}</td></tr>");
        }
        htmlContent.Append("</table>");

        // Render the HTML to PDF using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString());

        // Save the PDF to a file
        PDF.SaveAs("FruitsList.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}
using IronPdf;
using System;
using System.Collections.Generic;
using System.Text;

class Program
{
    static void Main()
    {
        // Initialize a list of strings representing data
        List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };

        // Convert the list to an HTML table
        StringBuilder htmlContent = new StringBuilder();
        htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>");
        foreach (var fruit in fruits)
        {
            htmlContent.Append($"<tr><td>{fruit}</td></tr>");
        }
        htmlContent.Append("</table>");

        // Render the HTML to PDF using IronPDF
        var Renderer = new ChromePdfRenderer();
        var PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString());

        // Save the PDF to a file
        PDF.SaveAs("FruitsList.pdf");
        Console.WriteLine("PDF generated successfully.");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Text

Friend Class Program
	Shared Sub Main()
		' Initialize a list of strings representing data
		Dim fruits As New List(Of String) From {"Apple", "Banana", "Cherry"}

		' Convert the list to an HTML table
		Dim htmlContent As New StringBuilder()
		htmlContent.Append("<table border='1'><tr><th>Fruit Name</th></tr>")
		For Each fruit In fruits
			htmlContent.Append($"<tr><td>{fruit}</td></tr>")
		Next fruit
		htmlContent.Append("</table>")

		' Render the HTML to PDF using IronPDF
		Dim Renderer = New ChromePdfRenderer()
		Dim PDF = Renderer.RenderHtmlAsPdf(htmlContent.ToString())

		' Save the PDF to a file
		PDF.SaveAs("FruitsList.pdf")
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class
$vbLabelText   $csharpLabel

C# Initialize List (How It Works For Developers): Figure 2 - Example output

This code initializes a list, creates an HTML table from it, and uses IronPDF to create a PDF file. It's a simple and direct way to generate PDFs from your data collections.

Conclusion

C# Initialize List (How It Works For Developers): Figure 3 - IronPDF licensing page

List initialization in C# is a fundamental concept that every software engineer should master. Whether you're working with simple lists of strings or complex lists of objects, C# offers several methods to initialize and populate lists efficiently. From basic initialization to object and collection initializers, these techniques help you write clean, concise, and maintainable code.

IronPDF offers a free trial that lets you try the product without making an initial investment. When you're confident it meets your needs, licenses are available starting at $749.

Frequently Asked Questions

What are the basic methods to initialize a list in C#?

In C#, you can initialize a list by creating an instance of the List<T> class, where T is the type of elements. For example, List<string> fruits = new List<string>(); is a basic way to initialize a list.

How can collection initializer syntax improve list initialization in C#?

Collection initializer syntax allows you to populate a list directly during its creation, making the code more concise. For instance: List<string> fruits = new List<string> { 'Apple', 'Banana', 'Cherry' };.

What is the purpose of object initializer syntax when initializing lists?

Object initializer syntax is beneficial for initializing lists with custom objects, allowing property values to be set as the list is created. For example: new Person { Name = 'John', Age = 30 }; within a list.

Can you set an initial capacity for a list and why is it helpful?

Yes, setting an initial capacity for a list can improve performance by reducing the need for memory reallocations as the list grows. Example: List<string> fruits = new List<string>(10);.

How can a list be initialized from an existing array in C#?

You can initialize a list from an array using the list constructor that accepts an IEnumerable<T>. Example: List<string> fruits = new List<string>(fruitArray);.

What role does the AddRange method play in list initialization?

The AddRange method adds multiple elements from a collection to a list at once, optimizing performance by minimizing reallocations. Example: fruits.AddRange(moreFruits);.

How can custom objects be initialized in a list using initializers?

Custom objects can be initialized in a list using a combination of object and collection initializers, enabling a single expression for list creation. Example: new List<Person> { new Person { Name = 'Alice', Age = 28 } };.

What are extension methods and how do they relate to list initialization?

Extension methods allow adding new functionalities to existing types. For instance, an extension method like InitializeWith can be written to streamline list initialization and population.

How can lists be converted to PDFs in C#?

Using IronPDF, you can convert a list to an HTML table and render it as a PDF, simplifying the process of generating PDFs from data collections in C#.

Is there a free trial available for generating PDFs from data collections?

Yes, IronPDF offers a free trial, allowing users to test its PDF generation capabilities from data collections without an initial purchase.

Chipego
Software Engineer
Chipego has a natural skill for listening that helps him to comprehend customer issues, and offer intelligent solutions. He joined the Iron Software team in 2023, after studying a Bachelor of Science in Information Technology. IronPDF and IronOCR are the two products Chipego has been focusing on, but his knowledge of ...Read More