Finalmente chegamos na parte conclusiva desta série de artigos. Iremos construir uma aplicação que irá gravar/ler um arquivo EDI. Estarei no artigo comentando o arquivo exemplo, portanto, façam o download do arquivo em anexo à este post!

Para o exemplo, na época do artigo original utilizei a IDE Sharp Develop versão 2.2, com o .NET Framework versão 2.0.

Mas antes, uma ressalva sobre o código do artigo anterior:

Caso vocês tenham notado, após o comando LoadFromFile o arquivo não é carregado, a quantidade de linhas da propriedade Count de Lines é 0. Mas por que isso?

Se olharmos na classe base, TEDIFile, o método LoadFromFile (ou LoadFromStream) faz chamada ao método virtual DecodeLine, que recebe como parâmetro uma string, que
é a linha a ser decodificada, vinda do arquivo.

Como na implementação do método não temos nenhum código, a aplicação somente irá passar por ele e não fará nenhuma ação; o método LoadFromFile simplesmente fará um looping
no arquivo texto carregado.

Como solucionar?

A classe TEDIFile apresenta comportamento genérico. Um arquivo poderá ter diferentes tipos de registro, que podem ter layouts diferentes entre si, por exemplo, um header, linhas detalhe e um registro trailler. Isto é específico de cada arquivo. Para ser mais específico, a classe deveria ser mais especializada, não é? Mas embora seja especializada, tenha o comportamento da TEDIFile.

Para tal especialização, iremos criar uma classe derivada de TEDIFile e iremos sobreescrever o método DecodeLine para adicionar os objetos à representação do nosso arquivo EDI em memória:

    public class TMeuArquivo : TEDIFile
    {
        public override void DecodeLine(string Line)
        {
            this.Lines.Add(new TRegistroEDI());
            this.Lines[Lines.Count - 1].LinhaRegistro := Line;
            this.Lines[Lines.Count - 1].DecodificarLinha();
        }
    }

Pronto, problema resolvido!

Agora, caso você tenha mais de um tipo de layout no arquivo, primeiro verifique em cada linha se há um campo para identificar o tipo de registro.

Com isso, você poderá fazer o controle através do parâmetro Line da instrução DecodeLine.

Supomos que temos três tipos de layouts (TMeuHeader,TMeuDetalhe e TMeuTrailler) e que temos um campo na posição 1 de cada linha que indica o tipo de registro, sendo H,D e T para Header, Detalhe e Trailler respectivamente. O código ficará assim:

    public override void DecodeLine(string Line)
    {
        if(Lines.Substring(0,1).Equals("H"))
        {
            this.Lines.Add(new TMeuHeader());
        }
        if(Lines.Substring(0,1).Equals("D"))
        {
            this.Lines.Add(new TMeuDetalhe());
       }
       if(Lines.Substring(0,1).Equals("T"))
       {
           this.Lines.Add(new TMeuTrailler());
       }
       this.Lines[Lines.Count - 1].LinhaRegistro := Line;
       this.Lines[Lines.Count - 1].DecodificarLinha();
   }

Como os três tipos de registros possuem comportamento semelhante, já que são herdados de TRegistroEDI e a propriedade Lines é uma coleção deste tipo de registro, a chamada ao método DecodificarLinha() é a chamada da classe correspondente.

Programa Exemplo do Artigo

Sim, notei que a explicação acima está um pouco adiantada, mas ela se fez necessária. Se não entendeu bulhufas, agora vamos à explicação do programa passo a passo!

No projeto ArquivosEDI, há um arquivo de classes chamado TArtigoEDI.cs que contém as classes especializadas. É ele que iremos explicar. No projeto também há um formulário básico, criado apenas para demonstração sem se preocupar com validações e coisas do gênero, o "framework" para criação de arquivos EDI composto pelos arquivos EDIBasicTypes.cs e EDIFile.cs.

No formulário, há um DataTable que utilizo para guardar os registros que serão necessários para guardar e receber o arquivo. O código dos botões de navegação são básicos: é incrementada uma variável de controle que indica a linha da tabela; na seleção do registro, atribuo cada campo da tabela em uma caixa de texto. O botão Inserir é análogo. O botão Novo simplesmente deixa as caixas de texto em branco.

O botão Codificar Linha pega os registros das caixas de texto e faz a formatação conforme o layout indicado no primeiro artigo e coloca o resultado na caixa de texto indicada pelo label LinhaFormatada. O botão Decodificar Linha, pega o conteúdo da caixa LinhaFormatada e joga em cada campo.

O botão Carregar Arquivo carrega o arquivo indicado na caixa de texto Nome do Arquivo e carrega o nosso DataTable; o botão Salvar Arquivo varre o DataTable e salva-o em um arquivo Texto com o nosso layout.

Observem o código:

    public class TRegistroArtigoEDICS : TRegistroEDI
    {
        #region Variáveis Privadas
         private string _Nome = "";
         private DateTime _DataNascimento = DateTime.MinValue;
         private string _TipoPessoa = "";
         private long _Documento = 0;
         private Double _SaldoAtual = 0;
        #endregion
      
       #region Propriedades (Públicas)
        public string Nome
        {
            get{return _Nome;}
            set{_Nome = value;}
        }
        public DateTime DataNascimento
        {
            get{return _DataNascimento;}
            set{_DataNascimento = value;}
        }
        public string TipoPessoa
        {
            get{return _TipoPessoa;}
            set{_TipoPessoa = value;}
        }
        public long Documento
        {
            get{return _Documento;}
            set{_Documento = value;}
        }
        public Double SaldoAtual
        {
            get{return _SaldoAtual;}
            set{_SaldoAtual = value;}
        }
       #endregion
      
      
       public TRegistroArtigoEDICS()
       {
           this._CamposEDI.Add(new TCampoRegistroEDI(TTiposDadoEDI.ediAlpha,40,0,"",null,null,1));
           this._CamposEDI.Add(new TCampoRegistroEDI(TTiposDadoEDI.ediDataDDMMAAAA,8,0,DateTime.MinValue,null,null,41));
           this._CamposEDI.Add(new TCampoRegistroEDI(TTiposDadoEDI.ediAlpha,1,0,"",null,null,49));
           this._CamposEDI.Add(new TCampoRegistroEDI(TTiposDadoEDI.ediInteiro,20,0,0,null,null,50));
           this._CamposEDI.Add(new TCampoRegistroEDI(TTiposDadoEDI.ediNumericoSemSeparador,12,2,0,null,null,70));
       }
      
       public override void CodificarLinha()
       {
           this._CamposEDI[0].ValorNatural = this._Nome;
           this._CamposEDI[1].ValorNatural = this._DataNascimento;
           this._CamposEDI[2].ValorNatural = this._TipoPessoa;
           this._CamposEDI[3].ValorNatural = this._Documento;
           this._CamposEDI[4].ValorNatural = this._SaldoAtual;
           base.CodificarLinha();
       }
      
       public override void DecodificarLinha()
       {
           base.DecodificarLinha();
           this._Nome = (string)this._CamposEDI[0].ValorNatural;
           this._DataNascimento = (DateTime)this._CamposEDI[1].ValorNatural;
           this._TipoPessoa = (string)this._CamposEDI[2].ValorNatural;
           this._Documento = (long)this._CamposEDI[3].ValorNatural;
           this._SaldoAtual = (double)this._CamposEDI[4].ValorNatural;
       }
   }
    
    
   public class TArquivoArtigoEDI : TEDIFile
   {
       protected override void DecodeLine(string Line)
       {
           base.DecodeLine(Line);
           Lines.Add(new TRegistroArtigoEDICS());
           Lines[Lines.Count - 1].LinhaRegistro = Line;
           Lines[Lines.Count - 1].DecodificarLinha();
       }
   }

Acima temos a definição das duas classes "principais" deste artigo.

Implementamos o nosso layout através de uma classe derivada de TRegistroEDI chamada TRegistroArtigoEDICS, onde criamos e inicializamos as variáveis privadas (e as propriedades que as expõe) correspondentes aos campos do registro. Portanto, este objeto representa cada linha do arquivo EDI.

O layout em si é definido no construtor de TRegistroArtigoEDICS, onde adicionamos em _CamposEDI os objetos do tipo TCampoRegistroEDI com a definição dos itens básicos do layout, lembra (tipo de dado, tamanho, posição inicial...)? Note que eu declarei os campos conforme eles aparecem no layout. Se quiser, pode acrescentar um comentário em cada linha de declaração de campo, para lembrar o nome dele. É importante também lembrar-se da ordem, já que iremos acessá-los através do índice (começando em zero).

Para gerar a linha formatada deste registro, sobreescrevemos o método CodificarLinha. Nele, eu atribuo cada propriedade em cada campo adicionado, campos estes que estarão dentro da coleção _CamposEDI e é acessado através do índice deste. Atribuimos a propriedade da classe na propriedade ValorNatural de cada campo. Após feita as atribuições, chamamos o método CodificarLinha() da classe pai que é o responsável pela formatação propriamente dita. O resultado formatado será acessado através da propriedade LinhaRegistro da nossa classe TRegistroArtigoEDICS.

Analogamente, temos a sobreescrita do método DecodificarLinha(): Primeiro, no nosso programa, setamos a propriedade LinhaRegistro com uma linha formatada (isto é feito na classe do arquivo, que veremos adiante), após isso, já dentro do método DecodificarLinha() é chamado o método da classe pai, que será o responsável por separar cada substring de LinhaRegistro e separar em campos com o tipo de dado definido no layout em _CamposEDI.

Feita a conversão, atribuimos nas propriedades de TRegistroArtigoEDICS os valores dos campos em _CamposEDI correspondentes, acessados através da propriedade ValorNatural do mesmo.

Como ValorNatural é do tipo object, e a conversão para outros tipos de dado não é explícita como o inverso ( = atribuir qualquer tipo de dado em uma variável object ) é necessário fazer um cast para o tipo adequado na propriedade. Um cuidado a se tomar é com valores nulos ou que não podem ser convertidos facilmente, como DateTime (já tive muuuuuito trabalho com esse tipo de dado...).

Definida a classe de cada registro, vamos definir uma classe que será responsável pelo salvamento/carregamento do arquivo texto em si. Esta classe é derivada de TEDIFile, que contém os métodos adequados) e chamaremos-a de TArquivoArtigoEDI.

De modo geral, somente o método DecodeLine precisa ser sobreescrito. Os métodos LoadFromFile, LoadFromStream e SaveToFile trabalham com a linha já codificada de cada registro.

O método DecodeLine, chamado nas funções de carga (LoadFromFile e LoadFromStream) é o responsável por adicionar efetivamente um registro vindo do arquivo texto na coleção Lines.

Neste método, adicionamos na coleção Lines um objeto do tipo do layout. No nosso exemplo, como temos somente um tipo de registro, adicionaremos um objeto do tipo TRegistroArtigoEDICS. Caso o seu arquivo tenha vários tipos de registros (e várias tipos de layout, claro) devemos fazer uma verificação que pergunta "Qual é o tipo de registro correspondente a esta linha?" ANTES de adicionar o objeto.

Como o método DecodeLine recebe a linha a ser decodificada como parâmetro, essa verificação geralmente é feita através de uma substring. Na nota no início do artigo tem um ponto explicando isso!

Feita a adição do objeto na coleção Lines, atribuimos o parâmetro Line (a linha a ser decodificada) neste objeto que acabamos de adicionar. Em seguida, chamamos o método DecodificarLinha() e a adição da linha está completa.

No nosso formulário... Agora, veja o código dos botões de salvamento e carga do arquivo do form da nossa aplicação:

    void BtnGravaArqClick(object sender, EventArgs e)
    {
        TArquivoArtigoEDI arq = new TArquivoArtigoEDI();
        foreach(DataRow r in tab.Rows)
        {
            TRegistroArtigoEDICS reg = new TRegistroArtigoEDICS();
            reg.Nome = r[0].ToString();
            reg.DataNascimento = (DateTime)r[2];
           reg.TipoPessoa = r[1].ToString();
           reg.Documento = (long)r[3];
           reg.SaldoAtual = (double)r[4];
           arq.Lines.Add(reg);
       }
       arq.SaveToFile(@tbxArq.Text);
   }
    
   void BtnCarregarArqClick(object sender, EventArgs e)
   {
       TArquivoArtigoEDI arq = new TArquivoArtigoEDI();
       tab.Rows.Clear();
       arq.LoadFromFile(@tbxArq.Text);
       foreach(TRegistroArtigoEDICS reg in arq.Lines)
       {
           DataRow linha = tab.NewRow();
           linha["NOME"] = reg.Nome;
           linha["TP_PESSOA"] = reg.TipoPessoa;
           linha["DT_NASC"] = reg.DataNascimento;
           linha["DOCTO"] = reg.Documento;
           linha["SALDO"] = reg.SaldoAtual;
           tab.Rows.Add(linha);
       }
       BtPrimeiroClick(null,null);
   }

No programa, guardamos em um DataTable os registros adicionados através do formulário.

Para exportar este DataTable para texto, criamos uma instância de TArquivoArtigoEDI (variável arq), varremos as linhas do DataTable. Dentro do foreach criamos uma instância de TRegistroArquivoEDICS (variável reg) que será cada linha do arquivo. Atribuimos cada coluna da linha do DataTable nas propriedades correspondentes de reg e no final adicionamos-a em arq. Terminando a iteração, chamamos o método SaveToFile() de arq para gravar o arquivo no disco.

Na importação do arquivo, o processo é o seguinte: Criamos a instância da classe do arquivo (variável arq) e limpamos o DataTable. Fazemos uma iteração percorrendo cada item da propriedade Lines da variável arq. Dentro da iteração, é criado um DataRow no esquema de tab (o nosso DataTable) e adicionamos em cada coluna desta linha as propriedades correspondentes de reg. Por fim, adicionamos o DataRow ao nosso DataTable. Concluído o processo de carga, apenas chamamos o método para ir para o primeiro registro.

Ufa! Finalmente acabou. Com isto é possível implementar rapidamente um gerador/leitor de arquivos EDI, muito utilizados no nosso dia-a-dia (vide Associação Comercial e outras entidades de proteção ao crédito, bancos, seguradoras, etc).

Exemplo de projeto com Arquivo EDI (61,8 KiB)

Um abraço a todos! :-)