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, 28 de março de 2009

Controle de Usuários para ASP.NET (e Windows Forms!) – Criando o primeiro usuário em um BD vazio

cadeado_arroba

Graças a Deus tenho recebido vários feedbacks positivos e com dúvidas a respeito do Controle de Acesso para Sistemas ASP.NET (a série de artigos mais popular do NM Tech) e isto tem me motivado e muito a continuar escrevendo!

Uma das dificuldades que me repassaram é a criação do primeiro usuário em um banco de dados vazio.

Mas não é só fazer um insert into na mão?

Infelizmente, da maneira que foi implementada, isto não é possível.

Veja como fazer (após o break!)

Para ter um “thans” de segurança a mais, implementei o campo SENHA como um BLOB, e neste BLOB será colocado o hash MD5 da senha que o usuário digitar, em sua forma binária. E convenhamos, como iremos inserir diretamente, na munheca mesmo um BLOB no banco de dados?

Para contornar este problema, fiz uma sugestão, baseando-se na nossa aplicação exemplo:

- Comentar, na masterpage, o trecho de código que faz a verificação de acesso.
- Entrar diretamente no cadastro de perfis (colocar esta página como página inicial do projeto).
- Cadastrar um perfil com todas as permissões e cadastrar um usuário neste perfil
- Descomentar o código do controle de acesso.

Pronto, uma sugestão que mais beira à POG, mas tá valendo!

Maaaaaaaaas… não é sempre que podemos fazer isso, não é?

Para facilitar as coisas, criei uma pequena aplicação Windows Forms com a qual poderão ser criados (porém não alterados, somente inserir) perfis e usuários.

screen-usermanagerwinf

Como você pode ver, é bem simples: basta digitar um perfil, clicar no botão “Criar Perfil”, digitar um usuário e uma senha e clicar em “Criar Usuário…”.

Para esta aplicação (download no final do post!), adicionei as referências da DLL do UserManager (a mesma que usamos na aplicação ASP.NET) e do Provider Firebird Client (sim, estou utilizando a versão do FB) e criei um arquivo de configuração com a string de conexão necessária.

Caso queiram utilizar a versão para SQL Server, basta trocar a DLL pela a que utiliza o SQL Server e mudar a string de conexão.

Vamos dar uma olhadinha no código desse formulário?

   1: using System;
   2: using System.Collections.Generic;
   3: using System.ComponentModel;
   4: using System.Data;
   5: using System.Drawing;
   6: using System.Text;
   7: using System.Windows.Forms;
   8: using UserManager;
   9:  
  10: namespace App1stUser
  11: {
  12:     public partial class frmPrincipal : Form
  13:     {
  14:         public frmPrincipal()
  15:         {
  16:             InitializeComponent();
  17:         }
  18:  
  19:         private void frmPrincipal_Load(object sender, EventArgs e)
  20:         {            
  21:             TPerfilUsuario p = new TPerfilUsuario();
  22:             try
  23:             {
  24:                 lbListaPerfil.DisplayMember = "Descricao";
  25:                 lbListaPerfil.DataSource = p.ListarTodos();
  26:             }
  27:             finally
  28:             {
  29:                 p.Dispose();
  30:             }
  31:         }
  32:  
  33:         private void btnCriaPerfil_Click(object sender, EventArgs e)
  34:         {
  35:             TPerfilUsuario p = new TPerfilUsuario();
  36:             try
  37:             {
  38:                 p.Descricao = tbxPerfil.Text;
  39:                 for (int i = 0; i < p.Modulos.Count; i++)
  40:                 {
  41:                     p.Modulos[i].PodeAcessar = 1;
  42:                 }
  43:                 p.Inserir();
  44:                 lbListaPerfil.DisplayMember = "Descricao";
  45:                 lbListaPerfil.DataSource = p.ListarTodos();
  46:                 MessageBox.Show(p.MsgInfo);
  47:             }
  48:             finally
  49:             {
  50:                 p.Dispose();
  51:             }
  52:         }
  53:  
  54:         private void btnCriaUser_Click(object sender, EventArgs e)
  55:         {
  56:             TUsuario u = new TUsuario();
  57:             try
  58:             {
  59:                 u.Nome = tbxLogin.Text;
  60:                 u.Login = tbxLogin.Text;
  61:                 u.Senha = tbxSenha.Text;
  62:                 u.PerfilId = (lbListaPerfil.SelectedItem as TPerfilUsuario).PerfilId;
  63:                 u.Status = "A";
  64:                 u.Inserir();
  65:                 MessageBox.Show(u.MsgInfo);
  66:             }
  67:             finally
  68:             {
  69:                 u.Dispose();
  70:             }
  71:         }
  72:  
  73:         private void btnAbreFrmTeste_Click(object sender, EventArgs e)
  74:         {
  75:             string msg = "";
  76:             TUsuario u = TUsuario.Autenticar(tbxLogin.Text, tbxSenha.Text, out msg);
  77:             wfCadUsuarios frmcaduser = new wfCadUsuarios();
  78:             if (u != null)
  79:             {
  80:                 try
  81:                 {
  82:                     if (u.Perfil.TemAcesso(frmcaduser.Name))
  83:                     {
  84:                         frmcaduser.ShowDialog();
  85:                     }
  86:                     else
  87:                     {
  88:                         MessageBox.Show("Ops, sem acesso!");
  89:                     }
  90:                 }
  91:                 finally
  92:                 {
  93:                     u.Dispose();
  94:                 }
  95:             }
  96:             else
  97:             {
  98:                 MessageBox.Show(msg);
  99:             }
 100:         }
 101:     }
 102: }

Mais simples que isso impossível…

Como você pode ver, apenas instanciei as classes, preenchi as propriedades e chamei os métodos, todos eles já conhecidos do exemplo em ASP.NET.

Lembra, como eu disse nesse post que pensava em portar para Windows Forms?

Pois é, meu querido… Este é um pequeno port, não tendo somente a funcionalidade de alteração, que pode ser facilmente implementada. O mais legal é que o controle de acesso aos formulários de uma aplicação Windows Forms é feito DA MESMA MANEIRA!!! Modificações na biblioteca UserManager: NENHUMA, ZERO.

No botão “Abrir Form de Teste” da nossa aplicação fazemos a autenticação do usuário que está digitado na caixa de texto “Login” e abrimos um formulário, chamado propositalmente de wfCadUsuarios.

Instanciamos este formulário em uma variável (no nosso exemplo, a variável frmcaduser), e passamos a propriedade Name para o método TemAcesso da classe TPerfilUsuario. Se o método retornar true, chamamos o método ShowDialog() do forumulário e caso contrário disparamos uma mensagem.

Neste caso, implementei o controle de acesso antes de abrir o formulário, diferentemente do ASP.NET que eu faço a verificação quando o form já está em processamento. Mas nada impede que seja criado um “formulário pai” e que o controle de acesso seja feito em seu evento OnLoad, e que os demais forms herdem dele.

Aplicação para criação de Usuários do “Controle de Acesso para ASP.NET” (82 KiB)

Um abraço e até!

Leia o restante deste post...

Métodos com argumentos indefinidos em C#

Você já deu uma olhadinha de leve no método String.Format?

Se você reparar bem, em uma de suas sobrecargas você poderá passar vários argumentos separados por vírgula (parâmetros), sendo que no primeiro é a string a ser formatada e os outros argumentos são o valores que serão colocado na string do primeiro.

Para fazer a mesma coisa nos nossos métodos em que o número de argumentos pode ser um ou vários, podemos fazer isso de duas maneiras, sendo que ambas se equivalem no uso dentro do médodo em si:

1. Declarando um argumento do tipo object[]:

Vamos pegar o método SetById da classe TGenericDAL do Simple PIM?

   1: public virtual void SetByID(object[] pkValues)
   2: {
   3:     //Monta as cláusula Where do SQL, baseando-se na propriedade _DataKeys
   4:     int pkCount = 0;
   5:     string Where = "";
   6:     ClearSQLParams();
   7:     foreach (string s in _DataKeys)
   8:     {
   9:         Where += String.Format(" and ({0} = {1}{2}) ", s, _ParameterDefinedBy, s);
  10:         AddSQLParam(_ParameterDefinedBy + s, pkValues[pkCount], ParameterDirection.Input);
  11:     }
  12:     _SelectSQL = String.Format("select * from {0} where (1 = 1) {1}", _TableName, Where);
  13:     this.Select((CountSQLParams() > 0));
  14: }

Declaramos como argumento do método um array de object que poderá receber em seus elementos qualquer variável com qualquer tipo de dado.

Para utilizá-lo, necessitamos primeiro declarar um array e passá-lo como argumento da função, vejam:

   1: //Declarando o array fora do método
   2: object[] valores = new object[2] {"Uma String",1};
   3: MinhaClasse.SetById(valores);
   4:  
   5: //Declarando o array dentro do método
   6: MinhaClasse.SetById(new object[2] {"Uma String",1});

2. Declarando um array como argumento e utilizando o modificador params:

Voltando ao método String.Format que mencionei no início do post, note que a sobrecarga que admite argumentos indefinidos é aquela em que o argumento declarado como object[] recebe o modificador params.

Ele é um parâmetro que indica que este argumento possui um número indefinido de valores. O argumento que recebe este modificador deve ser um array e deverá também ser o último da lista de argumentos da função (caso tenha vários). Também só poderemos ter um parâmetro que usa este modificador.

Por exemplo, se tivermos apenas um argumento e este tiver o modificador params, os vários argumentos separados por vírgula serão colocados dentro do array declarado como parâmetro automaticamente e não teremos que declará-lo previamente.

Poderemos reescrever o método SetById da seguinte forma:

   1: public virtual void SetByID(params object[] pkValues)
   2: {
   3:     //Monta as cláusula Where do SQL, baseando-se na propriedade _DataKeys
   4:     int pkCount = 0;
   5:     string Where = "";
   6:     ClearSQLParams();
   7:     foreach (string s in _DataKeys)
   8:     {
   9:         Where += String.Format(" and ({0} = {1}{2}) ", s, _ParameterDefinedBy, s);
  10:         AddSQLParam(_ParameterDefinedBy + s, pkValues[pkCount], ParameterDirection.Input);
  11:     }
  12:     _SelectSQL = String.Format("select * from {0} where (1 = 1) {1}", _TableName, Where);
  13:     this.Select((CountSQLParams() > 0));
  14: }

Note que a forma de utilização do argumento pkValues do mesmo dentro do método permanece a mesma. Veja como usá-lo:

   1: //Usando o modificador params no método SetById
   2: MinhaClasse.SetById("Uma String",1);

Veja que passamos os mesmos valores para o método SetById, porém não declaramos explicitamente um array para passá-los ao método.

Bem simples, não?

Um abraço!

Leia o restante deste post...

segunda-feira, 23 de março de 2009

Minha história de amor com a Informática e a Tecnologia

Assinatura do Tux Dando uma pequena pausa nos artigos de programação (logo vão ter mais, vamos dar uma destrinchada em alguns métodos interessantes da Classe de Conexão e aprender um pouquinho de Reflection com eles :-) ), nesse post vou escrever a minha jornada no mundo da informática, como comecei a mexer com computadores, programação e afins.

Depois do break, como diria no Rá-Tim-Bum, SENTA QUE LÁ VEM HISTÓRIA!!! :P

Lá pelos meados de 1995, quando fazia a 8ª série do ensino fundamental (antigo 1º grau), foram algumas pessoas para fazer a propaganda de um clube de informática chamado Clube do Micro (já extinto, que ficava no também extinto Shopping Diretão, em São Miguel Paulista), onde existiam alguns computadores ligados em rede e que pagando uma mensalidade poderíamos utilizar os micros por algumas horas no mês, além de fazer alguns cursos por lá mesmo.

Tirando a parte dos cursos, o mais próximo que podemos chegar hoje em dia são as lan-houses, por causa dos micros ligados em rede, e ter alguns programas instalados, como jogos, e naquela época eu nem imaginava que existia Internet e cia :P.

E claro que fiquei deslumbrado, afinal, mexeria em um computador e bem dizer “enchi o saco” da minha mãe para ir lá fazer a inscrição. E a fiz!

Lembro até hoje o meu número de matrícula: 571.

Certificado do meu curso de DOS :P A primeira coisa que fiz lá era praticar digitação através de um joguinho (em DOS) em que as letras caiam da tela, e para evitar que elas cheguem à parte de baixo da tela tínhamos que pressionar a letra que está caíndo.

Fiquei nessa um tempo, e navegando pelo menu que tinha nas máquinas, feito com com alguns programas em DOS que capturavam a tecla em um arquivo .bat (não era o CHOICE, porém não lembro do nome desse programinha agora) brinquei com alguns joguinhos, tais como o Golden Axe, Alley Cat, Arkanoid, entre alguns outros.

E fiz também cursos de DOS, Windows (3.1), Wordstar, Word (2.0), Excel, Lotus 1-2-3. Tenho os certificados aqui, vocês poderão ver abaixo no slideshow no final do post ;-)

Já queria ter meu próprio computador.

As máquinas que tinham lá variam, desde 286 até 486, sendo algumas equipadas com monitor VGA monocromático e as menos poderosas com monitor CGA de fósforo verde ou até mesmo laranja. E tinha uma com monitor CGA Colorido!!!

Memória? Hum… os mais poderosos tinham acho que 4 MB de RAM. As outras só mesmo com a memória convencional.

E HD? Eram estações diskless. Davam boot através de um servidor, e todos os dados dos alunos eram armazenados nele. Hora ou outra o HD do servidor era formatado.

Para fazer backup dos dados (nossos, dos alunos), uma máquina ou outra é que tinha drive de disquete.

E quando vi um micro com monitor VGA colorido pela primeira vez… nossa, que vontade de ter um micro.

Fiz, a partir de 1996, o colegial técnico (atual ensino médio, naquele tempo fiz o colegial integrado com o técnico, em um curso de 4 anos) em Eletrônica na E.T.E Prof. Aprígio Gonzaga, no bairro da Penha, em São Paulo – SP, justamente com a intenção de trabalhar com hardware de PC. Acabei fazendo estágio e trabalhando efetivo por 6 meses em manutenção de placas de telefones públicos à cartão. Mais tarde, já formado do técnico, fiz um curso de manutenção de micros na escola Compuway, porém nunca cheguei a trabalhar montando micros.

Desde criança gostei de eletrônica, e mesmo sem entender muita coisa lia uns fascículos do curso à distância que meu pai fez pelo Instituto Monitor, além das revistas “Saber Eletrônica”.

Minha primeira revista de Informática Comprei minha primeira revista de informática e nem tinha PC ainda. Era o primeiro número da revista Soft Easy, de uma editora de João Pessoa – PB onde vinha um disquete com alguns programas compactados (o slogan era: “O melhor do shareware em disquete”).

Onde eu usava esse disquete? Instalava os programinhas lá no Clube do Micro, e quando ia para a casa do meu primo, que nessa época tinha um 486, instalava lá.

Perto do final de 1996, comprei meu primeiro PC. Um Infoway Itautec, com processador Pentium 133 MHz, 16 MB de RAM, 1.2 GB de disco rígido, placa de vídeo ATI Mach 64 com 1 MB (expansível à 2 MB) integrada, placa de som com modem de 28.8 Kbps integrado MM AT 3100 da Aztech Labs, Placa de captura de TV.

Manual do meu primeiro PC Eu queria o PC com DOS e Windows 3.1, que era o que eu sabia mexer. Veio com o Windows 95, e eu bem dizer aprendi “na marra”. Foi uma experiência bem interessante.

Nossa, adivinhar que tinha que configurar o PC para reiniciar em modo DOS para rodar determinados programas, resolver um confilto de IRQ entre a porta MIDI e a LPT1 que veio DE FÁBRICA :P

Eu já guardava vários programinhas copiados backupeados do Clube do Micro e do meu primo.

Vejam o comercial que passava na TV:

Ele funciona até hoje, mas claro com modificações: modem de 56k, outro monitor, HD de 10 GB (a placa mãe reconhecia até 8 GB, mas um programa chamado Disk Manager, da Seagate, instalava o LBA no MBR, aí o S.O. – Win 98 na época – reconhecia os 10 GB)…

Meu primeiro contato com uma linguagem de programação foi em 1997, quando me inscrevi em um curso de Clipper promovido pelo SERT.

Estava no segundo ano do ensino médio, e as aulas eram ministradas na própria escola. Tínhamos uma aula de cidadania e outra do curso em si.

Aprendi a fazer uma interface com o usuário, comandos de entrada e saída de informações, mexer com banco de dados (dBase), estruturas de uma linguagem…

Foi legal, consegui aprender bastante coisa e já fiz alguns programinhas mais elaborados, só para treinar mesmo.

E por falar no curso, tinha uma japonesinha muito bonita, o nome dela é Tânia, se não me engano… que belezinha, que olhinhos puxadinhos mais lindos… Sim, desde essa época eu já era um Asiantard :P

Dentro do curso de Eletrônica, tínhamos uma disciplina que era Informática. Basicamente era aprender os conceitos básicos, comandos do DOS, essas coisas. As aulas, pelo perdão da palavra, eram toscas. Nelas vimos um pouquinho de linguagem C e Pascal, mas ben dizer não deu para aprender NADA. Já com o Clipper conseguia me virar bem, até uma vez sugeri para a professora ensinar ela, e não é que pelo menos vimos uma coisinha de Clipper!

Formado do curso de Eletrônica, com os 4 anos cumpridos SEM REPETIR DE ANO (sim, naquela época repetíamos de ano!), depois de sair da empresa onde eu trabalhava consertando placas de telefone público, resolvi que queria fazer uma faculdade mais voltada para a área de software, programação: Ciências da Computação, Engenharia (mais para hardware) ou Processamento de Dados.

Fiz um ano de cursinho no Etapa e consegui passar no curso de Processamento de Dados pela FATEC-SP, no período da tarde.

A partir daí vi que um software não são apenas linhas de código, vi que existem muitas coisas envolvidas nisso, como requisitos e principalmente pessoas.

Sim, pessoas. São elas que irão ditar como os sistemas irão se comportar. Linhas de código são apenas a parte quase que final do processo da construção de um sistema.

Aprendi a programar em Pascal, C, Java, Cobol, Delphi entre outros, os métodos e passos para análise de sistemas, noções de administração, economia, entre outras coisas.

Foi aí que vi que era isso o que sempre queria mesmo.

Meu primeiro estágio foi de suporte técnico na Procuradoria Regional da República da 3ª Região, onde eu ficava em uma sala aguardando os chamados dos usuários.

Era problemas de todos os tipos: Cabos de rede quebrados, instalar programas para os usuários, ensiná-los a mexer nos programas, trocar cartuchos e toner de impressora, entre outras atividades, tais como baixar os arquivos para auditoria das catracas eletrônicas.

Foi nesse estágio que comecei a juntar grana para montar um micro. O Pentium 133 estava lá, valente, resistindo mesmo não podendo rodar os programas mais atuais para a época, e precisava urgentemente trocar de micro.

Meu 2º PC Comprando um item de cada vez, finalmente consegui montar uma máquina decente para a época: Processador Intel Celeron 2.5 GHz, 256 MB de RAM, Placa mãe ASUS P4V8X-X, Gravador de CD, Placa de vídeo GeForce 4 MX 440, com 64 MB (como eu ainda não estava interado a respeito das VGA’s, comprei uma com barramento de 32 bits na memória, mas só fui descobrir isso depois), HD de 160 GB (eu usava o de 10 na outra máquina até comprar outro HD).

Claro que essa máquina, com o tempo foi sofrendo upgrades: VGA Radeon 9550 com 256MB e 128 bits, Placa de captura Pinnacle PCTV 110i, HD de 320 GB SATA, Gravador de DVD, 2 GB de RAM, monitor LCD de 19’’. Até hoje ela está ativa, mas não como meu PC principal (agora ele é usado pelo restante da família).

Meu primeiro contato com a Internet foi nos meados de 1999, quando acessei através de um quiosque em uma agência dos Correios. Fiz um e-mail em um serviço que a antiga BCP (atual Claro) prestava para seus clientes, que poderiam ter um email @bcponline.com.br, e me cadastrei em sites de curriculum para conseguir um emprego em eletrônica.

Em casa, só fui ter Internet em 2001. Comecei usando o modem de 28.8 do Pentium 133 (sim, esse PC ficou bem dizer uns 5 anos com o modem virgem, pois não tinha linha telefônica em casa na época hehe), depois feito o upgrade par ao 56K e em 2003 assinamos um serviço de banda-larga.

Frequentava direto os chats do Zip.NET, do Terra e do UOL, usei muito o ICQ (até hoje lembro do meu UIN e conecto com ele as vezes :-) ), também acessava com muita frequência o site da colônia nikkey Hainet (claro, qual Asiantard não passou por esse site, hein?), ouvia músicas no extinto Usina do Som, onde eu comecei a ouvir trance para valer (meu primeiro contato com o trance foi em um programa da rádio Transamérica, o Ministry of Sound, que não tem mais :-(), e estudava também.

Um programa de bate-papo que gostei bastante foi o TiVejo. Era um chat com voz e câmera, em salas que comportavam até 200 pessoas. Ele era uma “subsidiária” do programa Paltalk, era bem dizer um “Paltalk localizado para o Brasil”. Criei a minha conta lá no dia 09/11/2001 (no profile mostra :P).

Hoje apenas tem o Paltalk, o TiVejo está extinto, porém o grupo que eu mais frequentava continua na ativa com uma mail list no Yahoo. Boas amizades eu fiz lá, algumas se tornaram reais.

Em 2005, finalmente consegui um estágio na área de desenvolvimento.

É, finalmente estou trabalhando naquilo que eu amo fazer: programar e analisar sistemas. Claro, tem a parte de suporte ao usuário, que não é muito a minha praia principalmente quando estou mexendo com código, mas faz parte.

Comecei programando em Delphi 7, passei um pouco por ASP, VBA (Access) e PHP, e finalmente C# e ASP.NET.

Meu primeiro contato com o C# e o ASP.NET foi para dar manutenção em um dos sistemas desenvolvidos, e suei frio. NUNCA tinha contato com C#, ASP.NET, só sabia a sintaxe dos comandos de C. Classes do Framework? O que era isso!

Fui aprendendo na marra, e nos momentos de dúvida perguntava aos colegas ou consultava na Internet.

Foi aí que fiz um curso de ASP.NET e C# na Wincomp, e lá comecei a entender o que tudo aquilo que mexia queria dizer.

Saí de lá bem mais tranquilo em relação à plataforma .NET, e logo em seguida já fiz meu primeiro sistema em .NET.

É um sistema de gerenciamento de instalações de dispositivo antifurto, com funções de agendamento, exportação para as seguradoras, pesquisas, ordens de serviço…

Começou pequeno e com código tosco… hoje ele está bem melhor, mais estruturado, maior, código mais otimizado. Com ele aprendi de vez C#.

Foi a partir deste sistema que construí a minha Classe de Conexão, baseando-se no que eu aprendi no curso da Wincomp.

A partir daí só foi mais crescimento, e estou onde estou hoje! Reconhecido pelo meu trabalho, podendo ajudar a quem eu posso, conhecido como “o cara que mexe com computador”, etc :P

E claro que com um emprego melhor e com a tecnologia avançando, senti a necessidade de uma máquina mais potente. Montei uma, que agora só eu uso (como eu disse, o outro PC está em outro cômodo da casa e a família usa ele), que eu descrevi nesse post.

Enfim, é isso! Um abraço e até a próxima!

Leia o restante deste post...

terça-feira, 17 de março de 2009

Lixux: Um S.O. alternativo ao Windows?

tux Freetards de plantão, tenham calma. Minha intenção NÃO é atacar o Linux ou qualquer outro software livre, visto que eu gosto do Linux, do Firefox, do Audacity, entre outros.

Quem dá esse adjetivo ao Linux são os wintards de plantão que falam que tudo o que vêm do Tio Bill é supremo, e em uma das minhas pesquisas por palavras “incomuns” da tecnologia no Google, deu na telha de eu pesquisar exatamente pelo termo “Lixux”.

Como era de se esperar, encontrei inúmeras postagens de fóruns e blogs de pessoas que tiveram dificuldades com o S.O. do pinguim e descontam sua raiva colocando esses apelidos.

Mas, algumas páginas de pesquisa adiante, me deparei com vários sites PROFISSIONAIS, sejam vendendo produtos, anunciando vagas de emprego, curriculum-vitae, entre outros, que está lá, escrito LIXUX mesmo.

Erro de digitação do estagiário que fez a página? Pô, a letra “X” fica longe da letra “N”, mesmo se o cara tiver muita dislexia não cometeria um erro desses, acho.

Propositalmente colocado por algum wintard / appletard para tirar um sarro, só que o capivara esqueceu-se de que estava em ambiente de PRODUÇÃO? Uma nova distribuição?

Hum… inúmeras alternativas hehe.

Mas uma coisa é certa: Esse erro de escrita proposital é justificável em blogs e fóruns, pois assim como temos pessoas que falam Ruindows, os outros tem o mesmo direito de falar Lixux e cia. Mas em sites profissionais, pelo amor de Deus, hein! Tem que tomar cuidado com isso!

E como não pode deixar de ser, tirei algumas screenshots e vai o link das páginas onde não deveria estar escrito Lixux!

lixux-1
http://www.premiertecnologia.com.br/page_1152469152421.html

lixux-2
http://www.empregosti.com/Vaga.aspx?c=MTUwMjEw&q=T%C3%A9cnico%20de%20Suporte

lixux-3
http://transtavares.com/curriculo/cur1.htm

lixux-4
http://www.alcidesmaya.com.br/novo_portal/certificacao_linux.php

lixux-5
http://www.lojason.com/softregiscomp/index.php?page=shop.browse&option=com_virtuemart&Itemid=1&vmcchk=1&Itemid=1

Coloquei inclusive os links para as telas que capturei. Vamos ver se eles não vacilam mais!

Um abraço ;-)

Leia o restante deste post...

sexta-feira, 13 de março de 2009

Simple PIM – Exemplo Nova Classe de Conexão – Parte 4: Conclusões

Fechando esta sequência de artigos sobre a nova versão da Classe de Conexão, cheguei a algumas conclusões, sendo algumas meio óbvias, algumas melhorias a fazer, entre outras.

A mais óbvia é a capacidade de reaproveitamento de código que podemos obter seguindo este modelo de desenvolvimento, centralizando tudo o que for relacionado às chamadas de Providers na Classe de Conexão e centralizando as operações de persistência em uma classe DAL genérica.

Como pudemos ver nesta e em oportunidades anteriores, não usamos NENHUMA declaração de provider específico de banco de dados: é bem dizer o mesmo código para N bancos de dados; a diferença está na sintaxe dos comandos SQL em si.

Nestas mesmas oportunidades anteriores, vimos que as operações básicas das classes de cadastro são feitas da mesma maneira, e ao centralizar estas operações em uma classe genérica tivemos um aproveitamento monstruoso: Bastou construir a parte VO de uma classe e já estava tudo funcionando.

Economizamos código também na codificação (no code-behind) da interface de usuário. Um dos “trabalhos braçais” mais chatos que existem é exatamente a atribuição dos valores nos componentes da UI. Principalmente se tiver dezenas de campos a serem preenchidos.

De quebra, ainda pude aprender a usar um pouco do conceito de Reflection do .NET.

Como, já dizia o ditado, nem tudo são flores: Temos também a parte chata, de que temos que redobrar a atenção ao seguir algumas convenções. Nas primeiras vezes, é um pouco chato, mas vamos nos acostumando a isso e o resto vai de boa.

Embora facilite bastante, seguir as convenções ao pé-da-letra pode restringir um pouco o uso da Classe de Conexao. Nada que uma POG bem feita não resolva, mas o intuito não é apelar para este lado.

Pensando em algumas restrições que pude perceber ao longo da existência (e da adoção onde eu trabalho) da Classe de Conexão, há melhorias a serem feitas, com certeza.

Uma destas restrições é na parte de transações. Como a Classe de Conexão foi projetada pensando-se em uma aplicação Web, onde ela se conecta ao banco, faz o que tem que fazer, e desconecta-se, e quis evitar ao máximo possível a declaração de providers fora da Classe Conexao, tive que criar uma coleção e um método para executar instruções SQL em lote, em uma única transação.

Só que isso trouxe a limitação em si: Somente poderei executar instruções que não me retornem resultset dentro da coleção BatchSQLItens.

Só que também existem horas que eu preciso fazer um Select dentro da mesma sessão em que a transação é executada: o método ExecuteBatchSQL quando termina a execução ele já encerra a sessão. Desta forma não é possível fazer isso.

Já deu para saber uma deficiência a melhorar: Fazer um controle de transações que não dependa da coleção BatchSQLItens :-)

Outras melhorias são acrescentar o suporte para Windows Forms, e quem sabe, aplicações Mobile.

Mas… essa Classe de Conexão está me ajudando bastante em meus projetos, tenho tido um ótimo ganho de tempo com ela e esse jeito de desenvolver.

Um abraço!

Leia o restante deste post...

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

Voltar ao TOPO