Comment déclarez-vous un indexeur de base en C#?

Un indexeur de base en C# est déclaré en utilisant le mot-clé 'this' suivi de la déclaration de l'indexeur. Vous devez spécifier les types de paramètres et le type de retour. Par exemple : public return_type this[parameter_type index] { get; set; } .

Quel est le but des accesseurs 'get' et 'set' dans un indexeur?

L'accesseur 'get' dans un indexeur est utilisé pour récupérer des données à un index spécifié, tandis que l'accesseur 'set' est utilisé pour assigner des données à un index spécifié. Ils fonctionnent de manière similaire aux accesseurs de propriétés mais sont utilisés pour des collections de données.

Pouvez-vous fournir un exemple d'indexeur dans une classe C#?

Bien sûr. Considérez une classe 'Program' avec un tableau de chaînes privé. L'indexeur permet l'accès à ce tableau à l'aide d'un index entier. Par exemple : public string this[int index] { get { return values[index]; } set { values[index] = value; } } .

Comment créez-vous un indexeur générique en C#?

Un indexeur générique en C# peut être créé au sein d'une classe générique. Par exemple, la classe GenericClass inclut un indexeur pouvant gérer tout type de données. L'indexeur est déclaré comme public T this[int index] { get; set; } .

Comment pouvez-vous utiliser les indexeurs en C# pour rationaliser la génération de PDF?

En utilisant une bibliothèque comme IronPDF, vous pouvez utiliser des indexeurs pour gérer et accéder à des modèles HTML stockés dans une classe, qui sont ensuite convertis en documents PDF. Cette approche simplifie le processus de génération de PDF dynamiques à partir de multiples sources HTML.

Pouvez-vous donner un exemple d'utilisation d'une bibliothèque PDF avec un indexeur?

Certainement. Vous pouvez créer une classe qui contient des modèles HTML dans un tableau et utiliser un indexeur pour accéder à ces modèles. Ensuite, utilisez une bibliothèque PDF pour rendre ces chaînes HTML en tant que documents PDF. Par exemple, une classe appelée PdfGenerator utilise un indexeur pour accéder au HTML et générer des PDF.

Quels sont les avantages de l'utilisation des indexeurs en C#?

Les indexeurs en C# offrent une syntaxe simplifiée pour accéder aux éléments dans une collection, rendant votre code plus intuitif et lisible. Ils permettent aux classes et structures de se comporter comme des tableaux, permettant une encapsulation et un accès aux données efficace.

Comment les indexeurs peuvent-ils aider à créer des structures de données dynamiques en C#?

Les indexeurs permettent aux développeurs de créer des structures de données dynamiques en rendant les collections accessibles et modifiables à l'aide d'une syntaxe semblable à celle des tableaux. Cela peut être particulièrement utile dans des scénarios où les données doivent être gérées de manière flexible, comme dans la génération de contenu PDF dynamique.

How can developers start using IronPDF?

Developers can start with a free trial of IronPDF, offering full access to its features, and later purchase a license if satisfied with the functionality.

La Bibliothèque PDF C#

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

MISES À JOUR POUR LES DÉVELOPPEURS

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

Jacob Mellor

Updated: 19 juillet 2026

Un indexeur en C# est un type spécial de propriété qui permet d'accéder aux instances d'une classe ou d'une structure en utilisant l'opérateur d'accès de tableau []. Les indexeurs peuvent être très utiles pour créer des "tableaux intelligents" ou encapsuler des données dans une syntaxe simplifiée. Ils fournissent un moyen d'utiliser les instances d'une classe tout comme vous utiliseriez des tableaux, où vous pouvez accéder aux données via un indice. Cet article explorera comment déclarer et utiliser les indexeurs C# avec des exemples pratiques. Et nous explorerons également la bibliothèque IronPDF à la fin de l'article.

Syntaxe de base de l'indexeur

Un indexeur est un membre d'instance utilisant le mot-clé this dans une classe ou une structure, suivi de la déclaration de l'indexeur. Vous devez également spécifier les types de paramètres et le type de retour. La syntaxe générale pour un membre d'instance indexeur ressemble à ceci :

public return_type this[parameter_type index]
{
    get
    {
        // Code to return data
    }
    set
    {
        // Code to set data
    }
}

public return_type this[parameter_type index]
{
    get
    {
        // Code to return data
    }
    set
    {
        // Code to set data
    }
}

Default Public Property Item(ByVal index As parameter_type) As return_type
	Get
		' Code to return data
	End Get
	Set(ByVal value As return_type)
		' Code to set data
	End Set
End Property

Default Public Property Item(ByVal index As parameter_type) As return_type
	Get
		' Code to return data
	End Get
	Set(ByVal value As return_type)
		' Code to set data
	End Set
End Property

Ici, return_type est le type de valeur que l'indexeur retournera, tel qu'une valeur entière, et parameter_type est le type de l'index, souvent un int. L'accesseur get retourne la valeur à l'index spécifié, et l'accesseur de bloc de code set assigne une valeur à cet index.

Déclaration et utilisation de l'indexeur

Nous examinerons une illustration de base de l'implémentation d'un indexeur au sein d'une classe C#. Considérez une classe Program qui encapsule un tableau de chaînes.

class Program
{
    private string[] values = new string[5]; // Array with 5 elements
    public string this[int index]
    {
        get
        {
            return values[index];
        }
        set
        {
            values[index] = value;
        }
    }
}

class Program
{
    private string[] values = new string[5]; // Array with 5 elements
    public string this[int index]
    {
        get
        {
            return values[index];
        }
        set
        {
            values[index] = value;
        }
    }
}

Friend Class Program
	Private values(4) As String ' Array with 5 elements
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return values(index)
		End Get
		Set(ByVal value As String)
			values(index) = value
		End Set
	End Property
End Class

Friend Class Program
	Private values(4) As String ' Array with 5 elements
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return values(index)
		End Get
		Set(ByVal value As String)
			values(index) = value
		End Set
	End Property
End Class

Dans le code ci-dessus :

La classe Program contient un tableau de chaînes nommé values.
La string this[int index] est la déclaration de l'indexeur, où le int index est la propriété paramétrée par un index utilisée pour accéder aux éléments du tableau.
L'accesseur get retourne la valeur indexée à l'index spécifié, et l'accesseur set assigne une valeur indexée à cet index.

Cela signifie que vous pouvez créer une instance de la classe Program et accéder à son tableau values en utilisant l'indexeur, comme ceci :

class Program
{
    static void Main()
    {
        Program program = new Program();
        // Set values using indexer
        program[0] = "First";
        program[1] = "Second";
        // Access values using indexer
        Console.WriteLine(program[0]); // Output: First
        Console.WriteLine(program[1]); // Output: Second
    }
}

class Program
{
    static void Main()
    {
        Program program = new Program();
        // Set values using indexer
        program[0] = "First";
        program[1] = "Second";
        // Access values using indexer
        Console.WriteLine(program[0]); // Output: First
        Console.WriteLine(program[1]); // Output: Second
    }
}

Friend Class Program
	Shared Sub Main()
		Dim program As New Program()
		' Set values using indexer
		program(0) = "First"
		program(1) = "Second"
		' Access values using indexer
		Console.WriteLine(program(0)) ' Output: First
		Console.WriteLine(program(1)) ' Output: Second
	End Sub
End Class

Friend Class Program
	Shared Sub Main()
		Dim program As New Program()
		' Set values using indexer
		program(0) = "First"
		program(1) = "Second"
		' Access values using indexer
		Console.WriteLine(program(0)) ' Output: First
		Console.WriteLine(program(1)) ' Output: Second
	End Sub
End Class

Dans ce code, vous voyez que l'indexeur fournit une syntaxe simple pour accéder au tableau values, similaire à la façon dont vous accéderiez aux éléments dans un tableau.

Comprendre les accesseurs `get` et `set`

Les accesseurs get et set à l'intérieur de l'indexeur sont comme du code bloc qui vous permet de récupérer et d'assigner des données de manière similaire à ce que vous feriez avec des propriétés. La principale différence est que les indexeurs utilisent un paramètre d'indice pour travailler avec des collections de données plutôt qu'avec des membres de données individuels.

Le bloc get est responsable du retour des données à l'index spécifié, tandis que le bloc set assigne des données à l'index spécifié. Voici un autre exemple pour consolider votre compréhension :

class StudentRecords
{
    private string[] studentNames = new string[3];
    public string this[int index]
    {
        get
        {
            if (index >= 0 && index < studentNames.Length)
            {
                return studentNames[index];
            }
            return "Invalid Index";
        }
        set
        {
            if (index >= 0 && index < studentNames.Length)
            {
                studentNames[index] = value;
            }
        }
    }
    public int Length
    {
        get { return studentNames.Length; }
    }
}

class StudentRecords
{
    private string[] studentNames = new string[3];
    public string this[int index]
    {
        get
        {
            if (index >= 0 && index < studentNames.Length)
            {
                return studentNames[index];
            }
            return "Invalid Index";
        }
        set
        {
            if (index >= 0 && index < studentNames.Length)
            {
                studentNames[index] = value;
            }
        }
    }
    public int Length
    {
        get { return studentNames.Length; }
    }
}

Friend Class StudentRecords
	Private studentNames(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			If index >= 0 AndAlso index < studentNames.Length Then
				Return studentNames(index)
			End If
			Return "Invalid Index"
		End Get
		Set(ByVal value As String)
			If index >= 0 AndAlso index < studentNames.Length Then
				studentNames(index) = value
			End If
		End Set
	End Property
	Public ReadOnly Property Length() As Integer
		Get
			Return studentNames.Length
		End Get
	End Property
End Class

Friend Class StudentRecords
	Private studentNames(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			If index >= 0 AndAlso index < studentNames.Length Then
				Return studentNames(index)
			End If
			Return "Invalid Index"
		End Get
		Set(ByVal value As String)
			If index >= 0 AndAlso index < studentNames.Length Then
				studentNames(index) = value
			End If
		End Set
	End Property
	Public ReadOnly Property Length() As Integer
		Get
			Return studentNames.Length
		End Get
	End Property
End Class

Dans cet exemple :

La classe StudentRecords a un tableau privé string[] studentNames qui contient les noms des étudiants.
L'indexeur vérifie si l'indice est dans les limites du tableau avant de définir ou de récupérer la valeur.
Une propriété de type int Length fournit un accès à la longueur du tableau.

Vous pouvez utiliser cette classe dans la méthode Main comme suit :

class Program
{
    public static void Main()
    {
        StudentRecords records = new StudentRecords();
        // Set values using indexer
        records[0] = "John";
        records[1] = "Jane";
        records[2] = "Bob";
        // Access values using indexer
        for (int i = 0; i < records.Length; i++)
        {
            Console.WriteLine(records[i]);
        }
    }
}

class Program
{
    public static void Main()
    {
        StudentRecords records = new StudentRecords();
        // Set values using indexer
        records[0] = "John";
        records[1] = "Jane";
        records[2] = "Bob";
        // Access values using indexer
        for (int i = 0; i < records.Length; i++)
        {
            Console.WriteLine(records[i]);
        }
    }
}

Friend Class Program
	Public Shared Sub Main()
		Dim records As New StudentRecords()
		' Set values using indexer
		records(0) = "John"
		records(1) = "Jane"
		records(2) = "Bob"
		' Access values using indexer
		For i As Integer = 0 To records.Length - 1
			Console.WriteLine(records(i))
		Next i
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim records As New StudentRecords()
		' Set values using indexer
		records(0) = "John"
		records(1) = "Jane"
		records(2) = "Bob"
		' Access values using indexer
		For i As Integer = 0 To records.Length - 1
			Console.WriteLine(records(i))
		Next i
	End Sub
End Class

Créer un indexeur générique

Vous pouvez également créer des classes génériques avec des indexeurs, permettant à votre code de gérer plusieurs types de données. Voici un simple exemple de classe générique avec un indexeur générique :

class GenericClass<t>
{
    private T[] elements = new T[5];
    public T this[int index]
    {
        get
        {
            return elements[index];
        }
        set
        {
            elements[index] = value;
        }
    }
    public int Length
    {
        get { return elements.Length; }
    }
}

class GenericClass<t>
{
    private T[] elements = new T[5];
    public T this[int index]
    {
        get
        {
            return elements[index];
        }
        set
        {
            elements[index] = value;
        }
    }
    public int Length
    {
        get { return elements.Length; }
    }
}

Option Strict On
Option Infer On

Public Class GenericClass(Of T)
    Private elements As T() = New T(4) {}

    Default Public Property Item(index As Integer) As T
        Get
            Return elements(index)
        End Get
        Set(value As T)
            elements(index) = value
        End Set
    End Property

    Public ReadOnly Property Length As Integer
        Get
            Return elements.Length
        End Get
    End Property
End Class

Option Strict On
Option Infer On

Public Class GenericClass(Of T)
    Private elements As T() = New T(4) {}

    Default Public Property Item(index As Integer) As T
        Get
            Return elements(index)
        End Get
        Set(value As T)
            elements(index) = value
        End Set
    End Property

    Public ReadOnly Property Length As Integer
        Get
            Return elements.Length
        End Get
    End Property
End Class

Dans ce code :

La classe GenericClass définit un indexeur qui peut fonctionner avec n'importe quel type de données.
L'indexeur this[int index] vous permet d'accéder aux éléments du tableau, quel que soit le type.

Vous pouvez maintenant utiliser le GenericClass avec différents types de données dans la méthode Main :

class Program
{
    public static void Main()
    {
        GenericClass<int> intArray = new GenericClass<int>();
        intArray[0] = 10;
        intArray[1] = 20;

        GenericClass<string> stringArray = new GenericClass<string>();
        stringArray[0] = "Hello";
        stringArray[1] = "World";

        // Output the integer array values
        for (int i = 0; i < intArray.Length; i++)
        {
            Console.WriteLine(intArray[i]);
        }

        // Output the string array values
        for (int i = 0; i < stringArray.Length; i++)
        {
            Console.WriteLine(stringArray[i]);
        }
    }
}

class Program
{
    public static void Main()
    {
        GenericClass<int> intArray = new GenericClass<int>();
        intArray[0] = 10;
        intArray[1] = 20;

        GenericClass<string> stringArray = new GenericClass<string>();
        stringArray[0] = "Hello";
        stringArray[1] = "World";

        // Output the integer array values
        for (int i = 0; i < intArray.Length; i++)
        {
            Console.WriteLine(intArray[i]);
        }

        // Output the string array values
        for (int i = 0; i < stringArray.Length; i++)
        {
            Console.WriteLine(stringArray[i]);
        }
    }
}

Friend Class Program
	Public Shared Sub Main()
		Dim intArray As New GenericClass(Of Integer)()
		intArray(0) = 10
		intArray(1) = 20

		Dim stringArray As New GenericClass(Of String)()
		stringArray(0) = "Hello"
		stringArray(1) = "World"

		' Output the integer array values
		For i As Integer = 0 To intArray.Length - 1
			Console.WriteLine(intArray(i))
		Next i

		' Output the string array values
		For i As Integer = 0 To stringArray.Length - 1
			Console.WriteLine(stringArray(i))
		Next i
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim intArray As New GenericClass(Of Integer)()
		intArray(0) = 10
		intArray(1) = 20

		Dim stringArray As New GenericClass(Of String)()
		stringArray(0) = "Hello"
		stringArray(1) = "World"

		' Output the integer array values
		For i As Integer = 0 To intArray.Length - 1
			Console.WriteLine(intArray(i))
		Next i

		' Output the string array values
		For i As Integer = 0 To stringArray.Length - 1
			Console.WriteLine(stringArray(i))
		Next i
	End Sub
End Class

Utiliser IronPDF avec l'indexeur C#

Indexeurs C# (Comment cela fonctionne pour les développeurs) : Figure 1 - IronPDF

IronPDF est une bibliothèque C# conçue pour générer, éditer et convertir des PDFs dans des applications .NET. Elle simplifie le travail avec les PDFs pour les développeurs afin de créer des PDFs à partir de HTML, manipuler des fichiers PDF et gérer des fonctionnalités avancées telles que la fusion, l'impression et l'ajout de signatures par programmation.

Vous pouvez tirer parti d'IronPDF dans vos programmes C# qui utilisent des indexeurs pour générer et gérer dynamiquement le contenu des PDFs. Par exemple, supposons que vous ayez une classe qui contient des chaînes HTML, et que vous souhaitiez générer des PDFs pour chaque entrée HTML en utilisant un indexeur. Cette approche rationalise la génération de PDFs tout en gardant votre code organisé et intuitif.

using IronPdf;
using System;

class PdfGenerator
{
    private string[] htmlTemplates = new string[3];
    public string this[int index]
    {
        get { return htmlTemplates[index]; }
        set { htmlTemplates[index] = value; }
    }

    public void GeneratePdf(int index, string outputPath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this[index]); // Access HTML string using indexer
        pdfDocument.SaveAs(outputPath);
    }
}

class Program
{
    public static void Main()
    {
        PdfGenerator pdfGen = new PdfGenerator();
        // Populate HTML templates
        pdfGen[0] = "<h1>First Document</h1><p>This is the first PDF.</p>";
        pdfGen[1] = "<h1>Second Document</h1><p>This is the second PDF.</p>";
        pdfGen[2] = "<h1>Third Document</h1><p>This is the third PDF.</p>";

        // Generate PDFs using the indexer
        pdfGen.GeneratePdf(0, "first.pdf");
        pdfGen.GeneratePdf(1, "second.pdf");
        pdfGen.GeneratePdf(2, "third.pdf");

        Console.WriteLine("PDFs generated successfully.");
    }
}

using IronPdf;
using System;

class PdfGenerator
{
    private string[] htmlTemplates = new string[3];
    public string this[int index]
    {
        get { return htmlTemplates[index]; }
        set { htmlTemplates[index] = value; }
    }

    public void GeneratePdf(int index, string outputPath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this[index]); // Access HTML string using indexer
        pdfDocument.SaveAs(outputPath);
    }
}

class Program
{
    public static void Main()
    {
        PdfGenerator pdfGen = new PdfGenerator();
        // Populate HTML templates
        pdfGen[0] = "<h1>First Document</h1><p>This is the first PDF.</p>";
        pdfGen[1] = "<h1>Second Document</h1><p>This is the second PDF.</p>";
        pdfGen[2] = "<h1>Third Document</h1><p>This is the third PDF.</p>";

        // Generate PDFs using the indexer
        pdfGen.GeneratePdf(0, "first.pdf");
        pdfGen.GeneratePdf(1, "second.pdf");
        pdfGen.GeneratePdf(2, "third.pdf");

        Console.WriteLine("PDFs generated successfully.");
    }
}

Imports IronPdf
Imports System

Friend Class PdfGenerator
	Private htmlTemplates(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return htmlTemplates(index)
		End Get
		Set(ByVal value As String)
			htmlTemplates(index) = value
		End Set
	End Property

	Public Sub GeneratePdf(ByVal index As Integer, ByVal outputPath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(Me(index)) ' Access HTML string using indexer
		pdfDocument.SaveAs(outputPath)
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim pdfGen As New PdfGenerator()
		' Populate HTML templates
		pdfGen(0) = "<h1>First Document</h1><p>This is the first PDF.</p>"
		pdfGen(1) = "<h1>Second Document</h1><p>This is the second PDF.</p>"
		pdfGen(2) = "<h1>Third Document</h1><p>This is the third PDF.</p>"

		' Generate PDFs using the indexer
		pdfGen.GeneratePdf(0, "first.pdf")
		pdfGen.GeneratePdf(1, "second.pdf")
		pdfGen.GeneratePdf(2, "third.pdf")

		Console.WriteLine("PDFs generated successfully.")
	End Sub
End Class

Imports IronPdf
Imports System

Friend Class PdfGenerator
	Private htmlTemplates(2) As String
	Default Public Property Item(ByVal index As Integer) As String
		Get
			Return htmlTemplates(index)
		End Get
		Set(ByVal value As String)
			htmlTemplates(index) = value
		End Set
	End Property

	Public Sub GeneratePdf(ByVal index As Integer, ByVal outputPath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(Me(index)) ' Access HTML string using indexer
		pdfDocument.SaveAs(outputPath)
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		Dim pdfGen As New PdfGenerator()
		' Populate HTML templates
		pdfGen(0) = "<h1>First Document</h1><p>This is the first PDF.</p>"
		pdfGen(1) = "<h1>Second Document</h1><p>This is the second PDF.</p>"
		pdfGen(2) = "<h1>Third Document</h1><p>This is the third PDF.</p>"

		' Generate PDFs using the indexer
		pdfGen.GeneratePdf(0, "first.pdf")
		pdfGen.GeneratePdf(1, "second.pdf")
		pdfGen.GeneratePdf(2, "third.pdf")

		Console.WriteLine("PDFs generated successfully.")
	End Sub
End Class

Indexeurs C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Résultat de la console

Conclusion

Les indexeurs C# sont une fonctionnalité utile qui vous aide à faire en sorte que vos classes et structures se comportent comme des tableaux. En fournissant une syntaxe simplifiée et un accès flexible aux données, vous pouvez créer un code plus intuitif et lisible. Que vous travailliez avec des chaînes de caractères, des entiers ou tout autre type de données, les indexeurs vous donnent la possibilité d'encapsuler votre structure de données et d'y accéder en utilisant des indices de manière propre et efficace.

IronPDF facilite vos débuts avec un essai gratuit qui vous donne accès à toutes les fonctionnalités dont vous avez besoin pour créer, manipuler et restituer des PDFs. Vous pouvez prendre votre temps pour explorer le logiciel, et une fois que vous êtes satisfait, des licences sont disponibles à partir de $999.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...