DataColumn.Expression Vlastnost

Definice

Získá nebo nastaví výraz používaný k filtrování řádků, výpočtu hodnot ve sloupci nebo vytvoření agregačního sloupce.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); };
public string Expression { get; set; }
[System.Data.DataSysDescription("DataColumnExpressionDescr")]
public string Expression { get; set; }
member this.Expression : string with get, set
Public Property Expression As String

Hodnota vlastnosti

Výraz pro výpočet hodnoty sloupce nebo vytvoření agregačního sloupce.An expression to calculate the value of a column, or create an aggregate column. Návratový typ výrazu je určen DataType sloupce.The return type of an expression is determined by the DataType of the column.

Atributy

Výjimky

Vlastnost AutoIncrement nebo Unique je nastavena na hodnotu true.The AutoIncrement or Unique property is set to true.

Při použití funkce CONVERT je výraz vyhodnocen jako řetězec, ale řetězec neobsahuje reprezentace, která může být převedena na parametr typu.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.

Pokud používáte funkci CONVERT, požadované přetypování není možné.When you are using the CONVERT function, the requested cast is not possible. Podrobné informace o možných přetypování najdete v následující části funkce pro převod.See the Conversion function in the following section for detailed information about possible casts.

Když použijete funkci Substring, počáteční argument je mimo rozsah.When you use the SUBSTRING function, the start argument is out of range.

- nebo --Or-

Při použití funkce substring je argument Length mimo rozsah.When you use the SUBSTRING function, the length argument is out of range.

Při použití funkce LEN nebo funkce TRIM není výraz vyhodnocen jako řetězec.When you use the LEN function or the TRIM function, the expression does not evaluate to a string. To zahrnuje výrazy, které se vyhodnotí jako Char.This includes expressions that evaluate to Char.

Příklady

Následující příklad vytvoří tři sloupce v DataTable.The following example creates three columns in a DataTable. Druhý a třetí sloupec obsahuje výrazy; Druhá počítá daň pomocí proměnlivé daňové sazby a třetí přidá výsledek výpočtu do hodnoty prvního sloupce.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. Výsledná tabulka se zobrazí v ovládacím prvku DataGrid.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 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

Poznámky

Jedním z použití vlastnosti Expression je vytváření počítaných sloupců.One use of the Expression property is to create calculated columns. Například pro výpočet daňové hodnoty se Jednotková cena vynásobí daňovou sazbou konkrétní oblasti.For example, to calculate a tax value, the unit price is multiplied by a tax rate of a specific region. Vzhledem k tomu, že se daňové sazby liší od oblasti do oblasti, nebylo by možné do sloupce vložit jednu daňovou sazbu. místo toho se hodnota vypočítá pomocí vlastnosti Expression, jak je znázorněno v kódu Visual Basic v následující části: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"). Sloupce ("daň"). Výraz = "UnitPrice * 0,086"DataSet1.Tables("Products").Columns("tax").Expression = "UnitPrice * 0.086"

Druhým použitím je vytvořit agregovaný sloupec.A second use is to create an aggregate column. Podobně jako u počítané hodnoty provede agregace operaci na základě úplné sady řádků v DataTable.Similar to a calculated value, an aggregate performs an operation based on the complete set of rows in the DataTable. Jednoduchým příkladem je počet řádků vrácených v sadě.A simple example is to count the number of rows returned in the set. Toto je metoda, kterou použijete k výpočtu počtu transakcí dokončených konkrétním prodejcem, jak je znázorněno v tomto kódu 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)"  

Syntaxe výrazuExpression Syntax

Při vytváření výrazu použijte vlastnost ColumnName pro odkazování na sloupce.When you create an expression, use the ColumnName property to refer to columns. Pokud například ColumnName pro jeden sloupec je "UnitPrice" a další "množství", výraz by byl následující:For example, if the ColumnName for one column is "UnitPrice", and another "Quantity", the expression would be as follows:

"JednotkováCena * množství""UnitPrice * Quantity"

Poznámka

Je-li ve výrazu použit sloupec, je výraz označován jako závislost na tomto sloupci.If a column is used in an expression, then the expression is said to have a dependency on that column. Pokud je závislý sloupec přejmenován nebo odebrán, není vyvolána žádná výjimka.If a dependent column is renamed or removed, no exception is thrown. Pokud je k dispozici sloupec výrazu, který je právě poškozen, bude vyvolána výjimka.An exception will be thrown when the now-broken expression column is accessed.

Když vytvoříte výraz pro filtr, uzavřete řetězce s jednoduchými uvozovkami:When you create an expression for a filter, enclose strings with single quotation marks:

"LastName =" Novák """LastName = 'Jones'"

Pokud název sloupce obsahuje jakékoli jiné než alfanumerické znaky nebo začíná číslicí nebo se shoduje (nerozlišuje velká a malá písmena) žádné z následujících vyhrazených slov, vyžaduje speciální zpracování, jak je popsáno v následujících odstavcích.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.

AAnd

Je meziBetween

PodřízenáChild

NepravdaFalse

VIn

SeznamIs

Líbí se mi.Like

NotNot

NullNull

NeboOr

nadřazenéParent

PravdaTrue

Pokud název sloupce splňuje některou z výše uvedených podmínek, musí být zabalený buď v hranatých závorkách, nebo v uvozovkách "" "(čárka akcent).If a column name satisfies one of the above conditions, it must be wrapped in either square brackets or the "`" (grave accent) quotes. Chcete-li například použít sloupec s názvem "Column #" ve výrazu, zapište buď "[sloupec #]":For example, to use a column named "Column#" in an expression, you would write either "[Column#]":

Total * [sloupec #]Total * [Column#]

nebo "`sloupec č." ":or "`Column#`":

Total * `sloupec # 'Total * `Column#`

Pokud je název sloupce uzavřený v hranatých závorkách, pak všechny znaky '] ' a '\' (ale ne žádné jiné znaky) musí být uvozeny vyvoláním znaku zpětného lomítka ("\").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. Pokud je název sloupce uzavřený v nečárkách akcent znaků, nesmí v něm obsahovat žádné čárky se znaky akcentů.If the column name is enclosed in grave accent characters then it must not contain any grave accent characters in it. Například sloupec s názvem "Column []\" by byl napsán:For example, a column named "Column[]\" would be written:

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

neboor

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

Uživatelem definované hodnotyUser-Defined Values

Uživatelsky definované hodnoty lze použít ve výrazech, které mají být porovnány s hodnotami sloupce.User-defined values may be used within expressions to be compared with column values. Řetězcové hodnoty by měly být uzavřeny v jednoduchých uvozovkách (a každý znak jedné uvozovky v řetězcové hodnotě musí být uvozeny na základě předčekání na jiný znak uvozovky).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). Hodnoty data by měly být uzavřeny v závorkách (#) nebo jednoduchých uvozovkách (') založené na poskytovateli dat.Date values should be enclosed within pound signs (#) or single quotes (') based on the data provider. Pro číselné hodnoty je přípustný počet desetinných míst a vědecký zápis.Decimals and scientific notation are permissible for numeric values. Příklad:For example:

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

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

"DatumNarození < #1/31/82 #""Birthdate < #1/31/82#"

Pro sloupce, které obsahují hodnoty výčtu, přetypujte hodnotu na celočíselný datový typ.For columns that contain enumeration values, cast the value to an integer data type. Příklad:For example:

"EnumColumn = 5""EnumColumn = 5"

Analýza literálových výrazůParsing Literal Expressions

Všechny literálové výrazy musí být vyjádřeny v neutrálním národním prostředí pro invariantní jazykovou verzi.All literal expressions must be expressed in the invariant culture locale. Když DataSet analyzuje a převádí literální výrazy, vždy používá invariantní jazykovou verzi, nikoli aktuální jazykovou verzi.When DataSet parses and converts literal expressions, it always uses the invariant culture, not the current culture.

Řetězcové literály jsou identifikovány, pokud jsou kolem hodnoty jednoduché uvozovky.String literals are identified when there are single quotes surrounding the value. Příklad:For example:

Jan'John'

Boolean literály jsou true a false; nejsou uváděny ve výrazech.Boolean literals are true and false; they are not quoted in expressions.

Integer literály [+-]? [0-9] + se považují za System.Int32, System.Int64 nebo System.Double.Integer literals [+-]?[0-9]+ are treated as System.Int32, System.Int64 or System.Double. System.Double může přijít o přesnost v závislosti na tom, jak velký je číslo.System.Double can lose precision depending on how large the number is. Například pokud číslo v literálu je 2147483650, DataSet se nejprve pokusí analyzovat číslo jako Int32.For example, if the number in the literal is 2147483650, DataSet will first attempt to parse the number as an Int32. Tato operace nebude úspěšná, protože toto číslo je příliš velké.This will not succeed because the number is too large. V tomto případě DataSet bude číslo analyzovat jako Int64, což bude úspěšné.In this case DataSet will parse the number as an Int64, which will succeed. Pokud byl literál číslo větší než maximální hodnota Int64, DataSet analyzuje literál pomocí Double.If the literal was a number larger than the maximum value of an Int64, DataSet will parse the literal using Double.

Reálné literály používající vědecký zápis, jako je například 4.42372 E-30, se analyzují pomocí System.Double.Real literals using scientific notation, such as 4.42372E-30, are parsed using System.Double.

Reálné literály bez vědeckého zápisu, ale s desetinnou čárkou, jsou považovány za System.Decimal.Real literals without scientific notation, but with a decimal point, are treated as System.Decimal. Pokud číslo překročí maximální nebo minimální hodnoty podporované nástrojem System.Decimal, analyzuje se jako System.Double.If the number exceeds the maximum or minimum values supported by System.Decimal, then it is parsed as a System.Double. Příklad:For example:

142526,144524 se převede na Decimal.142526.144524 will be converted to a Decimal.

345262.78036719560925667 se bude považovat za Double.345262.78036719560925667 will be treated as a Double.

OperátoryOperators

Zřetězení je povoleno pomocí logických operátorů AND, OR a NOT.Concatenation is allowed using Boolean AND, OR, and NOT operators. Můžete použít závorky k seskupení klauzulí a vynucení přednosti.You can use parentheses to group clauses and force precedence. Operátor AND má přednost před jinými operátory.The AND operator has precedence over other operators. Příklad:For example:

(LastName = ' Smith ' nebo LastName = ' Novák ') A FirstName = ' Jan '(LastName = 'Smith' OR LastName = 'Jones') AND FirstName = 'John'

Při vytváření výrazů porovnání jsou povoleny následující operátory:When you create comparison expressions, the following operators are allowed:

<

>

<=

>=

<>

=

ININ

LIKELIKE

Ve výrazech jsou podporovány také následující aritmetické operátory:The following arithmetic operators are also supported in expressions:

+ (přidání)+ (addition)

- (odčítání)- (subtraction)

* (násobení)* (multiplication)

/ (dělení)/ (division)

% (modulo)% (modulus)

Operátory řetězceString Operators

Chcete-li zřetězit řetězec, použijte znak +.To concatenate a string, use the + character. Hodnota vlastnosti CaseSensitive třídy DataSet určuje, zda porovnávání řetězců rozlišuje velká a malá písmena.The value of the CaseSensitive property of the DataSet class determines whether string comparisons are case-sensitive. Tuto hodnotu však lze přepsat vlastností CaseSensitive třídy DataTable.However, you can override that value with the CaseSensitive property of the DataTable class.

Zástupné znakyWildcard Characters

* I% lze v porovnání s podobným způsobem použít pro zástupné znaky.Both the * and % can be used interchangeably for wildcard characters in a LIKE comparison. Pokud řetězec v klauzuli LIKE obsahuje znak * nebo%, tyto znaky by měly být uzavřeny do hranatých závorek ([]).If the string in a LIKE clause contains a * or %, those characters should be enclosed in brackets ([]). Pokud závorka. v klauzuli, každý znak závorky by měla být uzavřena do hranatých závorek (pro příklad [[] nebo []]).If a bracket is in the clause, each bracket character should be enclosed in brackets (for example [[] or []]). Zástupný znak je povolen na začátku a konci vzoru nebo na konci vzoru nebo na začátku vzoru.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. Příklad:For example:

"Typ položky jako **produktu" ""ItemName LIKE '*product*'"

"Typ položky jako * produkt" ""ItemName LIKE '*product'"

"Typ položky jako" produkt * """ItemName LIKE 'product*'"

Zástupné znaky nejsou v názvu uprostřed řetězce povoleny.Wildcard characters are not allowed in the middle of a string. Například "te * XT" není povolen.For example, 'te*xt' is not allowed.

Odkazování na vztah podřízený/nadřazenýParent/Child Relation Referencing

Ve výrazu může být odkazováno na nadřazenou tabulku pomocí názvu sloupce Parent.A parent table may be referenced in an expression by prepending the column name with Parent. Parent.Price například odkazuje na sloupec nadřazené tabulky s názvem Price.For example, the Parent.Price references the parent table's column named Price.

Pokud má podřízený objekt více než jeden nadřazený řádek, použijte nadřazenou položku (relation). ColumnName.When a child has more than one parent row, use Parent(RelationName).ColumnName. Například nadřazený prvek (relation). Cena odkazuje na sloupec nadřazené tabulky s názvem Price prostřednictvím vztahu.For example, the Parent(RelationName).Price references the parent table's column named Price via the relation.

Na sloupec v podřízené tabulce může být odkazováno ve výrazu na základě názvu sloupce Child.A column in a child table may be referenced in an expression by prepending the column name with Child. Vzhledem k tomu, že podřízené relace mohou vracet více řádků, musíte zahrnout odkaz na podřízený sloupec v agregační funkci.However, because child relationships may return multiple rows, you must include the reference to the child column in an aggregate function. Sum(Child.Price) například vrátí součet sloupce s názvem Price v podřízené tabulce.For example, Sum(Child.Price) would return the sum of the column named Price in the child table.

Pokud má tabulka více než jednu podřízenou položku, syntaxe je: Child(RelationName).If a table has more than one child, the syntax is: Child(RelationName). Například pokud má tabulka dvě podřízené tabulky s názvem Customers a Ordersa objekt DataRelation má název Customers2Orders, odkaz by byl následující: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:

Prům (Child) (Customers2Orders). MnožstvíAvg(Child(Customers2Orders).Quantity)

AgregaceAggregates

Podporovány jsou následující agregované typy:The following aggregate types are supported:

Sum (suma)Sum (Sum)

Průměr (průměr)Avg (Average)

Minimum (minimální)Min (Minimum)

Max (maximum)Max (Maximum)

Počet (počet)Count (Count)

StDev (Statistická směrodatná odchylka)StDev (Statistical standard deviation)

Var (statistická variance).Var (Statistical variance).

Agregace se obvykle provádějí společně s relacemi.Aggregates are ordinarily performed along relationships. Vytvořte agregační výraz pomocí jedné z výše uvedených funkcí a podřízeného sloupce tabulky, jak je popsáno v vztahu nadřazená/podřízená položka odkazující na předchozí verzi.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. Příklad:For example:

Průměrná (podřízená položka. Price)Avg(Child.Price)

Prům (Child) (Orders2Details). CenovéAvg(Child(Orders2Details).Price)

Agregaci lze také provést v jedné tabulce.An aggregate can also be performed on a single table. Například pro vytvoření souhrnu obrázků ve sloupci s názvem "Price":For example, to create a summary of figures in a column named "Price":

Sum (price)Sum(Price)

Poznámka

Použijete-li k vytvoření agregace jednu tabulku, neexistují žádné funkce pro seskupení.If you use a single table to create an aggregate, there would be no group-by functionality. Místo toho by všechny řádky zobrazovaly stejnou hodnotu ve sloupci.Instead, all rows would display the same value in the column.

Pokud tabulka neobsahuje žádné řádky, budou agregační funkce vracet null.If a table has no rows, the aggregate functions will return null.

Datové typy lze vždy určit kontrolou vlastnosti DataType sloupce.Data types can always be determined by examining the DataType property of a column. Datové typy můžete také převést pomocí funkce CONVERT, která je znázorněna v následující části.You can also convert data types using the Convert function, shown in the following section.

Agregaci lze použít pouze pro jeden sloupec a v agregaci nelze použít žádné jiné výrazy.An aggregate can only be applied to a single column and no other expressions can be used inside the aggregate.

FunkceFunctions

Podporují se taky tyto funkce:The following functions are also supported:

CONVERT

PopisDescription Převede konkrétní výraz na zadaný typ .NET Framework.Converts particular expression to a specified .NET Framework Type.
SyntaxeSyntax Convert (expression``type)Convert(expression, type)
ArgumentsArguments expression – výraz, který se má převéstexpression -- The expression to convert.

type--typ .NET Framework, na který se hodnota převede.type -- The .NET Framework type to which the value will be converted.

Příklad: myDataColumn. Expression = "Convert (Total; ' System. Int32 ')Example: myDataColumn.Expression="Convert(total, 'System.Int32')"

Všechny převody jsou platné s následujícími výjimkami: Boolean může být převedena na Byte, SByte``Int16, Int32, Int64, UInt16, UInt32, UInt64, String a samotná.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 může být převedena na Int32, UInt32, Stringa jenom na sebe.Char can be coerced to and from Int32, UInt32, String, and itself only. DateTime lze přiřadit pouze String a samotné.DateTime can be coerced to and from String and itself only. TimeSpan lze přiřadit pouze String a samotné.TimeSpan can be coerced to and from String and itself only.

LEN

PopisDescription Získá délku řetězce.Gets the length of a string
SyntaxeSyntax LEN (expression)LEN(expression)
ArgumentsArguments expression – řetězec, který má být vyhodnocen.expression -- The string to be evaluated.

Příklad: myDataColumn. Expression = "len (Item)"Example: myDataColumn.Expression="Len(ItemName)"

ISNULL

PopisDescription Zkontroluje výraz a buď vrátí kontrolovaný výraz, nebo hodnotu pro nahrazení.Checks an expression and either returns the checked expression or a replacement value.
SyntaxeSyntax ISNULL (expression``replacementvalue)ISNULL(expression, replacementvalue)
ArgumentsArguments expression – výraz, který se má kontrolovatexpression -- The expression to check.

replacementvalue--Pokud je výraz null, vrátí replacementvalue.replacementvalue -- If expression is null, replacementvalue is returned.

Příklad: myDataColumn. Expression = "IsNull (Price;-1)"Example: myDataColumn.Expression="IsNull(price, -1)"

IIF

PopisDescription Získá jednu ze dvou hodnot v závislosti na výsledku logického výrazu.Gets one of two values depending on the result of a logical expression.
SyntaxeSyntax IIF(expr, truepart, falsepart)IIF(expr, truepart, falsepart)
ArgumentsArguments expr – výraz, který se má vyhodnotitexpr -- The expression to evaluate.

truepart – hodnota, která se má vrátit, pokud je výraz pravdivý.truepart -- The value to return if the expression is true.

falsepart – hodnota, která se má vrátit, pokud je výraz nepravdivý.falsepart -- The value to return if the expression is false.

Příklad: myDataColumn. Expression = "IIF (Total > 1000," drahý "," Vážený ")Example: myDataColumn.Expression = "IIF(total>1000, 'expensive', 'dear')

TRIM

PopisDescription Odebere všechny úvodní a koncové prázdné znaky, jako je například \r, \n, \t, ' '.Removes all leading and trailing blank characters like \r, \n, \t, ' '
SyntaxeSyntax TRIM(expression)TRIM(expression)
ArgumentsArguments expression – výraz, který má být oříznut.expression -- The expression to trim.

SUBSTRING

PopisDescription Získá dílčí řetězec o zadané délce počínaje zadaným bodem v řetězci.Gets a sub-string of a specified length, starting at a specified point in the string.
SyntaxeSyntax Podřetězec (expression, start, length)SUBSTRING(expression, start, length)
ArgumentsArguments expression – zdrojový řetězec pro dílčí řetězec.expression -- The source string for the substring.

start--Integer, který určuje, kde se podřetězec spustí.start -- Integer that specifies where the substring starts.

length--Integer, který určuje délku podřetězce.length -- Integer that specifies the length of the substring.

Příklad: myDataColumn. Expression = "podřetězec (telefon, 7, 8)"Example: myDataColumn.Expression = "SUBSTRING(phone, 7, 8)"

Poznámka

Vlastnost Expression můžete obnovit tak, že jí přiřadíte hodnotu null nebo prázdný řetězec.You can reset the Expression property by assigning it a null value or empty string. Pokud je u sloupce Expression nastavená výchozí hodnota, všechny dříve vyplněné řádky mají po resetování vlastnosti Expression přiřazenou výchozí hodnotu.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.

Platí pro

Viz také