DataColumn.Expression DataColumn.Expression DataColumn.Expression DataColumn.Expression Property

Définition

Obtient ou définit l'expression utilisée pour filtrer des lignes, calculer les valeurs d'une colonne ou créer une colonne agrégat.Gets or sets the expression used to filter rows, calculate the values in a column, or create an aggregate column.

public:
 property System::String ^ Expression { System::String ^ get(); void set(System::String ^ value); };
[System.Data.DataSysDescription("DataColumnExpressionDescr")]
public string Expression { get; set; }
member this.Expression : string with get, set
Public Property Expression As String

Valeur de propriété

Expression permettant de calculer la valeur d'une colonne ou de créer une colonne agrégat.An expression to calculate the value of a column, or create an aggregate column. Le type de retour d'une expression est déterminé par le DataType de la colonne.The return type of an expression is determined by the DataType of the column.

Exceptions

La valeur true est affectée à la propriété AutoIncrement ou Unique.The AutoIncrement or Unique property is set to true.

Si vous utilisez la fonction CONVERT, le résultat de l'évaluation de l'expression est une chaîne, mais la chaîne ne contient pas de représentation pouvant être convertie en paramètre de type.When you are using the CONVERT function, the expression evaluates to a string, but the string does not contain a representation that can be converted to the type parameter.

Lorsque vous utilisez la fonction CONVERT, le cast demandé est impossible.When you are using the CONVERT function, the requested cast is not possible. Consultez la fonction Conversion dans la section suivante pour obtenir des informations détaillées sur les casts possibles.See the Conversion function in the following section for detailed information about possible casts.

Lorsque vous utilisez la fonction SUBSTRING, l'argument de départ est hors limites.When you use the SUBSTRING function, the start argument is out of range.

- ou --Or- Lorsque vous utilisez la fonction SUBSTRING, l'argument de longueur est hors limites.When you use the SUBSTRING function, the length argument is out of range.

Lorsque vous utilisez la fonction LEN ou la fonction TRIM, le résultat de l'évaluation de l'expression n'est pas une chaîne.When you use the LEN function or the TRIM function, the expression does not evaluate to a string. Cela comprend les expressions dont le résultat de l'évaluation est Char.This includes expressions that evaluate to Char.

Exemples

L’exemple suivant crée trois colonnes dans un DataTable.The following example creates three columns in a DataTable. La deuxième et la troisième colonne contiennent des expressions; le second calcule la taxe à l’aide d’un taux d’imposition variable et le troisième ajoute le résultat du calcul à la valeur de la première colonne.The second and third columns contain expressions; the second calculates tax using a variable tax rate, and the third adds the result of the calculation to the value of the first column. La table résultante est affichée dans DataGrid un contrôle.The resulting table is displayed in a DataGrid control.

private void CalcColumns()
{
    DataTable table = new DataTable ();

    // Create the first column.
    DataColumn priceColumn = new DataColumn();
    priceColumn.DataType = System.Type.GetType("System.Decimal");
    priceColumn.ColumnName = "price";
    priceColumn.DefaultValue = 50;
     
    // Create the second, calculated, column.
    DataColumn taxColumn = new DataColumn();
    taxColumn.DataType = System.Type.GetType("System.Decimal");
    taxColumn.ColumnName = "tax";
    taxColumn.Expression = "price * 0.0862";
     
    // Create third column.
    DataColumn totalColumn = new DataColumn();
    totalColumn.DataType = System.Type.GetType("System.Decimal");
    totalColumn.ColumnName = "total";
    totalColumn.Expression = "price + tax";

    // Add columns to DataTable.
    table.Columns.Add(priceColumn);
    table.Columns.Add(taxColumn);
    table.Columns.Add(totalColumn);

    DataRow row = table.NewRow();
    table.Rows.Add(row);
    DataView view = new DataView(table);
    dataGrid1.DataSource = view;
}
Private Sub CalcColumns()
     Dim rate As Single = .0862
     dim table as DataTable = New DataTable 
 
     ' Create the first column.
     Dim priceColumn As DataColumn = New DataColumn
     With priceColumn
         .DataType = System.Type.GetType("System.Decimal")
         .ColumnName = "price"
         .DefaultValue = 50
     End With
     
     ' Create the second, calculated, column.
     Dim taxColumn As DataColumn = New DataColumn
     With taxColumn
         .DataType = System.Type.GetType("System.Decimal")
         .ColumnName = "tax"
         .Expression = "price * 0.0862"
     End With
     
    ' Create third column
     Dim totalColumn As DataColumn = New DataColumn
     With totalColumn
         .DataType = System.Type.GetType("System.Decimal")
         .ColumnName = "total"
         .Expression = "price + tax"
     End With
 
     ' Add columns to DataTable
     With table.Columns
         .Add(priceColumn)
         .Add(taxColumn)
         .Add(totalColumn)
     End With
    
     Dim row As DataRow= table.NewRow
     table.Rows.Add(row)
     Dim view As New DataView
     view.Table = table
     DataGrid1.DataSource = view
 End Sub

Remarques

Une utilisation de la Expression propriété consiste à créer des colonnes calculées.One use of the Expression property is to create calculated columns. Par exemple, pour calculer une valeur de taxe, le prix unitaire est multiplié par un taux de taxe d’une région spécifique.For example, to calculate a tax value, the unit price is multiplied by a tax rate of a specific region. Étant donné que les taux de taxe varient d’une région à l’autres, il est impossible de placer un taux d’imposition unique dans une colonne; au lieu de cela, la valeur est Expression calculée à l’aide de la propriété, comme indiqué dans le code Visual Basic dans la section suivante:Because tax rates vary from region to region, it would be impossible to put a single tax rate in a column; instead, the value is calculated using the Expression property, as shown in the Visual Basic code in the following section:

DataSet1. tables («Products»). Columns («tax»). Expression = «UnitPrice * 0,086»DataSet1.Tables("Products").Columns("tax").Expression = "UnitPrice * 0.086"

Une deuxième utilisation consiste à créer une colonne d’agrégation.A second use is to create an aggregate column. À l’instar d’une valeur calculée, un agrégat effectue une opération en fonction de l’ensemble de DataTablelignes complet dans le.Similar to a calculated value, an aggregate performs an operation based on the complete set of rows in the DataTable. Un exemple simple consiste à compter le nombre de lignes retournées dans le jeu.A simple example is to count the number of rows returned in the set. Il s’agit de la méthode que vous utiliseriez pour compter le nombre de transactions terminées par un vendeur particulier, comme indiqué dans ce Visual Basic Code:This is the method you would use to count the number of transactions completed by a particular salesperson, as shown in this Visual Basic code:

DataSet1.Tables("Orders").Columns("OrderCount").Expression = "Count(OrderID)"  

Syntaxe d'expressionExpression Syntax

Lorsque vous créez une expression, utilisez la ColumnName propriété pour faire référence aux colonnes.When you create an expression, use the ColumnName property to refer to columns. Par exemple, si la ColumnName colonne pour une colonne est «UnitPrice» et une autre «Quantity», l’expression serait la suivante:For example, if the ColumnName for one column is "UnitPrice", and another "Quantity", the expression would be as follows:

"UnitPrice * Quantity""UnitPrice * Quantity"

Notes

Si une colonne est utilisée dans une expression, l’expression est considérée comme ayant une dépendance sur cette colonne.If a column is used in an expression, then the expression is said to have a dependency on that column. Si une colonne dépendante est renommée ou supprimée, aucune exception n’est levée.If a dependent column is renamed or removed, no exception is thrown. Une exception est levée lors de l’accès à la colonne d’expression «rompue».An exception will be thrown when the now-broken expression column is accessed.

Lorsque vous créez une expression pour un filtre, mettez les chaînes entre guillemets simples:When you create an expression for a filter, enclose strings with single quotation marks:

«LastName = «Jones»»"LastName = 'Jones'"

Si un nom de colonne contient des caractères non alphanumériques ou commence par un chiffre ou des correspondances (sans respect de la casse) de l’un des mots réservés suivants, il nécessite un traitement spécial, comme décrit dans les paragraphes suivants.If a column name contains any non-alphanumeric characters or starts with a digit or matches (case-insensitively) any of the following reserved words, it requires special handling, as described in the following paragraphs.

andAnd

DifférentsBetween

EnfantChild

FalseFalse

Vers l'avantIn

EstIs

LikeLike

notNot

NullNull

OuOr

ParentParent

TrueTrue

Si un nom de colonne remplit l’une des conditions ci-dessus, il doit être inclus entre crochets ou les guillemets «'» (accent grave).If a column name satisfies one of the above conditions, it must be wrapped in either square brackets or the "`" (grave accent) quotes. Par exemple, pour utiliser une colonne nommée «Column #» dans une expression, vous devez écrire «[column #]»:For example, to use a column named "Column#" in an expression, you would write either "[Column#]":

Total * [colonne n °]Total * [Column#]

ou «`colonne #»:or "`Column#`":

Total * `colonne n °Total * `Column#`

Si le nom de colonne est placé entre crochets, tous les caractères «]»\et «» (mais pas les autres caractères) qu’il contient doivent être placés dans une séquence d’échappement en les ajoutant\à la barre oblique inverse («»).If the column name is enclosed in square brackets then any ']' and '\' characters (but not any other characters) in it must be escaped by prepending them with the backslash ("\") character. Si le nom de colonne est entouré de caractères d’accent grave, il ne doit pas contenir de caractères d’accent grave.If the column name is enclosed in grave accent characters then it must not contain any grave accent characters in it. Par exemple, une colonne nommée «Column []\» serait écrite:For example, a column named "Column[]\" would be written:

Total * [colonne [\]\\]Total * [Column[\]\\]

ouor

Total * `colonne []\</span><span class="sxs-lookup"><span data-stu-id="f6e5f-310">Total \* \Column[]\`

Valeurs définies par l’utilisateurUser-Defined Values

Les valeurs définies par l’utilisateur peuvent être utilisées dans des expressions pour être comparées à des valeurs de colonne.User-defined values may be used within expressions to be compared with column values. Les valeurs de chaîne doivent être placées entre guillemets simples (et chaque caractère de guillemet simple dans une valeur de chaîne doit être placé dans une séquence d’échappement en l’ajoutant à un autre guillemet simple).String values should be enclosed within single quotation marks (and each single quotation character in a string value has to be escaped by prepending it with another single quotation character). Les valeurs de date doivent être placées entre des signes dièse (#) ou des guillemets simples (') en fonction du fournisseur de données.Date values should be enclosed within pound signs (#) or single quotes (') based on the data provider. Les décimales et la notation scientifique sont autorisées pour les valeurs numériques.Decimals and scientific notation are permissible for numeric values. Par exemple :For example:

«FirstName = «John»»"FirstName = 'John'"

«Price < = 50,00»"Price <= 50.00"

«DateNaissance < #1/31/82 #»"Birthdate < #1/31/82#"

Pour les colonnes qui contiennent des valeurs d’énumération, effectuez un cast de la valeur en un type de données Integer.For columns that contain enumeration values, cast the value to an integer data type. Par exemple :For example:

"EnumColumn = 5""EnumColumn = 5"

Analyse d’expressions littéralesParsing Literal Expressions

Toutes les expressions littérales doivent être exprimées dans les paramètres régionaux de la culture dite indifférente.All literal expressions must be expressed in the invariant culture locale. Lorsque DataSet analyse et convertit des expressions littérales, il utilise toujours la culture dite indifférente, et non la culture actuelle.When DataSet parses and converts literal expressions, it always uses the invariant culture, not the current culture.

Les littéraux de chaîne sont identifiés lorsqu’il y a des guillemets simples entourant la valeur.String literals are identified when there are single quotes surrounding the value. Par exemple :For example:

John'John'

Booleanles littéraux sont true et false; ils ne sont pas cités dans les expressions.Boolean literals are true and false; they are not quoted in expressions.

Integerlittéraux [+-]? [0-9] + sont traités comme System.Int32, System.Int64 ou System.Double.Integer literals [+-]?[0-9]+ are treated as System.Int32, System.Int64 or System.Double. System.Doublepeut perdre la précision en fonction de la taille du nombre.System.Double can lose precision depending on how large the number is. Par exemple, si le nombre dans le littéral est 2147483650, DataSet commence par essayer d’analyser le nombre comme un Int32.For example, if the number in the literal is 2147483650, DataSet will first attempt to parse the number as an Int32. Cette opération échouera, car le nombre est trop grand.This will not succeed because the number is too large. Dans ce cas DataSet Int64, analyse le nombre en tant que, ce qui va échouer.In this case DataSet will parse the number as an Int64, which will succeed. Si le littéral était un nombre supérieur à la valeur maximale d’un Int64, DataSet analyse le littéral à l' Doubleaide de.If the literal was a number larger than the maximum value of an Int64, DataSet will parse the literal using Double.

Les littéraux réels utilisant la notation scientifique, tels que 4.42372 E-30, sont analysés à l’aide System.Doublede.Real literals using scientific notation, such as 4.42372E-30, are parsed using System.Double.

Les littéraux réels sans notation scientifique, mais avec une virgule décimale, sont System.Decimaltraités comme.Real literals without scientific notation, but with a decimal point, are treated as System.Decimal. Si le nombre dépasse les valeurs maximales ou minimales prises System.Decimalen charge par, il est analysé System.Doubleen tant que.If the number exceeds the maximum or minimum values supported by System.Decimal, then it is parsed as a System.Double. Par exemple :For example:

142526,144524 sera converti en Decimal.142526.144524 will be converted to a Decimal.

345262.78036719560925667 sera traité comme un Double.345262.78036719560925667 will be treated as a Double.

OpérateursOperators

La concaténation est autorisée à l’aide d’opérateurs booléens AND, OR et NOT.Concatenation is allowed using Boolean AND, OR, and NOT operators. Vous pouvez utiliser des parenthèses pour regrouper des clauses et imposer la précédence.You can use parentheses to group clauses and force precedence. L’opérateur AND est prioritaire par rapport à d’autres opérateurs.The AND operator has precedence over other operators. Par exemple :For example:

(LastName = «Smith» ou LastName = «Jones») ET FirstName = «John»(LastName = 'Smith' OR LastName = 'Jones') AND FirstName = 'John'

Lorsque vous créez des expressions de comparaison, les opérateurs suivants sont autorisés:When you create comparison expressions, the following operators are allowed:

<

>

<=

>=

<>

=

ININ

LIKELIKE

Les opérateurs arithmétiques suivants sont également pris en charge dans les expressions:The following arithmetic operators are also supported in expressions:

+complément+ (addition)

- (soustraction)- (subtraction)

* (multiplication)* (multiplication)

/(Division)/ (division)

% (modulo)% (modulus)

Opérateurs de chaîneString Operators

Pour concaténer une chaîne, utilisez le caractère +.To concatenate a string, use the + character. La valeur de la CaseSensitive propriété de la DataSet classe détermine si les comparaisons de chaînes respectent la casse.The value of the CaseSensitive property of the DataSet class determines whether string comparisons are case-sensitive. Toutefois, vous pouvez remplacer cette valeur par la CaseSensitive propriété de la DataTable classe.However, you can override that value with the CaseSensitive property of the DataTable class.

Caractères génériquesWildcard Characters

* Et% peuvent être utilisés indifféremment pour les caractères génériques d’une comparaison LIKE.Both the * and % can be used interchangeably for wildcard characters in a LIKE comparison. Si la chaîne dans une clause LIKE contient un * ou%, ces caractères doivent être placés entre crochets ([]).If the string in a LIKE clause contains a * or %, those characters should be enclosed in brackets ([]). Si un crochet est présent dans la clause, chaque crochet doit être placé entre crochets (par exemple [[] ou []]).If a bracket is in the clause, each bracket character should be enclosed in brackets (for example [[] or []]). Un caractère générique est autorisé au début et à la fin d’un modèle, ou à la fin d’un modèle, ou au début d’un modèle.A wildcard is allowed at the start and end of a pattern, or at the end of a pattern, or at the start of a pattern. Par exemple :For example:

«ItemName LIKE «* Product*»"ItemName LIKE '*product*'"

«ItemName LIKE «* Product»"ItemName LIKE '*product'"

«ItemName LIKE «Product *»»"ItemName LIKE 'product*'"

Les caractères génériques ne sont pas autorisés au milieu d’une chaîne.Wildcard characters are not allowed in the middle of a string. Par exemple, «te * XT» n’est pas autorisé.For example, 'te*xt' is not allowed.

Référencement de relation parent/enfantParent/Child Relation Referencing

Une table parente peut être référencée dans une expression en ajoutant au début du nom Parentde la colonne.A parent table may be referenced in an expression by prepending the column name with Parent. Par exemple, le Parent.Price référence la colonne de la table parente nommée. PriceFor example, the Parent.Price references the parent table's column named Price.

Lorsqu’un enfant a plusieurs lignes parentes, utilisez le parent (RelationName). NomColonne.When a child has more than one parent row, use Parent(RelationName).ColumnName. Par exemple, le parent (RelationName). Le prix fait référence à la colonne de la table parent nommée Price via la relation.For example, the Parent(RelationName).Price references the parent table's column named Price via the relation.

Une colonne d’une table enfant peut être référencée dans une expression en ajoutant au début du nom Childde la colonne.A column in a child table may be referenced in an expression by prepending the column name with Child. Toutefois, étant donné que les relations enfants peuvent retourner plusieurs lignes, vous devez inclure la référence à la colonne enfant dans une fonction d’agrégation.However, because child relationships may return multiple rows, you must include the reference to the child column in an aggregate function. Par exemple, Sum(Child.Price) retourne la somme de la colonne nommée Price dans la table enfant.For example, Sum(Child.Price) would return the sum of the column named Price in the child table.

Si une table possède plusieurs enfants, la syntaxe est la suivante: Child(RelationName).If a table has more than one child, the syntax is: Child(RelationName). Par exemple, si une table a deux tables Customers enfants nommées Orderset, et DataRelation que l’objet Customers2Ordersest nommé, la référence est la suivante:For example, if a table has two child tables named Customers and Orders, and the DataRelation object is named Customers2Orders, the reference would be as follows:

Moy (enfant) (Customers2Orders). SpécifiéeAvg(Child(Customers2Orders).Quantity)

AgrégatsAggregates

Les types d’agrégats suivants sont pris en charge:The following aggregate types are supported:

Somme (Sum)Sum (Sum)

Moy (moyenne)Avg (Average)

Min (minimum)Min (Minimum)

Max (maximum)Max (Maximum)

Nombre (nombre)Count (Count)

ECARTYPE (écart type statistique)StDev (Statistical standard deviation)

Var (variance statistique).Var (Statistical variance).

Les agrégats sont généralement exécutés le long des relations.Aggregates are ordinarily performed along relationships. Créez une expression d’agrégation à l’aide de l’une des fonctions répertoriées ci-dessus et d’une colonne de table enfant, comme indiqué dans le Guide de référence des relations parent/enfant qui a été abordé précédemment.Create an aggregate expression by using one of the functions listed earlier and a child table column as detailed in Parent/Child Relation Referencing that was discussed earlier. Par exemple :For example:

Avg(Child.Price)Avg(Child.Price)

Moy (enfant) (Orders2Details). CompétitifAvg(Child(Orders2Details).Price)

Un agrégat peut également être effectué sur une seule table.An aggregate can also be performed on a single table. Par exemple, pour créer un résumé des chiffres dans une colonne nommée «Price»:For example, to create a summary of figures in a column named "Price":

Sum(Price)Sum(Price)

Notes

Si vous utilisez une seule table pour créer un agrégat, il n’y aurait pas de fonctionnalité Group by.If you use a single table to create an aggregate, there would be no group-by functionality. Au lieu de cela, toutes les lignes affichent la même valeur dans la colonne.Instead, all rows would display the same value in the column.

Si une table ne comporte aucune ligne, les fonctions d’agrégation nullretournent.If a table has no rows, the aggregate functions will return null.

Les types de données peuvent toujours être déterminés en DataType examinant la propriété d’une colonne.Data types can always be determined by examining the DataType property of a column. Vous pouvez également convertir les types de données à l’aide de la fonction Convert, comme indiqué dans la section suivante.You can also convert data types using the Convert function, shown in the following section.

Un agrégat ne peut être appliqué qu’à une seule colonne et aucune autre expression ne peut être utilisée à l’intérieur de l’agrégat.An aggregate can only be applied to a single column and no other expressions can be used inside the aggregate.

FonctionsFunctions

Les fonctions suivantes sont également prises en charge:The following functions are also supported:

CONVERT

DescriptionDescription Convertit une expression particulière en un type de .NET Framework spécifié.Converts particular expression to a specified .NET Framework Type.
SyntaxeSyntax Convert(expression, type)Convert(expression, type)
ArgumentsArguments expression: Expression à convertir.expression -- The expression to convert.

type: Le type de .NET Framework dans lequel la valeur sera convertie.type -- The .NET Framework type to which the value will be converted.

Exemple: myDataColumn. expression = "Convert (total, 'System. Int32 ')"Example: myDataColumn.Expression="Convert(total, 'System.Int32')"

Toutes les conversions sont valides avec les exceptions Boolean suivantes: peut être forcé vers et Byteà SBytepartir Int16de, Int64, UInt16 Int32, UInt32, UInt64,,,,, String et lui-même uniquement.All conversions are valid with the following exceptions: Boolean can be coerced to and from Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, String and itself only. Charpeut être forcé à et à à Int32partir UInt32de String,, et lui-même uniquement.Char can be coerced to and from Int32, UInt32, String, and itself only. DateTimepeut être forcé uniquement vers et à String partir de.DateTime can be coerced to and from String and itself only. TimeSpanpeut être forcé uniquement vers et à String partir de.TimeSpan can be coerced to and from String and itself only.

LEN

DescriptionDescription Obtient la longueur d’une chaîne.Gets the length of a string
SyntaxeSyntax LEN (expression)LEN(expression)
ArgumentsArguments expression--Chaîne à évaluer.expression -- The string to be evaluated.

Exemple: myDataColumn. expression = "Len (ItemName)"Example: myDataColumn.Expression="Len(ItemName)"

ISNULL

DescriptionDescription Vérifie une expression et retourne l’expression vérifiée ou une valeur de remplacement.Checks an expression and either returns the checked expression or a replacement value.
SyntaxeSyntax ISNULL(expression, replacementvalue)ISNULL(expression, replacementvalue)
ArgumentsArguments expression: Expression à vérifier.expression -- The expression to check.

replacementvalue--Si l’expression nullest replacementvalue , est retourné.replacementvalue -- If expression is null, replacementvalue is returned.

Exemple: myDataColumn. expression = "IsNull (Price,-1)"Example: myDataColumn.Expression="IsNull(price, -1)"

IIF

DescriptionDescription Obtient l’une des deux valeurs en fonction du résultat d’une expression logique.Gets one of two values depending on the result of a logical expression.
SyntaxeSyntax IIF(expr, truepart, falsepart)IIF(expr, truepart, falsepart)
ArgumentsArguments expr: Expression à évaluer.expr -- The expression to evaluate.

truepart: Valeur à retourner si l’expression a la valeur true.truepart -- The value to return if the expression is true.

falsepart--La valeur à retourner si l’expression est false.falsepart -- The value to return if the expression is false.

Exemple: myDataColumn. expression = "IIF (total > 1000, 'onéreux', 'cher')Example: myDataColumn.Expression = "IIF(total>1000, 'expensive', 'dear')

TRIM

DescriptionDescription Supprime tous les caractères vides de début et de fin, comme \r, \n, \t, ' 'Removes all leading and trailing blank characters like \r, \n, \t, ' '
SyntaxeSyntax TRIM (expression)TRIM(expression)
ArgumentsArguments expression: Expression à découper.expression -- The expression to trim.

SUBSTRING

DescriptionDescription Obtient une sous-chaîne d’une longueur spécifiée, en commençant à un point spécifié dans la chaîne.Gets a sub-string of a specified length, starting at a specified point in the string.
SyntaxeSyntax SUBSTRING(expression, start, length)SUBSTRING(expression, start, length)
ArgumentsArguments expression--Chaîne source de la sous-chaîne.expression -- The source string for the substring.

start--Entier qui spécifie l’emplacement de démarrage de la sous-chaîne.start -- Integer that specifies where the substring starts.

length--Entier qui spécifie la longueur de la sous-chaîne.length -- Integer that specifies the length of the substring.

Exemple: myDataColumn. expression = "Substring (téléphone, 7, 8)"Example: myDataColumn.Expression = "SUBSTRING(phone, 7, 8)"

Notes

Vous pouvez réinitialiser la Expression propriété en lui assignant une valeur null ou une chaîne vide.You can reset the Expression property by assigning it a null value or empty string. Si une valeur par défaut est définie sur la colonne expression, la valeur par défaut est affectée à toutes les lignes Expression précédemment remplies après la réinitialisation de la propriété.If a default value is set on the expression column, all previously filled rows are assigned the default value after the Expression property is reset.

S’applique à

Voir aussi