Diretivas do compilador

Este tópico descreve as diretivas do compilador, para diretivas F# Interativas (dotnet fsi), consulte Programação Interativa com F#.

Uma diretiva do compilador é prefixada com o símbolo #e aparece em uma linha por si só.

A tabela a seguir lista as diretivas do compilador que estão disponíveis em F#.

Directive	Description
#if if-expression	Suporte à compilação condicional. Código na seção após a #if é incluído se a expressão if for avaliada como defined (veja abaixo).
#else	Suporte à compilação condicional. Marca uma seção de código a ser incluída se o símbolo usado com o anterior #if não for avaliado como defined.
#endif	Suporte à compilação condicional. Marca o final de uma seção condicional do código.
#[linha] int, #[linha] intstring, #[linha] intverbatim-string	Indica a linha de código-fonte original e o nome do arquivo, para depuração. Esse recurso é fornecido para ferramentas que geram código-fonte em F#.
#nowarn códigos de aviso	Desabilita um ou mais avisos do compilador conforme especificado por códigos de aviso (veja abaixo).
#warnon códigos de aviso	Habilita um ou mais avisos do compilador conforme especificado por códigos de aviso (veja abaixo).

Diretivas de compilação condicional

O código desativado por uma dessas diretivas aparece esmaecido no Visual Studio Code Editor.

O código a seguir ilustra o uso das diretivas #if, #else e #endif. Neste exemplo, o código contém duas versões da definição de function1. Quando VERSION1 é definido usando a opção -define do compilador, o código entre a diretiva #if e a diretiva #else é ativado. Caso contrário, o código entre #else e #endif é ativado.

#if VERSION1
let function1 x y =
   printfn "x: %d y: %d" x y
   x + 2 * y
#else
let function1 x y =
   printfn "x: %d y: %d" x y
   x - 2*y
#endif

let result = function1 10 20

A #if diretiva também aceita expressões lógicas:

#if SILVERLIGHT || COMPILED && (NETCOREFX || !DEBUG)
#endif

As expressões a seguir podem ser usadas.

if-expr	avaliação
if-expr1 \|\| if-expr2	defined se if-expr1 ou if-expr2 estiver defined.
if-expr1 && if-expr2	defined se if-expr1 e if-expr2 são defined.
!if-expr1	defined se if-expr1 não for defined.
( if-expr1 )	definido se if-expr1 for definido.
symbol	defined se estiver marcado como definido pela opção de compilador -define.

Os operadores lógicos têm a precedência lógica usual.

Não há nenhuma #define diretiva do compilador em F#. Você deve usar a opção do compilador ou as configurações do projeto para definir os símbolos usados pela diretiva #if.

As diretivas de compilação condicional podem ser aninhadas. O recuo não é significativo para diretivas do compilador.

Símbolos predefinidos

O compilador F# e o sistema de build definem automaticamente vários símbolos que podem ser usados para compilação condicional.

Símbolos de configuração de build

Os seguintes símbolos são definidos com base na configuração de build:

• DEBUG: definido ao compilar no modo de depuração. No sistema de projetos, o DEBUG símbolo é definido automaticamente na configuração de Depuração, mas não na configuração de versão. Esse símbolo é comumente usado com declarações e código de diagnóstico. Para obter mais informações, consulte Asserções.
• TRACE: definido para builds que habilitam o rastreamento. Por exemplo DEBUG, esse símbolo normalmente é definido em configurações de Depuração, mas também pode ser habilitado nas configurações de versão.

Você pode substituir esses valores usando a opção do compilador ou as-define configurações do projeto.

Símbolos do modo de compilação

Os seguintes símbolos distinguem entre diferentes modos de compilação:

• COMPILED: definido ao compilar código com o compilador F#. Esse símbolo é útil quando você precisa de código para se comportar de forma diferente em assemblies compilados versus sessões interativas F#.
• INTERACTIVE: definido ao compilar ou executar código em F# Interativo (dotnet fsi), incluindo sessões interativas e execução de script. Isso permite que você escreva um código que funcione de forma diferente ao executar interativamente.

Para obter mais informações sobre como usar esses símbolos em scripts, consulte Programação Interativa com F#.

Exemplo:

#if INTERACTIVE
// Code specific to F# Interactive
#r "nuget: Newtonsoft.Json"
#endif

#if COMPILED
// Code specific to compiled assemblies
open System.Configuration
#endif

Símbolos da estrutura de destino

O sistema de build também define símbolos de pré-processador para estruturas de destino diferentes em projetos no estilo SDK. Esses símbolos são úteis ao criar bibliotecas ou aplicativos destinados a várias versões do .NET.

Frameworks de destino	Símbolos	Símbolos adicionais (disponível em SDKs do .NET 5+)	Símbolos de plataforma (disponíveis somente quando você especifica um TFM específico do sistema operacional)
.NET Framework	NETFRAMEWORK, NET481, NET48, NET472, , NET471, NET47, , NET462, NET461, NET46, NET452, , NET451, NET45, NET40, , NET35NET20	NET48_OR_GREATER, NET472_OR_GREATER, NET471_OR_GREATER, NET47_OR_GREATER, , NET462_OR_GREATER, NET461_OR_GREATER, , NET46_OR_GREATER, NET452_OR_GREATER, NET451_OR_GREATER, NET45_OR_GREATER, , NET40_OR_GREATER, , NET35_OR_GREATERNET20_OR_GREATER
.NET Standard	NETSTANDARD, NETSTANDARD2_1, NETSTANDARD2_0, NETSTANDARD1_6, NETSTANDARD1_5, , NETSTANDARD1_4, NETSTANDARD1_3, , NETSTANDARD1_2, NETSTANDARD1_1, NETSTANDARD1_0	NETSTANDARD2_1_OR_GREATER, NETSTANDARD2_0_OR_GREATER, NETSTANDARD1_6_OR_GREATER, NETSTANDARD1_5_OR_GREATER, , NETSTANDARD1_4_OR_GREATER, NETSTANDARD1_3_OR_GREATER, NETSTANDARD1_2_OR_GREATER, , NETSTANDARD1_1_OR_GREATERNETSTANDARD1_0_OR_GREATER
.NET 5+ (e .NET Core)	NET, NET10_0, NET9_0, NET8_0, , NET7_0, NET6_0, , NET5_0, NETCOREAPP, NETCOREAPP3_1, NETCOREAPP3_0, , NETCOREAPP2_2, NETCOREAPP2_1, NETCOREAPP2_0, , NETCOREAPP1_1NETCOREAPP1_0	NET10_0_OR_GREATER, NET9_0_OR_GREATER, NET8_0_OR_GREATER, NET7_0_OR_GREATER, , NET6_0_OR_GREATER, NET5_0_OR_GREATER, , NETCOREAPP3_1_OR_GREATER, NETCOREAPP3_0_OR_GREATER, NETCOREAPP2_2_OR_GREATER, NETCOREAPP2_1_OR_GREATER, , NETCOREAPP2_0_OR_GREATER, , NETCOREAPP1_1_OR_GREATERNETCOREAPP1_0_OR_GREATER	ANDROID, BROWSER, IOS, MACCATALYST, , MACOS, TVOS, , WINDOWS [OS][version] (por exemplo, IOS15_1), [OS][version]_OR_GREATER (por exemplo, IOS15_1_OR_GREATER)

Observação

• Os símbolos sem versão são definidos independentemente da versão que você está visando.
• Os símbolos específicos à versão são definidos apenas para a versão que você está direcionando.
• Os símbolos <framework>_OR_GREATER são definidos para a versão que você está almejando e para todas as versões anteriores. Por exemplo, se você estiver direcionando .NET Framework 2.0, os seguintes símbolos serão definidos: NET20, NET20_OR_GREATER, NET11_OR_GREATER e NET10_OR_GREATER.
• Os símbolos NETSTANDARD<x>_<y>_OR_GREATER são definidos apenas para destinos .NET Standard, e não para destinos que implementam o .NET Standard, como o .NET Core e o .NET Framework.
• Eles são diferentes dos TFMs (Moniker da Estrutura de Destino) usados pela propriedade MSBuild TargetFramework e pelo NuGet.

Por exemplo, você pode usar esses símbolos para compilar condicionalmente o código com base na estrutura de destino:

#if NET6_0_OR_GREATER
// Use .NET 6+ specific APIs
#else
// Use alternative implementation for older frameworks
#endif

Diretiva NULLABLE

A partir do F# 9, você pode habilitar tipos de referência anuláveis no projeto:

<Nullable>enable</Nullable>

Isso define automaticamente a diretiva NULLABLE para o build. É útil, ao distribuir inicialmente o recurso, alterar condicionalmente o código conflitante por meio de diretivas de hash #if NULLABLE.

#if NULLABLE 
let length (arg: 'T when 'T: not null) =
    Seq.length arg
#else
let length arg =
    match arg with
    | null -> -1
    | s -> Seq.length s
#endif

Diretivas de linha

Ao compilar, o compilador relata erros no código F# referenciando os números de linha em que cada erro ocorre. Esses números de linha começam em 1 para a primeira linha em um arquivo. No entanto, se você estiver gerando código-fonte F# de outra ferramenta, os números de linha no código gerado geralmente não são de interesse, porque os erros no código F# gerado provavelmente surgem de outra fonte. A diretiva #line fornece uma maneira para os autores de ferramentas que geram código-fonte F# passarem informações sobre os números de linha originais e os arquivos-fonte para o código F# gerado.

Ao usar a diretiva #line, os nomes dos arquivos devem ser colocados entre aspas. A menos que o token literal (@) apareça na frente da cadeia de caracteres, você deve escapar caracteres de barra invertida usando dois caracteres de barra invertida em vez de um para usá-los no caminho. A seguir estão os tokens de linha válidos. Nestes exemplos, suponha que o arquivo original Script1 resulte em um arquivo de código F# gerado automaticamente quando executado por meio de uma ferramenta e que o código no local dessas diretivas seja gerado a partir de alguns tokens na linha 25 do arquivo Script1.

# 25
#line 25
#line 25 "C:\\Projects\\MyProject\\MyProject\\Script1"
#line 25 @"C:\Projects\MyProject\MyProject\Script1"
# 25 @"C:\Projects\MyProject\MyProject\Script1"

Esses tokens indicam que o código F# gerado neste local é derivado de algumas construções na ou próximo à linha 25 em Script1.

Note que #line diretivas não influenciam o comportamento de#nowarn / #warnon. Essas duas diretivas sempre relacionam o arquivo que está sendo compilado.

Diretrizes de aviso

Diretivas 'warn' desabilitam ou habilitam avisos de compilador especificados para partes de um arquivo fonte.

Uma diretiva de aviso é uma única linha de código-fonte que consiste em

• Espaço em branco opcional no início
• A cadeia de caracteres #nowarn ou #warnon
• Whitespace
• Um ou mais códigos de aviso (veja abaixo), separados por espaço em branco
• Espaço em branco opcional
• Comentário de linha opcional

Um código de aviso é uma sequência de dígitos (representando o número de aviso), opcionalmente precedido por FS, opcionalmente, cercado por aspas duplas.

Uma diretiva #nowarn desabilita um aviso até que uma diretiva #warnon para o mesmo número de aviso seja encontrada, ou até o fim do arquivo. Da mesma forma, uma #nowarn diretiva desabilita um aviso até que uma #warnon diretiva para o mesmo número de aviso seja encontrada ou até o final do arquivo. Antes e depois desses pares, o padrão de compilação se aplica, que é

• nenhum aviso se desabilitado por uma opção do compilador --nowarn (ou a respectiva propriedade msbuild)
• nenhum aviso para avisos de aceitação, a menos que seja habilitado pela opção do compilador --warnon (ou a respectiva propriedade msbuild)

Aqui está um exemplo (artificial).

module A
match None with None -> ()     // warning
let x =
    #nowarn 25
    match None with None -> 1  // no warning
    #warnon FS25
match None with None -> ()     // warning
#nowarn "FS25" FS007 "42"
match None with None -> ()     // no warning

Consulte também

• Referência da Linguagem F#
• Opções do compilador