Meus queridos, essa é a segunda parte desta série de artigos explicando como é possível aplicar POO em arquivos do tipo fixo-blocado :-)

No artigo anterior, vimos que o elemento base deste tipo de arquivo é a definição de cada campo de um registro, definição esta que inclui o tipo de dado, a máscara, a quantidade de posições, a posição inicial na linha entre outros.

Uma linha de um arquivo, é uma coleção destes campos, ou seja, deve haver um atributo que indique os campos pertencentes à linha.

Vamos criar então uma classe que represente cada linha do arquivo, chamaremos-a com o nome sugestivo de TRegistroEDI

   1: public class TRegistroEDI

   2: {

   3:     protected TTipoRegistroEDI _TipoRegistro;

   4:     protected int _TamanhoMaximo = 0;

   5:     protected char _CaracterPreenchimento = ' ';

   6:     private string _LinhaRegistro;

   7:     protected List<TCampoRegistroEDI> _CamposEDI = new List<TCampoRegistroEDI>();

   8:  

   9:     public virtual void CodificarLinha()

  10:     {

  11:         this._LinhaRegistro = "";

  12:         foreach (TCampoRegistroEDI campos in this._CamposEDI)

  13:         {

  14:             campos.CodificarNaturalParaEDI();

  15:             this._LinhaRegistro += campos.ValorFormatado;

  16:         }

  17:     }

  18:  

  19:     public virtual void DecodificarLinha()

  20:     {

  21:         foreach (TCampoRegistroEDI campos in this._CamposEDI)

  22:         {

  23:             if (this._TamanhoMaximo > 0)

  24:             {

  25:                 this._LinhaRegistro = this._LinhaRegistro.PadRight(this._TamanhoMaximo, this._CaracterPreenchimento);

  26:             }

  27:             campos.ValorFormatado = this._LinhaRegistro.Substring(campos.PosicaoInicial, campos.TamanhoCampo);

  28:             campos.DecodificarEDIParaNatural();

  29:         }

  30:     }

  31: }

Acima, declaramos resumidamente a classe que compõe cada linha do registro em um arquivo. Note que eu omiti a parte de variáveis públicas...

As propriedades públicas são LinhaRegistro, TipoRegistro e CamposEDI, que correspondem às variáveis protegidas com o mesmo nome, precedidas de underline.

Ah, notou a presença de um objeto do tipo TTipoRegistroEDI? Sim, ele trata-se de uma enumeração que indica os tipos possíveis em um arquivo EDI: Header, Detalhe e Trailler.

De caráter meramente informativo, claro, dependendo da sua implementação.

A propriedade mais importante, é a coleção CamposEDI, que trata-se de uma impelemtação do objeto List, implementando uma lista de objetos do tipo TCampoRegistroEDI.

Note também que há dois métodos virtuais (notou? se o método é declarado como virtual, ele pode ser sobreescrito - override - em uma classe descendente né?), CodificarLinha e DecodificarLinha.

O primeiro, como o nome já diz, codifica um conjunto de campos EDI em uma única linha, que representa o registro do arquivo. O mecanismo é simples: A função varre a lista contendo os campos do registro; Em cada campo, é chamado o método CodificarNaturalParaEDI(), que aplica a máscara ao valor contido na propriedade ValorNatural (lembra,um object que pode receber qualquer tipo de dado?) e concatena-a na variável _LinhaRegistro. Após varrer todos os campos, é obtida uma linha completa, na propriedade
LinhaRegistro do objeto do tipo TRegistroEDI.

Analogamente, o método DecodificarLinha, faz a operação inversa: Varre cada campo do registro EDI (os objetos que estão definidos na lista _CamposEDI, já com as configurações),
acrescenta o caracter de preenchimento definido na variável _CaracterPreenchimento até completar a quantidade de caracteres que está definido no campo _TamanhoMaximo.

Em seguida, atribui uma substring da linha que vem do arquivo (na propriedade LinhaRegistro) na propriedade ValorFormatado no campo, substring esta que é iniciada no caracter correspondente ao valor inicial do campo e com tamanho definido como o tamanho do campo. Feito isso, é chamado o método de decodificação deste campo, transformando-o em um objeto que será atribuído na propriedade ValorNatural de cada campo.

Este é o funcionamento básico, mas aí você pode perguntar: Mas como e onde eu atribuo os valores?

Bem, isto é assunto para não o seguinte artigo, pois nele vamos construir a estrutura básica de um arquivo, juntando o conteúdo deste e do artigo anterior. No próximo, aí sim,
iremos implementar um layout utilizando isso tudo!

Mas se quiser, pode fazer o seguinte teste, seja com uma aplicação console, windows forms, web, com um layout de dois campos.

   1: public void TesteLayout()

   2: {

   3:     //Teste de formatação de um campo EDI:

   4:     TCampoRegistroEDI campo1 = new TCampoRegistroEDI(TTiposDadoEDI.ediInteiro, 8, 0, 0, null, null, 1);

   5:     TCampoRegistroEDI campo2 = new TCampoRegistroEDI(TTiposDadoEDI.ediDDMMAA, 6, 0, 0, null, null, 9);

   6:     

   7:     campo1.ValorNatural = 12;

   8:     campo2.ValorNatural = DateTime.Now();

   9:  

  10:     //Veja o resultado das variáveis abaixo!

  11:     string campo1formatado1 = campo1.CodificarNaturalParaEDI();

  12:     string campo1formatado2 = campo2.CodificarNaturalParaEDI();

  13:  

  14:     //Teste de montagem de linha de registro

  15:     TRegistroEDI reg = new TRegistroEDI();

  16:     reg.CamposEDI.Add(campo1);

  17:     reg.CamposEDI.Add(campo2);

  18:     reg.CodificarLinha();

  19:     //Veja o resultado da variável abaixo!

  20:     string linha = reg.LinhaRegistro;

  21: }

Com esse pequeno código, até já se pode fazer um trabalho pontual... mas o objetivo da série de artigos é construir uma classe que represente um arquivo INTEIRO, onde você só precisará carregá-lo para interpretar (ele já montará a coleção com todas as linhas, todos os campos em um único método), ou atribuir dados em campos e adicionar para montá-lo!

Abraço a todos!

Classe Base para Arquivos EDI (34 KiB)