DataColumn.Expression Propriété

public:
 property System::String ^ Expression { System::String ^ get(); void set(System::String ^ value); };

public string Expression { get; [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Members from types used in the expressions may be trimmed if not referenced directly.")] set; }

public string Expression { get; set; }

[System.Data.DataSysDescription("DataColumnExpressionDescr")]
public string Expression { get; set; }

[<set: System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("Members from types used in the expressions may be trimmed if not referenced directly.")>]
member this.Expression : string with get, set

member this.Expression : string with get, set

[<System.Data.DataSysDescription("DataColumnExpressionDescr")>]
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 d’agrégation. Le type de retour d’une expression est déterminé par la DataType colonne.

Attributs

RequiresUnreferencedCodeAttribute DataSysDescriptionAttribute

Exceptions

Exemples

L’exemple suivant crée trois colonnes dans un DataTable. Les deuxième et troisième colonnes contiennent des expressions ; le deuxième 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. La table obtenue s’affiche dans un DataGrid contrôle.

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 New DataTable()
 
     ' Create the first column.
     Dim priceColumn As New DataColumn()
     With priceColumn
         .DataType = System.Type.GetType("System.Decimal")
         .ColumnName = "price"
         .DefaultValue = 50
     End With
     
     ' Create the second, calculated, column.
     Dim taxColumn As New DataColumn()
     With taxColumn
         .DataType = System.Type.GetType("System.Decimal")
         .ColumnName = "tax"
         .Expression = "price * 0.0862"
     End With
     
    ' Create third column
     Dim totalColumn As 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

L’une des utilisations de la Expression propriété consiste à créer des colonnes calculées. Par exemple, pour calculer une valeur fiscale, le prix unitaire est multiplié par un taux d’imposition d’une région spécifique. Étant donné que les taux d’imposition varient d’une région à l’autre, il serait impossible de placer un taux d’imposition unique dans une colonne ; Au lieu de cela, la valeur est calculée à l’aide de la Expression propriété, comme indiqué dans le code suivant :

DataSet1.Tables("Products").Columns("tax").Expression = "UnitPrice * 0.086"

Une deuxième utilisation consiste à créer une colonne d’agrégation. Comme pour une valeur calculée, un agrégat effectue une opération en fonction de l’ensemble complet de lignes dans le DataTable. Un exemple simple consiste à compter le nombre de lignes retournées dans l'ensemble. Il s’agit de la méthode que vous utilisez pour compter le nombre de transactions effectuées par un vendeur particulier, comme indiqué dans le code suivant :

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

Syntaxe d’expression

Lorsque vous créez une expression, utilisez la ColumnName propriété pour faire référence à des colonnes. Par exemple, si la propriété ColumnName pour une colonne est « UnitPrice » et une autre colonne « Quantity », l’expression est :

"UnitPrice * Quantity"

Lorsque vous créez une expression pour un filtre, placez des chaînes entre guillemets simples :

"LastName = 'Jones'"

Si un nom de colonne contient des caractères non alphanumériques, commence par un chiffre ou correspond (sans respect de la casse) à l’un des mots réservés suivants, il nécessite une gestion spéciale, comme décrit dans les paragraphes suivants.

And

Between

Child

False

In

Is

Like

Not

Null

Or

Parent

True

Si un nom de colonne satisfait à l’une des conditions précédentes, il doit être encapsulé entre crochets ou entre guillemets « » (accent grave). Par exemple, pour utiliser une colonne nommée « Column# » dans une expression, vous devez écrire « [Column#] » ou « 'Column#' » :

Total * [Column#]

Si le nom de la colonne est placé entre crochets, les caractères ']' et '\' (mais pas d'autres caractères) doivent être échappés en les précédant du caractère de barre oblique inverse (« \ »). Si le nom de colonne est placé entre des caractères d’accentuation grave, il ne doit pas contenir de caractères d’accentuation grave. Par exemple, une colonne nommée « Column[]\ » est écrite :

Total * [Column[\]\\]

ou

Total * 'Column[]\'

Valeurs définies par l’utilisateur

Les valeurs définies par l’utilisateur peuvent être utilisées dans les expressions à comparer aux valeurs de colonne. Les valeurs de chaîne doivent être encadrées par des guillemets simples (et chaque caractère de guillemet simple dans une valeur de chaîne doit être échappé en le précédant d’un autre guillemet simple). Les valeurs de date doivent être placées entre dièses (#) ou guillemets simples (') selon le fournisseur de données. Les décimales et la notation scientifique sont autorisées pour les valeurs numériques. Par exemple:

"FirstName = 'John'"

"Price <= 50.00"

"Birthdate < #1/31/2006#"

Pour les colonnes qui contiennent des valeurs d’énumération, convertissez la valeur en type de données entier. Par exemple:

"EnumColumn = 5"

Analyser les expressions littérales

Toutes les expressions littérales doivent être exprimées dans les paramètres régionaux de culture invariante. Lors DataSet de l’analyse et de la conversion d’expressions littérales, elle utilise toujours la culture invariante, et non la culture actuelle.

Les littéraux de chaîne sont identifiés lorsqu’il existe des guillemets uniques entourant la valeur. Par exemple : 'John'.

Boolean les littéraux sont true et false ; ils ne sont pas cités dans les expressions.

Integer littéraux [+-] ? [0-9]+ sont traités comme System.Int32, System.Int64ou System.Double. System.Double peut perdre de précision en fonction de la taille du nombre. Par exemple, si le nombre dans le littéral est 2147483650, DataSet tente d’abord d’analyser le nombre sous la forme d’un Int32. Cela ne réussira pas, car le nombre est trop grand. Dans ce cas DataSet, analyse le nombre sous la forme d’un Int64, qui réussit. Si le littéral est un nombre supérieur à la valeur maximale d’un Int64, DataSet analyse le littéral à l’aide Doublede .

Les littéraux réels qui utilisent la notation scientifique, comme 4.42372E-30, sont analysés à l’aide de System.Double.

Les littéraux réels, qui ne sont pas en notation scientifique mais qui présentent un point décimal, sont traités comme System.Decimal. Si le nombre dépasse les valeurs maximales ou minimales prises en charge par System.Decimal, il est analysé en tant que System.Double. Par exemple:

• 142526.144524 est converti en Decimal.
• 345262.78036719560925667 est traité comme un Double.

Operators

La concaténation est autorisée à l’aide d’opérateurs Boolean AND, OR et NOT. Vous pouvez utiliser des parenthèses pour regrouper des clauses et forcer la priorité. L’opérateur AND est prioritaire sur d’autres opérateurs. Par exemple:

(LastName = 'Smith' OR LastName = 'Jones') AND FirstName = 'John'

Lorsque vous créez des expressions de comparaison, les opérateurs suivants sont autorisés :

• <
• >
• <=
• >=
• =
• IN
• LIKE

Les opérateurs arithmétiques suivants sont également pris en charge dans les expressions :

• + (addition)
• - (soustraction)
• * (multiplication)
• / (division)
• % (module)

Opérateurs de chaîne

Pour concaténer une chaîne, utilisez le + caractère. La valeur de la propriété CaseSensitive de la classe DataSet détermine si les comparaisons de chaînes respectent la casse. Toutefois, vous pouvez remplacer cette valeur par la CaseSensitive propriété de la DataTable classe.

Caractères génériques

Les caractères * et % peuvent être utilisés de manière interchangeable pour les caractères génériques dans une comparaison LIKE. Si la chaîne d’une clause LIKE contient un * ou %, ces caractères doivent être placés entre crochets ([]). Si un crochet se trouve dans la clause, chaque caractère de crochet doit être placé entre crochets (par exemple [[] ou []]). 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. Par exemple:

• "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. Par exemple, 'te*xt' n’est pas autorisé.

Référence de la relation parent/enfant

Une table parente peut être référencée dans une expression en préfixant le nom de la colonne avec Parent. Par exemple, Parent.Price fait référence à la colonne de la table parente nommée Price.

Lorsqu’un enfant a plusieurs lignes parentes, utilisez Parent(RelationName).ColumnName. Par exemple, Parent(RelationName).Price fait référence à la colonne de la table parente nommée « Price » via la relation.

Une colonne d'une table enfant peut être référencée dans une expression en préfaçant le nom de la colonne avec Child. Toutefois, étant donné que les relations de type enfant peuvent retourner plusieurs lignes, vous devez inclure la référence à la colonne de type enfant dans une fonction d’agrégation. Par exemple, Sum(Child.Price) retourne la somme de la colonne nommée Price dans la table enfant.

Si une table a plusieurs enfants, la syntaxe est : Child(RelationName). Par exemple, si une table a deux tables enfants nommées Customers et Ordersque l’objet DataRelation est nommé Customers2Orders, la référence se présente comme suit :

Avg(Child(Customers2Orders).Quantity)

Aggregates

Les types d’agrégation suivants sont pris en charge :

• Sum (Somme)
• Avg (Moyenne)
• Min (Minimum)
• Max (Maximal)
• Count (Nombre)
• StDev (écart-type statistique)
• Var (Variance statistique)

Les agrégats sont généralement effectués à travers des relations. Créez une expression d'agrégation à l'aide de l'une des fonctions répertoriées précédemment et d'une colonne d'une table enfant comme indiqué dans le référencement des relations parent/enfant. Par exemple:

• Avg(Child.Price)
• Avg(Child(Orders2Details).Price)

Une agrégation peut également être effectuée sur une table unique. Par exemple, pour créer un résumé des chiffres dans une colonne nommée « Price » :

Sum(Price)

Si une table n’a pas de lignes, les fonctions d’agrégation retournent null.

Les types de données peuvent toujours être déterminés en examinant la DataType propriété d’une colonne. Vous pouvez également convertir des types de données à l’aide de la Convert fonction, illustrée dans la section suivante.

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.

Functions

Les fonctions suivantes sont également prises en charge.

CONVERT

Cette fonction convertit une expression en type .NET spécifié.

Convert(expression, type)

Argument	Description
expression	L'expression à convertir.
type	Type .NET vers lequel la valeur sera convertie.

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

Toutes les conversions sont valides avec les exceptions suivantes : Boolean peut être coercé vers et depuis Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, String et elle-même uniquement. Char peut être converti en et depuis Int32, UInt32, String, et lui-même uniquement. DateTime peut être converti en et depuis String, et lui-même uniquement. TimeSpan peut être converti en et depuis String, et lui-même uniquement.

LEN

Cette fonction obtient la longueur d’une chaîne.

LEN(expression)

Arguments	Description
expression	La chaîne à évaluer.

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

ISNULL

Cette fonction vérifie une expression et retourne l’expression vérifiée ou une valeur de remplacement.

ISNULL(expression, replacementvalue)

Arguments	Description
expression	L'expression à vérifier.
replacementvalue	Si l’expression est null, replacementvalue est retournée.

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

IIF

Cette fonction obtient l’une des deux valeurs en fonction du résultat d’une expression logique.

IIF(expr, truepart, falsepart)

Arguments	Description
expr	Expression à évaluer.
truepart	La valeur à retourner si l’expression est true.
falsepart	Valeur à retourner si l’expression est false.

Exemple : myDataColumn.Expression = "IIF(total>1000, 'expensive', 'dear')

TRIM

Cette fonction supprime tous les caractères vides de début et de fin tels que \r, \n, \t et ' ' .

TRIM(expression)

Argument	Description
expression	L'expression à ajuster.

SUBSTRING

Cette fonction obtient une sous-chaîne d’une longueur spécifiée, en commençant à un point spécifié dans la chaîne.

SUBSTRING(expression, start, length)

Argument	Description
expression	La chaîne source pour la sous-chaîne.
start	Entier qui spécifie l’emplacement de démarrage de la sous-chaîne.
length	Entier qui spécifie la longueur de la sous-chaîne.

Exemple : myDataColumn.Expression = "SUBSTRING(phone, 7, 8)"

Voir aussi

• Using DataSets dans ADO.NET