Vue d'ensemble du système de type commun

Cette section décrit les concepts et définit les termes qui vous aideront à comprendre et à utiliser l'implémentation de votre langage du système de type commun.

Classification de types

Le système de type commun prend en charge deux catégories générales de types, chacune étant divisée en plusieurs sous-catégories :

• Types valeur

  Les types valeur contiennent directement leurs données ; les instances de types valeur sont allouées sur la pile ou font l'objet d'une allocation inline dans une structure. Les types valeur peuvent être intégrés (implémentés par le runtime), définis par l'utilisateur ou correspondre à des énumérations. Pour avoir la liste des types valeur intégrés, consultez Bibliothèque de classes .NET Framework.

• Types référence

  Les types référence stockent une référence à l'adresse mémoire de la valeur et sont alloués sur le tas. Les types référence peuvent être des types autodescriptifs, des types pointeur ou des types interface. Le type d'un type référence peut être déterminé à partir des valeurs des types autodescriptifs. Les types autodescriptifs sont divisés en tableaux et en types classe. Les types classe sont des classes définies par l'utilisateur, des types valeur boxed et des délégués.

Les variables qui sont des types valeur ont chacune leur propre copie des données ; par conséquent, les opérations sur une variable n'affectent pas les autres variables. Les variables qui sont des types référence peuvent faire référence au même objet ; par conséquent, les opérations sur une variable peuvent affecter le même objet référencé par une autre variable.

Tous les types dérivent du type de base System.Object.

L'exemple suivant illustre la différence entre les types référence et les types valeur.

Imports System

Class Class1
    Public Value As Integer = 0
End Class 'Class1

Class Test
    
    Shared Sub Main()
        Dim val1 As Integer = 0
        Dim val2 As Integer = val1
        val2 = 123
        Dim ref1 As New Class1()
        Dim ref2 As Class1 = ref1
        ref2.Value = 123
        Console.WriteLine("Values: {0}, {1}", val1, val2)
        Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value)
    End Sub 'Main
End Class 'Test

using System;
class Class1
{
public int Value = 0;
}
class Test
{
    static void Main() {
        int val1 = 0;
        int val2 = val1;
        val2 = 123;
        Class1 ref1 = new Class1();
        Class1 ref2 = ref1;
        ref2.Value = 123;
        Console.WriteLine("Values: {0}, {1}", val1, val2);
        Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
    }
}

La sortie de ce programme est présentée ci-dessous.

Values: 0, 123
Refs: 123, 123

Le diagramme suivant illustre les relations entre ces divers types. Notez que des instances de types peuvent être simplement des types valeur ou des types autodescriptifs, bien qu'il y ait des sous-catégories de ces types.

Classification des types

Pour plus d'informations sur chaque type, consultez : Types valeur, Énumérations, Classes, Délégués, Tableaux, Interfaces et Pointeurs.

Valeurs et objets

Les valeurs sont des représentations binaires des données et les types offrent un moyen d'interpréter ces données. Un type valeur est stocké directement sous la forme d'une représentation binaire des données du type. La valeur d'un type référence correspond à l'emplacement de la séquence de bits représentant les données du type.

Chaque valeur a un type exact qui définit complètement la représentation de la valeur et les opérations qui sont définies sur celle-ci. Les valeurs des types autodescriptifs sont appelées objets. Bien qu'il soit toujours possible de déterminer le type exact d'un objet en examinant sa valeur, vous ne pouvez pas le faire avec un type valeur ou un type pointeur. Une valeur peut avoir plusieurs types. Une valeur d'un type qui implémente une interface est également une valeur de ce type interface. De même, une valeur d'un type qui dérive d'un type de base est également une valeur de ce type de base.

Types et assemblys

Le runtime utilise des assemblys pour localiser et charger des types. Le manifeste d'assembly contient les informations que le runtime utilise pour résoudre toutes les références de type effectuées dans la portée de l'assembly.

Un nom de type dans le runtime se compose de deux parties logiques : le nom de l'assembly et le nom du type dans l'assembly. Deux types portant le même nom mais se trouvant dans des assemblys différents sont définis comme deux types distincts.

Les assemblys assurent la cohérence entre la portée des noms vue par le développeur et la portée des noms vue par le système runtime. Les développeurs créent les types dans le contexte d'un assembly. Le contenu de l'assembly qu'un développeur génère établit la portée des noms qui seront disponibles au moment de l'exécution.

Types et espaces de noms

Du point de vue du runtime, un espace de noms est simplement une collection de noms de types. Certains langages peuvent être dotés de constructions et de la syntaxe correspondante permettant aux développeurs de former des groupes logiques de types, mais ces constructions ne sont pas utilisées par le runtime lors de la liaison des types. Ainsi, les classes Object et String font partie de l'espace de noms System, mais le runtime reconnaît uniquement les noms complets de chaque type, qui sont respectivement System.Object et System.String.

Vous pouvez générer un assembly unique qui expose des types qui semblent provenir de deux espaces de noms hiérarchiques différents, tels que System.Collections et System.Windows.Forms. Vous pouvez également générer deux assemblys qui exportent tous deux des types d'exportation dont les noms contiennent MyDll.MyClass.

Si vous créez un outil pour représenter des types dans un assembly comme appartenant à un espace de noms hiérarchique, l'outil doit énumérer les types dans un assembly ou un groupe d'assemblys et analyser les noms de types pour dériver une relation hiérarchique.

Voir aussi

Concepts

Vue d'ensemble de la bibliothèque de classes du .NET Framework
Spécification CLS (Common Language Specification)

Autres ressources

Assemblys dans le Common Language Runtime
Système de type commun
Common Language Runtime
Métadonnées et composants autodescriptifs
Interopérabilité interlangage