Linguagem C#: Trabalhando com arquivos de texto

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (12)  (0)

Veja nesse artigo como trabalhar com arquivos de texto pelo Visual Studio na linguagem C#. Veja como criar, alterar e ler textos em C#.

Arquivos textos são sequências de caracteres que são estruturados por uma sequência de linhas e para saber qual o fim de um arquivo desses, é colocado ao final, sem que o usuário tenha visão disso, uma sequência de caracteres especiais, chamados marcadores fim-de-arquivo.

Quando falamos em arquivo texto, não estamos falando de textos e sim de um tipo de recipiente para texto. Já o texto em si, que são os conteúdos do arquivo texto, chamamos de texto plano. O armazenamento desse tipo de arquivo é bem mais simplificado do que de outros tipos de ficheiros de informação, pois nos arquivos texto, quando existe corrupção de dados, quase sempre é bem mais fácil recuperar o conteúdo e continuar utilizando-o do que em outros tipos de arquivos.

Seu formato geralmente é em ASCII, que permite seu funcionamento em vários tipos de sistemas operacionais. Geralmente, a extensão utilizada em arquivos textos é o formato .txt, que é uma extensão que consiste pouquíssimo tipo de formatação, geralmente sem negrito ou itálico.

Utilização de arquivos textos em softwares

Os arquivos textos são quase sempre muito úteis para programadores, pois existem vários tipos de problemas que podem ser facilmente solucionados com a utilização deles dentro dos códigos de programação dos softwares.

Imagine a seguinte situação: o desenvolvedor cria um software para uma empresa específica e o mesmo precisa que o software gere um recibo de pagamento para os clientes quando pague suas parcelas. Este problema pode ser facilmente resolvido com a utilização de arquivos textos, assim, é possível criar um arquivo texto com o conteúdo deste recibo e sempre que o cliente pagar uma prestação, o desenvolvedor pode alterar apenas alguns dados, com o auxílio de variáveis para atualizar os dados e imprimi-los para este cliente.

A DevMedia atualizou seus cursos de .NET, confira!

Podemos também quadrar informações que precisaremos utilizar no código do software quando formos instalar este em outro computador como, por exemplo, a string de conexão com o banco de dados, que muda de computador para computador. Assim, muda o dado apenas no arquivo texto, sem necessidade de abrir o código para ser alterado, porém, é apenas um exemplo.

Biblioteca IO de arquivos no Visual Studio

A biblioteca de entrada e saída de arquivo é necessária toda vez que formos trabalhar com arquivos externos, como fotos, pastas, arquivos pdf, arquivos txt, entre outros.

Antes de começarmos, é necessário declarar no topo da tela da pagina que esta sendo utilizada no Visual Studio, as bibliotecas que iremos utilizar no sistema que estamos desenvolvendo, as bibliotecas padrões (que sempre são utilizadas) já vem declaradas, neste caso, iremos acrescentar apenas a biblioteca “IO”, que é a biblioteca que precisamos para trabalhar com arquivos texto.

Para declarar essa biblioteca, utilizamos o comando “using System.IO; ” , isso como mostra a Listagem 1.

Listagem 1. Declarando a biblioteca IO.

  //Essas são as bibliotecas padrões, que já veem declaradas.
 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
   
  using System.IO; //declarando a biblioteca de entrada e saída de arquivos
                   //a biblioteca IO
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
          }
      }
  }

Criando um arquivo texto pelo Visual Studio

Podemos utilizar os arquivos textos em todo tipo de aplicação, mas para esse exemplo utilizaremos o Console Application.

Para Trabalharmos com arquivo texto, utilizaremos uma variável do tipo StreamWriter, assim como o tipo int é para utilização de números inteiro e o tipo string é para utilização de cadeia de caracteres, o tipo StreamWriter é um tipo de variável para trabalhar com arquivos externos, como por exemplo criar, abrir e ler, alterar e excluir arquivos externos, como por exemplo, arquivos txt, arquivos pdf, arquivos jpeg, pastas, etc.

Para a criação de um arquivo texto, utilizaremos o método File.CreateText da variável StreamWriter, esse método, pede como parâmetro, uma variável do tipo string ou uma cadeia de caracteres, com o endereço físico de onde será criado o arquivo texto, que é o caminho da pasta na qual deseja cria-lo, mais o nome que você deseja dar para esse arquivo, como mostra a Listagem 2.

Esse comando criará o arquivo texto e automaticamente o abrirá.

Listagem 2. Criando um arquivo texto.

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.IO;
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              //declarando a variavel do tipo StreamWriter para 
             //abrir ou criar um arquivo para escrita 
              StreamWriter x;
   
              //Colocando o caminho fisico e o nome do arquivo a ser criado
             //finalizando com .txt
              string CaminhoNome = "C:\\Users\\AntonioMarlon\\Desktop\\arq01.txt";
   
              //utilizando o método para criar um arquivo texto
              //e associando o caminho e nome ao metodo
              x = File.CreateText(CaminhoNome);
              Console.ReadKey();
          }
      }
  }

Escrevendo no arquivo

Como acabamos de criar e abrir automaticamente o arquivo texto, e não utilizamos o comando para fecha-lo, ele estará aberto para escrita. Para escrever neste arquivo texto, utilizaremos a mesma variável do tipo StreamWriter criada anteriormente, como mostrado na Listagem 2, e utilizaremos o método Write ou WriteLine, que pede como parâmetro, uma cadeia de caracteres, como o conteúdo de deseja escrever no arquivo.

Utilizaremos o método Write para escrever e continuar na mesma linha e o método WriteLine para escrever e passar para a próxima linha.

Para o exemplo, utilizaremos o problema citado acima, no qual devemos criar um recibo de pagamento.

Após escrever a cadeia de caracteres desejada no arquivo texto, devemos fechar este, pois se o mesmo não for fechado, nada que foi escrito será salvo. Para isso, utilizaremos a mesma variável já criada do tipo StreamWriter, e utilizaremos o método Close, conforme o código da Listagem 3.

Na Listagem 3vamos criar e escrever no arquivo texto, e após feito isso, iremos fechar esse arquivo, para que seja salvo o conteúdo escrito nele.

Listagem 3. Criando e já escrevendo no arquivo texto.

using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.IO;
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              ////declarando a variavel do tipo StreamWriter para 
              //abrir ou criar um arquivo para escrita 
              StreamWriter x;
   
              ////Colocando o caminho fisico e o nome do arquivo a ser criado
              //finalizando com .txt
              string CaminhoNome = "C:\\Users\\AntonioMarlon\\Desktop\\arq01.txt";
   
              //utilizando o metodo para criar um arquivo texto
              //e associando o caminho e nome ao metodo
              x = File.CreateText(CaminhoNome);
   
              //aqui, exemplo de escrever no arquivo texto
              //como se fossemos criar um recibo de pagamento
   
              //escrevendo o titulo
              x.WriteLine("Recibo de Pagamanto");
              //pulando linha sem escrita
              x.WriteLine();
              x.WriteLine();
              //escrevendo conteúdo do recibo
              x.WriteLine("Recebi do Sr: Nome do Pagador");
              x.WriteLine("a quantia de VALOR DO RECIBO (VALOR POR EXTENSO),");
              x.WriteLine("referente ao DESCRIÇÃO DO QUE FOI PAGO... ");
              x.WriteLine("CIDADE, DATA");
              x.WriteLine();
              x.WriteLine();
              x.WriteLine("__________________________________________________");
              x.WriteLine("Nome do pagador");
              x.WriteLine("CPF do pagador: CPF");
              x.WriteLine();
   
              //fechando o arquivo texto com o método .Close()
              x.Close();
          }
      }
  } 

Abrir um arquivo texto

Para abrir um arquivo texto já existente e continuarmos escrevendo nele devemos declarar uma variável do tipo StreamWriter e nela utilizarmos a função AppendText, que serve para abrir um arquivo texto e escrever. Além disso, devemos passar como parâmetro o endereço físico deste arquivo.

Feito isso, devemos escrever nele utilizando Write para escrever sem passar para a próxima linha, ou WriteLine para escrever e depois passar para próxima linha.

Para que seja salvo a nova escrita, após escrevermos devemos fechar o arquivo com o método Close, como mostra a Listagem 4.

Listagem 4. Abrindo e continuando escrevendo em um arquivo texto.

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.IO;
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              ////declarando a variável do tipo StreamWriter para 
              //abrir ou criar um arquivo para escrita
              StreamWriter x;
   
              //Colocando o endereço físico (caminho do arquivo texto) 
              string Caminho = "C:\\Users\\AntonioMarlon\\Desktop\\arq01.txt";
   
              //usando o metodo e abrindo o arquivo texto
              x = File.AppendText(Caminho);
   
              //continuando escrevendo neste arquivo
              //escrevendo a partir da ultima linha 
              x.WriteLine();
              x.WriteLine("__________________________________________________");
              x.WriteLine("Recebedor");
              x.WriteLine("CPF do Recebedor: CPF");
   
              x.Close();
          }
      }
  } 

Vejamos na Figura 1, o resultado do arquivo texto criado com os códigos da Listagem 3 e Listagem 4.

Arquivo texto criado e escrito,
feito com os códigos anteriores

Figura 1. Arquivo texto criado e escrito, feito com os códigos anteriores.

Lendo arquivos texto

Para abrir um arquivo texto e ler seu conteúdo, devemos criar uma variável do tipo StreamReader, e nessa variável utilizaremos o método File.OpenText para abrir e passar como parâmetro o endereço físico do arquivo texto. Para ler o conteúdo basta utilizar o método ReadLine da variável criada. Esse método começa da primeira linha, lê e passa para a próxima linha deste arquivo texto. Observe como funciona com a Listagem 5.

Listagem 5. Lendo linha do arquivo texto.

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.IO;
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              //declarando a variável do tipo StreamReader
              //que é a variável usada para abrir um arquivo texto para leitura 
              StreamReader x;
   
              //Colocando o endereço físico (caminho do arquivo texto)
              string Caminho = "C:\\Users\\AntonioMarlon\\Desktop\\arq01.txt";
   
              //abrindo um arquivo texto indicado
              x = File.OpenText(Caminho);
   
              //lendo conteúdo da linha do arquivo texto
              string linha = x.ReadLine();
   
              //escrevendo este conteúdo na tela
              //mais podemos salvar esse conteúdo em uma variável
              //do tipo string, para utilização no nosso código
              Console.WriteLine(linha);
   
              //fecha arquivo texto
              x.Close();
   
              Console.ReadKey();
          }
      }
  }

Como não sabemos quantas linhas tem um arquivo texto precisamos de algo que nos avise quando acabar, e isso é o que o método EndOfStream da variável do tipo StreamReader faz. Este método retorna um valor booleano, no qual retorna “true” caso esteja na última linha deste arquivo. Então criaremos um loop, no qual enquanto o método EndOfStream retornar valor booleano “false”, ele lê o conteúdo da linha, e se ele retornar valor booleano “true”, quer dizer que chegou ao fim do arquivo, então para de ler e saiu do loop criado. Para isso ser feito, utilizaremos a função while passando como parâmetro o método EndOfStream da variável StremReader com o simbolo “!=”, que significa “diferente”, e o valor booleano “true”.

Veja o resultado na Listagem 6.

Listagem 6. Lendo todo conteúdo do arquivo texto.

 using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.IO;
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              //declarando a variavel do tipo StreamWriter 
              StreamReader x;
   
              //Colocando o caminho fisico 
              string Caminho = "C:\\Users\\AntonioMarlon\\Desktop\\arq01.txt";
   
              //abrindo um arquivo texto
              x = File.OpenText(Caminho);
   
                                           //enquanto nao retornar valor booleano true 
              while (x.EndOfStream != true)//quer dizer que não chegou no fim do  
                                           //arquivo
              {
                  //le conteúdo da linha
                  string linha = x.ReadLine();
                  //escreve na tela o conteúdo da linha
                  Console.WriteLine(linha);
              }
              //após sair do while, é porque leu todo o conteúdo, então
              //temos que fechar o arquivo texto que está aberto
              x.Close();
   
              Console.ReadKey();//esse comando é para não fechar a tela do console
                                //fechar so após o usuário clicar em uma tecla do  
                                //teclado
          }
      }
  }

Veja na Figura 2, a tela do console aberta, contendo todos os dados do arquivo texto no qual foi lido e escrito na tela. Isso foi feito através dos códigos mostrado na Listagem 6.

Conteúdo lido de um arquivo texto

Figura 2. Conteúdo lido de um arquivo texto.

Abrindo um arquivo texto em um leitor

Para abrir o arquivo texto em um leitor de texto, como o bloco de notas, para que possamos imprimir, utilizaremos o comando a seguir:

System.Diagnostics.Process.Start(NOME DO LEITOR, CAMINHO DO ARQUIVO)

Veja na Listagem 7 como abrir o arquivo no bloco de notas.

Listagem 7. Abrindo arquivo texto no bloco de notas.

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.IO;
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              //Colocando o endereço físico (caminho do arquivo texto) 
              string Caminho = "C:\\Users\\AntonioMarlon\\Desktop\\arq01.txt";
   
              //Abrindo o arquivo texto em um leitor de texto, no caso, 
              //o bloco de notas(notepad)
   
              System.Diagnostics.Process.Start("notepad", Caminho);
              //feito isso, será aperto o bloco de notas com o conteúdo do 
              //arquivo txt
          }
      }
  }

Deletando um arquivo texto

Para apagar um arquivo texto pelo código de programação na linguagem C#, utilizaremos a rotina File.Delete, passando como parâmetro o endereço físico do arquivo. Veja como funciona na Listagem 8.

Listagem 8. Deletando arquivo texto.

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.IO; //declarando a biblioteca arquivos externos
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              //Colocando o endereço físico (caminho do arquivo texto) 
              string Caminho = "C:\\Users\\AntonioMarlon\\Desktop\\arq01.txt";
   
              //usando o método para deletar o arquivo texto
              //passando como parâmetro o caminho físico do arquivo
              //que deseja apagar
              File.Delete(Caminho);
   
              //o arquivo texto foi deletado
          }
      }
  }

Utilizando um arquivo texto para salvar e ler uma string de conexão

Uma string de conexão, também conhecida como connection string, é uma cadeia de caracteres que o sistema utiliza para se conectar com um banco de dados.

Todo banco de dados possui uma string de conexão própria e, portando, depois de concluído o desenvolvimento de um software, para que ele seja instalado nas máquinas de N clientes, necessitará de N strings de conexão, e isso não é uma boa prática de programação, pois não é bom ter que abrir o código-fonte do software para alterar a string de conexão toda vez que nos formos instalar esse software para um cliente.

Veremos nesse artigo como utilizar um arquivo txt para que não necessitemos abrir o código fonte para a alteração desta string de conexão.

Primeiramente vamos criar um arquivo texto dentro da pasta no do nosso software em desenvolvimento, como mostrado na Figura 3, e nomearemos este arquivo texto como “stringConexao”.

Criando um arquivo texto dentro da pasta do software em
desenvolvimento

Figura 3. Criando um arquivo texto dentro da pasta do software em desenvolvimento.

Neste arquivo texto que criamos vamos escrever dentro dele, na primeira linha, a string de conexão do cliente. Desta forma, toda vez que formos instalar o software para um cliente não precisaremos abrir o código fonte, pois bastará apenas abrir este arquivo txt e escrever a string de conexão, salvar e fechar o arquivo.

O código é o mesmo apresentado na Listagem 9.

Listagem 9. String de conexão na primeira linha do arquivo txt

  Data Source=localhost;Initial Catalog=Loteamento;Integrated Security=true

Agora, dentro do código-fonte, para que seja feito a leitura desta string de conexão, vamos utilizar uma variável do tipo StreamReader com o método File.OpenText para abrir o arquivo texto que contem a string de conexão, e passaremos como parâmetro o endereço físico do arquivo texto criado e mostrado na Figura 3.

Para ler a string de conexão utilizaremos o método ReadLine da variável StreamReader que já foi criada. Feito isso, devemos fechar esse arquivo texto, com o método Close desta variável. Veja tudo isso sendo feito na Listagem 10.

Listagem 10. Abrindo o arquivo texto para ler a string de conexão salva dentro dele.

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.IO;//declarando a biblioteca IO para que seja 
                  //utilizado arquivos externos
                  //no caso o arquivo txt.
   
  namespace Artigo_arquivoTexto
  {
      class Program
      {
          static void Main(string[] args)
          {
              //declarando a variavel do tipo StreamWriter 
              StreamReader x;
   
              //Colocando o caminho fisico + o nome do arquivo criado
    string Caminho = "C:\\Users\\AntonioMarlon\\Desktop\\Artigo ArquivoTexto\\"+
                     "LendoTodoArquivoTexto\\stringConexao.txt";
   
              //abrindo este arquivo texto com o metodo OpenText.
              x = File.OpenText(Caminho);
   
              //lendo a string de conexao e salvando essa string de conexao
              //em uma variavel do tipo string, para ser utilizada no codigo
              string StringdeConexao = x.ReadLine();
              
              //fechando arquivo texto aberto
              x.Close();
   
              Console.ReadKey();
          }
      }
  }

É isso ai pessoal, espero que tenham gostado desse artigo. Até a próxima.


 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?