Partager via

Opérateurs nullables dans les requêtes

Les opérateurs nullables sont des opérateurs arithmétiques ou de comparaison binaires qui fonctionnent avec des types arithmétiques nullables d’un ou des deux côtés. Les types nullables surviennent lorsque vous travaillez avec des données provenant de sources telles que des bases de données qui autorisent des valeurs null à la place des valeurs réelles. Les opérateurs nullables sont utilisés dans les expressions de requête. En plus des opérateurs nullables pour l’arithmétique et la comparaison, les opérateurs de conversion peuvent être utilisés pour effectuer la conversion entre les types nullables. Il existe également des versions nullables de certains opérateurs de requête.

Remarque

Les opérateurs nullables sont généralement utilisés uniquement dans les expressions de requête. Si vous n’utilisez pas d’expressions de requête, vous n’avez pas besoin de connaître ou d’utiliser ces opérateurs.

Table des opérateurs Nullable

Le tableau suivant répertorie les opérateurs nullables pris en charge dans F#.

Nullable à gauche Nullable à droite Les deux côtés peuvent être nullables
?>= >=? ?>=?
?> >? ?>?
?<= <=? ?<=?
?< <? ?<?
?= =? ?=?
?<> <>? ?<>?
?+ +? ?+?
?- -? ?-?
?* *? ?*?
?/ /? ?/?
?% %? ?%?

Remarques

Les opérateurs Nullable sont inclus dans le module NullableOperators de l’espace de noms FSharp.Linq. Le type pour les données nullables est System.Nullable<'T>.

Dans les expressions de requête, les types nullables se produisent lors de la sélection de données à partir d’une source de données qui autorise les valeurs Null au lieu des valeurs. Dans une base de données SQL Server, chaque colonne de données d’une table a un attribut qui indique si les valeurs Null sont autorisées. Si les valeurs Null sont autorisées, les données retournées à partir de la base de données peuvent contenir des valeurs Null qui ne peuvent pas être représentées par un type de données primitif tel que int, floatetc. Par conséquent, les données sont retournées en tant que System.Nullable<int> non intpas , et System.Nullable<float> au lieu de float. La valeur réelle peut être obtenue à partir d’un System.Nullable<'T> objet à l’aide de la Value propriété, et vous pouvez déterminer si un System.Nullable<'T> objet a une valeur en appelant la HasValue méthode. Une autre méthode utile est la System.Nullable<'T>.GetValueOrDefault méthode, qui vous permet d’obtenir la valeur ou une valeur par défaut du type approprié. La valeur par défaut est une forme de valeur « zéro », telle que 0, 0,0 ou false.

Les types nullables peuvent être convertis en types primitifs non nullables à l’aide des opérateurs de conversion habituels tels que int ou float. Il est également possible de convertir d’un type Nullable en un autre type Nullable à l’aide des opérateurs de conversion pour les types nullables. Les opérateurs de conversion appropriés ont le même nom que les opérateurs standard, mais ils se trouvent dans un module distinct, le module Nullable dans l’espace de noms FSharp.Linq . En règle générale, vous ouvrez cet espace de noms lors de l’utilisation d’expressions de requête. Dans ce cas, vous pouvez utiliser les opérateurs de conversion Nullable en ajoutant le préfixe Nullable. à l’opérateur de conversion approprié, comme indiqué dans le code suivant.

open Microsoft.FSharp.Linq

let nullableInt = new System.Nullable<int>(10)

// Use the Nullable.float conversion operator to convert from one nullable type to another nullable type.
let nullableFloat = Nullable.float nullableInt

// Use the regular non-nullable float operator to convert to a non-nullable float.
printfn $"%f{float nullableFloat}"

La sortie est 10.000000.

Les opérateurs de requête sur des champs de données nullables, tels que sumByNullable, existent également pour une utilisation dans les expressions de requête. Les opérateurs de requête pour les types non nullables ne sont pas compatibles avec les types nullables. Vous devez donc utiliser la version nullable de l’opérateur de requête approprié lorsque vous utilisez des valeurs de données nullables. Pour plus d’informations, consultez Expressions de requête.

L’exemple suivant montre l’utilisation d’opérateurs nullables dans une expression de requête F#. La première requête montre comment écrire une requête sans opérateur nullable ; la deuxième requête affiche une requête équivalente qui utilise un opérateur Nullable. Pour obtenir le contexte complet, notamment comment configurer la base de données pour utiliser cet exemple de code, consultez Procédure pas à pas : accès à une base de données SQL à l’aide de fournisseurs de types.

open System
open System.Data
open System.Data.Linq
open Microsoft.FSharp.Data.TypeProviders
open Microsoft.FSharp.Linq

[<Generate>]
type dbSchema = SqlDataConnection<"Data Source=MYSERVER\INSTANCE;Initial Catalog=MyDatabase;Integrated Security=SSPI;">

let db = dbSchema.GetDataContext()

query {
    for row in db.Table2 do
    where (row.TestData1.HasValue && row.TestData1.Value > 2)
    select row
} |> Seq.iter (fun row -> printfn $"%d{row.TestData1.Value} %s{row.Name}")

query {
    for row in db.Table2 do
    // Use a nullable operator ?>
    where (row.TestData1 ?> 2)
    select row
} |> Seq.iter (fun row -> printfn "%d{row.TestData1.GetValueOrDefault()} %s{row.Name}")

Voir aussi

  • Last updated on