Tipos de valor anulável

Um tipoNullable<'T> de valor anulável representa qualquer tipo struct que também pode ser null. Isso é útil ao interagir com bibliotecas e componentes que podem optar por representar esses tipos de tipos, como inteiros, com um null valor por motivos de eficiência. O tipo subjacente que apoia essa construção é System.Nullable<T>.

Sintaxe

Nullable<'T>
Nullable value

Declarar e atribuir com valores

Declarar um tipo de valor anulável é como declarar qualquer tipo semelhante a um wrapper em F#:

open System

let x = 12
let nullableX = Nullable<int> x

Você também pode elidir o parâmetro de tipo genérico e permitir a inferência de tipo para resolvê-lo:

open System

let x = 12
let nullableX = Nullable x

Para atribuir a um tipo de valor anulável, você também precisará ser explícito. Não há conversão implícita para tipos de valor anulável definidos por F#:

open System

let mutable x = Nullable 12
x <- Nullable 13

Atribuir nulo

Não é possível atribuir null diretamente a um tipo de valor anulável. Utilize Nullable() em vez disso:

let mutable a = Nullable 42
a <- Nullable()

Isto porque Nullable<'T> não tem null como valor próprio.

Passar e atribuir aos membros

Uma diferença fundamental entre trabalhar com membros e valores F# é que os tipos de valor nulo podem ser inferidos implicitamente quando você está trabalhando com membros. Considere o seguinte método que usa um tipo de valor anulável como entrada:

type C() =
    member _.M(x: Nullable<int>) = x.HasValue
    member val NVT = Nullable 12 with get, set

let c = C()
c.M(12)
c.NVT <- 12

No exemplo anterior, você pode passar 12 para o método M. Você também pode atribuir 12 à propriedade NVTauto . Se a entrada puder ser construída como um tipo de valor anulável e corresponder ao tipo de destino, o compilador F# converterá implicitamente tais chamadas ou atribuições.

Examinar uma instância de tipo de valor nulo

Ao contrário de Options, que são uma construção generalizada para representar um valor possível, os tipos de valor anulável não são usados com correspondência de padrões. Em vez disso, você precisa usar uma if expressão e verificar a HasValue propriedade.

Para obter o valor subjacente, use a Value propriedade após uma HasValue verificação, da seguinte forma:

open System

let a = Nullable 42

if a.HasValue then
    printfn $"{a} is {a.Value}"
else
    printfn $"{a} has no value."

Operadores anuláveis

Operações em tipos de valores anuláveis, como aritmética ou comparação, podem exigir o uso de operadores anuláveis.

Você pode converter de um tipo de valor nulo para outro usando operadores de conversão do FSharp.Linq namespace:

open System
open FSharp.Linq

let nullableInt = Nullable 10
let nullableFloat = Nullable.float nullableInt

Você também pode usar um operador não anulável apropriado para converter em um tipo primitivo, arriscando uma exceção se ela não tiver valor:

open System
open FSharp.Linq

let nullableFloat = Nullable 10.0
let standardFloat = float nullableFloat

printfn $"value is %f{float standardFloat}"

Você também pode usar operadores anuláveis como uma abreviação para verificar HasValue e Value:

open System
open FSharp.Linq

let nullableInt = Nullable 10
let nullableFloat = Nullable.float nullableInt

let isBigger = nullableFloat ?> 1.0
let isBiggerLongForm = nullableFloat.HasValue && nullableFloat.Value > 1.0

A ?> comparação verifica se o lado esquerdo é anulável e só é bem-sucedida se tiver um valor. É equivalente à linha que se lhe segue.

Consulte também

  • Last updated on