Manipulando arquivos texto

[Marcos Guedes]

Segue uma pequena rotina que fiz para ler arquivos texto, espero que seja útil aos colegas:

Código:

/// <sumary>
/// Autor: Marcos Guedes
/// Email: [Você precisa estar registrado e conectado para ver este link.]
/// </sumary>

using System;
using System.IO;
using System.Windows.Forms;

namespace Arquivos
{
    public class ArquivosTXT
    {
        private int quantasLinhas = 0;
        private bool formatoTexto = true;
        private string conteudoArquivo = "";
        private string mensagemErro = "";
        private string caminho = "";

        public bool lerArquivo()
        {
            /**
            * Lê um arquivo texto,
            * retornando valores possíveis para copiar para outro arquivo texto,
            * ou para web.
            */
            if (!this.arquivoExiste())
            {
                this.mensagemErro = "Arquivo não existe!";
                return false;
            }

            // Verifica se a extensão é .txt           
            if (!this.getExtensaoValida(this.caminho))
            {               
                this.mensagemErro = "Formato inválido!";
                return false;
            }

            bool sucesso;

            try
            {
                StreamReader sr = new StreamReader(this.caminho);
                string linha = sr.ReadLine();
                int quantos = 0;
                string conteudo = "";

                // Preenche a variável com os dados do arquivo.
                while (linha != null)
                {
                    conteudo += linha.ToString();
                    linha = sr.ReadLine();

                    quantos += 1;
                    if (this.formatoTexto)
                        conteudo += "\r\n";
                    else
                        conteudo += "<br/>";
                }

                // Fecha o arquivo
                sr.Close();

                this.quantasLinhas = quantos;
                this.conteudoArquivo = conteudo;

                this.mensagemErro = "";
                sucesso = true;
            }
            catch(Exception oErro)
            {
                this.mensagemErro = oErro.Message;
                sucesso = false;
            }
           
            return sucesso;
        }

        public bool escreverArquivo()
        {
            /**
            * Escreve um novo arquivo texto.
            * Utilize o método "setConteudoArquivo()" para definir o
            * conteúdo que será escrito no arquivo.
            * Obs: Se o arquivo já existir, será sobrescrito.
            */

            // Verifica se a extensão é .txt           
            if (Path.GetExtension(this.caminho).ToUpper() != ".TXT")
            {
                this.mensagemErro = "Formato inválido!";
                return false;
            }

            bool sucesso;

            try
            {               
                StreamWriter sw = new StreamWriter(this.caminho);               
                sw.WriteLine(this.conteudoArquivo);                               
                // Fecha o arquivo
                sw.Close();

                this.mensagemErro = "";
                sucesso = true;
            }
            catch (Exception oErro)
            {
                this.mensagemErro = oErro.Message;
                sucesso = false;
            }

            return sucesso;
        }
       
        #region Métodos SET's
        public void setFormatoTexto(bool formatoTexto)
        {
            /**
            * Se for "true" a quebra de linha será "\n".
            * Se for "false" a quebra de linha será "<br/>"
            */
            this.formatoTexto = formatoTexto;
        }

        public void setCaminhoArquivo(string caminho)
        {
            /**
            * Altera/Define o caminho do arquivo o qual será trabalhado.
            */
            this.caminho = caminho;
        }

        public void setConteudoArquivo(string conteudo)
        {
            /**
            * Define o conteúdo do arquivo que será escrito.
            * Obs: Este método deverá ser usado para definir o conteúdo do arquivo
            * antes de se usar o método "escreverArquivoNovo()" e/ou "escreveArquivoVelho()".
            */
            this.conteudoArquivo = conteudo;
        }
        #endregion

        #region Métodos Get's
        public int getQuantasLinhas()
        {
            /**
            * Retorna a quantidade de linhas
            * existente no arquivo selecionado.
            */
            return this.quantasLinhas;
        }

        public string getConteudoArquivo()
        {
            /**
            * Retorna o conteúdo do arquivo lido.
            * Obs: Este método é usado para se obter o conteúdo do arquivo
            * após ter usado o método "lerArquivo()".
            */
            return conteudoArquivo;
        }

        public string getMensagemErro()
        {
            /**
            * Rtorna a última mensagem de erro armazenada.
            * No caso de operações bem sucessididas,
            * o retorno será uma string vazia.
            */
            return this.mensagemErro;
        }
        #endregion

        public bool getExtensaoValida(string caminho)
        {
            // Verifica se a extensão é .txt           
            return (Path.GetExtension(caminho).ToUpper() == ".TXT");
        }
       
        private bool arquivoExiste()
        {
            /**
            * Verifica se um arquivo existe.
            */
            return File.Exists(this.caminho);
        }
    }   
}

Se desejarem, segue um exemplo que fiz utilizando a rotina:
[Você precisa estar registrado e conectado para ver este link.]

No link abaixo está disponível o projeto para quem interessar:
[Você precisa estar registrado e conectado para ver este link.]