namespace

Les espaces de noms sont largement utilisés dans les programmes C#, et ce de deux façons différentes.

En premier lieu, les classes .NET Framework utilisent les espaces de noms à des fins d'organisation. System est un espace de noms et Console est une classe de cet espace de noms.
En deuxième lieu, la déclaration de vos propres espaces de noms peut faciliter le contrôle de la portée des noms de classes et de méthodes dans les projets de programmation de plus grande envergure.

Le mot clé namespace est utilisé pour déclarer une portée qui contient un ensemble d'objets connexes. Vous pouvez utiliser un espace de noms pour organiser les éléments de code et créer des types globaux uniques.

Dans un espace de noms, vous pouvez déclarer zéro ou plusieurs des types suivants :

• autre espace de noms
• class
• interface
• struct
• enum
• delegate

Le compilateur ajoute un espace de noms par défaut, que vous déclariez ou non explicitement un espace de noms dans un fichier source C#. Cet espace de noms sans nom, parfois appelé espace de noms global, est présent dans chaque fichier. Tout identificateur dans l'espace de noms global peut être utilisé dans un espace de noms nommé.

Les espaces de noms ont implicitement un accès public, et cela n'est pas modifiable.

Il est possible de définir un espace de noms dans deux déclarations ou plus. Par exemple, l'exemple suivant définit deux classes comme appartenant à l'espace de noms MyCompany :

L'exemple suivant montre comment appeler une méthode static dans un espace de noms imbriqué.

using (directive)

La plupart des applications C# commencent par une section de directives using.

Cette section répertorie les espaces de noms que l'application est appelée à utiliser fréquemment et évite au programmeur de spécifier un nom qualifié complet chaque fois qu'une méthode qu'elle contient est utilisée.

La directive using a trois utilisations :

Pour autoriser l'utilisation de types dans un espace de noms pour ne pas avoir à qualifier l'utilisation d'un type dans cet espace de noms :

Pour vous permettre d'accéder aux membres static et aux types imbriqués d'un type sans devoir qualifier l'accès avec le nom du type.


Pour créer un alias d'espace de noms ou un type. Cela s'appelle une directive using alias.

Le mot clé using est également utilisé pour créer des instructions usingIDisposable, qui garantissent que les objets tels que les fichiers et les polices sont gérés correctement.


Notes

La portée d'une directive using se limite au fichier dans lequel elle apparaît. La directive using peut être placée :

• Au début d'un fichier de code source, avant les définitions de type ou d'espace de noms.
• Dans n'importe quel espace de noms, mais avant les espaces de noms ou types déclarés dans cet espace de noms.

Créez une directive d'alias using afin de faciliter la qualification d'un identificateur pour un espace de noms ou un type. Dans une directive using, le type ou l'espace de noms complet doit toujours être utilisé, indépendamment des directives using placées avant. Aucun alias using ne peut être utilisé dans la déclaration d'une directive using.

Par exemple, les lignes ci-dessous génèrent une erreur de compilation :

Créez une directive using pour utiliser les types dans un espace de noms sans avoir à spécifier l'espace de noms. Une directive using ne vous donne pas accès à des espaces de noms imbriqués dans l'espace de noms que vous spécifiez.

Les espaces de noms sont organisés en deux catégories : définis par l'utilisateur et définis par le système. Les espaces de noms définis par l'utilisateur sont des espaces de noms définis dans votre code.

L'exemple suivant montre comment définir et utiliser un alias using pour un espace de noms :

Une directive d'alias using ne peut pas avoir un type générique ouvert sur le côté droit. Par exemple, vous ne pouvez pas créer un alias using pour un List‹T›, mais vous pouvez en créer un pour un List‹int›.

L'exemple suivant montre comment définir une directive using et un alias using pour une classe :

using static (directive)

La directive using static désigne un type dont vous pouvez accéder aux membres statiques et aux types imbriqués sans spécifier de nom de type. Sa syntaxe est la suivante :

Où fully-qualified-type-name est le nom du type dont les membres statiques et les types imbriqués peuvent être référencés sans spécifier de nom de type.


La directive using static s'applique à tout type ayant des membres statiques (ou des types imbriqués), même s'il a également des membres d'instance. Toutefois, les membres d'instance ne peuvent être appelés que par l'instance du type.


Notes

En général, quand vous appelez un membre statique, vous indiquez le nom du type, ainsi que le nom du membre. Entrer plusieurs fois le même nom de type pour appeler des membres du type peut produire du code détaillé et peu clair. Par exemple, la définition suivante d'une classe Circle référence un certain nombre de membres de la classe Math.

En éliminant la nécessité de référencer explicitement la classe Math chaque fois qu'un membre est référencé, la directive using static génère du code beaucoup plus clair :

using static importe uniquement les membres statiques accessibles et les types imbriqués déclarés dans le type spécifié. Les membres hérités ne sont pas importés. Vous pouvez importer à partir de n'importe quel type nommé avec une directive static.

using static rend les méthodes d'extension déclarées dans le type spécifié disponibles pour la recherche de méthode d'extension. Toutefois, les noms des méthodes d'extension ne sont pas importés dans la portée pour la référence non qualifiée dans le code.

Les méthodes portant le même nom et qui sont importées à partir de différents types par différentes directives using static dans la même unité de compilation ou le même espace de noms forment un groupe de méthodes. La résolution de surcharge au sein de ces groupes de méthodes suit des règles C# normales.

Exemple

L'exemple suivant utilise la directive using static pour que les membres statiques des classes Console, Math et String soient disponibles sans que vous ayez à spécifier leur nom de type.

using (instruction)

Fournit une syntaxe pratique qui garantit l'utilisation correcte d'objets IDisposable.

L'exemple suivant montre comment utiliser l'instruction using.

File et Font sont des exemples de types managés qui accèdent à des ressources non managées (dans le cas présent, des handles de fichiers et des contextes d'appareil). Beaucoup d'autres types de ressources non managées et de bibliothèques de classes peuvent les encapsuler. Tous les types de cette sorte doivent implémentent l'interface IDisposable.

Quand la durée de vie d'un objet IDisposable est limitée à une seule méthode, vous devez le déclarer et l'instancier dans l'instruction using. L'instruction using appelle la méthode Dispose correctement sur l'objet et, quand vous l'utilisez comme indiqué précédemment, elle met également l'objet lui-même hors de portée dès que Dispose est appelée. Dans le bloc using, l'objet est en lecture seule et ne peut être ni modifié ni réassigné.

L'instruction using garantit que Dispose est appelée même si une exception se produit dans le bloc using. Vous pouvez obtenir le même résultat en plaçant l'objet dans un bloc try, puis en appelant Dispose dans un bloc finally; c'est d'ailleurs ainsi que l'instruction using est traduite par le compilateur. L'exemple de code précédent se développe pour donner le code suivant au moment de la compilation (notez les accolades supplémentaires pour créer la portée limitée de l'objet) :

Vous pouvez déclarer plusieurs instances d'un type dans l'instruction using, comme indiqué dans l'exemple suivant :

Il n'est pas recommandé d'instancier l'objet de ressource, puis de passer la variable à l'instruction using. Dans ce cas, une fois que le contrôle a quitté le bloc using, l'objet reste dans la portée mais n'a probablement pas accès à ses ressources non managées. En d'autres termes, il n'est plus complètement initialisé. Si vous essayez d'utiliser l'objet à l'extérieur du bloc /code>using, vous risquez de provoquer la levée d'une exception. C'est pourquoi il est généralement préférable d'instancier l'objet dans l'instruction using et de limiter sa portée au bloc using.

alias extern

Il se peut que vous deviez référencer deux versions d'assemblys qui ont le même nom de type qualifié complet. Par exemple, vous pourriez avoir à utiliser plusieurs versions d'un assembly dans la même application. En utilisant un alias d'assembly externe, vous pouvez encapsuler les espaces de noms de chaque assembly dans des espaces de noms racines nommés par l'alias, ce qui permet de les utiliser dans le même fichier.


Pour référencer deux assemblys portant le même nom de type qualifié complet, vous devez spécifier un alias à l'invite de commandes, comme suit :

/r:GridV1=grid.dll

/r:GridV2=grid20.dll

Cela crée les alias externes GridV1 et GridV2. Pour utiliser ces alias à partir d'un programme, référencez-les en utilisant le mot clé extern. Par exemple :

extern alias GridV1;

extern alias GridV2;

Chaque déclaration d'alias externe introduit un espace de noms racine supplémentaire qui est parallèle à l'espace de noms global (mais n'est pas compris dedans). Ainsi, vous pouvez référencer les types de chaque assembly sans ambiguïté en utilisant leur nom qualifié complet, enraciné dans l'alias d'espace de noms approprié.

Dans l'exemple précédent, GridV1::Grid serait le contrôle de grille de grid.dll, et GridV2::Grid serait le contrôle de grille de grid20.dll.