Introdução ao F# I/O
O F# IO permite que você leia e grave arquivos, gerencie fluxos de arquivos e interaja com o sistema de arquivos de várias maneiras. Este artigo irá guiá-lo pelos conceitos essenciais e pelo uso do F# IO.
Ao longo desta lição, abordaremos o processo de ler a entrada do console ao trabalhar com o objeto stdin, como ler e gravar arquivos ao trabalhar com o módulo System.IO.File e como formatar e imprimir a saída no console ao usando a função printfn.
Índice-
Módulo Core.Printf
Para escrever no console, usamos uma combinação das funções printf e printfn.
Além dessas funções, o módulo Core.Printf do F# também é equipado com uma variedade de outros métodos que podem ser usados para imprimir e formatar usando espaços reservados, como marcadores %.
Abaixo está uma tabela com uma breve descrição de cada um dos métodos listados:
| Valor | Visão geral |
| bprintf : StringBuilder → BuilderFormat<'T> → 'T | Este método imprime em um objeto StringBuilder. |
| eprintf : TextWriterFormat<'T> → 'T | Este comando imprime a saída formatada para o erro padrão. |
| eprintfn : TextWriterFormat<'T> → 'T | Uma nova linha é adicionada à saída formatada antes de ser impressa no stderr. |
| failwithf : StringFormat<'T,'Resultado> → 'T | Uma exceção é gerada imprimindo o resultado fornecido em um buffer de string e, em seguida, imprimindo-o em um buffer de string. |
| fprintf : TextWriter → TextWriterFormat<'T> → 'T | O texto é impresso em um gravador de texto. |
| fprintfn : TextWriter → TextWriterFormat<'T> → 'T | Uma nova linha é adicionada ao final do texto quando ele é impresso em um gravador de texto. |
| kbprintf : (unidade → 'Resultado) → StringBuilder → BuilderFormat<'T,'Resultado> → 'T | O resultado é gerado da mesma forma que bprintf, mas é chamado pela função especificada. |
| kfprintf : (unidade → 'Resultado) → TextWriter → TextWriterFormat<'T,'Resultado> → 'T | Uma função que gera o resultado chamando a função especificada, semelhante a fprintf. |
| kprintf : (string → 'Resultado) → StringFormat<'T,'Resultado> → 'T | A função é chamada da mesma forma que printf, mas o resultado é gerado pela função especificada. É útil, por exemplo, se o software de impressão forçar uma descarga após a saída ter sido inserida no canal, mas não antes, ou seja, após toda a saída ter sido inserida. |
| ksprintf : (string → 'Resultado) → StringFormat<'T,'Resultado> → 'T | Essa função é semelhante a sprintf, mas gera o resultado chamando a função especificada. |
| printf : TextWriterFormat<'T> → 'T | Stdout é impresso com a saída formatada. |
| printfn : TextWriterFormat<'T> → 'T | Adiciona uma nova linha ao final da saída ao imprimir em stdout com saída formatada. |
| sprintf : StringFormat<'T> → 'T | Esta função gera o conteúdo de um buffer de string interno para uma string de saída e retorna uma string de saída como resultado. |
Especificações de formato
Ao trabalhar com F# IO, é importante especificar os formatos de entrada e saída usando uma especificação de formato que atenda às suas necessidades de programação.
Para indicar que uma string é um espaço reservado para um formato, um marcador % é usado na string.
O marcador de posição de formato é escrito em uma sintaxe específica que inclui um símbolo de porcentagem seguido por um caractere que especifica o tipo de formato.
Por exemplo, %d é usado para formato inteiro, %f é usado para formato de ponto flutuante, %s é usado para formato de string e assim por diante.
Os espaços reservados de formato também podem incluir opções adicionais que definem a largura, o alinhamento e a precisão do valor que está sendo formatado. Por exemplo, %5d especifica que o valor inteiro deve ser formatado com uma largura mínima de 5 caracteres, enquanto %-10s especifica que o valor da string deve ser formatado com uma largura mínima de 10 caracteres e alinhado à esquerda.
Ao usar essas especificações de formato, você pode garantir que seus valores de entrada e saída sejam formatados corretamente de acordo com o formato desejado e os requisitos de exibição.
Sintaxe
%[flags][width][.precision][type]
Os tipos são interpretados da seguinte forma:
| Tipo | Descrição |
| %b | Tenta formatar um bool, que será verdadeiro ou falso. |
| %c | Os caracteres podem ser formatados usando esta função. |
| %s | Uma string pode ser formatada de acordo com seu conteúdo, sem a necessidade de entender nenhum caractere de escape na string. |
| %d, %i | Um formato inteiro decimal é criado formatando qualquer tipo inteiro básico como um inteiro decimal, assinado se for um tipo inteiro básico assinado. |
| %você | Tipos inteiros que não contêm sinais podem ser formatados como inteiros decimais sem sinal para qualquer tipo de inteiro. |
| %x | Nesta função, você pode formatar qualquer tipo inteiro básico usando as letras minúsculas de a a f em um formato hexadecimal sem sinal. |
| %X | Usando letras maiúsculas de A a F, esta função formata qualquer tipo inteiro básico como um inteiro hexadecimal sem sinal. |
| %o | O formatador pega qualquer tipo inteiro básico e o transforma em um tipo inteiro octal sem sinal. |
| %e, %E, %f, %F, %g, %G | Tipos de ponto flutuante (float, float32) são formatados de acordo com um conjunto de padrões para formatos de ponto flutuante definidos por uma linguagem de programação semelhante a C. |
| %e, %E | Existe um formato de valor com sinal que pode ser configurado no formato [-]d.dddde[sinal]ddd que consiste em d como um único dígito decimal, dddd como um ou mais dígitos decimais e ddd como exatamente três dígitos decimais, com sinal = + ou -. |
| %f | A função formata um valor de sinal com o formato [-]dddd.dddd, onde dddd refere-se a um número de dígitos decimais. Dependendo da magnitude do número, o número de dígitos antes da vírgula, bem como o número de dígitos após a vírgula, será determinado pela precisão exigida. |
| %g, %G | O formato no qual um valor com sinal deve ser impresso é f ou e, dependendo da compactação e precisão do valor. |
| %M | Fornece um formato para um valor decimal. |
| %O | Para formatar qualquer valor, o objeto deve estar em uma caixa, e o método ToString é usado para imprimi-lo. |
| %A, %+A | Essa função formata qualquer valor com base nas configurações de layout padrão e imprime o resultado. Para imprimir a estrutura de uniões discriminadas com representações privadas e internas, você pode usar a combinação de teclas %+A. |
| %a | Há dois argumentos que devem ser fornecidos ao especificar um especificador de formato geral. Primeiro, há uma função que recebe dois argumentos: o primeiro é um parâmetro de contexto do tipo apropriado para a função de formatação que está sendo usada (por exemplo, um TextWriter) e o segundo é um valor a ser impresso, que gera ou retorna um sequência apropriada.
No segundo argumento, você pode especificar qual valor deseja imprimir. |
| %t | Há apenas um argumento necessário para um especificador de formato geral; ou seja, uma função que aceita um parâmetro de contexto do tipo apropriado (aTextWriter neste caso) e gera ou retorna o texto apropriado com base nos parâmetros. Um tipo inteiro consiste em um byte, um sbyte, um int16, um uint16, um int32, um uint32, um int64, um uint64, um nativeint e um unativeint. Um número de ponto flutuante pode ser expresso como float ou float32. |
Um parâmetro de largura pode ser usado como um parâmetro opcional.
A largura mínima do resultado é um número inteiro que indica o tamanho do resultado no nível mínimo.
Por exemplo, %5d imprime um inteiro com pelo menos 5 caracteres de espaços entre cada dígito.
Abaixo está uma tabela que descreve os sinalizadores válidos que devem ser definidos:
| Valor | Descrição |
| 0 | A largura do campo deve ser composta por zeros ao invés de espaços, conforme especificado acima. |
| – | Define o resultado para ser justificado à esquerda quando dentro da largura especificada. |
| + | Especifica que o número será acompanhado por um símbolo + se for positivo (para corresponder ao símbolo – para números negativos). |
| ' '(espaço) | Se o número for positivo, um espaço extra deve ser adicionado (para corresponder a um sinal - para números negativos). |
| # | Inválido |
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
printf "mrexamples "
printf "- FSharp"
printfn ""
printfn "mrexamples "
printfn "- FSharp"
printf "Hello, from %s" "mrexamples"
printfn "a: %f" 115.098f
printfn "b: %f" 232.768f
printfn "c: %g" 115.098f
printfn "d: %g" 232.768f
printfn "e: %e" 115.098f
printfn "f: %e" 232.768f
printfn "False: %b" false
mrexamples - FSharp mrexamples - FSharp Hello, from mrexamplesa: 115.098000 b: 232.768000 c: 115.098 d: 232.768 e: 1.150980e+002 f: 2.327680e+002 False: false
Classe de Console F# IO
Há uma classe neste módulo que faz parte do framework .NET.
Para aplicativos de console, representa os fluxos de entrada padrão, fluxos de saída e fluxos de erro usados no programa.
Há uma variedade de métodos que podem ser usados para ler e gravar no console por meio dele.
Abaixo está uma tabela que mostra os diferentes métodos que podem ser usados:
| Métodos | Visão geral |
| Bip() | O alto-falante do console reproduzirá o som de um bipe pelo console. |
| Bipe (Int32, Int32) | Um bipe será reproduzido pelo alto-falante do console em uma frequência especificada e por uma duração especificada toda vez que o botão for pressionado. |
| Claro | O objetivo desta função é limpar o buffer do console, bem como a janela do console correspondente de qualquer informação exibida. |
| MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32) | Esta função copia o buffer de tela de uma área de origem especificada para uma área de destino especificada. |
| MoveBufferArea(Int32, Int32, Int32, Int32, Int32, Int32, Char, ConsoleColor, ConsoleColor) | Esta função copia o buffer de tela de uma área de origem especificada para uma área de destino especificada. |
| OpenStandardError() | O fluxo de erros padrão é adquirido. |
| OpenStandardError(Int32) | Um fluxo de erro padrão, cujo tamanho de buffer é especificado, é adquirido como um fluxo para armazenar os dados de erro padrão. |
| OpenStandardInput() | O fluxo de entrada padrão é adquirido por este método. |
| OpenStandardInput(Int32) | Fornece um fluxo de entrada definido para um tamanho de buffer especificado para receber o fluxo de entrada padrão. |
| OpenStandardOutput() | O fluxo de saída padrão é adquirido por esta função. |
| OpenStandardOutput(Int32) | Um fluxo de saída com um tamanho de buffer especificado é adquirido do fluxo de saída padrão. |
| Ler | No fluxo de entrada padrão, essa função lê o próximo caractere. |
| Chave de leitura() | Fornece ao usuário o próximo caractere que será inserido ou a tecla de função que será pressionada em seguida. Ele é exibido na janela do console quando uma tecla é pressionada. |
| ReadKey(Booleano) | Esta função é responsável por determinar qual caractere ou tecla de função foi pressionada pelo usuário em seguida. Você pode optar por exibir a tecla pressionada na janela do console, se desejar. |
| Leia a linha | A partir do fluxo de entrada padrão, a próxima linha de caracteres será lida. |
| ResetColor | Isso definirá as cores do console de fundo e de primeiro plano para seus valores padrão. |
| SetBufferSize | Define os parâmetros para modificar a altura e a largura da área de buffer da tela especificando os valores desejados. |
| DefinirCursorPosition | A posição do cursor é definida pela posição do cursor. |
| SetError | Especifica o objeto TextWriter a ser usado como a propriedade Error. |
| SetIn | Especifica o objeto TextReader a ser usado como a propriedade In. |
| Estabelecer | Especifica o objeto TextReader a ser usado como a propriedade Out. |
| Definir posição da janela | É usado para definir a posição da janela do console em relação ao buffer na tela. |
| Definir tamanho da janela | Na janela do console, a altura e a largura são definidas com os valores especificados pelo usuário. |
| Escreva (Booleano) | Um fluxo de saída é criado para gravar a representação de texto do valor booliano especificado para o fluxo de saída padrão. |
| Escrever (Car) | O fluxo de saída padrão é gravado com o valor do caractere Unicode especificado como a entrada. |
| Escreva(Char[]) | O fluxo de saída padrão é gravado com a matriz especificada de caracteres Unicode na ordem especificada. |
| Escreva (decimal) | Um fluxo de saída é usado para gravar uma representação de texto do valor decimal especificado como parte do comando. |
| Escreva (Duplo) | O fluxo de saída do dispositivo de saída padrão é gravado com a representação de texto do valor de ponto flutuante de precisão dupla especificado. |
| Escrever(Int32) | O fluxo de saída padrão será gravado com a representação de texto do valor inteiro com sinal de 32 bits apontado pelo argumento. |
| Escreva(Int64) | O fluxo de saída padrão será gravado com a representação de texto do valor inteiro com sinal de 64 bits apontado pelo argumento. |
| Escrever (objeto) | Com o fluxo de saída padrão, o valor inteiro com sinal de 32 bits digitado como argumento será representado como a representação de texto do valor inteiro com sinal de 32 bits. |
| Escreva (Único) | O fluxo de saída padrão é gravado com uma representação de texto do valor de ponto flutuante de precisão única especificado descrito na especificação. |
| Escreva(String) | Essa função gera o valor de string especificado na string de entrada para o fluxo de saída padrão. |
| Escrever (UInt32) | Ele grava o valor inteiro sem sinal de 32 bits especificado no fluxo de entrada como uma representação de texto no fluxo de saída padrão. |
| Escrever (UInt64) | Ele grava o valor inteiro sem sinal de 64 bits especificado no fluxo de entrada como uma representação de texto no fluxo de saída padrão. |
| Write(String, Objeto) | Usando as informações de formato especificadas, o fluxo de saída padrão será preenchido com a representação de texto do objeto especificado. |
| Escreva(String, Objeto[]) | Uma matriz de objetos será gravada no fluxo de saída padrão usando as informações de formato especificadas para criar a representação de texto da matriz. |
| Write(Char[], Int32, Int32) | O fluxo de saída padrão é gravado com a submatriz especificada de caracteres Unicode na ordem especificada. |
| Write(String, Objeto, Objeto) | Com a ajuda das informações de formato especificadas, o fluxo de saída padrão é gravado com a representação de texto dos objetos especificados. |
| Write(String, Objeto, Objeto, Objeto) | Com a ajuda das informações de formato especificadas, o fluxo de saída padrão é gravado com a representação de texto dos objetos especificados. |
| Write(String, Objeto, Objeto, Objeto, Objeto) | Com a ajuda das informações de formato especificadas, o fluxo de saída padrão será usado para escrever a representação de texto dos objetos especificados e a lista de parâmetros de comprimento variável. |
| WriteLine() | Um fluxo de saída padrão é gravado com o terminador de linha atual nele. |
| WriteLine(Booleano) | Para criar um fluxo de saída padrão, o valor booliano especificado é gravado como uma representação de texto, seguido pelo terminador de linha que controla o fluxo atual. |
| WriteLine(Char) | O fluxo de saída padrão é gravado com o caractere Unicode especificado na linha de comando, seguido pelo valor do terminador de linha atual. |
| WriteLine(Char[]) | O fluxo de saída padrão é gravado com uma matriz de caracteres Unicode, seguida pelo terminador de linha atual, para representar a matriz Unicode especificada. |
| WriteLine(Decimal) | Um fluxo de saída no qual os dados são gravados é criado gravando a representação decimal do valor especificado, seguido pelo terminador de linha atual. |
| WriteLine(Duplo) | Um fluxo de saída padrão é criado para a especificação de um valor de ponto flutuante de precisão dupla, seguido por um terminador de linha e a representação de texto desse valor. |
| WriteLine(Int32) | Existe um fluxo de saída padrão que grava a representação de texto do valor inteiro com sinal de 32 bits que foi especificado, seguido pelo terminador de linha no final da linha. |
| WriteLine(Int64) | Há um fluxo de saída padrão que grava a representação de texto do valor inteiro com sinal de 64 bits especificado, seguido pelo terminador de linha no final da linha. |
| WriteLine(objeto) | A representação de texto do objeto especificado é gravada no fluxo de saída padrão no formato de representação de texto, seguido pelo terminador de linha atual. |
| WriteLine(Single) | Ao pressionar o comando de gravação, a representação de texto do valor de ponto flutuante especificado será gravada no fluxo de saída padrão, seguida pelo terminador de linha atual. |
| WriteLine(String) | O valor de string especificado será gravado no fluxo de saída padrão junto com o terminador de linha atual, seguido pelo final da linha atual. |
| WriteLine(UInt32) | Um valor inteiro de 32 bits sem sinal é gravado no fluxo de saída padrão usando a representação de texto junto com o terminador de linha atual, seguido pelo valor exatamente conforme especificado. |
| WriteLine(UInt64) | Um valor inteiro de 64 bits sem sinal é gravado no fluxo de saída padrão usando a representação de texto junto com o terminador de linha atual, seguido pelo valor exatamente conforme especificado. |
| WriteLine(String, Objeto) | Usando as informações de formato especificadas para o fluxo de saída padrão, a representação de texto do objeto especificado será gravada, seguida pelo terminador de linha atual, no fluxo de saída padrão. |
| WriteLine(String, Objeto[]) | A matriz de objeto especificada é gravada na saída padrão usando as informações de formato especificadas, seguidas pelo terminador de linha atual. |
| WriteLine(Char[], Int32, Int32) | Para o fluxo de saída padrão, o subarray Unicode especificado é gravado, seguido pelo terminador de linha atual. |
| WriteLine(String, Objeto, Objeto) | Com a especificação das informações de formato, este programa grava a representação de texto dos objetos especificados no fluxo de saída padrão, seguido pelo terminador de linha atual. |
| WriteLine(String, Objeto, Objeto, Objeto) | Com a especificação das informações de formato, este programa grava a representação de texto dos objetos especificados no fluxo de saída padrão, seguido pelo terminador de linha atual. |
| WriteLine(String, Objeto, Objeto, Objeto, Objeto) | As informações de formato para o fluxo de saída padrão são usadas para gravar a representação de texto dos objetos especificados, seguida por uma lista de parâmetros de comprimento variável, seguida pelo terminador de linha atual, no fluxo de saída padrão. |
No exemplo abaixo, demonstramos como ler e escrever no console ao mesmo tempo:
Example:
1
2
3
4
5
6
7
8
9
10
11
open System
let main() =
Console.Write("What's your name? ")
let name = Console.ReadLine()
Console.Write("Hello, {0}\n", name)
Console.WriteLine(System.String.Format("Greetings from {0}", "mrexamples"))
Console.WriteLine(System.String.Format("|{0:yyyy-MMM-dd}|", System.DateTime.Now))
main()
A saída do programa acima é a seguinte:
What's your name? John Hello, John Greetings from mrexamples |2023-Apr-11|
Coleta e impressão de dados usando classe de console
Veja a seguir um exemplo de como obter dados do usuário e imprimi-los:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
open System
// Function to get user input
let getUserInput() =
Console.WriteLine("Enter your name:")
let name = Console.ReadLine()
Console.WriteLine("Enter your age:")
let age = Console.ReadLine()
Console.WriteLine("Enter your gender:")
let gender = Console.ReadLine()
(name, age, gender)
// Function to display output
let displayOutput (name: string) (age: string) (gender: string)=
printfn "Hello, %s! \nYour age is: %s. \nAnd your gender is: %s" name age gender
// Main function
[<EntryPoint>]
let main argv =
// Get user input
let name, age, gender = getUserInput()
displayOutput name age gender
0
E a saída será como:
Enter your name: John Enter your age: 24 Enter your gender: male Hello, John! Your age is: 24. And your gender is: male.
Exemplo de Explicação:
Escrevemos esse código em F# para fornecer um aplicativo de console simples que aceita a entrada do usuário para nome, idade e sexo e exibe a saída com uma mensagem de saudação.
Começamos com uma instrução aberta para o módulo System, que é usada para acessar o módulo Console para ler a entrada e exibir a saída.
Definimos a função getUserInput() para ler a entrada do usuário para nome, idade e sexo usando a função Console.ReadLine() , que lê uma linha de texto da entrada padrão. Os valores são então armazenados nas variáveis name, age e gender, e uma tupla (name, age, gender) é retornada.
Definimos a função displayOutput() para obter o nome, a idade e o sexo como argumentos de entrada e exibi-los usando a função printfn , que é usada para formatar e exibir a saída no console. Os espaços reservados %s são usados para formatar a string com os valores de nome, idade e sexo.
Na função principal, que é o ponto de entrada do programa indicado pelo atributo [ <EntryPoint> ], chamamos a função getUserInput() para obter a entrada do usuário e, em seguida, chamamos a função displayOutput() com os valores recuperados. Por fim, retornamos 0 , indicando uma execução bem-sucedida do programa.
O namespace System.IO
System.IO é um namespace que contém várias classes úteis para executar operações básicas de entrada/saída no sistema.
Esses tipos ou classes incluem tipos que fornecem suporte básico a arquivos e diretórios, bem como aqueles que permitem leitura e gravação de e para arquivos e fluxos de dados.
As seguintes classes podem ser úteis ao trabalhar com o sistema de arquivos:
- System.IO.File é uma classe usada para criar, anexar e excluir arquivos em um sistema.
- A classe System.IO.Directory é usada para criar, mover e excluir diretórios como parte das operações de todo o sistema.
- A classe System.IO.Path é responsável por realizar operações em strings, que representam caminhos para arquivos.
- A classe System.IO.FileSystemWatcher permite que os usuários acompanhem todas as alterações feitas em um diretório ouvindo-as.
A lista a seguir classes que podem ser úteis para trabalhar com fluxos (sequências de bytes)
- Para ler caracteres de um stream, usamos uma classe chamada System.IO.StreamReader.
- Para gravar caracteres em um fluxo, a classe System.IO.StreamWriter é usada.
- Para criar um fluxo de bytes na memória, você precisa usar a classe System.IO.MemoryStream.
Aqui está uma breve descrição de cada uma das classes que podem ser encontradas no namespace, bem como as próprias classes.
| Aulas | Visão geral |
| Leitor Binário | Os tipos de dados primitivos podem ser lidos em formato binário e codificados de acordo com uma especificação de codificação específica. |
| BinaryWriter | Os tipos primitivos podem ser escritos em binário para um fluxo e as strings podem ser escritas em uma codificação específica. |
| BufferedStream | Essa função adiciona uma camada de buffer no topo de um fluxo para melhorar a eficiência de leituras e gravações. |
| Diretório | Cria, move e enumera diretórios e subdiretórios por meio de métodos estáticos, que podem ser utilizados por qualquer usuário. |
| DirectoryInfo | Cria, move e enumera diretórios e subdiretórios por meio de métodos de instância, que podem ser usados por qualquer usuário. |
| DirectoryNotFoundException | A exceção que é lançada quando uma parte de um arquivo ou diretório não pode ser localizada após uma pesquisa ter sido realizada nele. |
| Drive Info | Fornece a capacidade de acessar informações armazenadas em uma unidade. |
| DriveNotFoundException | Quando você tenta acessar um drive compartilhado ou drive que não está disponível, você recebe uma exceção. |
| EndOfStreamException | Uma tentativa de leitura que ultrapasse o final de um fluxo resultará no lançamento de uma exceção. |
| ErrorEventArgs | FileSystemWatcher.Error é um evento que fornece dados para o erro ocorrido. |
| Arquivo | Essa classe fornece métodos estáticos para criar, copiar, excluir, mover e abrir um único arquivo, bem como auxiliar na criação de objetos associados a um único fluxo de arquivo. |
| FileFormatException | Esta é uma exceção lançada quando o fluxo de dados ou o arquivo de entrada são formatados incorretamente ou não obedecem a uma determinada especificação para o formato do arquivo. |
| Informações do arquivo | O objeto de fluxo de arquivo tem propriedades e métodos de instância que permitem criar, copiar, excluir, mover e abrir arquivos, bem como auxiliar na criação de objetos FileStream no futuro. |
| FileLoadException | Se um assembly gerenciado for encontrado e não puder ser carregado, essa exceção será lançada, juntamente com uma descrição do erro. |
| FileNotFoundException | Para acessar um arquivo que não existe no disco, uma exceção é lançada sempre que é feita uma tentativa de acesso ao arquivo. |
| FileStream | Oferece suporte a leituras e gravações síncronas e assíncronas centralizadas em um arquivo, oferecendo um Stream em torno dele. |
| FileSystemEventArgs | Existem três tipos de eventos que podem ser registrados no diretório: Alterado, Criado e Excluído. |
| FileSystemInfo | Essa classe fornece o objeto FileInfo e o objeto DirectoryInfo como sua classe base. |
| FileSystemWatcher | Quando um diretório ou arquivo dentro de um diretório é alterado, essa classe escuta as alterações no sistema de arquivos e gera um evento quando as alterações são feitas. |
| InternalBufferOverflowException | No caso de um estouro de buffer interno, uma exceção é lançada. |
| InvalidDataException | Se o fluxo de dados estiver em um formato inválido, essa exceção será lançada quando for encontrada. |
| IODescriptionAttribute | Os designers visuais podem usar essa propriedade para definir a descrição que aparecerá ao fazer referência a um evento, extensor ou propriedade. |
| IOException | Uma exceção de erro de E/S é lançada sempre que há um erro nos dados que estão sendo lidos ou gravados. |
| MemoryStream | Essa função cria um fluxo que tem memória como armazenamento de apoio. |
| Caminho | Nesse método, realizamos operações em instâncias de String que contêm informações de caminho relacionadas a arquivos ou diretórios. Há uma natureza de plataforma cruzada para essas operações, o que as torna fáceis de implementar. |
| PathTooLongException | Exceções são lançadas quando o comprimento máximo de um caminho ou nome de arquivo excede o comprimento máximo definido pelo sistema. |
| PipeException | Isso é acionado quando um dos pipes nomeados dentro do aplicativo encontra um erro. |
| RenamedEventArgs | Dados de eventos renomeados são fornecidos neste objeto. |
| Fluxo | Uma sequência de bytes pode ser vista genericamente como uma sequência de bytes. A classe em questão é abstrata por natureza. |
| StreamReader | TextReader é uma biblioteca que implementa um método para ler caracteres de um fluxo de bytes em uma codificação específica baseada nos caracteres. |
| StreamWriter | Cria um TextWriter que pode ser usado para gravar um fluxo de caracteres em uma codificação de sua escolha. A fonte de referência para esse tipo pode ser pesquisada se você estiver interessado em pesquisar o código-fonte do .NET Framework. |
| StringReader | Uma implementação do TextReader é fornecida para ler a partir de uma string. |
| StringWriter | Implementa um TextWriter que permite que as informações sejam gravadas em uma string em um formato textual. StringBuilder é a classe subjacente na qual as informações são armazenadas. |
| Leitor de texto | Atribui ao leitor um grupo de caracteres que podem ser lidos sequencialmente de várias maneiras. |
| TextWriter | Esse tipo de escritor representa alguém capaz de escrever uma série de caracteres sequenciais. A classe é abstrata por natureza. |
| Acessor de memória não gerenciado | Um método que permite que o código gerenciado acesse aleatoriamente blocos de memória na memória não gerenciada . |
| Fluxo de memória não gerenciado | O código gerenciado pode acessar blocos de memória não gerenciados por meio desse método. |
| WindowsRuntimeStorageExtensions | O Windows Runtime consiste em métodos de extensão para as interfaces IStorageFile e IStorageFolder para permitir que os desenvolvedores os usem ao criar aplicativos da Windows Store. |
| WindowsRuntimeStreamExtensions | Essa extensão fornece métodos para converter entre fluxos no Windows Runtime e fluxos no .NET para aplicativos da Windows Store gerenciados por meio da estrutura .NET. |
Aqui está um exemplo de como criar um arquivo chamado test.txt, escrever uma mensagem nele, ler o texto do arquivo e imprimi-lo no console no exemplo a seguir.
Observação : você ficará surpreso ao saber como é necessário pouco código para fazer isso!
Example:
1
2
3
4
5
6
7
open System.IO // Name spaces can be opened just as modules
File.WriteAllText("sample.txt", "Hello Developers,\n Welcome to mrexamples!")
let message = File.ReadAllText("sample.txt")
printfn "%s" message
E a saída será:
Hello Developers, Welcome to mrexamples!
Nós valorizamos o seu feedback.
+1
+1
+1
+1
+1
+1
+1
