Linguagem C#: Trabalhando com arquivos de texto

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.


//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)
        {
        }
    }
}

Listagem 1. Declarando a biblioteca IO

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�.


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();
        }
    }
}

Listagem 2. Criando um arquivo texto

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 3 vamos criar e escrever no arquivo texto, e ap�s feito isso, iremos fechar esse arquivo, para que seja salvo o conte�do escrito nele.


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();
        }
    }
}

Listagem 3. Criando e j� escrevendo no arquivo texto

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.


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();
        }
    }
}

Listagem 4. Abrindo e continuando escrevendo em um arquivo texto

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

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.


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();
    }
}
}

Listagem 5. Lendo linha do arquivo texto

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.


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
      }
  }
}

Listagem 6. Lendo todo conte�do do arquivo texto

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.

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.


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
      }
  }
}

Listagem 7. Abrindo arquivo texto no bloco de notas

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.


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
        }
    }
}

Listagem 8. Deletando arquivo texto

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�.

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.


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

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

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.


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();
        }
    }
}

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

� isso ai pessoal, espero que tenham gostado desse artigo. At� a pr�xima.