Directive `using`

Article
11/16/2024

La directive using vous permet d’utiliser des types définis dans un espace de noms sans spécifier l’espace de noms complet de ce type. Dans sa forme de base, la directive using importe tous les types à partir d’un espace de noms unique, comme illustré dans l’exemple suivant :

using System.Text;

Vous pouvez appliquer deux modificateurs à une directive using :

Le modificateur global a le même effet que l’ajout de la même directive using à chaque fichier source dans votre projet. Ce modificateur a été introduit dans C# 10.
Le modificateur static importe les membres static et les types imbriqués à partir d’un type unique, plutôt que d’importer tous les types dans un espace de noms.

Vous pouvez combiner les deux modificateurs pour importer les membres statiques à partir d’un type vers tous les fichiers sources de votre projet.

Vous pouvez également créer un alias pour un espace de noms ou un type avec une directive d’alias using.

using Project = PC.MyCompany.Project;

Vous pouvez utiliser le modificateur global sur une directive d’alias using.

Remarque

Le mot clé using est également utilisé pour créer des instructions using, qui garantissent que les objets IDisposable comme les fichiers et les polices sont gérés correctement. Pour plus d’informations sur l’instruction using, consultez Instruction using.

La portée d'une directive using sans le modificateur global est le fichier dans lequel elle apparaît.

La global using directive doit apparaître avant toutes les déclarations d’espace de noms et de type. Toutes les directives d’utilisation globale doivent apparaître dans un fichier source avant toutes les directives non globales using .

D’autres using directives peuvent apparaître :

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 bloqué, mais avant les espaces de noms ou types déclarés dans cet espace de noms.

Sinon, une erreur du compilateur est générée.

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. Pour obtenir la liste des espaces de noms définis par le système, consultez Navigateur d’API .NET.

Modificateur `global`

L’ajout du modificateur global à une directive usingsignifie que l’utilisation est appliquée à tous les fichiers de la compilation (généralement un projet). La directive global using a été ajoutée dans C# 10 Sa syntaxe est la suivante :

global using <fully-qualified-namespace>;

Où l’espace de noms complet est le nom complet de l’espace de noms dont les types peuvent être référencés sans spécifier l’espace de noms.

Une directive using globale peut apparaître au début de n’importe quel fichier de code source. Toutes les directives global using d’un seul fichier doivent apparaître avant :

Toutes les directives using sans le modificateur global.
Toutes les déclarations d’espace de noms et de type dans le fichier.

Vous pouvez ajouter des global using directives à n’importe quel fichier source. En règle générale, vous souhaitez les conserver dans un emplacement unique. L’ordre des directives global using n’a pas d’importance, soit dans un fichier unique, soit entre des fichiers.

Le global modificateur peut être combiné avec le static modificateur. Le global modificateur peut être appliqué à une directive d’alias using. Dans les deux cas, l’étendue de la directive est tous les fichiers de la compilation actuelle. L’exemple suivant active l’utilisation de toutes les méthodes déclarées dans System.Math dans tous les fichiers de votre projet :

global using static System.Math;

Vous pouvez également inclure un espace de noms de manière globale en ajoutant un <Using> élément à votre fichier projet, par exemple, <Using Include="My.Awesome.Namespace" />. Pour plus d’informations, consultez l’élément<Using>.

Les analyseurs émettent des diagnostics si vous dupliquez global à l’aide de directives dans différents emplacements. Ces mêmes analyseurs vous informent également si vous ajoutez une using directive pour un espace de noms ou un type qu’une global directive using référence déjà. Vous pouvez trouver plus facile de gérer vos global utilisations en les gardant ensemble dans un fichier du projet.

Important

Les modèles C# pour .NET 6 utilisent des instructions de niveau supérieur. Votre application ne correspond peut-être pas au code de cet article, si vous avez déjà effectué une mise à niveau vers .NET 6. Pour plus d’informations, consultez l’article Les nouveaux modèles C# génèrent des instructions de niveau supérieur.

Le Kit de développement logiciel (SDK) .NET 6 ajoute également un ensemble de directives global using implicites pour les projets qui utilisent les SDK suivants :

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Ces directives implicites global using incluent les espaces de noms les plus courants pour le type de projet.

Pour plus d’informations, consultez l’article sur les directives d’utilisation implicite

Modificateur `static`

La directive using static nomme 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 :

using static <fully-qualified-type-name>;

<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. Si vous ne fournissez pas de nom de type complet (le nom de l’espace de noms complet avec le nom du type), C# génère l’erreur du compilateur CS0246 : « Le nom du type ou de l’espace de noms 'type/espace_de_nom' est introuvable (il manque peut-être une directive using ou une référence d’assembly) ».

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.

Vous pouvez accéder aux membres statiques d'un type sans devoir qualifier l'accès avec le nom du type :

using static System.Console;
using static System.Math;
class Program
{
    static void Main()
    {
        WriteLine(Sqrt(3*3 + 4*4));
    }
}

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 de nombreux membres de la classe Math.

using System;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * Math.PI; }
   }

   public double Area
   {
      get { return Math.PI * Math.Pow(Radius, 2); }
   }
}

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 plus clair :

using System;
using static System.Math;

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * PI; }
   }

   public double Area
   {
      get { return PI * Pow(Radius, 2); }
   }
}

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 using static, notamment des modules Visual Basic. Si des fonctions de niveau supérieur F# apparaissent dans les métadonnées comme membres statiques d’un type nommé dont le nom est un identificateur C# valide, les fonctions F# peuvent être importées.

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.

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 System;
using static System.Console;
using static System.Math;
using static System.String;

class Program
{
   static void Main()
   {
      Write("Enter a circle's radius: ");
      var input = ReadLine();
      if (!IsNullOrEmpty(input) && double.TryParse(input, out var radius)) {
         var c = new Circle(radius);

         string s = "\nInformation about the circle:\n";
         s = s + Format("   Radius: {0:N2}\n", c.Radius);
         s = s + Format("   Diameter: {0:N2}\n", c.Diameter);
         s = s + Format("   Circumference: {0:N2}\n", c.Circumference);
         s = s + Format("   Area: {0:N2}\n", c.Area);
         WriteLine(s);
      }
      else {
         WriteLine("Invalid input...");
      }
   }
}

public class Circle
{
   public Circle(double radius)
   {
      Radius = radius;
   }

   public double Radius { get; set; }

   public double Diameter
   {
      get { return 2 * Radius; }
   }

   public double Circumference
   {
      get { return 2 * Radius * PI; }
   }

   public double Area
   {
      get { return PI * Pow(Radius, 2); }
   }
}
// The example displays the following output:
//       Enter a circle's radius: 12.45
//
//       Information about the circle:
//          Radius: 12.45
//          Diameter: 24.90
//          Circumference: 78.23
//          Area: 486.95

Dans l’exemple, la using static directive peut également être appliquée au Double type. Ajouter cette directive aurait permis d’appeler la méthode TryParse(String, Double) sans spécifier un nom de type. Toutefois, utiliser TryParse sans nom de type crée un code moins lisible, car il est nécessaire de vérifier les directives using static, afin de déterminer quelle méthode du type numérique TryParse est appelée.

using static s’applique également aux types enum. En ajoutant using static avec l’énumération, le type n’est plus nécessaire pour utiliser les membres enum.

using static Color;

enum Color
{
    Red,
    Green,
    Blue
}

class Program
{
    public static void Main()
    {
        Color color = Green;
    }
}

Alias `using`

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, l’exemple suivant génère une erreur de compilation :

using s = System.Text;
using s.RegularExpressions; // Generates a compiler error.

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

namespace PC
{
    // Define an alias for the nested namespace.
    using Project = PC.MyCompany.Project;
    class A
    {
        void M()
        {
            // Use the alias
            var mc = new Project.MyClass();
        }
    }
    namespace MyCompany
    {
        namespace Project
        {
            public class MyClass { }
        }
    }
}

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 System;

// Using alias directive for a class.
using AliasToMyClass = NameSpace1.MyClass;

// Using alias directive for a generic class.
using UsingAlias = NameSpace2.MyClass<int>;

namespace NameSpace1
{
    public class MyClass
    {
        public override string ToString()
        {
            return "You are in NameSpace1.MyClass.";
        }
    }
}

namespace NameSpace2
{
    class MyClass<T>
    {
        public override string ToString()
        {
            return "You are in NameSpace2.MyClass.";
        }
    }
}

namespace NameSpace3
{
    class MainClass
    {
        static void Main()
        {
            var instance1 = new AliasToMyClass();
            Console.WriteLine(instance1);

            var instance2 = new UsingAlias();
            Console.WriteLine(instance2);
        }
    }
}
// Output:
//    You are in NameSpace1.MyClass.
//    You are in NameSpace2.MyClass.

À compter de C# 12, vous pouvez créer des alias pour les types qui ont été précédemment restreints, notamment les types de tuples, les types pointeurs et d’autres types non sécurisés. Pour plus d’informations sur les règles mises à jour, consultez les spécifications de fonctionnalité.

Membre d’alias qualifié

Le qualificateur :: d’alias d’espace de noms fournit un accès explicite à l’espace de noms global ou à d’autres alias potentiellement masqués par d’autres entités.

Garantit global:: que la recherche d’espace de noms pour l’espace de noms suivant le :: jeton est relative à l’espace de noms global. Sinon, le jeton doit être résolu en alias d’utilisation, et le jeton suivant :: doit être résolu en type dans cet espace de noms alias. L’exemple suivant montre les deux formulaires :

using S = System.Net.Sockets;

class A
{
    public static int x;
}

class C
{
    public void F(int A, object S)
    {
        // Use global::A.x instead of A.x
        global::A.x += A;

        // Using ::, S must resolve to a namespace alias:
        S::Socket s = S as S::Socket;

        // In this form, if S were a class, it would be a compile-time error:
        S.Socket s1 = S as S.Socket;
    }
}

spécification du langage C#

Pour plus d’informations, consultez Directives using dans la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Pour plus d’informations sur le modificateur global using, consultez la spécification de fonctionnalité globale usings - C# 10.

Partager via

Directive `using`

Modificateur `global`

Modificateur `static`

Alias `using`

Membre d’alias qualifié

spécification du langage C#

Voir aussi

Ressources supplémentaires

Partager via

Directive using

Modificateur global

Modificateur static

Alias using

Membre d’alias qualifié

spécification du langage C#

Voir aussi

Ressources supplémentaires

Directive `using`

Modificateur `global`

Modificateur `static`

Alias `using`