C# New (How It Works For Developers)

Creating Instances with new

To create an instance of an object, the new operator is followed by the class name and a pair of parentheses. If the class has a constructor that takes parameters, arguments must be supplied within these parentheses.

public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");

public class Book
{
    public string Title { get; set; }

    public Book(string title)
    {
        Title = title;
    }
}

Book book = new Book("The C# Programming Language");

Default and Parameterless Constructors

A default constructor is provided by C# if no constructors are explicitly defined in a class. However, once a constructor with parameters is defined, a parameterless constructor must be explicitly declared if needed.

public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}

public class ExampleClass
{
    // Parameterless constructor
    public ExampleClass()
    {
        // Initialization code here
    }
}

Arrays and Collections

Creating arrays of a specific array type in C# is a fundamental skill, but it's the nuances that elevate your coding capabilities. Using the new keyword, you can instantiate arrays, specifying their type and the number of elements they should contain. This is crucial for managing collections of variables in a structured way. Beyond basic arrays, new facilitates the creation of multidimensional and jagged arrays, accommodating complex data structures.

// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns

// Single-dimensional array
int[] numbers = new int[5]; // Initializes an array for 5 integers

// Multidimensional array
int[,] matrix = new int[3, 2]; // A 3x2 matrix

// Jagged array (an array of arrays)
int[][] jaggedArray = new int[3][];
jaggedArray[0] = new int[4]; // First row has 4 columns
jaggedArray[1] = new int[5]; // Second row has 5 columns
jaggedArray[2] = new int[3]; // Third row has 3 columns

Anonymous Types

Anonymous types shine in scenarios requiring temporary data structures without the overhead of declaring a formal class. By using new with a property initializer syntax, you can create objects on the fly. This feature is incredibly useful for LINQ queries where you need to select a subset of properties from a larger object or for quickly grouping data without creating a specific type.

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");

// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

Object Initializers

An object initializer represents a syntactic convenience, allowing you to create an instance of a class and immediately set its properties without calling a constructor with parameters. This not only makes the code more readable but also reduces the likelihood of errors by eliminating the need for multiple constructors for different scenarios. Object initializers are particularly handy when working with complex objects, enabling you to set only the properties you need.

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

public class Rectangle
{
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}

Rectangle rect = new Rectangle
{
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

Local Function

A local function is a method defined within the scope of another method, serving as a powerful tool for organizing code and encapsulating functionality.

public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

public void PerformOperation()
{
    int LocalFunction(int x)
    {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

Lambda Expressions

Lambda expression provides a concise way to write inline expressions or methods without the need for explicit delegate types.

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Hiding Inherited Members

Using new to hide a member in a derived class does not override the same member; instead, it introduces a new member that is distinct from the base class version.

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}

public class BaseClass
{
    public void Display()
    {
        Console.WriteLine("Base display");
    }
}

public class DerivedClass : BaseClass
{
    public new void Display()
    {
        Console.WriteLine("Derived display");
    }
}

The new() Constraint in Generic Type

The new() constraint is a cornerstone of using new with generics, specifying that a type argument in a generic class or method must have a public parameterless constructor. This constraint enables you to create instances of your generic type within the class or method, making your generic classes and methods more flexible and powerful.

public class Container<T> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}

public class Container<T> where T : new()
{
    public T CreateItem()
    {
        return new T();
    }
}

In this example, Container can create instances of T, provided T has a parameterless constructor. This capability is invaluable when developing libraries or frameworks that require object creation but don't know the specific types ahead of time.

Code Example

using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

using IronPdf;
using System;

namespace IronPdfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";

            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");

            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);

            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

In this class Program snippet, new IronPdf.ChromePdfRenderer() demonstrates the instantiation of an IronPDF renderer object. This object is then used to create a new PDF from an HTML string, showcasing the seamless integration of third-party libraries with C#’s object creation patterns. IronPDF requires the use of the new keyword to initiate its classes, making it a relevant example for developers learning about object instantiation and exploring advanced features of C#.