Operadores que aceptan valores NULL (F#)
Los operadores Nullable son aritmética binaria o los operadores de comparación que ejecutan los tipos aritméticos valores NULL en uno o ambos lados.Los tipos que aceptan valores NULL surgen con frecuencia cuando trabaje con datos de orígenes como bases de datos que permiten anulen en lugar de valores reales.Se utilizan los operadores Nullable con frecuencia en expresiones de consulta.Además de los operadores que acepta valores NULL para la aritmética y comparación, los operadores de conversión se pueden utilizar para convertir entre tipos que aceptan valores NULL.También hay versiones que acepta valores NULL de ciertos operadores de consulta.
Tabla de operadores Nullable
La tabla siguiente enumera los operadores que admitidos en el lenguaje F#.
Valores NULL en izquierda |
Valores NULL en la derecha |
Ambos lados valores NULL |
Comentarios
Incluyen operadores valores NULL en el módulo de NullableOperators en el espacio de nombres Microsoft.FSharp.Linq.El tipo de datos que es Nullable<T>.
En expresiones de consulta, los tipos que surgen al seleccionar datos de un origen de datos que permite null en lugar de valores.en una base de datos de SQL Server, cada columna de datos en una tabla tiene un atributo que indique si anula están permitidos.Si anula se permiten, los datos devueltos de la base de datos puede contener valores nulos que no se puede representar mediante un tipo de datos primitivo como int, float, etc.Por consiguiente, los datos se devuelven como System.Nullable<int> en lugar de int, y System.Nullable<float> en lugar de float.El valor real se puede obtener de un objeto de Nullable<T> mediante la propiedad de Value , y determinar si un objeto de Nullable<T> tiene un valor llamando al método de HasValue .Otro método útil es el método de GetValueOrDefault , que permite obtener el valor o un valor predeterminado del tipo adecuado.El valor predeterminado es una forma de “cero " valor, como 0, 0,0, o false.
Los tipos que aceptan valores NULL se pueden convertir a los tipos primitivos que no aceptan valores NULL mediante operadores de conversión habituales como int o float.También es posible convertir de un tipo que acepta valores NULL a otro tipo que acepta valores NULL mediante los operadores de conversión para los tipos que aceptan valores NULL.Los operadores de conversión adecuados tienen el mismo nombre que los estándar, pero están en un módulo independiente, el agente de Valores NULL en el espacio de nombres Microsoft.FSharp.Linq .Normalmente, abra este espacio de nombres al trabajar con expresiones de consulta.En ese caso, puede utilizar los operadores de conversión que acepta valores NULL agregando el prefijo Nullable. el operador de conversión adecuado, tal y como se muestra en el código siguiente.
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 salida es 10.000000.
Vea operadores en campos de datos que acepta valores NULL, como sumByNullable, también existe para el uso en expresiones de consulta.Los operadores de consulta para los tipos que no aceptan valores NULL no son tipo-compatible con tipos que aceptan valores NULL, por lo que debe utilizar la versión que acepta valores NULL de operador adecuado de la consulta cuando se trabaja con los valores de los datos que aceptan valores NULL.Para obtener más información, vea Expresiones de consulta (F#).
El ejemplo siguiente se muestra el uso de operadores valores NULL en una expresión de consulta de F#.La primera consulta muestra cómo debe escribirse una consulta sin un operador que acepta valores NULL; la segunda consulta muestra una consulta equivalente que utiliza un operador que acepta valores NULL.Para el contexto completo, incluido cómo configurar la base de datos para utilizar este código de ejemplo, vea Tutorial: Obtener acceso a una base de datos SQL mediante proveedores de tipo (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)