Principes de base de la programmation

Le langage de programmation Visual Basic .NET propose des concepts de base tels que les variables, les opérateurs, les instructions, les classes,... Contrairement aux langages de programmation Visual Basic classique (Visual Basic 6), elle ne font plus partie des instructions de bases. Ainsi, c'est le cas par exemple, pour les fonctions mathématiques (Math), les entrées/sorties de fichier et les déclarations de formulaire. Ils sont fournis par le cadre d'application .NET. En outre, les fonctions Visual Basic .NET existent uniquement pour la compatibilité descendante avec Visual Basic 6.

Fichiers source

Le code source de Visual Basic .NET est enregistré dans des fichiers avec une extension .vb. L'exception à cette règle est lorsque le code Visual Basic .NET est incorporé dans des fichiers de page Web ASP.NET. Ces fichiers ont une extension .aspx.

Les fichiers sources sont des fichiers de texte brut pouvant être créés et modifiés avec n'importe quel éditeur de texte, y compris par le Notepad de Windows. Le code source peut être divisé en autant ou aussi peu de fichiers que vous le souhaitez. Lorsque vous utilisez Visual Studio .NET, les fichiers sources sont répertoriés dans la fenêtre Explorateur de solutions et toutes les sources sont incluses à partir de ces fichiers lorsque la solution est générée. Lorsque vous compilez à partir de la ligne de commande, tous les fichiers source doivent apparaître comme paramètres de ligne de commande pour la commande de compilation. L'emplacement des déclarations dans les fichiers source n'a pas d'importance. Tant que toutes les déclarations référencées apparaissent quelque part dans un fichier source en cours de compilation, elles seront trouvées.

Contrairement aux versions précédentes de Visual Basic classique, aucune extension de fichier spéciale n'est utilisée pour indiquer diverses constructions de langage (par exemple, .cls pour les classes, .frm pour les formulaires,...). La syntaxe a été ajoutée au langage pour différencier diverses constructions. De plus, le pseudolangage permettant de spécifier la disposition graphique des formulaires a été supprimé. La disposition du formulaire est spécifiée en définissant les propriétés des objets de formulaire explicitement dans le code. Soit ce code peut être écrit manuellement, soit le concepteur de formulaires WYSIWYG de Visual Studio .NET peut l'écrire.

Identificateurs

Les identificateurs sont soit des noms donnés aux espaces de noms, soit des types (énumérations, structures, classes, modules standard, interfaces et délégués), soit des membres de type (méthodes, constructeurs, événements, constantes, champs et propriétés) et soit des variables. Les identificateurs doivent commencer par un caractère alphabétique ou un trait de soulignement (_), peuvent être de n'importe quelle longueur et après le premier caractère doivent être composés uniquement de caractères alphanumériques et de soulignement. Les déclarations d'espace de noms peuvent être déclarées soit avec des identificateurs, soit avec des identificateurs qualifiés. Les identificateurs qualifiés se composent de deux identificateurs ou plus liés au caractère point (.). Seules les déclarations d'espaces de noms peuvent utiliser des identificateurs qualifiés. Prenons pour base ce fragment de code :

Ce fragment de code déclare trois identificateurs : Gladir.ProgVBNet (un nom d'espace de noms), Hello (un nom de classe) et SayHello (un nom de méthode). En plus de ceux-ci, le fragment de code utilise trois identificateurs déclarés ailleurs : System (un nom d'espace de noms), Console (un nom de classe) et WriteLine (un nom de méthode).

Bien que Visual Basic .NET ne respecte pas la casse, la casse des identificateurs est conservée lorsque les applications sont compilées. Lors de l'utilisation de composantes Visual Basic .NET à partir de langages sensibles à la casse, l'appelant doit utiliser la casse appropriée. En règle générale, les identificateurs peuvent ne pas correspondre aux mots-clefs Visual Basic .NET. S'il est nécessaire de déclarer ou d'utiliser un identifiant correspondant à un mot-clef, l'identificateur doit être placé entre crochets ([]). Considérez ce fragment de code :

Ce code déclare une classe nommée Public, puis déclare une classe et une méthode utilisant la classe Public. Public est un mot clef dans Visual Basic .NET. L'échapper avec des crochets permet de l'utiliser comme identificateur, dans ce cas le nom d'une classe. Par souci de style, l'utilisation de mots-clefs comme identificateurs doit être évitée, sauf en cas de besoin impérieux. Cette fonctionnalité permet aux applications Visual Basic .NET d'utiliser des composantes externes déclarant des identificateurs correspondant aux mots-clefs Visual Basic .NET.

Mots clefs

Les mots clefs sont des mots ayant une signification particulière dans un langage de programmation. Dans Visual Basic .NET, les mots clefs sont réservés; autrement dit, ils ne peuvent pas être utilisés comme jetons à des fins telles que la dénomination de variables et de sous-programmes. Les mots-clefs de Visual Basic .NET sont indiqués dans le tableau suivants :

Littéraux

Les littéraux sont des représentations de valeurs dans le texte d'un programme. Par exemple, dans la ligne de code suivante, 10 est un littéral, mais x et y ne le sont pas :

Les littéraux ont des types de données tout comme les variables. Le 10 de ce fragment de code est interprété par le compilateur comme de type Integer car il s'agit d'un entier compris dans l'intervalle du type Integer.

Littéraux numériques

Tout littéral entier compris dans l'intervalle du type de données Integer (-2147483648 à 2147483647) est interprété comme le type de données Integer, même si la valeur est suffisamment petite pour être interprétée comme du type Byte ou Short. Les littéraux entiers étant en dehors de l'intervalle Integer mais sont dans l'intervalle du type de données Long (-9223372036854775808 à 9223372036854775807) sont interprétés comme du type de données Long. Les littéraux entiers en dehors de l'intervalle Long provoquent une erreur de compilation. Les littéraux numériques peuvent également être de l'un des types à virgule flottante : Single, Double et Decimal. Par exemple, dans cette ligne de code, 3.14 est un littéral de type Double :

En l'absence d'une indication explicite de type (discutée brièvement), Visual Basic .NET interprète les littéraux à virgule flottante comme type de données Double. Si le littéral est en dehors de l'intervalle du type de données Double (-1,7976931348623157E308 à 1,7976931348623157E308), une erreur de compilation se produit. Le Visual Basic .NET permet aux programmeurs de spécifier explicitement les types de littéraux. Notez que pour certains types intrinsèques, il n'existe aucun moyen d'écrire un littéral.

Littéraux de chaîne de caractères

Les littéraux de type de données String sont constitués de caractères entre guillemets. Par exemple, dans la ligne de code suivante, "Bonjour gladir.com" est un littéral de type de données String :

Les littéraux de chaîne ne sont pas autorisés à s'étendre sur plusieurs lignes source. En d'autres termes, ce n'est pas autorisé :

Pour écrire une chaîne de caractères littérale contenant des guillemets, tapez le caractère deux fois pour chaque fois qu'il doit apparaître. Par exemple :

Cette ligne produit la sortie suivante :

Littéraux de caractères

Le type Char de Visual Basic .NET représente un seul caractère. Ce n'est pas la même chose qu'une chaîne de caractères à un caractère; les chaînes de caractères et les caractères sont des types distincts. Les littéraux de type Char se composent d'un seul caractère entouré de guillemets, suivi du caractère c. Par exemple, dans le code suivant, "A"c est un littéral de type Char :

Pour souligner que ce littéral est d'un type de données différent d'une chaîne de caractères à un seul caractère, notez que ce code provoque une erreur de compilation si Option Strict est On :

L'erreur est :

Littéraux de date

Les littéraux de type de données Date sont formés en insérant une chaîne de caractères de date et d'heure dans des caractères de signe dièse. Par exemple :

Les littéraux de date dans le code Visual Basic .NET doivent être au format m/j/aaaa, quels que soient les paramètres régionaux de l'ordinateur sur lequel le code est écrit.

Littéraux booléens

Les mots-clefs True et False sont les seuls littéraux booléens. Ils représentent respectivement les états booléens True et False. Par exemple :

Nothing

Il existe un littéral n'ayant pas de type : le mot-clef Nothing. Nothing est un symbole spécial représentant une valeur non initialisée de tout type. Il peut être affecté à n'importe quelle variable et passé dans n'importe quel paramètre. Lorsqu'il est utilisé à la place d'un type référence, il représente une référence ne faisant référence à aucun objet. Lorsqu'il est utilisé à la place d'un type valeur, il représente une valeur vide de ce type. Pour les types numériques, il s'agit de 0 ou 0,0. Pour le type de données String, il s'agit de la chaîne de caractères vide (""). Pour le type de données Boolean, il s'agit de False. Pour le type de données Char, il s'agit du caractère Unicode ayant un code numérique de 0. Pour les types de valeur définis par le programmeur, Nothing représente une instance du type ayant été créée mais qui n'a pas reçu de valeur.

Résumé des formats littéraux

Le tableau suivant montre tous les types intrinsèques de Visual Basic .NET, ainsi que le format d'écriture de littéraux de ces types dans les programmes :

Notez les faits suivants sur la formation de littéraux dans Visual Basic .NET :

• Il n'existe aucun moyen de représenter un littéral de type Byte. Cependant, cela ne signifie pas que les littéraux ne peuvent pas être utilisés dans les situations où le type Byte est attendu. Par exemple, le code suivant convient :
  1. Dim MonOctet As Byte = 100
• Même si le compilateur Visual Basic .NET considère 100 comme étant de type Integer dans cet exemple, il reconnaît que le nombre est suffisamment petit pour tenir dans une variable de type Byte.
• Les types non présentés dans le tableau précédent ne peuvent pas être exprimés sous forme de littéraux.

Types

Les types dans Visual Basic .NET sont divisés en deux catégories : les types valeur et les types référence. Les types de valeur minimisent la surcharge de mémoire et maximisent la vitesse d'accès, mais ils manquent de certaines fonctionnalités d'une conception entièrement orientée objet (comme l'héritage). Les types de référence donnent un accès complet aux fonctionnalités orientées objet, mais ils imposent une surcharge de mémoire et de vitesse pour la gestion et l'accès aux objets. Lorsqu'une variable contient un type valeur, les données elles-mêmes sont entreposées dans la variable. Lorsqu'une variable contient un type de référence, une référence aux données (également appelée pointeur) est entreposée dans la variable et les données elles-mêmes sont entreposées ailleurs. Les types primitifs de Visual Basic .NET incluent à la fois les types valeur et les types référence. Pour étendre le système de types, Visual Basic .NET fournit une syntaxe pour définir à la fois l es nouveaux types de valeur et les nouveaux types de référence.

Tous les types de référence dérivent du type Object. Pour unifier le système de types, les types valeur peuvent être traités comme des types de référence si nécessaire. Cela signifie que tous les types peuvent dériver du type Object. Le traitement des types de valeur comme des types de référence est un processus connu sous le nom de boite.

Types fondamentaux

Le Visual Basic .NET a plusieurs types intégrés. Chacun de ces types est un alias pour un type fourni par l'architecture .NET. Étant donné que les types Visual Basic .NET sont équivalents aux types fournis sous-jacents .NET correspondants, il n'y a aucun problème de compatibilité de type lors du passage de paramètres aux composantes développés dans d'autres langages. Dans le code, cela ne fait aucune différence pour le compilateur que les types soient spécifiés à l'aide du nom de mot-clef du type ou du nom de type .NET sous-jacent. Par exemple, le test de ce fragment de code réussit :

Les types fondamentaux de Visual Basic .NET sont :

Parmi les types fondamentaux, Boolean, Byte, Char, Date, Decimal, Double, Integer, Long, Short et Single (c'est-à-dire, tous sauf Object et String) sont des types de valeur. Les types de données Object et String sont des types de référence.

Types personnalisés

Le Visual Basic .NET fournit une syntaxe riche pour étendre le système de types. Les programmeurs peuvent définir à la fois de nouveaux types de valeur et de nouveaux types de référence. Les types déclarés avec les instructions Structure et Enum de Visual Basic .NET sont des types de valeur, comme le sont tous les types du cadre d'application .NET dérivant de System.ValueType. Les types de référence incluent Object, String, tous les types déclarés avec les instructions Class, Interface et Delegate de Visual Basic .NET, et tous les types du cadre d'application .NET ne dérivant pas de System.ValueType.

Tableaux

Les déclarations de tableau dans Visual Basic .NET sont similaires à celles de Visual Basic 6 et d'autres langages. Par exemple, voici une déclaration d'un tableau Integer ayant cinq éléments :

Le littéral 4 dans cette déclaration spécifie la limite supérieure du tableau. Tous les tableaux dans Visual Basic .NET ont une limite inférieure de 0, il s'agit donc d'une déclaration d'un tableau avec cinq éléments, ayant les index 0, 1, 2, 3 et 4. La déclaration précédente est une variable nommée a, étant de type «ARRAY OF INTEGER». Les types Array héritent implicitement du type Array du cadre d'application .NET (défini dans l'espace de noms System) et, par conséquent, ont accès aux méthodes définies dans ce type. Par exemple, le code suivant affiche les limites inférieure et supérieure d'un tableau en appelant les méthodes GetLowerBound et GetUpperBound de la classe Array :

La sortie est la suivante :

Notez que la limite supérieure du tableau est dynamique : elle peut être modifiée par les méthodes disponibles dans le type Array. Les éléments du tableau sont initialisés à la valeur par défaut du type d'élément. La valeur par défaut d'un type est déterminée comme suit :

• Pour les types numériques, la valeur par défaut est 0.
• Pour le type Boolean, la valeur par défaut est False.
• Pour le type Char, la valeur par défaut est le caractère dont la valeur Unicode est 0.
• Pour les types de structure, la valeur par défaut est une instance du type de structure avec tous ses champs définis sur leurs valeurs par défaut.
• Pour les types d'énumération, la valeur par défaut est une instance du type d'énumération avec sa représentation interne définie sur 0, pouvant ou non correspondre à une valeur légale dans l'énumération.
• Pour les types de référence (y compris String), la valeur par défaut est Nothing.

Vous pouvez accéder aux éléments du tableau en suffixant le nom du tableau avec l'index de l'élément souhaité entre parenthèses, comme indiqué ici :

Les tableaux peuvent être multidimensionnels. Des virgules séparent les dimensions du tableau lorsqu'il est utilisé dans les déclarations et lors de l'accès aux éléments. Voici la déclaration d'un tableau en trois dimensions, où chaque dimension a une taille différente :

Comme avec les tableaux unidimensionnels, les éléments du tableau sont initialisés à leurs valeurs par défaut.

Initialisation des tableaux

Les tableaux de types primitifs peuvent être initialisés en plaçant les valeurs initiales entre accolades ({}). Par exemple :

Notez que lorsque les tableaux sont initialisés de cette manière, la déclaration de tableau n'est pas autorisée à spécifier une taille explicite. Le compilateur déduit la taille à partir du nombre d'éléments dans l'initialiseur. Pour initialiser des tableaux multidimensionnels, incluez le nombre approprié de virgules dans la déclaration de nom de tableau et utilisez des accolades imbriquées dans l'initialiseur. Voici une déclaration d'un tableau à deux dimensions comportant trois lignes et deux colonnes :

Cette déclaration produit le tableau suivant :

Lors de l'initialisation de tableaux multidimensionnels, les accolades les plus internes correspondent à la dimension la plus à droite.

Allocation dynamique de tableaux

Utilisez le mot clef New pour allouer des tableaux de n'importe quel type. Par exemple, ce code crée un tableau de cinq entiers et initialise les éléments comme indiqué :

Si les éléments du tableau ne seront pas initialisés par l'allocation, il est toujours nécessaire d'inclure les accolades :

Les accolades sont nécessaires pour que le compilateur ne confondra pas la syntaxe du tableau avec la syntaxe du constructeur. Notez également la signification de cette déclaration en elle-même :

Il s'agit de la déclaration d'une référence pouvant pointer vers un tableau unidimensionnel d'entiers, mais pas encore. Sa valeur initiale est Nothing.

Les collections

Une collection est n'importe quel type exposant l'interface ICollection (définie dans l'espace de noms System.Collections). Une interface est un accord dans lequel le type expose certaines méthodes, propriétés et autres membres. En exposant l'interface ICollection, un type garantit qu'il peut être utilisé partout où une collection est attendue. En général, les collections entreposent plusieurs valeurs et fournissent un moyen d'itérer ces valeurs. Les types de collections spécialisées peuvent également fournir d'autres moyens pour ajouter et lire des valeurs. Par exemple, le type Stack (défini dans l'espace de noms System.Collections) fournit des méthodes, telles que Push et Pop, pour effectuer des opérations appropriées pour la structure de données de la pile. Le mécanisme d'exécution Visual Basic .NET fournit un type appelé Collection (défini dans l'espace de noms Microsoft.VisualBasic) imitant le comportement des collections Visual Basic 6 et expose l'interface ICollection. Voici un exemple de son utilisation :

La méthode Add du type Collection ajoute des éléments à la collection. Bien que des chaînes de caractères soient ajoutées à la collection dans l'exemple précédent, la méthode Add est définie pour accepter des éléments de type de données Object, ce qui signifie que tout type peut être passé à la méthode. Une fois les éléments ajoutés à la collection, ils peuvent être itérés à l'aide de l'instruction For Each. Étant donné que la classe Collection est définie pour entreposer des éléments de type Object, la variable de boucle dans l'instruction For Each doit être de type Object. Étant donné que les éléments sont en fait des chaînes de caractères, le code de l'exemple précédent convertit les références Object en références String à l'aide de la fonction CType. La sortie du code de l'exemple précédent est :

Les éléments d'un objet Collection peuvent également être itérés à l'aide d'un index numérique. L'objet Collection a une propriété Count, indiquant le nombre d'éléments dans la collection. L'exemple suivant est exactement le même que l'exemple précédent, sauf qu'il parcourt l'objet Collection en utilisant un index numérique et une boucle de compteur For :

Notez que pour accéder à un élément par index, le numéro d'index est placé entre parenthèses après le nom de la variable de référence Collection, comme illustré à nouveau ici :

La syntaxe de la méthode Add est :

Les paramètres sont :

Il est a noter que la bibliothèque de classes du cadre d'application .NET fournit également plusieurs types de collections supplémentaires.

Conversions de type

Le Visual Basic .NET propose différentes méthodes pour convertir les valeurs d'un type en valeurs d'un autre type. Il existe deux catégories principales de conversions : les conversions élargies et les conversions réduites. Les conversions élargies sont des conversions dans lesquelles il n'y a aucune possibilité de perte de données ou de résultats incorrects. Par exemple, la conversion d'une valeur de type de données Integer en une valeur de type de données Long est une conversion élargie car le type de données Long peut accepter toutes les valeurs possibles du type de données Integer. Le rétrécissement est l'opération inverse - conversion d'un Long en un Integer - car certaines valeurs de type de données Long ne peuvent pas être représentées comme des valeurs de type de données Integer.

Le Visual Basic .NET effectue automatiquement des conversions élargies chaque fois que nécessaire. Par exemple, une conversion d'élargissement se produit dans la deuxième ligne du code suivant. La valeur Integer sur le côté droit de l'affectation est automatiquement convertie en une valeur Long afin qu'elle puisse être entreposée dans la variable b :

Une conversion se produisant automatiquement est appelée une conversion implicite. Considérons maintenant la situation inverse :

La deuxième ligne de code tente ici d'effectuer une conversion de rétrécissement implicite. Le fait que le compilateur autorise cette ligne de code dépend de la valeur définie pour l'option du compilateur Option Strict. Lorsque Option Strict est On, les tentatives d'effectuer une conversion d'élargissement implicite entraînent une erreur du compilateur. Lorsque Option Strict est Off, le compilateur ajoute automatiquement du code en arrière-plan pour effectuer la conversion. Lors de l'exécution, si la valeur réelle en cours de conversion est hors de l'intervalle pouvant être représentée par le type de cible, une exception d'exécution se produit. Le Option Strict peut être définie de deux manières. Tout d'abord, il peut être défini dans le code en haut d'un fichier source, comme ceci :

ou

L'autre méthode consiste à définir un paramètre de compilateur, affectant tous les fichiers source de l'application. Si vous compilez à partir de la ligne de commande, spécifiez /optionstrict+ sur la ligne de commande pour définir Option Strict On. Spécifiez /optionstrict- pour définir Option Strict Off. Par exemple :

Pour définir Option Strict dans Visual Studio .NET :

• Cliquez avec le bouton droit sur le nom du projet dans la fenêtre Solution Explorer et choisissez Properties. Cela ouvre la boîte de dialogue Project Property Pages. (Si la fenêtre Solution Explorer n'est pas visible, choisissez View → Solution Explorer dans le menu principal de Visual Studio .NET pour la faire apparaître.)
• Dans la boîte de dialogue Project Property Pages, choisissez le dossier Common Properties. Dans ce dossier, choisissez la page de propriétés Build. Cela provoque l'affichage des options de génération de projet sur le côté droit de la boîte de dialogue.
• Définissez la valeur souhaitée pour l'option Option Strict.

Par défaut, Option Strict est Off, ce qui signifie que les conversions restrictives implicites sont autorisées. Cela correspond au paramètre par défaut de Visual Basic 6. Toutefois, la plupart des développeurs expérimentés considèrent qu'il est avantageux de définir Option Strict On afin que le compilateur puisse aider à détecter les erreurs de codage avant qu'elles ne deviennent des erreurs d'exécution. Tenter d'affecter un Long à un Integer, par exemple, est généralement le signe que quelque chose a été mal saisi ou qu'il y a un problème avec la conception du programme. La définition Option Strict On aide le développeur à découvrir de telles erreurs au moment de la compilation. D'un autre côté, il peut parfois y avoir un besoin légitime d'effectuer une conversion restrictive. Peut-être que l'application s'interface avec une autre application transmettant une valeur en tant que Long, mais il est garanti que la valeur réelle transmise ne sera jamais en dehors de l'intervalle du type Integer. Le Option Strict peut être définie sur Off pour permettre des conversions restrictives implicites, mais une meilleure alternative est d'avoir Option Strict On (afin qu'elle puisse protéger la majorité du programme) et de spécifier une conversion restrictive explicite. Par exemple :

C'est ce qu'on appelle une conversion explicite car le programmeur demande explicitement une conversion en Integer. Si au moment de l'exécution a contient une valeur étant en dehors de l'intervalle Integer, une exception est levée. Le tableau suivant présente les fonctions de conversion de Visual Basic .NET :

Les fonctions présentées dans le tableau précédent acceptent toutes un seul paramètre. Si le paramètre ne peut pas être converti dans le type donné, une exception est levée. Notez les points suivants :

• Lors de la conversion d'une valeur numérique quelconque en valeur booléenne, zéro convertit en False et différent de zéro convertit en True.
• Lors de la conversion de Boolean en valeur numérique, False se convertit en 0 et True en -1.
• Lors de la conversion de String en Boolean, la chaîne de caractères doit contenir soit le mot "false", se convertissant en False, soit le mot "true", se convertissant en True. Le cas de la chaîne de caractères n'est pas important.
• Lors de la conversion de Boolean en String, le True se convertit en "True" et False en "False".
• Tout peut être converti en objet de type.

Il est également possible de convertir entre les types de référence. Toute conversion de référence d'objet d'un type dérivé vers un type de base est considérée comme une conversion élargie et peut donc être effectuée implicitement. Inversement, la conversion d'un type de base en un type dérivé est une conversion restrictive. Comme indiqué précédemment, pour réduire les conversions à compiler, Option Strict doit être désactivée ou une conversion explicite doit être effectuée. Les conversions explicites des types de référence sont effectuées avec la fonction CType. La fonction CType prend deux paramètres. Le premier est une référence à un objet et le second est le nom du type vers lequel la référence sera convertie. Lors de l'exécution, si une conversion est possible, la valeur de retour de la fonction est une référence d'objet du type approprié. Si aucune conversion n'est possible, une exception est levée.

Les références Object peuvent également être converties implicitement en n'importe quelle interface exposée par la classe de l'objet.

Espaces de noms

Des milliers de types sont définis dans le cadre d'application .NET. De plus, les programmeurs peuvent définir de nouveaux types à utiliser dans leurs programmes. Avec autant de types, les conflits de noms sont inévitables. Pour éviter les conflits de noms, les types sont considérés comme résidant à l'intérieur des espaces de noms. Souvent, ce fait peut être ignoré. Par exemple, dans Visual Basic .NET, une classe peut être définie comme ceci :

Cette définition de classe peut se trouver dans une bibliothèque de classes utilisée par des clients tiers ou dans le même fichier ou le même projet que le code client. Le code client utilisant cette classe peut ressembler à ceci :

Considérez maintenant ce qui se passe si le client tiers achète également la bibliothèque de classes d'un autre fournisseur, exposant également une classe ClasseQuelconque. Le compilateur Visual Basic .NET ne peut pas savoir quelle définition de ClasseQuelconque sera utilisée. Le client doit donc utiliser le nom complet du type, également appelé son nom complet. Le code devant utiliser les deux types peut ressembler à ceci :

Notez qu'un nom d'espace de noms peut lui-même contenir des points (.). Lorsque vous examinez un nom de type complet, tout ce qui précède le point finale est le nom de l'espace de noms. Le nom après le dernier point est le nom du type. Microsoft recommande que les espaces de noms soient nommés selon le format NomCompagnie.NomTechnologie. Par exemple, «Microsoft.VisualBasic».