Operadores anuláveis (F#)
Operadores anuláveis são operadores de aritmética ou comparação binários que funcionam com tipos anuláveis de aritméticos em um ou ambos os lados. Tipos anuláveis surgem com freqüência ao trabalhar com dados de fontes, como bancos de dados que permitem valores nulos no lugar dos valores reais. Operadores anuláveis são usadas freqüentemente em expressões de consulta. Além de anuláveis operadores de aritmética e comparação, os operadores de conversão podem ser usados para converter entre tipos anuláveis. Também existem versões anuláveis de determinados operadores de consulta.
Tabela de operadores anuláveis
A tabela a seguir lista operadores anuláveis, suportadas na linguagem F#.
Anulável à esquerda |
Anulável direita |
Ambos os lados anuláveis |
Comentários
Os operadores anuláveis são incluídos na NullableOperators o módulo no namespace Microsoft.FSharp.Linq. O tipo de dados anuláveis é Nullable.
Em expressões de consulta, os tipos anuláveis surgirem ao selecionar os dados de uma fonte de dados que permite valores nulos em vez de valores. Em um banco de dados de SQL Server, cada coluna de dados em uma tabela tem um atributo que indica se os valores nulos são permitidos. Se valores nulos são permitidos, os dados retornados do banco de dados podem conter valores nulos, o que não podem ser representados por um tipo de dados primitivos, como int, floate assim por diante. Portanto, os dados são retornados como um System.Nullable<int> em vez de int, e System.Nullable<float> em vez de float. O valor real pode ser obtido em um Nullable objeto usando o Value propriedade e você pode determinar se um Nullable objeto tem um valor chamando o HasValue método. Outro método útil é o GetValueOrDefault método, que permite que você obtenha o valor ou um valor padrão do tipo apropriado. O valor padrão é de alguma forma de "zero" valor, como, por exemplo, 0, 0,0, ou false.
Tipos anuláveis podem ser convertidos para tipos primitivos não anuláveis, usando os operadores de conversão usuais, como int ou float. Também é possível converter de um tipo anulável para outro tipo anulável, usando os operadores de conversão de tipos anuláveis. Os operadores de conversão apropriado têm o mesmo nome dos padrões, mas eles estão em um módulo separado, o Nullable módulo de Microsoft.FSharp.Linq namespace. Normalmente, você abrir este espaço para nome ao trabalhar com expressões de consulta. Nesse caso, você pode usar os operadores de conversão anulável adicionando o prefixo Nullable. para o operador de conversão apropriado, conforme mostrado no código a seguir.
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)
A saída é 10.000000.
Consulta em campos de dados anulável, tais como sumByNullable, também existem para uso em expressões de consulta. Os operadores de consulta para tipos não anuláveis não são tipo compatível com tipos anuláveis, portanto você deve usar a versão anulável do operador de consulta apropriada quando você estiver trabalhando com valores de dados anulável. Para obter mais informações, consulte Expressões de consulta (F#).
O exemplo a seguir mostra o uso de operadores anuláveis em uma expressão de consulta F#. A primeira consulta mostra como seria escrever uma consulta sem um operador anulável; a segunda consulta mostra uma consulta equivalente que usa um operador anulável. No contexto completo, incluindo como configurar o banco de dados para usar este código de exemplo, consulte Instruções passo a passo: acessando um banco de dados SQL por meio de provedores de tipos (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)