Types référence intégrés (Référence C#)Built-in reference types (C# reference)

C# a un nombre de types référence intégrés.C# has a number of built-in reference types. Ils ont des mots clés ou des opérateurs qui sont synonymes pour un type dans la bibliothèque .NET.They have keywords or operators that are synonyms for a type in the .NET library.

Type d’objetThe object type

Le type object est un alias de System.Object dans .NET.The object type is an alias for System.Object in .NET. Dans le système de type unifié de C#, tous les types (les types référence et valeur, prédéfinis ou définis par l’utilisateur) héritent directement ou indirectement du type System.Object.In the unified type system of C#, all types, predefined and user-defined, reference types and value types, inherit directly or indirectly from System.Object. Vous pouvez assigner des valeurs de tout type aux variables de type object.You can assign values of any type to variables of type object. Toute variable object peut être attribuée à sa valeur par défaut à l’aide du littéral null.Any object variable can be assigned to its default value using the literal null. Quand une variable d’un type valeur est convertie en type objet, elle est dite boxed.When a variable of a value type is converted to object, it is said to be boxed. Quand une variable de type objet est convertie en type valeur, elle est dite unboxed.When a variable of type object is converted to a value type, it is said to be unboxed. Pour plus d’informations, consultez Conversion boxing et unboxing.For more information, see Boxing and Unboxing.

Type de chaîneThe string type

Le type string représente une séquence de zéro, un ou plusieurs caractères Unicode.The string type represents a sequence of zero or more Unicode characters. string est un alias de System.String dans .NET.string is an alias for System.String in .NET.

Bien que string soit un type référence, les opérateurs d’égalité== (!= et ) sont définis pour comparer les valeurs des objets string, pas les références.Although string is a reference type, the equality operators == and != are defined to compare the values of string objects, not references. Cela permet de tester l’égalité de chaînes de façon plus intuitive.This makes testing for string equality more intuitive. Par exemple :For example:

string a = "hello";
string b = "h";
// Append to contents of 'b'
b += "ello";
Console.WriteLine(a == b);
Console.WriteLine(object.ReferenceEquals(a, b));

Cette opération affiche « True », puis « False », car le contenu des chaînes est équivalent, mais a et b ne font pas référence à la même instance de chaîne.This displays "True" and then "False" because the content of the strings are equivalent, but a and b do not refer to the same string instance.

L’opérateur + concatène les chaînes :The + operator concatenates strings:

string a = "good " + "morning";

Cela crée un objet String qui contient « good morning ».This creates a string object that contains "good morning".

Les chaînes sont immuables : il est impossible de changer le contenu d’un objet String après avoir créé l’objet, bien que la syntaxe semble indiquer le contraire.Strings are immutable--the contents of a string object cannot be changed after the object is created, although the syntax makes it appear as if you can do this. Par exemple, lorsque vous écrivez ce code, le compilateur crée en fait un nouvel objet String pour stocker la nouvelle séquence de caractères, et ce nouvel objet est attribué à b.For example, when you write this code, the compiler actually creates a new string object to hold the new sequence of characters, and that new object is assigned to b. La mémoire allouée pour b (quand elle contenait la chaîne « h ») est alors éligible pour le garbage collection.The memory that had been allocated for b (when it contained the string "h") is then eligible for garbage collection.

string b = "h";
b += "ello";

L’opérateur [] peut être utilisé pour un accès en lecture seule aux différents caractères d’une string :The [] operator can be used for readonly access to individual characters of a string. Les valeurs valides commencent à 0 et doivent être inférieures à la longueur de la string :Valid values start at 0 and must be less than the length of the string:

string str = "test";
char x = str[2];  // x = 's';

De la même façon, l’opérateur [] permet également d’itérer sur chaque caractère dans une string :In similar fashion, the [] operator can also be used for iterating over each character in a string:

string str = "test";

for (int i = 0; i < str.Length; i++)
{
  Console.Write(str[i] + " ");
}
// Output: t e s t

Les littéraux de chaîne sont de type string et peuvent être écrits sous deux formes, entre guillemets et entre @.String literals are of type string and can be written in two forms, quoted and @-quoted. Les littéraux de chaîne entre guillemets sont placés entre guillemets doubles (") :Quoted string literals are enclosed in double quotation marks ("):

"good morning"  // a string literal

Les littéraux de chaîne peuvent contenir tout littéral de caractère.String literals can contain any character literal. Les séquences d’échappement sont incluses.Escape sequences are included. L’exemple suivant utilise la séquence d’échappement \\ pour la barre oblique inverse, \u0066 pour la lettre f et \n pour un saut de ligne.The following example uses escape sequence \\ for backslash, \u0066 for the letter f, and \n for newline.

string a = "\\\u0066\n F";
Console.WriteLine(a);
\\ Output:
\\ \f
\\  F

Notes

Le code d’échappement \udddd (où dddd est un nombre à quatre chiffres) représente le caractère Unicode U+dddd.The escape code \udddd (where dddd is a four-digit number) represents the Unicode character U+dddd. Les codes d’échappement Unicode à huit chiffres sont également reconnus : \Udddddddd.Eight-digit Unicode escape codes are also recognized: \Udddddddd.

Les littéraux de chaîne textuelle commencent par @ et sont placés entre guillemets doubles.Verbatim string literals start with @ and are also enclosed in double quotation marks. Par exemple :For example:

@"good morning"  // a string literal

L’avantage des chaînes textuelles est que les séquences d’échappement ne sont pas traitées, ce qui facilite l’écriture, par exemple, d’un nom de fichier complet Windows :The advantage of verbatim strings is that escape sequences are not processed, which makes it easy to write, for example, a fully qualified Windows file name:

@"c:\Docs\Source\a.txt"  // rather than "c:\\Docs\\Source\\a.txt"

Pour inclure un guillemet double dans une chaîne @-quoted, doublez-le :To include a double quotation mark in an @-quoted string, double it:

@"""Ahoy!"" cried the captain." // "Ahoy!" cried the captain.

Type de déléguéThe delegate type

La déclaration d’un type délégué est semblable à une signature de méthode.The declaration of a delegate type is similar to a method signature. Elle a une valeur de retour et un nombre quelconque de paramètres de type quelconque :It has a return value and any number of parameters of any type:

public delegate void MessageDelegate(string message);
public delegate int AnotherDelegate(MyType m, long num);

Dans .NET, les types System.Action et System.Func fournissent des définitions génériques pour de nombreux délégués courants.In .NET, System.Action and System.Func types provide generic definitions for many common delegates. Vous n’avez probablement pas besoin de définir de nouveaux types de délégué personnalisés.You likely don't need to define new custom delegate types. À la place, vous pouvez créer des instanciations des types génériques fournis.Instead, you can create instantiations of the provided generic types.

Un delegate est un type référence qui peut être utilisé pour encapsuler une méthode anonyme ou nommée.A delegate is a reference type that can be used to encapsulate a named or an anonymous method. Les délégués sont comparables aux pointeurs fonction en C++, mais ils offrent l’avantage d’être sûrs et de type sécurisé.Delegates are similar to function pointers in C++; however, delegates are type-safe and secure. Pour les applications de délégués, consultez Délégués et Délégués génériques.For applications of delegates, see Delegates and Generic Delegates. Les délégués sont la base des événements.Delegates are the basis for Events. Un délégué peut être instancié en l’associant à une méthode nommée ou anonyme.A delegate can be instantiated by associating it either with a named or anonymous method.

Le délégué doit être instancié avec une méthode ou une expression lambda qui a un type de retour compatible et des paramètres d’entrée.The delegate must be instantiated with a method or lambda expression that has a compatible return type and input parameters. Pour plus d’informations sur le degré de variance autorisé dans la signature de méthode, consultez Variance dans les délégués.For more information on the degree of variance that is allowed in the method signature, see Variance in Delegates. Pour une utilisation avec des méthodes anonymes, le délégué et le code à lui associer sont déclarés ensemble.For use with anonymous methods, the delegate and the code to be associated with it are declared together.

Type dynamiqueThe dynamic type

Le type dynamic indique que l’utilisation de la variable et des références à ses membres contourne la vérification du type au moment de la compilation.The dynamic type indicates that use of the variable and references to its members bypass compile-time type checking. Au lieu de cela, ces opérations sont résolues au moment de l’exécution.Instead, these operations are resolved at run time. Le type dynamic simplifie l’accès aux API COM telles que les API Office Automation, aux API dynamiques telles que les bibliothèques IronPython et au modèle DOM (Document Object Model) HTML.The dynamic type simplifies access to COM APIs such as the Office Automation APIs, to dynamic APIs such as IronPython libraries, and to the HTML Document Object Model (DOM).

Le type dynamic se comporte comme le type object dans la plupart des cas.Type dynamic behaves like type object in most circumstances. En particulier, toute expression non null peut être convertie en type dynamic.In particular, any non-null expression can be converted to the dynamic type. Le type dynamic diffère de object en cela que les opérations qui contiennent des expressions de type dynamic ne sont pas résolues et leur type n’est pas vérifié par le compilateur.The dynamic type differs from object in that operations that contain expressions of type dynamic are not resolved or type checked by the compiler. Le compilateur empaquète des informations sur l’opération, qui sont ensuite utilisées pour évaluer l’opération au moment de l’exécution.The compiler packages together information about the operation, and that information is later used to evaluate the operation at run time. Dans le cadre du processus, les variables de type dynamic sont compilées dans des variables de type object.As part of the process, variables of type dynamic are compiled into variables of type object. Ainsi, le type dynamic existe seulement au moment de la compilation, et non au moment de l’exécution.Therefore, type dynamic exists only at compile time, not at run time.

L’exemple suivant compare une variable de type dynamic à une variable de type object.The following example contrasts a variable of type dynamic to a variable of type object. Pour vérifier le type de chaque variable au moment de la compilation, placez le pointeur de la souris sur dyn ou obj dans les instructions WriteLine.To verify the type of each variable at compile time, place the mouse pointer over dyn or obj in the WriteLine statements. Copiez le code suivant dans un éditeur où IntelliSense est disponible.Copy the following code into an editor where IntelliSense is available. IntelliSense affiche dynamic pour dyn et object pour obj.IntelliSense shows dynamic for dyn and object for obj.

class Program
{
    static void Main(string[] args)
    {
        dynamic dyn = 1;
        object obj = 1;

        // Rest the mouse pointer over dyn and obj to see their
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
    }
}

Les instructions WriteLine affichent les types d’exécution de dyn et obj.The WriteLine statements display the run-time types of dyn and obj. À ce stade, tous deux ont le même type, entier.At that point, both have the same type, integer. La sortie suivante est produite :The following output is produced:

System.Int32
System.Int32

Pour voir la différence entre dyn et obj au moment de la compilation, ajoutez les deux lignes suivantes entre les déclarations et les instructions WriteLine de l’exemple précédent.To see the difference between dyn and obj at compile time, add the following two lines between the declarations and the WriteLine statements in the previous example.

dyn = dyn + 3;
obj = obj + 3;

Une erreur du compilateur est signalée pour la tentative d’ajout d’un entier et un d’objet dans l’expression obj + 3.A compiler error is reported for the attempted addition of an integer and an object in expression obj + 3. Toutefois, aucune erreur n’est signalée pour dyn + 3.However, no error is reported for dyn + 3. L’expression qui contient dyn n’est pas vérifié au moment de la compilation, car le type de dyn est dynamic.The expression that contains dyn is not checked at compile time because the type of dyn is dynamic.

L’exemple suivant utilise dynamic dans plusieurs déclarations.The following example uses dynamic in several declarations. La méthode Main compare également la vérification de type au moment de la compilation avec la vérification de type au moment de l’exécution.The Main method also contrasts compile-time type checking with run-time type checking.

using System;

namespace DynamicExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass ec = new ExampleClass();
            Console.WriteLine(ec.exampleMethod(10));
            Console.WriteLine(ec.exampleMethod("value"));

            // The following line causes a compiler error because exampleMethod
            // takes only one argument.
            //Console.WriteLine(ec.exampleMethod(10, 4));

            dynamic dynamic_ec = new ExampleClass();
            Console.WriteLine(dynamic_ec.exampleMethod(10));

            // Because dynamic_ec is dynamic, the following call to exampleMethod
            // with two arguments does not produce an error at compile time.
            // However, it does cause a run-time error. 
            //Console.WriteLine(dynamic_ec.exampleMethod(10, 4));
        }
    }

    class ExampleClass
    {
        static dynamic field;
        dynamic prop { get; set; }

        public dynamic exampleMethod(dynamic d)
        {
            dynamic local = "Local variable";
            int two = 2;

            if (d is int)
            {
                return local;
            }
            else
            {
                return two;
            }
        }
    }
}
// Results:
// Local variable
// 2
// Local variable

Voir aussiSee also