VariablesVariables

Les variables représentent des emplacements de stockage.Variables represent storage locations. Chaque variable a un type qui détermine les valeurs qui peuvent être stockées dans la variable.Every variable has a type that determines what values can be stored in the variable. C#est un langage de type sécurisé, et le C# compilateur garantit que les valeurs stockées dans les variables sont toujours du type approprié.C# is a type-safe language, and the C# compiler guarantees that values stored in variables are always of the appropriate type. La valeur d’une variable peut être modifiée par le biais de l’assignation ou ++ par -- le biais de l’utilisation des opérateurs et.The value of a variable can be changed through assignment or through use of the ++ and -- operators.

Une variable doit être assignée définitivement (assignation définie) avant que sa valeur puisse être obtenue.A variable must be definitely assigned (Definite assignment) before its value can be obtained.

Comme décrit dans les sections suivantes, les variables sont initialement assignées ou initialement non assignées.As described in the following sections, variables are either initially assigned or initially unassigned. Une variable initialement assignée a une valeur initiale bien définie et est toujours considérée comme assignée définitivement.An initially assigned variable has a well-defined initial value and is always considered definitely assigned. Une variable initialement non assignée n’a pas de valeur initiale.An initially unassigned variable has no initial value. Pour qu’une variable initialement non assignée soit considérée comme définitivement assignée à un certain emplacement, une assignation à la variable doit se produire dans chaque chemin d’exécution possible menant à cet emplacement.For an initially unassigned variable to be considered definitely assigned at a certain location, an assignment to the variable must occur in every possible execution path leading to that location.

Catégories de variablesVariable categories

C#définit sept catégories de variables : les variables statiques, les variables d’instance, les éléments de tableau, les paramètres de valeur, les paramètres de référence, les paramètres de sortie et les variables locales.C# defines seven categories of variables: static variables, instance variables, array elements, value parameters, reference parameters, output parameters, and local variables. Les sections qui suivent décrivent chacune de ces catégories.The sections that follow describe each of these categories.

Dans l’exempleIn the example

class A
{
    public static int x;
    int y;

    void F(int[] v, int a, ref int b, out int c) {
        int i = 1;
        c = a + b++;
    }
}

xest une variable statique, y est une variable d’instance v[0] , est un élément de a tableau, est un paramètre b de valeur, est un c paramètre de référence, est un i paramètre de sortie et est une variable locale .x is a static variable, y is an instance variable, v[0] is an array element, a is a value parameter, b is a reference parameter, c is an output parameter, and i is a local variable.

Variables statiquesStatic variables

Un champ déclaré avec le static modificateur est appelé une variable statique.A field declared with the static modifier is called a static variable. Une variable statique est entamée avant l’exécution du constructeur statique (constructeurs statiques) pour son type conteneur et cesse d’exister lorsque le domaine d’application associé cesse d’exister.A static variable comes into existence before execution of the static constructor (Static constructors) for its containing type, and ceases to exist when the associated application domain ceases to exist.

La valeur initiale d’une variable statique est la valeur par défaut (valeurs par défaut) du type de la variable.The initial value of a static variable is the default value (Default values) of the variable's type.

À des fins de vérification de l’attribution définie, une variable statique est considérée comme initialement assignée.For purposes of definite assignment checking, a static variable is considered initially assigned.

Variables d’instanceInstance variables

Un champ déclaré sans le static modificateur est appelé une variable d’instance.A field declared without the static modifier is called an instance variable.

Variables d’instance dans les classesInstance variables in classes

Une variable d’instance d’une classe intervient lorsqu’une nouvelle instance de cette classe est créée et cesse d’exister lorsqu’il n’existe aucune référence à cette instance et que le destructeur de l’instance (le cas échéant) a été exécuté.An instance variable of a class comes into existence when a new instance of that class is created, and ceases to exist when there are no references to that instance and the instance's destructor (if any) has executed.

La valeur initiale d’une variable d’instance d’une classe est la valeur par défaut (valeurs par défaut) du type de la variable.The initial value of an instance variable of a class is the default value (Default values) of the variable's type.

Dans le cadre de la vérification de l’assignation définie, une variable d’instance d’une classe est considérée comme initialement assignée.For the purpose of definite assignment checking, an instance variable of a class is considered initially assigned.

Variables d’instance dans les structsInstance variables in structs

Une variable d’instance d’un struct a exactement la même durée de vie que la variable struct à laquelle elle appartient.An instance variable of a struct has exactly the same lifetime as the struct variable to which it belongs. En d’autres termes, lorsqu’une variable d’un type struct entre en existence ou cesse d’exister, il en est de même pour les variables d’instance du struct.In other words, when a variable of a struct type comes into existence or ceases to exist, so too do the instance variables of the struct.

L’état d’assignation initial d’une variable d’instance d’un struct est le même que celui de la variable de struct conteneur.The initial assignment state of an instance variable of a struct is the same as that of the containing struct variable. En d’autres termes, lorsqu’une variable de struct est considérée comme initialement assignée, il s’agit également de ses variables d’instance, et lorsqu’une variable de struct est considérée comme initialement non assignée, ses variables d’instance ne sont pas assignées de la même façon.In other words, when a struct variable is considered initially assigned, so too are its instance variables, and when a struct variable is considered initially unassigned, its instance variables are likewise unassigned.

Éléments de tableauArray elements

Les éléments d’un tableau existent lorsqu’une instance de tableau est créée et cessent d’exister lorsqu’il n’existe aucune référence à cette instance de tableau.The elements of an array come into existence when an array instance is created, and cease to exist when there are no references to that array instance.

La valeur initiale de chacun des éléments d’un tableau est la valeur par défaut (valeurs par défaut) du type des éléments du tableau.The initial value of each of the elements of an array is the default value (Default values) of the type of the array elements.

Dans le cadre de la vérification de l’assignation définie, un élément de tableau est considéré comme initialement assigné.For the purpose of definite assignment checking, an array element is considered initially assigned.

Paramètres de valeurValue parameters

Un paramètre déclaré sans ref modificateur ou out est un paramètre de valeur.A parameter declared without a ref or out modifier is a value parameter.

Un paramètre de valeur intervient lors de l’appel de la fonction membre (méthode, constructeur d’instance, accesseur ou opérateur) ou de la fonction anonyme à laquelle le paramètre appartient, et est initialisée avec la valeur de l’argument fourni dans l’appel.A value parameter comes into existence upon invocation of the function member (method, instance constructor, accessor, or operator) or anonymous function to which the parameter belongs, and is initialized with the value of the argument given in the invocation. Un paramètre de valeur cesse normalement d’exister lors du retour de la fonction membre ou de la fonction anonyme.A value parameter normally ceases to exist upon return of the function member or anonymous function. Toutefois, si le paramètre de valeur est capturé par une fonction anonyme (expressions de fonction anonymes), sa durée de vie s’étend au moins jusqu’à ce que le délégué ou l’arborescence d’expression créé à partir de cette fonction anonyme soit éligible pour garbage collection.However, if the value parameter is captured by an anonymous function (Anonymous function expressions), its life time extends at least until the delegate or expression tree created from that anonymous function is eligible for garbage collection.

Dans le cadre de la vérification de l’attribution définie, un paramètre de valeur est considéré comme initialement assigné.For the purpose of definite assignment checking, a value parameter is considered initially assigned.

Paramètres de référenceReference parameters

Un paramètre déclaré avec un ref modificateur est un paramètre de référence.A parameter declared with a ref modifier is a reference parameter.

Un paramètre de référence ne crée pas un nouvel emplacement de stockage.A reference parameter does not create a new storage location. Au lieu de cela, un paramètre de référence représente le même emplacement de stockage que la variable donnée comme argument dans le membre de fonction ou l’appel de fonction anonyme.Instead, a reference parameter represents the same storage location as the variable given as the argument in the function member or anonymous function invocation. Ainsi, la valeur d’un paramètre de référence est toujours la même que la variable sous-jacente.Thus, the value of a reference parameter is always the same as the underlying variable.

Les règles d’assignation définie suivantes s’appliquent aux paramètres de référence.The following definite assignment rules apply to reference parameters. Notez les différentes règles pour les paramètres de sortie décrits dans paramètres de sortie.Note the different rules for output parameters described in Output parameters.

  • Une variable doit être assignée de manière définitive (assignation définie) avant de pouvoir être passée en tant que paramètre de référence dans un membre de fonction ou un appel de délégué.A variable must be definitely assigned (Definite assignment) before it can be passed as a reference parameter in a function member or delegate invocation.
  • Dans un membre de fonction ou une fonction anonyme, un paramètre de référence est considéré comme initialement assigné.Within a function member or anonymous function, a reference parameter is considered initially assigned.

Dans une méthode d’instance ou un accesseur d’instance d’un this type struct, le mot clé se comporte exactement comme un paramètre de référence du type struct (cet accès).Within an instance method or instance accessor of a struct type, the this keyword behaves exactly as a reference parameter of the struct type (This access).

Paramètres de sortieOutput parameters

Un paramètre déclaré avec un out modificateur est un paramètre de sortie.A parameter declared with an out modifier is an output parameter.

Un paramètre de sortie ne crée pas un nouvel emplacement de stockage.An output parameter does not create a new storage location. Au lieu de cela, un paramètre de sortie représente le même emplacement de stockage que la variable donnée comme argument dans le membre de fonction ou l’appel de délégué.Instead, an output parameter represents the same storage location as the variable given as the argument in the function member or delegate invocation. Ainsi, la valeur d’un paramètre de sortie est toujours la même que la variable sous-jacente.Thus, the value of an output parameter is always the same as the underlying variable.

Les règles d’assignation définie suivantes s’appliquent aux paramètres de sortie.The following definite assignment rules apply to output parameters. Notez les différentes règles pour les paramètres de référence décrites dans paramètres de référence.Note the different rules for reference parameters described in Reference parameters.

  • Une variable n’a pas besoin d’être définitivement assignée avant de pouvoir être passée en tant que paramètre de sortie dans un membre de fonction ou un appel de délégué.A variable need not be definitely assigned before it can be passed as an output parameter in a function member or delegate invocation.
  • Après l’achèvement normal d’un membre de fonction ou d’un appel de délégué, chaque variable qui a été passée comme paramètre de sortie est considérée comme affectée dans ce chemin d’exécution.Following the normal completion of a function member or delegate invocation, each variable that was passed as an output parameter is considered assigned in that execution path.
  • Dans un membre de fonction ou une fonction anonyme, un paramètre de sortie est considéré comme initialement non assigné.Within a function member or anonymous function, an output parameter is considered initially unassigned.
  • Chaque paramètre de sortie d’un membre de fonction ou d’une fonction anonyme doit être assignée définitivement (assignation définie) avant que la fonction membre ou la fonction anonyme retourne normalement.Every output parameter of a function member or anonymous function must be definitely assigned (Definite assignment) before the function member or anonymous function returns normally.

Dans un constructeur d’instance d’un type struct, this le mot clé se comporte exactement comme un paramètre de sortie du type struct (cet accès).Within an instance constructor of a struct type, the this keyword behaves exactly as an output parameter of the struct type (This access).

Variables localesLocal variables

Une variable locale est déclarée par un local_variable_declaration, qui peut se produire dans un bloc, un for_Statement, un switch_Statement ou un using_statement; ou par un foreach_statement ou un specific_catch_clause pour un try_statement.A local variable is declared by a local_variable_declaration, which may occur in a block, a for_statement, a switch_statement or a using_statement; or by a foreach_statement or a specific_catch_clause for a try_statement.

La durée de vie d’une variable locale correspond à la partie de l’exécution du programme pendant laquelle le stockage est garanti comme étant réservé.The lifetime of a local variable is the portion of program execution during which storage is guaranteed to be reserved for it. Cette durée de vie étend au moins l’entrée dans le bloc, for_Statement, switch_Statement, using_statement, foreach_statementou specific_catch_clause auquel elle est associée, jusqu’à ce que l’exécution de ce bloc, for_Statement, switch_Statement, using_statement, foreach_statementou specific_catch_clause se termine de quelque manière que ce soit.This lifetime extends at least from entry into the block, for_statement, switch_statement, using_statement, foreach_statement, or specific_catch_clause with which it is associated, until execution of that block, for_statement, switch_statement, using_statement, foreach_statement, or specific_catch_clause ends in any way. (L’entrée d’un bloc délimité ou l’appel d’une méthode interrompt, mais ne termine pas, l’exécution du blocen cours, for_Statement, switch_Statement, using_statement, foreach_statementou specific_ catch_clause.) Si la variable locale est capturée par une fonction anonyme (variables externes capturées), sa durée de vie s’étend au moins jusqu’à ce que le délégué ou l’arborescence de l’expression soit créée à partir de la fonction anonyme, avec tous les autres objets qui font référence à l’objet variable capturée, pouvant être garbage collection.(Entering an enclosed block or calling a method suspends, but does not end, execution of the current block, for_statement, switch_statement, using_statement, foreach_statement, or specific_catch_clause.) If the local variable is captured by an anonymous function (Captured outer variables), its lifetime extends at least until the delegate or expression tree created from the anonymous function, along with any other objects that come to reference the captured variable, are eligible for garbage collection.

Si le blocparent, for_Statement, switch_Statement, using_statement, foreach_statementou specific_catch_clause est entré de manière récursive, une nouvelle instance de la variable locale est créée chaque Time, et son local_variable_initializer, le cas échéant, est évalué à chaque fois.If the parent block, for_statement, switch_statement, using_statement, foreach_statement, or specific_catch_clause is entered recursively, a new instance of the local variable is created each time, and its local_variable_initializer, if any, is evaluated each time.

Une variable locale introduite par un local_variable_declaration n’est pas initialisée automatiquement et n’a donc pas de valeur par défaut.A local variable introduced by a local_variable_declaration is not automatically initialized and thus has no default value. Dans le cadre de la vérification de l’attribution définie, une variable locale introduite par un local_variable_declaration est considérée comme initialement non assignée.For the purpose of definite assignment checking, a local variable introduced by a local_variable_declaration is considered initially unassigned. Un local_variable_declaration peut inclure un local_variable_initializer, auquel cas la variable est considérée comme définitivement assignée uniquement après l’expression d’initialisation (instructions de déclaration).A local_variable_declaration may include a local_variable_initializer, in which case the variable is considered definitely assigned only after the initializing expression (Declaration statements).

Dans l’étendue d’une variable locale introduite par un local_variable_declaration, il s’agit d’une erreur de compilation pour faire référence à cette variable locale dans une position textuelle qui précède son local_variable_declarator.Within the scope of a local variable introduced by a local_variable_declaration, it is a compile-time error to refer to that local variable in a textual position that precedes its local_variable_declarator. Si la déclaration de variable locale est implicite (déclarations de variables locales), il s’agit également d’une erreur qui fait référence à la variable dans son local_variable_declarator.If the local variable declaration is implicit (Local variable declarations), it is also an error to refer to the variable within its local_variable_declarator.

Une variable locale introduite par un foreach_statement ou un specific_catch_clause est considérée comme assignée de manière définitive dans sa portée entière.A local variable introduced by a foreach_statement or a specific_catch_clause is considered definitely assigned in its entire scope.

La durée de vie réelle d’une variable locale dépend de l’implémentation.The actual lifetime of a local variable is implementation-dependent. Par exemple, un compilateur peut déterminer statiquement qu’une variable locale dans un bloc est utilisée uniquement pour une petite partie de ce bloc.For example, a compiler might statically determine that a local variable in a block is only used for a small portion of that block. À l’aide de cette analyse, le compilateur peut générer du code qui donne au stockage de la variable une durée de vie plus faible que le bloc qui le contient.Using this analysis, the compiler could generate code that results in the variable's storage having a shorter lifetime than its containing block.

Le stockage référencé par une variable de référence locale est récupéré indépendamment de la durée de vie de cette variable de référence locale (gestion automatiquede la mémoire).The storage referred to by a local reference variable is reclaimed independently of the lifetime of that local reference variable (Automatic memory management).

Valeurs par défautDefault values

Les catégories de variables suivantes sont automatiquement initialisées à leurs valeurs par défaut :The following categories of variables are automatically initialized to their default values:

  • variables statiquesStatic variables.
  • Variables d’instance des instances de classe.Instance variables of class instances.
  • Éléments du tableau.Array elements.

La valeur par défaut d’une variable dépend du type de la variable et est déterminée comme suit :The default value of a variable depends on the type of the variable and is determined as follows:

  • Pour une variable d’un Value_type, la valeur par défaut est la même que la valeur calculée par le constructeur par défaut de Value_type(constructeurs par défaut).For a variable of a value_type, the default value is the same as the value computed by the value_type's default constructor (Default constructors).
  • Pour une variable d’un reference_type, la valeur par défaut nullest.For a variable of a reference_type, the default value is null.

L’initialisation aux valeurs par défaut est généralement effectuée en faisant en sorte que le gestionnaire de mémoire ou le garbage collector initialise la mémoire à tous les bits-zéro avant qu’il ne soit alloué pour utilisation.Initialization to default values is typically done by having the memory manager or garbage collector initialize memory to all-bits-zero before it is allocated for use. Pour cette raison, il est pratique d’utiliser All-bits-Zero pour représenter la référence null.For this reason, it is convenient to use all-bits-zero to represent the null reference.

Assignation définieDefinite assignment

À un emplacement donné dans le code exécutable d’un membre de fonction, une variable est dite assignée de manière définitive si le compilateur peut prouver, par une analyse de workflow statique particulière (règles précises pour déterminer l’assignation définie), que la variable a été initialisé automatiquement ou a été la cible d’au moins une attribution.At a given location in the executable code of a function member, a variable is said to be definitely assigned if the compiler can prove, by a particular static flow analysis (Precise rules for determining definite assignment), that the variable has been automatically initialized or has been the target of at least one assignment. Comme indiqué de façon informelle, les règles d’attribution définie sont les suivantes :Informally stated, the rules of definite assignment are:

La spécification formelle sous-jacente aux règles informelles ci-dessus est décrite dans variables initialement attribuées, variables initialement non assignéeset règles précises pour déterminer l’assignation définie.The formal specification underlying the above informal rules is described in Initially assigned variables, Initially unassigned variables, and Precise rules for determining definite assignment.

Les États d’assignation définie des variables d’instance d’une variable struct_type sont suivis individuellement et collectivement.The definite assignment states of instance variables of a struct_type variable are tracked individually as well as collectively. Outre les règles ci-dessus, les règles suivantes s’appliquent aux variables struct_type et à leurs variables d’instance :In addition to the rules above, the following rules apply to struct_type variables and their instance variables:

  • Une variable d’instance est considérée comme assignée définitivement si sa variable struct_type conteneur est considérée comme assignée de manière définitive.An instance variable is considered definitely assigned if its containing struct_type variable is considered definitely assigned.
  • Une variable struct_type est considérée comme assignée définitivement si chacune de ses variables d’instance est considérée comme assignée de manière définitive.A struct_type variable is considered definitely assigned if each of its instance variables is considered definitely assigned.

L’assignation définie est une exigence dans les contextes suivants :Definite assignment is a requirement in the following contexts:

  • Une variable doit être assignée de manière définitive à chaque emplacement où sa valeur est obtenue.A variable must be definitely assigned at each location where its value is obtained. Cela permet de s’assurer que les valeurs non définies ne se produisent jamais.This ensures that undefined values never occur. L’occurrence d’une variable dans une expression est considérée pour obtenir la valeur de la variable, sauf lorsqueThe occurrence of a variable in an expression is considered to obtain the value of the variable, except when
    • la variable est l’opérande gauche d’une assignation simple.the variable is the left operand of a simple assignment,
    • la variable est transmise en tant que paramètre de sortie, outhe variable is passed as an output parameter, or
    • la variable est une variable struct_type et se produit comme opérande gauche d’un accès au membre.the variable is a struct_type variable and occurs as the left operand of a member access.
  • Une variable doit être assignée de manière définitive à chaque emplacement où elle est passée en tant que paramètre de référence.A variable must be definitely assigned at each location where it is passed as a reference parameter. Cela garantit que le membre de fonction appelé peut prendre en compte le paramètre de référence initialement assigné.This ensures that the function member being invoked can consider the reference parameter initially assigned.
  • Tous les paramètres de sortie d’un membre de fonction doivent être assignés définitivement à chaque emplacement où le membre return de fonction retourne (via une instruction ou l’exécution atteint la fin du corps du membre de la fonction).All output parameters of a function member must be definitely assigned at each location where the function member returns (through a return statement or through execution reaching the end of the function member body). Cela garantit que les fonctions membres ne retournent pas de valeurs non définies dans les paramètres de sortie, ce qui permet au compilateur de considérer un appel de membre de fonction qui prend une variable comme paramètre de sortie équivalent à une assignation à la variable.This ensures that function members do not return undefined values in output parameters, thus enabling the compiler to consider a function member invocation that takes a variable as an output parameter equivalent to an assignment to the variable.
  • La this variable d’un constructeur d’instance struct_type doit être assignée de manière définitive à chaque emplacement que le constructeur d’instance retourne.The this variable of a struct_type instance constructor must be definitely assigned at each location where that instance constructor returns.

Variables initialement attribuéesInitially assigned variables

Les catégories de variables suivantes sont classées comme initialement attribuées :The following categories of variables are classified as initially assigned:

  • variables statiquesStatic variables.
  • Variables d’instance des instances de classe.Instance variables of class instances.
  • Variables d’instance de variables de struct initialement attribuées.Instance variables of initially assigned struct variables.
  • Éléments du tableau.Array elements.
  • Paramètres de valeur.Value parameters.
  • Paramètres de référence.Reference parameters.
  • Variables déclarées dans catch une clause ou foreach une instruction.Variables declared in a catch clause or a foreach statement.

Variables initialement non assignéesInitially unassigned variables

Les catégories de variables suivantes sont classées comme étant initialement non assignées :The following categories of variables are classified as initially unassigned:

  • Variables d’instance de variables de struct initialement non assignées.Instance variables of initially unassigned struct variables.
  • Paramètres de sortie, y this compris la variable des constructeurs d’instance de struct.Output parameters, including the this variable of struct instance constructors.
  • Les variables locales, à l’exception de catch celles déclarées foreach dans une clause ou une instruction.Local variables, except those declared in a catch clause or a foreach statement.

Règles précises pour déterminer l’assignation définiePrecise rules for determining definite assignment

Pour déterminer que chaque variable utilisée est assignée de manière définitive, le compilateur doit utiliser un processus qui est équivalent à celui décrit dans cette section.In order to determine that each used variable is definitely assigned, the compiler must use a process that is equivalent to the one described in this section.

Le compilateur traite le corps de chaque membre de fonction qui a une ou plusieurs variables initialement non assignées.The compiler processes the body of each function member that has one or more initially unassigned variables. Pour chaque variable vnon assignée initialement, le compilateur détermine un État d’assignation définie pour v à chacun des points suivants dans le membre de fonction :For each initially unassigned variable v, the compiler determines a definite assignment state for v at each of the following points in the function member:

  • Au début de chaque instructionAt the beginning of each statement
  • Au point de terminaison (points de terminaison et accessibilité) de chaque instructionAt the end point (End points and reachability) of each statement
  • Sur chaque arc qui transfère le contrôle à une autre instruction ou jusqu’au point de terminaison d’une instructionOn each arc which transfers control to another statement or to the end point of a statement
  • Au début de chaque expressionAt the beginning of each expression
  • À la fin de chaque expressionAt the end of each expression

L’état d’assignation définie de v peut être :The definite assignment state of v can be either:

  • Assigné de manière définitive.Definitely assigned. Cela indique qu’une valeur a été assignée à v pour tous les flux de contrôle possibles à ce stade.This indicates that on all possible control flows to this point, v has been assigned a value.
  • Pas définitivement assigné.Not definitely assigned. Pour l’état d’une variable à la fin d’une expression de type bool, l’état d’une variable qui n’est pas définitivement assignée peut (mais n’est pas nécessairement) appartenir à l’un des sous-États suivants :For the state of a variable at the end of an expression of type bool, the state of a variable that isn't definitely assigned may (but doesn't necessarily) fall into one of the following sub-states:
    • Assigné définitivement après une expression true.Definitely assigned after true expression. Cet état indique que v est définitivement affecté si l’expression booléenne est évaluée comme true, mais n’est pas nécessairement affectée si l’expression booléenne est évaluée comme false.This state indicates that v is definitely assigned if the boolean expression evaluated as true, but is not necessarily assigned if the boolean expression evaluated as false.
    • Assigné définitivement après une expression false.Definitely assigned after false expression. Cet état indique que v est définitivement affecté si l’expression booléenne est évaluée comme false, mais n’est pas nécessairement affectée si l’expression booléenne est évaluée comme true.This state indicates that v is definitely assigned if the boolean expression evaluated as false, but is not necessarily assigned if the boolean expression evaluated as true.

Les règles suivantes régissent la façon dont l’état d’une variable v est déterminé à chaque emplacement.The following rules govern how the state of a variable v is determined at each location.

Règles générales pour les instructionsGeneral rules for statements

  • v n’est pas définitivement assignée au début d’un corps de membre de fonction.v is not definitely assigned at the beginning of a function member body.
  • v est définitivement assignée au début de toute instruction inaccessible.v is definitely assigned at the beginning of any unreachable statement.
  • L’état d’assignation définie de v au début d’une autre instruction est déterminé en vérifiant l’état d’assignation définie de v sur tous les transferts de workflow de contrôle qui ciblent le début de cette instruction.The definite assignment state of v at the beginning of any other statement is determined by checking the definite assignment state of v on all control flow transfers that target the beginning of that statement. Si (et seulement si) v est définitivement assigné sur tous les transferts de ce type de contrôle, v est définitivement assigné au début de l’instruction.If (and only if) v is definitely assigned on all such control flow transfers, then v is definitely assigned at the beginning of the statement. L’ensemble des transferts de workflow possibles est déterminé de la même façon que pour la vérification de l’accessibilité des instructions (points de terminaison et accessibilité).The set of possible control flow transfers is determined in the same way as for checking statement reachability (End points and reachability).
  • État d’assignation définie de v au point de terminaison d’un bloc, checked do, foreach unchecked if while,,,, for,, lock using, ou switchl’instruction est déterminée en vérifiant l’état d’assignation définie de v sur tous les transferts de workflow de contrôle qui ciblent le point de terminaison de cette instruction.The definite assignment state of v at the end point of a block, checked, unchecked, if, while, do, for, foreach, lock, using, or switch statement is determined by checking the definite assignment state of v on all control flow transfers that target the end point of that statement. Si v est définitivement assignée à tous les transferts de ce type de contrôle, v est définitivement assigné au point de terminaison de l’instruction.If v is definitely assigned on all such control flow transfers, then v is definitely assigned at the end point of the statement. Dispose v n’est pas définitivement assigné au point de terminaison de l’instruction.Otherwise; v is not definitely assigned at the end point of the statement. L’ensemble des transferts de workflow possibles est déterminé de la même façon que pour la vérification de l’accessibilité des instructions (points de terminaison et accessibilité).The set of possible control flow transfers is determined in the same way as for checking statement reachability (End points and reachability).

Instructions de bloc, instructions vérifiées et non vérifiéesBlock statements, checked, and unchecked statements

L’état d’assignation définie de v sur le transfert de contrôle vers la première instruction de la liste d’instructions dans le bloc (ou jusqu’au point de terminaison du bloc, si la liste d’instructions est vide) est le même que l’instruction d’assignation définie de v avant le bloc instruction checked, ou unchecked .The definite assignment state of v on the control transfer to the first statement of the statement list in the block (or to the end point of the block, if the statement list is empty) is the same as the definite assignment statement of v before the block, checked, or unchecked statement.

Instructions d’expressionExpression statements

Pour une instruction d’expression stmt qui se compose de l’expression expr:For an expression statement stmt that consists of the expression expr:

  • v a le même état d’assignation définie au début de expr qu’au début de stmt.v has the same definite assignment state at the beginning of expr as at the beginning of stmt.
  • Si v est assignée de manière définitive à la fin de expr, elle est définitivement assignée au point de terminaison de stmt; dispose elle n’est pas définitivement assignée au point de terminaison de stmt.If v if definitely assigned at the end of expr, it is definitely assigned at the end point of stmt; otherwise; it is not definitely assigned at the end point of stmt.

Instructions de déclarationDeclaration statements

  • Si stmt est une instruction de déclaration sans initialiseurs, alors v a le même état d’assignation définie au point de terminaison de stmt qu’au début de stmt.If stmt is a declaration statement without initializers, then v has the same definite assignment state at the end point of stmt as at the beginning of stmt.
  • Si stmt est une instruction de déclaration avec des initialiseurs, l’état d’assignation définie pour v est déterminé comme si stmt était une liste d’instructions, avec une instruction d’assignation pour chaque déclaration avec un initialiseur (dans l’ordre de déclaration).If stmt is a declaration statement with initializers, then the definite assignment state for v is determined as if stmt were a statement list, with one assignment statement for each declaration with an initializer (in the order of declaration).

Instructions IfIf statements

Pour une if instruction stmt de la forme :For an if statement stmt of the form:

if ( expr ) then_stmt else else_stmt
  • v a le même état d’assignation définie au début de expr qu’au début de stmt.v has the same definite assignment state at the beginning of expr as at the beginning of stmt.
  • Si v est définitivement assignée à la fin de expr, il est définitivement assigné sur le transfert du workflow de contrôle à then_stmt et else_stmt ou sur le point de terminaison de stmt s’il n’y a aucune clause Else.If v is definitely assigned at the end of expr, then it is definitely assigned on the control flow transfer to then_stmt and to either else_stmt or to the end-point of stmt if there is no else clause.
  • Si v a l’état « définitivement assigné après une expression true » à la fin de expr, il est définitivement affecté sur le transfert du workflow de contrôle à then_stmtet n’est pas définitivement assigné sur le transfert de workflow à else_ stmt ou jusqu’au point de terminaison de stmt s’il n’y a aucune clause Else.If v has the state "definitely assigned after true expression" at the end of expr, then it is definitely assigned on the control flow transfer to then_stmt, and not definitely assigned on the control flow transfer to either else_stmt or to the end-point of stmt if there is no else clause.
  • Si v a l’état « définitivement assigné après une expression false » à la fin de expr, il est définitivement assigné sur le transfert du workflow de contrôle à else_stmtet n’est pas définitivement assigné sur le transfert du workflow de contrôle à then_stmt .If v has the state "definitely assigned after false expression" at the end of expr, then it is definitely assigned on the control flow transfer to else_stmt, and not definitely assigned on the control flow transfer to then_stmt. Elle est définitivement assignée au point de terminaison de stmt si et seulement si elle est définitivement assignée au point de terminaison de then_stmt.It is definitely assigned at the end-point of stmt if and only if it is definitely assigned at the end-point of then_stmt.
  • Dans le cas contraire, v est considéré comme n’étant pas définitivement affecté sur le transfert du workflow de contrôle vers then_stmt ou else_stmt, ou vers le point de terminaison de stmt s’il n’y a aucune clause Else.Otherwise, v is considered not definitely assigned on the control flow transfer to either the then_stmt or else_stmt, or to the end-point of stmt if there is no else clause.

Instructions SwitchSwitch statements

Dans une switch instruction stmt avec une expression de contrôle expr:In a switch statement stmt with a controlling expression expr:

  • L’état d’assignation définie de v au début de expr est identique à l’état v au début de stmt.The definite assignment state of v at the beginning of expr is the same as the state of v at the beginning of stmt.
  • L’état d’assignation définie de v sur le transfert du workflow de contrôle vers une liste d’instructions de bloc switch accessible est le même que l’état d’assignation définie de v à la fin de expr.The definite assignment state of v on the control flow transfer to a reachable switch block statement list is the same as the definite assignment state of v at the end of expr.

Instructions whileWhile statements

Pour une while instruction stmt de la forme :For a while statement stmt of the form:

while ( expr ) while_body
  • v a le même état d’assignation définie au début de expr qu’au début de stmt.v has the same definite assignment state at the beginning of expr as at the beginning of stmt.
  • Si v est définitivement assignée à la fin de expr, il est définitivement affecté sur le transfert du workflow de contrôle à while_body et jusqu’au point de terminaison de stmt.If v is definitely assigned at the end of expr, then it is definitely assigned on the control flow transfer to while_body and to the end point of stmt.
  • Si v a l’état « définitivement assigné après une expression true » à la fin de expr, il est définitivement affecté au transfert du workflow de contrôle à while_body, mais il n’est pas définitivement assigné au point de terminaison de stmt.If v has the state "definitely assigned after true expression" at the end of expr, then it is definitely assigned on the control flow transfer to while_body, but not definitely assigned at the end-point of stmt.
  • Si v a l’état « définitivement assigné après une expression false » à la fin de expr, il est définitivement affecté sur le transfert du workflow de contrôle au point de terminaison de stmt, mais pas définitivement assigné sur le transfert du workflow de contrôle à quand _body.If v has the state "definitely assigned after false expression" at the end of expr, then it is definitely assigned on the control flow transfer to the end point of stmt, but not definitely assigned on the control flow transfer to while_body.

Instructions doDo statements

Pour une do instruction stmt de la forme :For a do statement stmt of the form:

do do_body while ( expr ) ;
  • v a le même état d’assignation définie sur le transfert du workflow de contrôle entre le début de stmt et do_body qu’au début de stmt.v has the same definite assignment state on the control flow transfer from the beginning of stmt to do_body as at the beginning of stmt.
  • v a le même état d’assignation définie au début de expr comme au point de terminaison de do_body.v has the same definite assignment state at the beginning of expr as at the end point of do_body.
  • Si v est définitivement assignée à la fin de expr, elle est définitivement assignée sur le transfert du workflow de contrôle vers le point de terminaison de stmt.If v is definitely assigned at the end of expr, then it is definitely assigned on the control flow transfer to the end point of stmt.
  • Si v a l’état « définitivement assigné après une expression false » à la fin de expr, il est définitivement affecté sur le transfert du workflow de contrôle au point de terminaison de stmt.If v has the state "definitely assigned after false expression" at the end of expr, then it is definitely assigned on the control flow transfer to the end point of stmt.

Pour les instructionsFor statements

Vérification de l’assignation définie pour for une instruction de la forme :Definite assignment checking for a for statement of the form:

for ( for_initializer ; for_condition ; for_iterator ) embedded_statement

est effectué comme si l’instruction était écrite :is done as if the statement were written:

{
    for_initializer ;
    while ( for_condition ) {
        embedded_statement ;
        for_iterator ;
    }
}

Si le for_condition est omis de l' for instruction, l’évaluation de l’assignation définie se poursuit comme si for_condition était remplacé par true dans l’expansion ci-dessus.If the for_condition is omitted from the for statement, then evaluation of definite assignment proceeds as if for_condition were replaced with true in the above expansion.

Instructions break, continue et GOTOBreak, continue, and goto statements

L’état d’assignation définie de v sur le transfert de workflow de contrôle provoqué breakpar continueune instruction goto , ou est le même que l’état d’assignation définie de v au début de l’instruction.The definite assignment state of v on the control flow transfer caused by a break, continue, or goto statement is the same as the definite assignment state of v at the beginning of the statement.

Instructions throwThrow statements

Pour une instruction stmt au formatFor a statement stmt of the form

throw expr ;

L’état d’assignation définie de v au début de expr est le même que l’état d’assignation définie de v au début de stmt.The definite assignment state of v at the beginning of expr is the same as the definite assignment state of v at the beginning of stmt.

Instructions ReturnReturn statements

Pour une instruction stmt au formatFor a statement stmt of the form

return expr ;
  • L’état d’assignation définie de v au début de expr est le même que l’état d’assignation définie de v au début de stmt.The definite assignment state of v at the beginning of expr is the same as the definite assignment state of v at the beginning of stmt.
  • Si v est un paramètre de sortie, il doit être affecté définitivement :If v is an output parameter, then it must be definitely assigned either:
    • après exprafter expr
    • ou finally à la fin du bloc d’un try - oureturn qui englobe l’instruction. catch try - finally - finallyor at the end of the finally block of a try-finally or try-catch-finally that encloses the return statement.

Pour une instruction stmt de la forme :For a statement stmt of the form:

return ;
  • Si v est un paramètre de sortie, il doit être affecté définitivement :If v is an output parameter, then it must be definitely assigned either:
    • avant stmtbefore stmt
    • ou finally à la fin du bloc d’un try - oureturn qui englobe l’instruction. catch try - finally - finallyor at the end of the finally block of a try-finally or try-catch-finally that encloses the return statement.

Instructions Try-CatchTry-catch statements

Pour une instruction stmt de la forme :For a statement stmt of the form:

try try_block
catch(...) catch_block_1
...
catch(...) catch_block_n
  • L’état d’assignation définie de v au début de try_block est identique à l’état d’assignation définie de v au début de stmt.The definite assignment state of v at the beginning of try_block is the same as the definite assignment state of v at the beginning of stmt.
  • L’état d’assignation définie de v au début de catch_block_i (pour Any i) est identique à l’état d’assignation définie de v au début de stmt.The definite assignment state of v at the beginning of catch_block_i (for any i) is the same as the definite assignment state of v at the beginning of stmt.
  • L’état d’assignation définie de v à l’extrémité de stmt est définitivement affecté si (et seulement si) v est définitivement assigné au point de terminaison de try_block et chaque catch_block_i (pour chaque i de 1 à n ).The definite assignment state of v at the end-point of stmt is definitely assigned if (and only if) v is definitely assigned at the end-point of try_block and every catch_block_i (for every i from 1 to n).

Instructions try-finallyTry-finally statements

Pour une try instruction stmt de la forme :For a try statement stmt of the form:

try try_block finally finally_block
  • L’état d’assignation définie de v au début de try_block est identique à l’état d’assignation définie de v au début de stmt.The definite assignment state of v at the beginning of try_block is the same as the definite assignment state of v at the beginning of stmt.
  • L’état d’assignation définie de v au début de finally_block est identique à l’état d’assignation définie de v au début de stmt.The definite assignment state of v at the beginning of finally_block is the same as the definite assignment state of v at the beginning of stmt.
  • L’état d’assignation définie de v à l’extrémité de stmt est définitivement affecté si (et seulement si) au moins l’une des conditions suivantes est vraie :The definite assignment state of v at the end-point of stmt is definitely assigned if (and only if) at least one of the following is true:
    • v est définitivement assignée au point de terminaison de try_blockv is definitely assigned at the end-point of try_block
    • v est définitivement assignée au point de terminaison de finally_blockv is definitely assigned at the end-point of finally_block

Si un transfert de workflow de contrôle (par exemple goto , une instruction) commence dans try_blocket se termine en dehors de try_block, v est également considéré comme définitivement assigné sur ce transfert de workflow si v est assigné de manière définitive au point de terminaison de finally_block.If a control flow transfer (for example, a goto statement) is made that begins within try_block, and ends outside of try_block, then v is also considered definitely assigned on that control flow transfer if v is definitely assigned at the end-point of finally_block. (Il ne s’agit pas d’un seul si, si v est définitivement affecté pour une autre raison sur ce transfert de workflow, il est toujours considéré comme définitivement affecté.)(This is not an only if—if v is definitely assigned for another reason on this control flow transfer, then it is still considered definitely assigned.)

Instructions try-catch-finallyTry-catch-finally statements

Analyse d’assignation définie pour une try - catch - instruction delaforme:finallyDefinite assignment analysis for a try-catch-finally statement of the form:

try try_block
catch(...) catch_block_1
...
catch(...) catch_block_n
finally *finally_block*

est effectué comme si l’instruction était une try - try - finally instruction englobant une catch instruction :is done as if the statement were a try-finally statement enclosing a try-catch statement:

try {
    try try_block
    catch(...) catch_block_1
    ...
    catch(...) catch_block_n
}
finally finally_block

L’exemple suivant montre comment les différents blocs d’une try instruction (instruction try) affectent l’assignation définie.The following example demonstrates how the different blocks of a try statement (The try statement) affect definite assignment.

class A
{
    static void F() {
        int i, j;
        try {
            goto LABEL;
            // neither i nor j definitely assigned
            i = 1;
            // i definitely assigned
        }

        catch {
            // neither i nor j definitely assigned
            i = 3;
            // i definitely assigned
        }

        finally {
            // neither i nor j definitely assigned
            j = 5;
            // j definitely assigned
            }
        // i and j definitely assigned
        LABEL:;
        // j definitely assigned

    }
}

Instructions foreachForeach statements

Pour une foreach instruction stmt de la forme :For a foreach statement stmt of the form:

foreach ( type identifier in expr ) embedded_statement
  • L’état d’assignation définie de v au début de expr est identique à l’état v au début de stmt.The definite assignment state of v at the beginning of expr is the same as the state of v at the beginning of stmt.
  • L’état d’assignation définie de v sur le transfert du workflow de contrôle vers embedded_statement ou vers le point de terminaison de stmt est le même que l’état de v à la fin de expr.The definite assignment state of v on the control flow transfer to embedded_statement or to the end point of stmt is the same as the state of v at the end of expr.

Instructions usingUsing statements

Pour une using instruction stmt de la forme :For a using statement stmt of the form:

using ( resource_acquisition ) embedded_statement
  • L’état d’assignation définie de v au début de resource_acquisition est identique à l’état v au début de stmt.The definite assignment state of v at the beginning of resource_acquisition is the same as the state of v at the beginning of stmt.
  • L’état d’assignation définie de v sur le transfert du workflow de contrôle vers embedded_statement est identique à l’état v à la fin de resource_acquisition.The definite assignment state of v on the control flow transfer to embedded_statement is the same as the state of v at the end of resource_acquisition.

Instructions LockLock statements

Pour une lock instruction stmt de la forme :For a lock statement stmt of the form:

lock ( expr ) embedded_statement
  • L’état d’assignation définie de v au début de expr est identique à l’état v au début de stmt.The definite assignment state of v at the beginning of expr is the same as the state of v at the beginning of stmt.
  • L’état d’assignation définie de v sur le transfert du workflow de contrôle vers embedded_statement est identique à l’état v à la fin de expr.The definite assignment state of v on the control flow transfer to embedded_statement is the same as the state of v at the end of expr.

Instructions yieldYield statements

Pour une yield return instruction stmt de la forme :For a yield return statement stmt of the form:

yield return expr ;
  • L’état d’assignation définie de v au début de expr est identique à l’état v au début de stmt.The definite assignment state of v at the beginning of expr is the same as the state of v at the beginning of stmt.
  • L’état d’assignation définie de v à la fin de stmt est identique à l’état v à la fin de expr.The definite assignment state of v at the end of stmt is the same as the state of v at the end of expr.
  • Une yield break instruction n’a aucun effet sur l’état d’assignation définie.A yield break statement has no effect on the definite assignment state.

Règles générales pour les expressions simplesGeneral rules for simple expressions

La règle suivante s’applique à ces types d’expressions : les littéraux (littéraux), les noms simples (noms simples), les expressions d’accès au membre (accès aux membres), les expressions d’accès de base non indexées (accès de base) typeof.expressions (opérateur typeof), expressions de valeur par défaut (expressions de valeur par défaut) et nameof expressions (expressions Nameof).The following rule applies to these kinds of expressions: literals (Literals), simple names (Simple names), member access expressions (Member access), non-indexed base access expressions (Base access), typeof expressions (The typeof operator), default value expressions (Default value expressions) and nameof expressions (Nameof expressions).

  • L’état d’assignation définie de v à la fin d’une telle expression est le même que l’état d’assignation définie de v au début de l’expression.The definite assignment state of v at the end of such an expression is the same as the definite assignment state of v at the beginning of the expression.

Règles générales pour les expressions avec des expressions incorporéesGeneral rules for expressions with embedded expressions

Les règles suivantes s’appliquent à ces types d’expressions : expressions entre parenthèses (expressions entre parenthèses), expressions d’accès aux éléments (accès aux éléments), expressions d’accès de base avec indexation (accès de base), incrémentation et expressions de décrémentation (opérateurs d’incrémentation et de décrémentation suffixés, opérateurs de préfixe d’incrémentation et de décrémentation), ~expressions de cast (expressions deCast), unaire + -,, *,expressions, Binary + - ,*,, ,%, ,>>,, ,,>, << < / <= >= ==, !=, ,is,, ,^expressions (opérateurs arithmétiques, opérateurs de décalage, relationnel et test de type | as & opérateurs, opérateurs logiques), expressions d’assignation composée ( checked assignation composée) unchecked et expressions (opérateurs activés et désactivés), plus un tableau et un délégué expressions de création (opérateur New).The following rules apply to these kinds of expressions: parenthesized expressions (Parenthesized expressions), element access expressions (Element access), base access expressions with indexing (Base access), increment and decrement expressions (Postfix increment and decrement operators, Prefix increment and decrement operators), cast expressions (Cast expressions), unary +, -, ~, * expressions, binary +, -, *, /, %, <<, >>, <, <=, >, >=, ==, !=, is, as, &, |, ^ expressions (Arithmetic operators, Shift operators, Relational and type-testing operators, Logical operators), compound assignment expressions (Compound assignment), checked and unchecked expressions (The checked and unchecked operators), plus array and delegate creation expressions (The new operator).

Chacune de ces expressions a une ou plusieurs sous-expressions qui sont évaluées de manière non conditionnelle dans un ordre fixe.Each of these expressions has one or more sub-expressions that are unconditionally evaluated in a fixed order. Par exemple, l’opérateur % binaire évalue le côté gauche de l’opérateur, puis le côté droit.For example, the binary % operator evaluates the left hand side of the operator, then the right hand side. Une opération d’indexation évalue l’expression indexée, puis évalue chacune des expressions d’index, dans l’ordre, de gauche à droite.An indexing operation evaluates the indexed expression, and then evaluates each of the index expressions, in order from left to right. Pour une expression expr, qui contient des sous-expressions E1, E2,..., en, évaluées dans cet ordre :For an expression expr, which has sub-expressions e1, e2, ..., eN, evaluated in that order:

  • L’état d’assignation définie de v au début de E1 est le même que l’état d’assignation définie au début de expr.The definite assignment state of v at the beginning of e1 is the same as the definite assignment state at the beginning of expr.
  • L’état d’assignation définie de v au début de l' AE (i supérieur à un) est identique à l’état d’assignation définie à la fin de la sous-expression précédente.The definite assignment state of v at the beginning of ei (i greater than one) is the same as the definite assignment state at the end of the previous sub-expression.
  • L’état d’assignation définie de v à la fin de expr est identique à l’état d’assignation définie à la fin de laThe definite assignment state of v at the end of expr is the same as the definite assignment state at the end of eN

Expressions d’appel et expressions de création d’objetInvocation expressions and object creation expressions

Pour une expression d’appel expr de la forme :For an invocation expression expr of the form:

primary_expression ( arg1 , arg2 , ... , argN )

ou une expression de création d’objet de la forme suivante :or an object creation expression of the form:

new type ( arg1 , arg2 , ... , argN )
  • Pour une expression d’appel, l’état d’assignation définie de v avant primary_expression est identique à l’état v avant expr.For an invocation expression, the definite assignment state of v before primary_expression is the same as the state of v before expr.
  • Pour une expression d’appel, l’état d’assignation définie de v avant Arg1 est le même que l’état de v après primary_expression.For an invocation expression, the definite assignment state of v before arg1 is the same as the state of v after primary_expression.
  • Pour une expression de création d’objet, l’état d’assignation définie de v avant Arg1 est le même que l’état de v avant expr.For an object creation expression, the definite assignment state of v before arg1 is the same as the state of v before expr.
  • Pour chaque argument Argi, l’état d’assignation définie de v après Argi est déterminé par les règles d’expression normales, en ignorant ref les out modificateurs ou.For each argument argi, the definite assignment state of v after argi is determined by the normal expression rules, ignoring any ref or out modifiers.
  • Pour chaque argument Argi pour un i supérieur à un, l’état d’assignation définie de v avant Argi est identique à l’état v après l' argument précédent.For each argument argi for any i greater than one, the definite assignment state of v before argi is the same as the state of v after the previous arg.
  • Si la variable v est out passée comme argument (c’est-à-dire un argument du out vformulaire) dans l’un des arguments, l’état v après expr est définitivement assigné.If the variable v is passed as an out argument (i.e., an argument of the form out v) in any of the arguments, then the state of v after expr is definitely assigned. Dispose l’état de v après expr est identique à l’état v après argN.Otherwise; the state of v after expr is the same as the state of v after argN.
  • Pour les initialiseurs de tableau (expressions de création de tableau), les initialiseurs d’objets (initialiseurs d’objets), les initialiseurs de collection (initialiseurs de collection) et les initialiseurs d’objets anonymes (création d'objets anonymes expressions), l’état d’assignation défini est déterminé par l’expansion que ces constructions sont définies en termes de.For array initializers (Array creation expressions), object initializers (Object initializers), collection initializers (Collection initializers) and anonymous object initializers (Anonymous object creation expressions), the definite assignment state is determined by the expansion that these constructs are defined in terms of.

Expressions d’assignation simplesSimple assignment expressions

Pour une expression expr de la forme w = expr_rhs:For an expression expr of the form w = expr_rhs:

  • L’état d’assignation définie de v avant expr_rhs est identique à l’état d’assignation définie de v avant expr.The definite assignment state of v before expr_rhs is the same as the definite assignment state of v before expr.
  • L’état d’assignation définie de v après expr est déterminé par :The definite assignment state of v after expr is determined by:
    • Si w est la même variable que v, l’état d’assignation définie de v après expr est définitivement assigné.If w is the same variable as v, then the definite assignment state of v after expr is definitely assigned.
    • Sinon, si l’assignation se produit dans le constructeur d’instance d’un type struct, si w est un accès à la propriété désignant une propriété implémentée automatiquement P sur l’instance en cours de construction et que v est le champ de stockage masqué de P, puis l’état d’assignation définie de v après expr est définitivement assigné.Otherwise, if the assignment occurs within the instance constructor of a struct type, if w is a property access designating an automatically implemented property P on the instance being constructed and v is the hidden backing field of P, then the definite assignment state of v after expr is definitely assigned.
    • Dans le cas contraire, l’état d’assignation définie de v après expr est le même que l’état d’assignation définie de v après expr_rhs.Otherwise, the definite assignment state of v after expr is the same as the definite assignment state of v after expr_rhs.

& les expressions & (conditionnelles et)&& (conditional AND) expressions

Pour une expression expr de la forme expr_first && expr_second:For an expression expr of the form expr_first && expr_second:

  • L’état d’assignation définie de v avant expr_first est identique à l’état d’assignation définie de v avant expr.The definite assignment state of v before expr_first is the same as the definite assignment state of v before expr.
  • L’état d’assignation définie de v avant expr_second est définitivement assigné si l’état de v après expr_first est défini de manière définitive ou « définitivement assigné après l’expression true ».The definite assignment state of v before expr_second is definitely assigned if the state of v after expr_first is either definitely assigned or "definitely assigned after true expression". Dans le cas contraire, elle n’est pas définitivement assignée.Otherwise, it is not definitely assigned.
  • L’état d’assignation définie de v après expr est déterminé par :The definite assignment state of v after expr is determined by:
    • Si expr_first est une expression constante avec la valeur false, l’état d’assignation définie de v après expr est le même que l’état d’assignation définie de v après expr_first.If expr_first is a constant expression with the value false, then the definite assignment state of v after expr is the same as the definite assignment state of v after expr_first.
    • Sinon, si l’état de v après expr_first est définitivement assigné, l’état v après expr est définitivement assigné.Otherwise, if the state of v after expr_first is definitely assigned, then the state of v after expr is definitely assigned.
    • Sinon, si l’état de v après expr_second est assignée définitivement, et que l’état de v après expr_first est « définitivement assigné après false expression », alors l’état de v après expr est définitivement ont.Otherwise, if the state of v after expr_second is definitely assigned, and the state of v after expr_first is "definitely assigned after false expression", then the state of v after expr is definitely assigned.
    • Dans le cas contraire, si l’état de v après expr_second est définitivement assigné ou « définitivement assigné après une expression true », l’état v après expr est « définitivement assigné après une expression true ».Otherwise, if the state of v after expr_second is definitely assigned or "definitely assigned after true expression", then the state of v after expr is "definitely assigned after true expression".
    • Sinon, si l’état de v après expr_first est « définitivement assigné après une expression false » et que l’état de v après expr_second est « définitivement assigné après une expression false », alors l’état de v après Expr est « définitivement assigné après false expression ».Otherwise, if the state of v after expr_first is "definitely assigned after false expression", and the state of v after expr_second is "definitely assigned after false expression", then the state of v after expr is "definitely assigned after false expression".
    • Dans le cas contraire, l’état de v après expr n’est pas définitivement assigné.Otherwise, the state of v after expr is not definitely assigned.

Dans l’exempleIn the example

class A
{
    static void F(int x, int y) {
        int i;
        if (x >= 0 && (i = y) >= 0) {
            // i definitely assigned
        }
        else {
            // i not definitely assigned
        }
        // i not definitely assigned
    }
}

la variable i est considérée comme définitivement assignée dans l’une des instructions if incorporées d’une instruction, mais pas dans l’autre.the variable i is considered definitely assigned in one of the embedded statements of an if statement but not in the other. Dans l' if instruction de la Fméthode, la i variable est définitivement assignée dans la première instruction incorporée, (i = y) car l’exécution de l’expression précède toujours l’exécution de cette instruction incorporée.In the if statement in method F, the variable i is definitely assigned in the first embedded statement because execution of the expression (i = y) always precedes execution of this embedded statement. En revanche, la variable i n’est pas définitivement assignée dans la deuxième instruction x >= 0 incorporée, car peut avoir testé false i , ce qui entraîne la non-attribution de la variable.In contrast, the variable i is not definitely assigned in the second embedded statement, since x >= 0 might have tested false, resulting in the variable i being unassigned.

|| expressions (conditionnelles ou)|| (conditional OR) expressions

Pour une expression expr de la forme expr_first || expr_second:For an expression expr of the form expr_first || expr_second:

  • L’état d’assignation définie de v avant expr_first est identique à l’état d’assignation définie de v avant expr.The definite assignment state of v before expr_first is the same as the definite assignment state of v before expr.
  • L’état d’assignation définie de v avant expr_second est définitivement assigné si l’état de v après expr_first est défini de manière définitive ou « définitivement assigné après une expression false ».The definite assignment state of v before expr_second is definitely assigned if the state of v after expr_first is either definitely assigned or "definitely assigned after false expression". Dans le cas contraire, elle n’est pas définitivement assignée.Otherwise, it is not definitely assigned.
  • L’instruction d’assignation définie de v après expr est déterminée par :The definite assignment statement of v after expr is determined by:
    • Si expr_first est une expression constante avec la valeur true, l’état d’assignation définie de v après expr est le même que l’état d’assignation définie de v après expr_first.If expr_first is a constant expression with the value true, then the definite assignment state of v after expr is the same as the definite assignment state of v after expr_first.
    • Sinon, si l’état de v après expr_first est définitivement assigné, l’état v après expr est définitivement assigné.Otherwise, if the state of v after expr_first is definitely assigned, then the state of v after expr is definitely assigned.
    • Dans le cas contraire, si l’état de v après expr_second est assignée définitivement, et que l’état de v après expr_first est « définitivement assigné après true expression », alors l’état de v après expr est définitivement ont.Otherwise, if the state of v after expr_second is definitely assigned, and the state of v after expr_first is "definitely assigned after true expression", then the state of v after expr is definitely assigned.
    • Sinon, si l’état de v après expr_second est définitivement assigné ou « définitivement assigné après false expression », alors l’état de v après expr est « définitivement assigné après une expression false ».Otherwise, if the state of v after expr_second is definitely assigned or "definitely assigned after false expression", then the state of v after expr is "definitely assigned after false expression".
    • Sinon, si l’état de v après expr_first est « définitivement assigné après une expression true », et que l’état v après expr_second est « définitivement assigné après l’expression true », alors l’état de v après expr est « définitivement assigné après l’expression true ».Otherwise, if the state of v after expr_first is "definitely assigned after true expression", and the state of v after expr_second is "definitely assigned after true expression", then the state of v after expr is "definitely assigned after true expression".
    • Dans le cas contraire, l’état de v après expr n’est pas définitivement assigné.Otherwise, the state of v after expr is not definitely assigned.

Dans l’exempleIn the example

class A
{
    static void G(int x, int y) {
        int i;
        if (x >= 0 || (i = y) >= 0) {
            // i not definitely assigned
        }
        else {
            // i definitely assigned
        }
        // i not definitely assigned
    }
}

la variable i est considérée comme définitivement assignée dans l’une des instructions if incorporées d’une instruction, mais pas dans l’autre.the variable i is considered definitely assigned in one of the embedded statements of an if statement but not in the other. Dans l' if instruction de la Gméthode, la i variable est définitivement assignée dans la deuxième instruction incorporée, (i = y) car l’exécution de l’expression précède toujours l’exécution de cette instruction incorporée.In the if statement in method G, the variable i is definitely assigned in the second embedded statement because execution of the expression (i = y) always precedes execution of this embedded statement. En revanche, la variable i n’est pas définitivement assignée dans la première instruction x >= 0 incorporée, car peut avoir testé la valeur i true, ce qui a pour effet que la variable n’est pas assignée.In contrast, the variable i is not definitely assigned in the first embedded statement, since x >= 0 might have tested true, resulting in the variable i being unassigned.

!! expressions (négation logique)(logical negation) expressions

Pour une expression expr de la forme ! expr_operand:For an expression expr of the form ! expr_operand:

  • L’état d’assignation définie de v avant expr_operand est identique à l’état d’assignation définie de v avant expr.The definite assignment state of v before expr_operand is the same as the definite assignment state of v before expr.
  • L’état d’assignation définie de v après expr est déterminé par :The definite assignment state of v after expr is determined by:
    • Si l’état v après * expr_operand * est définitivement affecté, l’état v après expr est définitivement assigné.If the state of v after *expr_operand *is definitely assigned, then the state of v after expr is definitely assigned.
    • Si l’état de v après * expr_operand * n’est pas définitivement assigné, l’état de v après expr n’est pas définitivement assigné.If the state of v after *expr_operand *is not definitely assigned, then the state of v after expr is not definitely assigned.
    • Si l’état v après * expr_operand * est « définitivement assigné après une expression false », alors l’état de v après expr est « définitivement assigné après l’expression true ».If the state of v after *expr_operand *is "definitely assigned after false expression", then the state of v after expr is "definitely assigned after true expression".
    • Si l’état de v après * expr_operand * est « définitivement assigné après l’expression true », alors l’état de v après expr est « définitivement assigné après une expression false ».If the state of v after *expr_operand *is "definitely assigned after true expression", then the state of v after expr is "definitely assigned after false expression".

???? expressions (fusion de valeurs null)(null coalescing) expressions

Pour une expression expr de la forme expr_first ?? expr_second:For an expression expr of the form expr_first ?? expr_second:

  • L’état d’assignation définie de v avant expr_first est identique à l’état d’assignation définie de v avant expr.The definite assignment state of v before expr_first is the same as the definite assignment state of v before expr.
  • L’état d’assignation définie de v avant expr_second est identique à l’état d’assignation définie de v après expr_first.The definite assignment state of v before expr_second is the same as the definite assignment state of v after expr_first.
  • L’instruction d’assignation définie de v après expr est déterminée par :The definite assignment statement of v after expr is determined by:
    • Si expr_first est une expression constante (expressions constantes) avec la valeur null, l’état de v après expr est identique à l’état v après expr_second.If expr_first is a constant expression (Constant expressions) with value null, then the state of v after expr is the same as the state of v after expr_second.
  • Dans le cas contraire, l’état de v après expr est le même que l’état d’assignation définie de v après expr_first.Otherwise, the state of v after expr is the same as the definite assignment state of v after expr_first.

?: (conditionnel), expressions?: (conditional) expressions

Pour une expression expr de la forme expr_cond ? expr_true : expr_false:For an expression expr of the form expr_cond ? expr_true : expr_false:

  • L’état d’assignation définie de v avant expr_cond est identique à l’état v avant expr.The definite assignment state of v before expr_cond is the same as the state of v before expr.
  • L’état d’assignation définie de v avant expr_true est définitivement affecté si et seulement si l’un des éléments suivants est présent :The definite assignment state of v before expr_true is definitely assigned if and only if one of the following holds:
    • expr_cond est une expression constante avec la valeurfalseexpr_cond is a constant expression with the value false
    • État de v après que expr_cond a été assigné définitivement ou « définitivement assigné après l’expression true ».the state of v after expr_cond is definitely assigned or "definitely assigned after true expression".
  • L’état d’assignation définie de v avant expr_false est définitivement affecté si et seulement si l’un des éléments suivants est présent :The definite assignment state of v before expr_false is definitely assigned if and only if one of the following holds:
    • expr_cond est une expression constante avec la valeurtrueexpr_cond is a constant expression with the value true
  • État de v après que expr_cond a été assigné définitivement ou « définitivement assigné après une expression false ».the state of v after expr_cond is definitely assigned or "definitely assigned after false expression".
  • L’état d’assignation définie de v après expr est déterminé par :The definite assignment state of v after expr is determined by:
    • Si expr_cond est une expression constante (expressions constantes) avec true la valeur, l’état de v après expr est identique à l’état v après expr_true.If expr_cond is a constant expression (Constant expressions) with value true then the state of v after expr is the same as the state of v after expr_true.
    • Sinon, si expr_cond est une expression constante (expressions constantes) avec false la valeur, l’état de v après expr est identique à l’état v après expr_false.Otherwise, if expr_cond is a constant expression (Constant expressions) with value false then the state of v after expr is the same as the state of v after expr_false.
    • Sinon, si l’état de v après expr_true est assignée définitivement et que l’état de v après l’assignation définitive de expr_false , l’état v après expr est définitivement assigné.Otherwise, if the state of v after expr_true is definitely assigned and the state of v after expr_false is definitely assigned, then the state of v after expr is definitely assigned.
    • Dans le cas contraire, l’état de v après expr n’est pas définitivement assigné.Otherwise, the state of v after expr is not definitely assigned.

Fonctions anonymesAnonymous functions

Pour un expr lambda_expression ou anonymous_method_expression avec un corps (de type bloc ou expression ) :For a lambda_expression or anonymous_method_expression expr with a body (either block or expression) body:

  • L’état d’assignation définie d’une variable externe v avant le corps est identique à l’état v avant expr.The definite assignment state of an outer variable v before body is the same as the state of v before expr. Autrement dit, l’état d’assignation définie des variables externes est hérité du contexte de la fonction anonyme.That is, definite assignment state of outer variables is inherited from the context of the anonymous function.
  • L’état d’assignation définie d’une variable externe v après expr est identique à l’état v avant expr.The definite assignment state of an outer variable v after expr is the same as the state of v before expr.

L’exempleThe example

delegate bool Filter(int i);

void F() {
    int max;

    // Error, max is not definitely assigned
    Filter f = (int n) => n < max;

    max = 5;
    DoWork(f);
}

génère une erreur au moment de la max compilation, car n’est pas définitivement assignée où la fonction anonyme est déclarée.generates a compile-time error since max is not definitely assigned where the anonymous function is declared. L’exempleThe example

delegate void D();

void F() {
    int n;
    D d = () => { n = 1; };

    d();

    // Error, n is not definitely assigned
    Console.WriteLine(n);
}

génère également une erreur au moment de la compilation, car n l’assignation à dans la fonction anonyme n’a aucun effet sur l’état n d’assignation définie de l’extérieur de la fonction anonyme.also generates a compile-time error since the assignment to n in the anonymous function has no affect on the definite assignment state of n outside the anonymous function.

Références de variablesVariable references

Un variable_reference est une expression classée en tant que variable.A variable_reference is an expression that is classified as a variable. Un variable_reference désigne un emplacement de stockage qui est accessible à la fois pour extraire la valeur actuelle et pour stocker une nouvelle valeur.A variable_reference denotes a storage location that can be accessed both to fetch the current value and to store a new value.

variable_reference
    : expression
    ;

En C et C++, un variable_reference est appelé lvalue.In C and C++, a variable_reference is known as an lvalue.

Atomicité des références de variableAtomicity of variable references

Les lectures et les écritures des types de données suivants sont booldes chartypes de référence Atomic : uint, int, float short byte sbyte,,, ushort,,, et.Reads and writes of the following data types are atomic: bool, char, byte, sbyte, short, ushort, uint, int, float, and reference types. En outre, les lectures et écritures de types ENUM avec un type sous-jacent dans la liste précédente sont également atomiques.In addition, reads and writes of enum types with an underlying type in the previous list are also atomic. Les lectures et écritures d’autres types, longnotamment ulong double,,, decimalet, ainsi que les types définis par l’utilisateur, ne sont pas nécessairement atomiques.Reads and writes of other types, including long, ulong, double, and decimal, as well as user-defined types, are not guaranteed to be atomic. Outre les fonctions de bibliothèque conçues à cet effet, il n’existe aucune garantie de lecture-modification/écriture atomique, comme dans le cas de l’incrémentation ou de la décrémentation.Aside from the library functions designed for that purpose, there is no guarantee of atomic read-modify-write, such as in the case of increment or decrement.