O NeoMatrix Tech está de casa nova!

Você deverá ser redirecionado em 6 segundos. Se não, visite:
http://www.leonelfraga.com/neomatrixtech
e atualize seus favoritos.

Aviso IMPORTANTÍSSIMO!

Aviso aos navegantes:

O NeoMatrix Tech mudou de casa!!!

A partir de agora, acessem pelo novo endereço:

http://www.leonelfraga.com/neomatrixtech

Ué... mas é só o domínio mudou de lugar?

R: Na verdade, não é bem assim hehe. Este domínio que você acessa agora aponta para um blog hospedado no Blogger, enquanto no novo, aponta para um blog na plataforma Wordpress, hospedagem própria, muito mais rápida e com um layout mais agradável de ler ;)

Não vou fechar este domínio igual ao que eu fiz com o NM Light (que já está 100% na nova plataforma). Talvez beeeeeeem depois eu faça isso.

Todos os posts daqui se encontram lá, e novos posts serão colocados somente no novo endereço.
A única coisa que não consegui importar foram os comentários. Mas em breve vai ter um post contando sobre a epopéia que foi migrar o NeoMatrix Tech!

Somente vou fechar a área de comentários daqui. Caso queiram comentar, favor ver o post correspondente no "Novo NeoMatrix Tech" e comentem por lá. É bem melhor! (pena que os permalinks "amigáveis para SEO" não funcionam lá, dá erro 404 e não consigo fazer a configuração funcionar. E olha que eu já vi vários artigos falando desse assunto :( ).

Quem assina o feed, já está lendo o conteúdo do novo NeoMatrix Tech!

sábado, 20 de junho de 2009

Fazendo Arquivos EDI com C# Aplicando POO - Parte 2

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)

0 comentários:


Postar um comentário

Para tornar este artigo ainda mais interessante, escreva suas críticas (desde que construtivas e sem ofenças), elogios, sugestões, complementos, dúvidas, etc, etc, etc!!!

  © Blogger templates ProBlogger Template by Ourblogtemplates.com 2008 - Editado e configurado por Leonel F.

Voltar ao TOPO