using (directive)

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 dans 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.

La portée d'une directive using sans le modificateur global est le 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 tous les espaces de noms ou types déclarés dans cet espace de noms, sauf si le modificateur global est utilisé, auquel cas la directive doit apparaître avant toutes les déclarations d’espace de noms et de type.

Sinon, une erreur de compilateur CS1529 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ù fully-qualified-namespace 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 directives global using à n’importe quel fichier source. En règle générale, il convient de 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 modificateur global peut être combiné avec le modificateur static. Le modificateur global peut être appliqué à une directive 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>.

static (modificateur)

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 cet exemple, la directive using static aurait également pu être appliquée au type Double. 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é.

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.

Voir aussi

• Mots clés C#
• Espaces de noms
• Règle de style IDE0005 - Supprimer les directives « using » inutiles
• Règle de style IDE0065 : placement de directive « using »
• instruction using