Opérateurs autorisant la valeur Null (F#)
Les opérateurs nullables sont des arithmétiques binaire ou opérateurs de comparaison qui fonctionnent avec des types arithmétiques nullables sur un ou les deux côtés. Les types Nullable surviennent fréquemment lorsque vous utilisez des données à partir de sources telles que des bases de données qui autorisent la valeur null au lieu des valeurs réelles. Les opérateurs nullables sont fréquemment utilisés dans les expressions de requête. Outre les opérateurs nullables pour des opérations arithmétiques et comparaisons, des opérateurs de conversion peuvent être utilisés pour effectuer des conversions entre des types Nullable. Il existe également des versions nullables de certains opérateurs de requête.
Tableau des opérateurs nullable
Le tableau suivant répertorie les opérateurs nullables pris en charge dans le langage F#.
Nullable sur la gauche |
Nullable sur la droite |
Les deux côtés nullable |
Notes
Les opérateurs nullables sont inclus dans le module NullableOperators dans l'espace de noms Microsoft.FSharp.Linq. Le type pour données Nullable est Nullable.
Dans les expressions de requête, les types Nullable surviennent en sélectionnant des données d'une source de données qui permet les nulls à la place de valeurs. Dans une base de données SQL Server, chaque colonne de données dans une table possède un attribut qui indique si les nulls sont autorisés ou non. Si les nulls sont autorisés, les données retournées de la base de données peuvent contenir des nulls qui ne peuvent pas être représentés par un type de données primitif tel que int, float, et ainsi de suite. Par conséquent, les données sont retournées sous forme de System.Nullable<int> au lieu d´ int, et System.Nullable<float> au lieu de float. La valeur réelle peut être obtenue à partir d'un objet Nullable à l'aide de la propriété Value , et vous pouvez déterminer si un objet Nullable a une valeur en appelant la méthode HasValue . Une autre méthode utile est la méthode GetValueOrDefault , 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 ¨zero¨ , telle que 0, 0,0, ou false.
Les types Nullable peuvent être convertis en types primitifs non nullables utilisation des opérateurs habituels de conversion tels que int ou float. Il est également possible de convertir un type Nullable en un autre type Nullable à l'aide des opérateurs de conversion pour les types Nullable. Les opérateurs de conversion appropriés ont le même nom que les standard, mais ils sont dans un module distinct, le module de nullable dans l'espace de noms Microsoft.FSharp.Linq . En général, vous ouvrez cet espace de noms lorsque vous utilisez des 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 approprié de conversion, 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)
Le résultat est 10.000000.
Les opérateurs de requête sur les champs de données nullables, tels que sumByNullable, existe également pour l´utilisation dans les expressions de requête. Les opérateurs de requête pour les types non-nullable ne sont pas compatibles en type avec les types Nullable, vous devez utiliser la version nullable de l'opérateur de requête approprié lorsque vous travaillez avec des valeurs de données nullables. Pour plus d’informations, consultez Expressions de requête (F#).
L'exemple suivant illustre l'utilisation des opérateurs nullables dans une expression de requête F#. La première requête montre comment vous écririez une requête sans opérateur nullable ; la deuxième requête affiche une requête équivalente qui utilise un opérateur nullable. Pour le contexte complet, notamment comment installer 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 des fournisseurs de type (F#).
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 %s" row.TestData1.Value 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 %s" (row.TestData1.GetValueOrDefault()) row.Name)