C# Deconstructor (Comment ça fonctionne pour les développeurs)

Example of a Basic Deconstructor

Consider a simple Person class. This class can have a deconstructor that splits the object into name and age. Here’s how you can define it:

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

    // Deconstructor method to split Person object into its properties
    public void Deconstruct(out string name, out int age)
    {
        name = this.Name;
        age = this.Age;
    }
}

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

    // Deconstructor method to split Person object into its properties
    public void Deconstruct(out string name, out int age)
    {
        name = this.Name;
        age = this.Age;
    }
}

Public Class Person
	Public Property Name() As String
	Public Property Age() As Integer

	' Deconstructor method to split Person object into its properties
	Public Sub Deconstruct(<System.Runtime.InteropServices.Out()> ByRef name As String, <System.Runtime.InteropServices.Out()> ByRef age As Integer)
		name = Me.Name
		age = Me.Age
	End Sub
End Class

In the above example, the Person class has a Deconstruct method that outputs the Name and Age properties. This is particularly useful when you want to assign these values to variables quickly.

Practical Application

To use a deconstructor, you typically employ tuple deconstruction syntax. Here’s how you can use the deconstructor for the Person class:

public static void Main()
{
    // Create a new Person instance
    Person person = new Person { Name = "Iron Developer", Age = 30 };

    // Use the deconstructor to assign values to the tuple elements
    (string name, int age) = person;

    // Output the extracted values
    Console.WriteLine($"Name: {name}, Age: {age}");
}

public static void Main()
{
    // Create a new Person instance
    Person person = new Person { Name = "Iron Developer", Age = 30 };

    // Use the deconstructor to assign values to the tuple elements
    (string name, int age) = person;

    // Output the extracted values
    Console.WriteLine($"Name: {name}, Age: {age}");
}

Public Shared Sub Main()
	' Create a new Person instance
	Dim person As New Person With {
		.Name = "Iron Developer",
		.Age = 30
	}

	' Use the deconstructor to assign values to the tuple elements
'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
	(String name, Integer age) = person

	' Output the extracted values
	Console.WriteLine($"Name: {name}, Age: {age}")
End Sub

The public static void Main method in this instance creates a new Person, then uses the deconstructor to extract the Name and Age. This method is implicitly called when the program runs, simplifying the extraction of data from objects.

Tuple Deconstruction

using System;

public class Program
{
    public static void Main()
    {
        // Create an instance of the Book class
        var book = new Book
        {
            Title = "C# Programming",
            Author = "Jon Skeet",
            Pages = 300
        };

        // Deconstruct the book object to get properties directly
        var (title, author, pages) = DeconstructBook(book);

        // Output the deconstructed properties
        Console.WriteLine($"Title: {title}, Author: {author}, Pages: {pages}");
    }

    // Deconstructor method for a Book class
    private static (string title, string author, int pages) DeconstructBook(Book book)
    {
        return (book.Title, book.Author, book.Pages);
    }
}

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
    public int Pages { get; set; }
}

using System;

public class Program
{
    public static void Main()
    {
        // Create an instance of the Book class
        var book = new Book
        {
            Title = "C# Programming",
            Author = "Jon Skeet",
            Pages = 300
        };

        // Deconstruct the book object to get properties directly
        var (title, author, pages) = DeconstructBook(book);

        // Output the deconstructed properties
        Console.WriteLine($"Title: {title}, Author: {author}, Pages: {pages}");
    }

    // Deconstructor method for a Book class
    private static (string title, string author, int pages) DeconstructBook(Book book)
    {
        return (book.Title, book.Author, book.Pages);
    }
}

public class Book
{
    public string Title { get; set; }
    public string Author { get; set; }
    public int Pages { get; set; }
}

Imports System

Public Class Program
	Public Shared Sub Main()
		' Create an instance of the Book class
		Dim book As New Book With {
			.Title = "C# Programming",
			.Author = "Jon Skeet",
			.Pages = 300
		}

		' Deconstruct the book object to get properties directly
'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
		var(title, author, pages) = DeconstructBook(book)

		' Output the deconstructed properties
		Console.WriteLine($"Title: {title}, Author: {author}, Pages: {pages}")
	End Sub

	' Deconstructor method for a Book class
	Private Shared Function DeconstructBook(ByVal book As Book) As (title As String, author As String, pages As Integer)
		Return (book.Title, book.Author, book.Pages)
	End Function
End Class

Public Class Book
	Public Property Title() As String
	Public Property Author() As String
	Public Property Pages() As Integer
End Class

Key Features and Behavior

Deconstructors provide a way to explicitly extract information from an object. They must be called explicitly to retrieve data. This ensures that the information can be accessed directly and immediately. Deconstructors simplify the process of breaking down an object into its parts. They are especially useful for pattern matching and value extraction.

Inheritance and Deconstructors

If a base class has a deconstructor, it can be extended or overridden in a derived class. This follows the inheritance chain, allowing for extension methods to be applied, which can further customize the deconstruction process. This is particularly useful when the derived class includes additional properties that need to be extracted alongside those inherited from the base class.

Exemple de code

The following code shows how you might use IronPDF in C# to generate a PDF from HTML content, and then use a deconstructor to handle the resulting PDF document for further operations like reading properties without needing multiple method calls or temporary variables. This is a basic usage pattern emphasizing the generation and deconstruction aspects:

using IronPdf;

public class PdfGenerator
{
    public static void Main()
    {
        // Set your License Key
        License.LicenseKey = "License-Key";

        // Create an instance of the PDF renderer
        var renderer = new ChromePdfRenderer();

        // Generate a PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF!</h1>");

        // Deconstruct the PDF document to get properties directly
        var (pageCount, author) = DeconstructPdf(pdfDocument);

        // Output the deconstructed properties
        Console.WriteLine($"Page Count: {pageCount}, Author: {author}");
    }

    // Deconstructor method for a PdfDocument
    private static (int pageCount, string author) DeconstructPdf(PdfDocument document)
    {
        return (document.PageCount, document.MetaData.Author);
    }
}

using IronPdf;

public class PdfGenerator
{
    public static void Main()
    {
        // Set your License Key
        License.LicenseKey = "License-Key";

        // Create an instance of the PDF renderer
        var renderer = new ChromePdfRenderer();

        // Generate a PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF!</h1>");

        // Deconstruct the PDF document to get properties directly
        var (pageCount, author) = DeconstructPdf(pdfDocument);

        // Output the deconstructed properties
        Console.WriteLine($"Page Count: {pageCount}, Author: {author}");
    }

    // Deconstructor method for a PdfDocument
    private static (int pageCount, string author) DeconstructPdf(PdfDocument document)
    {
        return (document.PageCount, document.MetaData.Author);
    }
}

Imports IronPdf

Public Class PdfGenerator
	Public Shared Sub Main()
		' Set your License Key
		License.LicenseKey = "License-Key"

		' Create an instance of the PDF renderer
		Dim renderer = New ChromePdfRenderer()

		' Generate a PDF from HTML content
		Dim pdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF!</h1>")

		' Deconstruct the PDF document to get properties directly
'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
		var(pageCount, author) = DeconstructPdf(pdfDocument)

		' Output the deconstructed properties
		Console.WriteLine($"Page Count: {pageCount}, Author: {author}")
	End Sub

	' Deconstructor method for a PdfDocument
	Private Shared Function DeconstructPdf(ByVal document As PdfDocument) As (pageCount As Integer, author As String)
		Return (document.PageCount, document.MetaData.Author)
	End Function
End Class

This C# example abstracts the process of fetching properties from a PDF document, illustrating how you can use a deconstructor in practical scenarios to simplify your code structure and improve readability. Remember, IronPDF does not inherently support deconstructors; this is just a custom implementation for demonstration purposes.