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

Definizione

Ottiene o imposta l'espressione utilizzata per filtrare le righe, calcolare i valori in una colonna o creare una colonna aggregata.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

Valore della proprietà

Un'espressione per calcolare il valore di una colonna o creare una colonna aggregata.An expression to calculate the value of a column, or create an aggregate column. Il tipo restituito di un'espressione è determinato dal DataType della colonna.The return type of an expression is determined by the DataType of the column.

Eccezioni

Il AutoIncrement oppure Unique è impostata su true.The AutoIncrement or Unique property is set to true.

Quando si utilizza la funzione CONVERT, l'espressione restituisce una stringa, ma la stringa non contiene una rappresentazione che può essere convertita in parametro di tipo.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.

Quando si usa la funzione CONVERT, eseguire il cast richiesto non è possibile.When you are using the CONVERT function, the requested cast is not possible. Vedere la funzione di conversione nella sezione seguente per informazioni dettagliate sui cast possibili.See the Conversion function in the following section for detailed information about possible casts.

Quando si usa la funzione SUBSTRING, l'argomento start JE MIMO rozsah.When you use the SUBSTRING function, the start argument is out of range.

oppure-Or- Quando si usa la funzione SUBSTRING, l'argomento length JE MIMO rozsah.When you use the SUBSTRING function, the length argument is out of range.

Quando si usa la funzione LEN o TRIM, l'espressione non restituisce una stringa.When you use the LEN function or the TRIM function, the expression does not evaluate to a string. Incluse le espressioni che restituiscono Char.This includes expressions that evaluate to Char.

Esempi

L'esempio seguente crea tre colonne in un DataTable.The following example creates three columns in a DataTable. Il secondo e la terza colonna contiene espressioni. il secondo calcola l'IVA usando un'aliquota di imposta variabile e il terzo il risultato del calcolo viene aggiunto al valore della prima colonna.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 tabella risultante viene visualizzata un DataGrid controllo.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

Commenti

Un uso del Expression proprietà consiste nel creare colonne calcolate.One use of the Expression property is to create calculated columns. Ad esempio, per calcolare un valore di imposta, il prezzo unitario viene moltiplicato per un'aliquota di un'area specifica.For example, to calculate a tax value, the unit price is multiplied by a tax rate of a specific region. Poiché aliquote variare in base al paese, sarebbe Impossibile inserire un'aliquota di imposta solo in una colonna. al contrario, il valore viene calcolato usando la Expression proprietà, come illustrato nel codice Visual Basic nella sezione seguente: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"

Un altro possibile uso consiste nel creare una colonna aggregata.A second use is to create an aggregate column. Simile a un valore calcolato, una funzione di aggregazione esegue un'operazione basata sul set completo di righe di DataTable.Similar to a calculated value, an aggregate performs an operation based on the complete set of rows in the DataTable. Un esempio semplice è per contare il numero di righe restituite nel set.A simple example is to count the number of rows returned in the set. Si tratta del metodo che si utilizzerebbe per contare il numero di transazioni completate da un particolare agente, come illustrato in questo codice di Visual Basic: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)"  

Sintassi delle espressioniExpression Syntax

Quando si crea un'espressione, usare il ColumnName proprietà fare riferimento alle colonne.When you create an expression, use the ColumnName property to refer to columns. Ad esempio, se il ColumnName per una colonna è "UnitPrice" e un altro "Quantity", l'espressione sarà come segue:For example, if the ColumnName for one column is "UnitPrice", and another "Quantity", the expression would be as follows:

"UnitPrice * Quantity""UnitPrice * Quantity"

Nota

Se una colonna viene utilizzata in un'espressione, l'espressione è definita per avere una dipendenza su tale colonna.If a column is used in an expression, then the expression is said to have a dependency on that column. Se una colonna dipendente verrà rinominata o rimossi, viene generata alcuna eccezione.If a dependent column is renamed or removed, no exception is thrown. Verrà generata un'eccezione quando si accede alla colonna dell'ora-broken espressione.An exception will be thrown when the now-broken expression column is accessed.

Quando si crea un'espressione di filtro, racchiudere le stringhe tra virgolette singole:When you create an expression for a filter, enclose strings with single quotation marks:

"LastName = 'Jones'""LastName = 'Jones'"

Se un nome di colonna contiene caratteri non alfanumerici (senza) corrisponde a una delle seguenti parole riservate o inizia con una cifra, richiede una gestione speciale, come descritto nei paragrafi seguenti.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.

eAnd

TraBetween

FiglioChild

FalseFalse

InIn

ÈIs

Ad esempioLike

notNot

NullNull

OrOr

PadreParent

TrueTrue

Se un nome di colonna soddisfa una delle condizioni precedenti, devono essere racchiuse nelle parentesi quadre o le "'" le virgolette (accento grave).If a column name satisfies one of the above conditions, it must be wrapped in either square brackets or the "`" (grave accent) quotes. Ad esempio, per utilizzare una colonna denominata "Colonna #" in un'espressione, si scriverebbe entrambi "[colonna #]":For example, to use a column named "Column#" in an expression, you would write either "[Column#]":

Totale * [colonna #]Total * [Column#]

o "`colonna #'":or "`Column#`":

Totale * `colonna #'Total * `Column#`

Se il nome della colonna è racchiuso tra parentesi quadre, qualsiasi ']' e '\' caratteri (ma non altri caratteri) in essa devono essere precedute da loro con la barra rovesciata ("\") caratteri.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. Se il nome della colonna è racchiuso tra caratteri accentati accento grave non deve contenere alcun carattere di accento grave in esso.If the column name is enclosed in grave accent characters then it must not contain any grave accent characters in it. Ad esempio, una colonna denominata "[] colonna\" verrebbe scritto:For example, a column named "Column[]\" would be written:

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

oppureor

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

Valori definiti dall'utenteUser-Defined Values

Valori definiti dall'utente possono essere utilizzati all'interno di espressioni da confrontare con i valori di colonna.User-defined values may be used within expressions to be compared with column values. I valori stringa devono essere racchiuse tra virgolette singole (e ogni carattere di virgoletta singola in un valore stringa con caratteri di escape da un'altra virgoletta singola).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). I valori di data devono essere racchiusi tra segni di cancelletto (#) o virgolette singole (') in base al provider di dati.Date values should be enclosed within pound signs (#) or single quotes (') based on the data provider. Numeri decimali e la notazione scientifica sono consentiti per i valori numerici.Decimals and scientific notation are permissible for numeric values. Ad esempio:For example:

"FirstName = 'John'""FirstName = 'John'"

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

"Data di nascita < # di #1/31/82""Birthdate < #1/31/82#"

Per le colonne contenenti valori di enumerazione, il cast del valore a un tipo di dati integer.For columns that contain enumeration values, cast the value to an integer data type. Ad esempio:For example:

"EnumColumn = 5""EnumColumn = 5"

Espressioni letterali di analisiParsing Literal Expressions

Tutte le espressioni letterali devono essere espressi nelle impostazioni locali delle impostazioni cultura invarianti.All literal expressions must be expressed in the invariant culture locale. Quando DataSet analizza e converte le espressioni letterali, Usa sempre le impostazioni cultura invariabili, non le impostazioni cultura correnti.When DataSet parses and converts literal expressions, it always uses the invariant culture, not the current culture.

Valori letterali stringa sono identificati quando sono presenti virgolette che racchiudono il valore.String literals are identified when there are single quotes surrounding the value. Ad esempio:For example:

'John''John'

Boolean i valori letterali sono true e false. essi non vengono racchiusi tra virgolette nelle espressioni.Boolean literals are true and false; they are not quoted in expressions.

Integer valori letterali [+-]? [0-9] + vengono considerati System.Int32, System.Int64 o System.Double.Integer literals [+-]?[0-9]+ are treated as System.Int32, System.Int64 or System.Double. System.Double possibile perdita di precisione a seconda delle dimensioni di numero.System.Double can lose precision depending on how large the number is. Ad esempio, se il numero nel valore letterale, 2147483650 DataSet si tenterà innanzitutto di analizzare il numero come un Int32.For example, if the number in the literal is 2147483650, DataSet will first attempt to parse the number as an Int32. Questo non riuscirà poiché il numero è troppo grande.This will not succeed because the number is too large. In questo caso DataSet analizzerà il numero come un Int64, che avrà esito positivo.In this case DataSet will parse the number as an Int64, which will succeed. Se il valore letterale è un numero maggiore del valore massimo di un Int64 DataSet analizzerà il valore letterale tramite Double.If the literal was a number larger than the maximum value of an Int64, DataSet will parse the literal using Double.

Valori letterali reali usando la notazione scientifica, ad esempio 4.42372 e-30, vengono analizzate usando System.Double.Real literals using scientific notation, such as 4.42372E-30, are parsed using System.Double.

I valori letterali reali senza la notazione scientifica, ma con un separatore decimale, vengono considerati System.Decimal.Real literals without scientific notation, but with a decimal point, are treated as System.Decimal. Se il numero supera i valori massimi o minimi supportati da System.Decimal, quindi viene analizzato come un System.Double.If the number exceeds the maximum or minimum values supported by System.Decimal, then it is parsed as a System.Double. Ad esempio:For example:

142526.144524 verrà convertito in un Decimal.142526.144524 will be converted to a Decimal.

345262.78036719560925667 verrà considerato un Double.345262.78036719560925667 will be treated as a Double.

OperatoriOperators

È consentita la concatenazione usando gli operatori NOT e AND, OR booleano.Concatenation is allowed using Boolean AND, OR, and NOT operators. È possibile utilizzare le parentesi per raggruppare le clausole e forzare la precedenza.You can use parentheses to group clauses and force precedence. L'operatore AND ha la precedenza sugli altri operatori.The AND operator has precedence over other operators. Ad esempio:For example:

(LastName = 'Smith' o LastName = 'Jones') Nome e cognome = 'John'(LastName = 'Smith' OR LastName = 'Jones') AND FirstName = 'John'

Quando si creano espressioni di confronto, sono consentiti gli operatori seguenti:When you create comparison expressions, the following operators are allowed:

<

>

<=

>=

<>

=

ININ

LIKELIKE

Gli operatori aritmetici seguenti sono supportati anche nelle espressioni:The following arithmetic operators are also supported in expressions:

+ (addizione)+ (addition)

- (sottrazione)- (subtraction)

* (moltiplicazione)* (multiplication)

/ (divisione)/ (division)

% (modulo)% (modulus)

Operatori di stringaString Operators

Per concatenare una stringa, usare il carattere +.To concatenate a string, use the + character. Il valore della CaseSensitive proprietà del DataSet classe determina se i confronti di stringhe sono tra maiuscole e minuscole.The value of the CaseSensitive property of the DataSet class determines whether string comparisons are case-sensitive. Tuttavia, è possibile eseguire l'override di tale valore con il CaseSensitive proprietà del DataTable classe.However, you can override that value with the CaseSensitive property of the DataTable class.

Caratteri jollyWildcard Characters

Sia il * % possono utilizzarlo in modo intercambiabile per i caratteri jolly nei confronti LIKE.Both the * and % can be used interchangeably for wildcard characters in a LIKE comparison. Se la stringa in una clausola LIKE contiene un' * o %, tali caratteri devono essere racchiuso tra parentesi quadre ([]).If the string in a LIKE clause contains a * or %, those characters should be enclosed in brackets ([]). Se una parentesi quadra è nella clausola, ogni carattere di parentesi quadra deve essere racchiuso tra parentesi (ad esempio [[] o []]).If a bracket is in the clause, each bracket character should be enclosed in brackets (for example [[] or []]). Un carattere jolly è consentito all'inizio e alla fine di un criterio di ricerca o alla fine di un modello o all'inizio di un modello.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. Ad esempio:For example:

"ItemName, ad esempio ' * prodotto*'""ItemName LIKE '*product*'"

"ItemName, ad esempio ' * prodotto '""ItemName LIKE '*product'"

"ItemName LIKE 'prodotto *'""ItemName LIKE 'product*'"

Caratteri jolly non sono consentiti all'interno di una stringa.Wildcard characters are not allowed in the middle of a string. Ad esempio, ' te * testing esplorativo ' non è consentita.For example, 'te*xt' is not allowed.

Riferimenti a relazioni padre/figlioParent/Child Relation Referencing

In un'espressione è possibile fare riferimento a una tabella padre facendo precedere il nome della colonna con Parent.A parent table may be referenced in an expression by prepending the column name with Parent. Ad esempio, il Parent.Price fa riferimento alla colonna della tabella padre denominata Price.For example, the Parent.Price references the parent table's column named Price.

Quando un elemento figlio ha più di una riga padre, usare Parent (RelationName). ColumnName.When a child has more than one parent row, use Parent(RelationName).ColumnName. Ad esempio, il Parent (RelationName). Prezzo fa riferimento a colonna della tabella padre denominata Price tramite la relazione.For example, the Parent(RelationName).Price references the parent table's column named Price via the relation.

In un'espressione è possibile fare riferimento a una colonna in una tabella figlio facendo precedere il nome della colonna con Child.A column in a child table may be referenced in an expression by prepending the column name with Child. Tuttavia, poiché le relazioni figlio potrebbero restituire più righe, è necessario includere il riferimento alla colonna figlio in una funzione di aggregazione.However, because child relationships may return multiple rows, you must include the reference to the child column in an aggregate function. Ad esempio, Sum(Child.Price) restituirà la somma della colonna denominata Price nella tabella figlio.For example, Sum(Child.Price) would return the sum of the column named Price in the child table.

Se una tabella dispone di più elementi figlio, la sintassi è: Child(RelationName).If a table has more than one child, the syntax is: Child(RelationName). Ad esempio, se una tabella dispone di due tabelle figlio denominate Customers e Orderse il DataRelation oggetto è denominato Customers2Orders, il riferimento sarà la seguente: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:

AVG(Child(Customers2Orders). Quantità)Avg(Child(Customers2Orders).Quantity)

AggregatiAggregates

Sono supportati i tipi di aggregazione seguenti:The following aggregate types are supported:

SUM (Sum)Sum (Sum)

AVG (Average)Avg (Average)

Min (minimo)Min (Minimum)

Max (massimo)Max (Maximum)

Count (conteggio)Count (Count)

Funzione StDev (deviazione statistica standard)StDev (Statistical standard deviation)

Var (varianza statistica).Var (Statistical variance).

Le aggregazioni vengono eseguite normalmente lungo le relazioni.Aggregates are ordinarily performed along relationships. Creare un'espressione di aggregazione usando una delle funzioni elencate in precedenza e una colonna della tabella figlio come descritto in dettaglio nella relazione padre/figlio relazione di riferimento che è stato illustrato in precedenza.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. Ad esempio:For example:

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

AVG(Child(Orders2Details). Prezzo)Avg(Child(Orders2Details).Price)

Una funzione di aggregazione possono essere eseguite anche in una singola tabella.An aggregate can also be performed on a single table. Ad esempio, per creare un riepilogo delle cifre in una colonna denominata "Price":For example, to create a summary of figures in a column named "Price":

Sum(Price)Sum(Price)

Nota

Se si usa una singola tabella per creare una funzione di aggregazione, non vi sarà alcuna funzionalità group by.If you use a single table to create an aggregate, there would be no group-by functionality. Al contrario, tutte le righe verranno visualizzati lo stesso valore nella colonna.Instead, all rows would display the same value in the column.

Se una tabella non contiene righe, le funzioni di aggregazione restituirà null.If a table has no rows, the aggregate functions will return null.

Tipi di dati possono sempre essere determinati esaminando la DataType proprietà di una colonna.Data types can always be determined by examining the DataType property of a column. È anche possibile convertire i tipi di dati tramite la funzione Convert, illustrata nella sezione seguente.You can also convert data types using the Convert function, shown in the following section.

Un'aggregazione può essere applicata solo a una singola colonna e non altre espressioni possono essere utilizzate all'interno dell'aggregazione.An aggregate can only be applied to a single column and no other expressions can be used inside the aggregate.

FunzioniFunctions

Sono supportate anche le funzioni seguenti:The following functions are also supported:

CONVERT

DescrizioneDescription Converte una particolare espressione a un tipo .NET Framework specificato.Converts particular expression to a specified .NET Framework Type.
SintassiSyntax Convert(expression, type)Convert(expression, type)
ArgomentiArguments expression -L'espressione da convertire.expression -- The expression to convert.

type -- Il tipo di .NET Framework a cui il valore verrà convertito.type -- The .NET Framework type to which the value will be converted.

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

Tutte le conversioni sono valide con le eccezioni seguenti: Boolean può essere assegnato da e verso Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, String e solo se stessa.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. Char può essere assegnato da e verso Int32, UInt32, Stringe solo se stessa.Char can be coerced to and from Int32, UInt32, String, and itself only. DateTime può essere assegnato da e verso String e solo se stessa.DateTime can be coerced to and from String and itself only. TimeSpan può essere assegnato da e verso String e solo se stessa.TimeSpan can be coerced to and from String and itself only.

LEN

DescrizioneDescription Ottiene la lunghezza della stringaGets the length of a string
SintassiSyntax LEN(expression)LEN(expression)
ArgomentiArguments expression -Stringa da valutare.expression -- The string to be evaluated.

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

ISNULL

DescrizioneDescription Controlla un'espressione e restituisce un valore di sostituzione o l'espressione selezionata.Checks an expression and either returns the checked expression or a replacement value.
SintassiSyntax ISNULL(expression, replacementvalue)ISNULL(expression, replacementvalue)
ArgomentiArguments expression -Espressione da controllare.expression -- The expression to check.

replacementvalue : Se l'espressione è null, replacementvalue viene restituito.replacementvalue -- If expression is null, replacementvalue is returned.

Esempio: myDataColumn.Expression="IsNull (prezzo, -1)"Example: myDataColumn.Expression="IsNull(price, -1)"

IIF

DescrizioneDescription Ottiene uno dei due valori a seconda del risultato di un'espressione logica.Gets one of two values depending on the result of a logical expression.
SintassiSyntax IIF(expr, truepart, falsepart)IIF(expr, truepart, falsepart)
ArgomentiArguments expr -Espressione da valutare.expr -- The expression to evaluate.

truepart -- Il valore da restituire se l'espressione è true.truepart -- The value to return if the expression is true.

falsepart -- Il valore da restituire se l'espressione è false.falsepart -- The value to return if the expression is false.

Esempio: myDataColumn.Expression = "IIF (totale > 1000,"costosa", 'dear')Example: myDataColumn.Expression = "IIF(total>1000, 'expensive', 'dear')

TRIM

DescrizioneDescription Rimuove tutte le iniziali e finali vuoto caratteri, ad esempio a capo \r, \n, \t, ' 'Removes all leading and trailing blank characters like \r, \n, \t, ' '
SintassiSyntax TRIM(expression)TRIM(expression)
ArgomentiArguments expression -Espressione da eliminare.expression -- The expression to trim.

SUBSTRING

DescrizioneDescription Ottiene una sottostringa di lunghezza specificata, iniziando in corrispondenza di un punto specificato nella stringa.Gets a sub-string of a specified length, starting at a specified point in the string.
SintassiSyntax SUBSTRING(expression, start, length)SUBSTRING(expression, start, length)
ArgomentiArguments expression -- La stringa di origine della sottostringa.expression -- The source string for the substring.

start -Numero intero che specifica dove inizia la sottostringa.start -- Integer that specifies where the substring starts.

length -Numero intero che specifica la lunghezza della sottostringa.length -- Integer that specifies the length of the substring.

Esempio: myDataColumn.Expression = "SOTTOSTRINGA (telefono, 7, 8)"Example: myDataColumn.Expression = "SUBSTRING(phone, 7, 8)"

Nota

È possibile reimpostare il Expression proprietà assegnandole un valore null o una stringa vuota.You can reset the Expression property by assigning it a null value or empty string. Se un valore predefinito è impostato sulla colonna dell'espressione, tutte le righe precedentemente colorate vengono assegnate il valore predefinito dopo il Expression viene reimpostata.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.

Si applica a

Vedi anche