DataColumn.Expression Proprietà

Definizione

Spazio dei nomi:

System.Data

Assembly:

System.Data.Common.dll

Ottiene o imposta l'espressione utilizzata per filtrare righe, calcolare i valori di una colonna o creare una colonna aggregata.

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

public string Expression { get; set; }

member this.Expression : string with get, set

Public Property Expression As String

Valore della proprietà

String

Espressione per calcolare il valore di una colonna o creare una colonna aggregata. Il tipo restituito di un'espressione è determinato dalla proprietà DataType della colonna.

Eccezioni

ArgumentException

La proprietà AutoIncrement o la proprietà Unique è impostata su true.

FormatException

Quando si utilizza la funzione CONVERT, l'espressione viene valutata in una stringa, ma la stringa non contiene alcuna rappresentazione convertibile nel parametro del tipo.

InvalidCastException

Quando si utilizza la funzione CONVERT, non è possibile eseguire il cast richiesto. Per informazioni dettagliate sui cast possibili, vedere la funzione Conversion nella sezione seguente.

ArgumentOutOfRangeException

Quando si utilizza la funzione SUBSTRING, l'argomento start non rientra nell'intervallo.

Oppure

Quando si utilizza la funzione SUBSTRING, l'argomento length non rientra nell'intervallo.

Exception

Quando si utilizza la funzione LEN o TRIM, l'espressione non viene valutata in una stringa. Sono incluse le espressioni che vengono valutate in Char.

Esempio

Nell'esempio seguente vengono create tre colonne in un oggetto DataTable. La seconda e la terza colonna contengono espressioni; il secondo calcola l'imposta usando un'aliquota fiscale variabile e il terzo aggiunge il risultato del calcolo al valore della prima colonna. La tabella risultante viene visualizzata in un DataGrid controllo .

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

Commenti

Un uso della proprietà consiste nel Expression creare colonne calcolate. Ad esempio, per calcolare un valore fiscale, il prezzo unitario viene moltiplicato per un tasso di imposta di un'area specifica. Poiché le imposte variano da un'area all'altra, sarebbe impossibile inserire un'unica aliquota fiscale in una colonna; Il valore viene invece calcolato usando la Expression proprietà , come illustrato nel codice visual Basic nella sezione seguente:

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

Un secondo utilizzo consiste nel creare una colonna di aggregazione. Analogamente a un valore calcolato, un'aggregazione esegue un'operazione basata sul set completo di righe in DataTable. Un semplice esempio consiste nel contare il numero di righe restituite nel set. Questo è il metodo usato per contare il numero di transazioni completate da un determinato venditore, come illustrato in questo codice Visual Basic:

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

Sintassi delle espressioni

Quando si crea un'espressione, utilizzare la ColumnName proprietà per fare riferimento alle colonne. Ad esempio, se per ColumnName una colonna è "UnitPrice" e un'altra "Quantity", l'espressione sarà la seguente:

"UnitPrice * Quantity"

Nota

Se una colonna viene usata in un'espressione, l'espressione viene detta dipendente da tale colonna. Se una colonna dipendente viene rinominata o rimossa, non viene generata alcuna eccezione. Verrà generata un'eccezione quando si accede alla colonna dell'espressione ora interrotta.

Quando si crea un'espressione per un filtro, racchiudere le stringhe tra virgolette singole:

"LastName = 'Jones'"

Se un nome di colonna contiene caratteri non alfanumerici o inizia con una cifra o una corrispondenza (senza distinzione tra maiuscole e minuscole), è necessaria una gestione speciale, come descritto nei paragrafi seguenti.

e

tra le

Figlio

Falso

In

Is

Simile a

Not

Null

Oppure

Padre

True

Se un nome di colonna soddisfa una delle condizioni precedenti, deve essere racchiuso tra parentesi quadre o virgolette "'" (accento grave). Ad esempio, per usare una colonna denominata "Column#" in un'espressione, è necessario scrivere "[Column#]":

Totale * [Column#]

o "'Column#'":

Totale * 'Column#'

Se il nome della colonna è racchiuso tra parentesi quadre, tutti i caratteri ']' e '\' (ma non altri caratteri) in esso devono essere preceduti da un carattere di escape anteponendoli con la barra rovesciata ("\"). Se il nome della colonna è racchiuso tra caratteri accentati gravi, non deve contenere caratteri accentati gravi. Ad esempio, verrà scritta una colonna denominata "Column[]\":

Totale * [Colonna[\]\\]

oppure

Totale * 'Column[]\'

valori User-Defined

I valori definiti dall'utente possono essere usati all'interno delle espressioni da confrontare con i valori di colonna. I valori stringa devono essere racchiusi tra virgolette singole e ogni virgoletta singola in un valore stringa deve essere preceduta da un carattere di escape anteponendolo a un'altra virgoletta singola. I valori di data devono essere racchiusi tra segni di cancelletto (#) o virgolette singole (') in base al provider di dati. I decimali e la notazione scientifica sono consentiti per i valori numerici. Ad esempio:

"FirstName = 'John'"

"Prezzo <= 50,00"

"Birthdate < #1/31/82#"

Per le colonne che contengono valori di enumerazione, eseguire il cast del valore a un tipo di dati integer. Ad esempio:

"EnumColumn = 5"

Analisi delle espressioni letterali

Tutte le espressioni letterali devono essere espresse nelle impostazioni locali delle impostazioni cultura invarianti. Quando DataSet analizza e converte le espressioni letterali, usa sempre le impostazioni cultura invarianti, non le impostazioni cultura correnti.

I valori letterali stringa vengono identificati quando sono presenti virgolette singole che circondano il valore. Ad esempio:

'John'

Boolean i valori letterali sono true e false; non sono racchiusi tra virgolette nelle espressioni.

Integer valori letterali [+-]? [0-9]+ vengono considerati come System.Int32o System.Int64System.Double. System.Double può perdere precisione a seconda della dimensione del numero. Ad esempio, se il numero nel valore letterale è 2147483650, DataSet tenterà prima di tutto di analizzare il numero come .Int32 L'operazione non riesce perché il numero è troppo grande. In questo caso DataSet il numero verrà analizzato come Int64, che avrà esito positivo. Se il valore letterale è maggiore del valore massimo di int64, DataSet analizzerà il valore letterale usando Double.

I valori letterali reali che usano la notazione scientifica, ad esempio 4.42372E-30, vengono analizzati usando System.Double.

I valori letterali reali senza notazione scientifica, ma con un separatore decimale, vengono considerati come System.Decimal. Se il numero supera i valori massimi o minimi supportati da System.Decimal, viene analizzato come .System.Double Ad esempio:

142526.144524 verrà convertito in .Decimal

345262.78036719560925667 verrà considerato come .Double

Operatori

La concatenazione è consentita tramite operatori AND, OR e NOT booleani. È possibile usare le parentesi per raggruppare le clausole e forzare la precedenza. L'operatore AND ha la precedenza su altri operatori. Ad esempio:

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

Quando si creano espressioni di confronto, sono consentiti gli operatori seguenti:

<

>

<=

>=

<>

=

IN

LIKE

Nelle espressioni sono supportati anche gli operatori aritmetici seguenti:

+ (addizione)

- (sottrazione)

* (moltiplicazione)

/ (divisione)

% (modulo)

Operatori stringa

Per concatenare una stringa, usare il carattere + . Il valore della CaseSensitive proprietà della DataSet classe determina se i confronti tra stringhe fanno distinzione tra maiuscole e minuscole. Tuttavia, è possibile eseguire l'override di tale valore con la CaseSensitive proprietà della DataTable classe .

Caratteri jolly

Sia il valore * che % possono essere utilizzati in modo intercambiabile per i caratteri jolly in un confronto LIKE. Se la stringa in una clausola LIKE contiene un *o %, tali caratteri devono essere racchiusi tra parentesi quadre ([]). Se una parentesi è nella clausola , ogni carattere di parentesi quadre deve essere racchiuso tra parentesi quadre (ad esempio [[] o []]). Un carattere jolly è consentito all'inizio e alla fine di un criterio, o alla fine di un criterio o all'inizio di un criterio. Ad esempio:

"ItemName LIKE '*product*'"

"ItemName LIKE '*product'"

"ItemName LIKE 'product*'"

I caratteri jolly non sono consentiti al centro di una stringa. Ad esempio, 'te*xt' non è consentito.

Riferimento alle relazioni padre/figlio

È possibile fare riferimento a una tabella padre in un'espressione anteponendo il nome della colonna con Parent. Ad esempio, fa Parent.Price riferimento alla colonna della tabella padre denominata Price.

Quando un elemento figlio ha più righe padre, usare Parent(RelationName). Columnname. Ad esempio, Parent(RelationName). Price fa riferimento alla colonna della tabella padre denominata Price tramite la relazione.

È possibile fare riferimento a una colonna in una tabella figlio in un'espressione anteponendo il nome della colonna con Child. Tuttavia, poiché le relazioni figlio possono restituire più righe, è necessario includere il riferimento alla colonna figlio in una funzione di aggregazione. Ad esempio, Sum(Child.Price) restituirebbe la somma della colonna denominata Price nella tabella figlio.

Se una tabella ha più di un elemento figlio, la sintassi è : Child(RelationName). Ad esempio, se una tabella ha due tabelle figlio denominate Customers e Orderse l'oggetto DataRelation è denominato Customers2Orders, il riferimento sarà il seguente:

Avg(Child(Customers2Orders). Quantità)

Aggregazioni

Sono supportati i tipi di aggregazione seguenti:

Sum (Sum)

Media (media)

Min (minimo)

Max (massimo)

Conteggio (conteggio)

StDev (deviazione standard statistica)

Var (varianza statistica).

Le aggregazioni vengono in genere eseguite lungo le relazioni. Creare un'espressione di aggregazione usando una delle funzioni elencate in precedenza e una colonna di tabella figlio come descritto in precedenza in Riferimento alla relazione padre/figlio descritta in precedenza. Ad esempio:

Avg(Child.Price)

Avg(Child(Orders2Details). Prezzo)

È anche possibile eseguire un'aggregazione in una singola tabella. Ad esempio, per creare un riepilogo delle figure in una colonna denominata "Price":

Sum(Price)

Nota

Se si usa una singola tabella per creare un'aggregazione, non sarà disponibile alcuna funzionalità group-by. Tutte le righe visualizzano invece lo stesso valore nella colonna.

Se una tabella non contiene righe, le funzioni di aggregazione restituiranno null.

I tipi di dati possono essere sempre determinati esaminando la DataType proprietà di una colonna. È anche possibile convertire i tipi di dati usando la funzione Convert, illustrata nella sezione seguente.

Un'aggregazione può essere applicata solo a una singola colonna e nessun'altra espressione può essere utilizzata all'interno dell'aggregazione.

Funzioni

Sono supportate anche le funzioni seguenti:

CONVERT

Descrizione	Converte un'espressione specifica in un tipo .NET Framework specificato.
Sintassi	Convert(expression, type)
Argomenti	expression -- Espressione da convertire. type -- . TIPONET in cui verrà convertito il valore.

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

Tutte le conversioni sono valide con le eccezioni seguenti: Boolean possono essere forzate in e da Byte, , SByteInt64UInt32Int32UInt16Int16, , UInt64String e solo da . Char può essere costretto a e solo da Int32, UInt32, Stringe . DateTime può essere costretto a e da String e solo. TimeSpan può essere costretto a e da String e solo.

LEN

Descrizione	Ottiene la lunghezza di una stringa
Sintassi	LEN(expression)
Argomenti	expression -- Stringa da valutare.

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

ISNULL

Descrizione	Controlla un'espressione e restituisce l'espressione selezionata o un valore di sostituzione.
Sintassi	ISNULL(expression, replacementvalue)
Argomenti	expression -- Espressione da controllare. replacementvalue -- Se l'espressione è null, replacementvalue viene restituita.

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

IIF

Descrizione	Ottiene uno dei due valori a seconda del risultato di un'espressione logica.
Sintassi	IIF(expr, truepart, falsepart)
Argomenti	expr -- Espressione da valutare. truepart -- Valore da restituire se l'espressione è true. falsepart -- Valore da restituire se l'espressione è false.

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

TRIM

Descrizione	Rimuove tutti i caratteri vuoti iniziali e finali, ad esempio \r, \n, \t, ' '
Sintassi	TRIM(expression)
Argomenti	expression -- Espressione da tagliare.

SUBSTRING

Descrizione	Ottiene una sotto stringa di una lunghezza specificata, a partire da un punto specificato nella stringa.
Sintassi	SUBSTRING(expression, start, length)
Argomenti	expression -- Stringa di origine per la sottostringa. start -- Intero che specifica dove inizia la sottostringa. length -- Intero che specifica la lunghezza della sottostringa.

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

Nota

È possibile reimpostare la Expression proprietà assegnandole un valore Null o una stringa vuota. Se viene impostato un valore predefinito nella colonna dell'espressione, tutte le righe compilate in precedenza vengono assegnate al valore predefinito dopo la reimpostazione della Expression proprietà.

Vedi anche

• Uso di DataSet in ADO.NET