E lá vem 2012…
Mais um ano vencido, graças a Deus. No meu balanço, foi o meu melhor ano nos últimos 4 anos. Muitas vitórias. Mais coisas positivas do que negativas. Apesar de poucos, os fatos negativos foram muito marcantes. Muita decepção com algumas pessoas e situações vividas. Mas agora é hora de organizar a vida e procurar colocar em prática as lições aprendidas em 2011 para que 2012 seja um ano com muito mais conquistas do que o ano que termina hoje.
Gostaria de agradecer a todos aqueles que me proporcionaram alegrias e decepções durante 2011. Aprendi muito com os dois extremos. Espero que vocês também tenham aprendido o necessário.
Quero salientar duas importantes lições que aprendi nesse ano. A primeira pode ser um clichê batido para muitos: não ignorar seu coração. Não se intimide em mostrar sua opinião, seja qual for. O certo e o errado, a verdade e as obrigações que o indivíduo possui são conceitos variáveis, mas que são tratados pela maioria das pessoas como constantes. Quer ter a consciência tranquila? Não ignore o que seu coração lhe mostra.
A segunda lição, para mim, é a mais importante: que a amizade é o resultado da cumplicidade, afinidade, convivência e aceitação daquilo que o seu próximo é. Em alguns momentos, eu vi a amizade ser tratada como um objetivo, uma moeda de troca. Um artefato por meio do qual as pessoas escondiam suas limitações e procuravam tirar a responsabilidade dos seus ombros, querendo ficar bem com todo mundo. Ser útil a uma pessoa que seja é muito mais importante do que querer ser amigo de todas elas.
2012 está chegando. Espero limpar a poeira acumulada no blog, que foi criada durante o período sabático gerado pelo corre-corre e falta de criatividade deste que vos fala. Muitas coisas mudaram. Não estranhem se eu falar mais de Linux, por exemplo!!!
Também espero que em 2012 eu possa ser uma pessoa mais útil e criativa, transformar o blog em um site pessoal e iniciar uma pós-graduação.
E vocês? O que esperam do ano que está chegando?
Obrigado por acompanhar meu desabafo e tenham um ótimo ano novo. Fiquem com Deus!!!
Validação de Dados no ASP.NET – Parte III
Olá, pessoal!
Hoje iremos encerrar nossa série de artigos “Validação de Dados no ASP.NET”. Conforme planejado, o artigo de hoje tem como objetivo demonstrar validações personalizadas através do componente CustomValidator.
Será criado um exemplo básico de divisão numérica, onde serão lidos os dois termos da divisão (dividendo e divisor). Se o divisor for igual a 0 (zero), será emitida uma mensagem para informar um número diferente de zero no divisor, caso contrário, será emitida uma mensagem informando o resultado da divisão.
Então, mãos à obra!
Estarei utilizando o Visual Studio 2010 com o Framework 4.0 para a construção do exemplo. Em primeiro lugar, criaremos uma Aplicação Web (File > New > Project > ASP.NET Empty Web Application).
Ao criar o projeto, podemos observar que não há nenhuma página. Assim, precisamos criar uma nova página *.aspx. Então, vamos na solution Explorer, clicar no ícone do projeto com o botão direito do mouse para criarmos uma nova página (Add > New Item > Web Form, e então, clique em Add), conforme as figuras abaixo.
Após criar a página, vamos para o código-fonte da mesma (arquivo *.aspx) para criarmos a nossa função JavaScript para ser utilizada em conjunto com o CustomValidator. Esse script deve estar dentro da sessão <head></head>.
Terminando de digitar a função, vamos voltar para o design da página e inserir uma tabela (Table > Insert Table) com 3 (três) linhas e 2 (duas) colunas. Nas duas primeiras linhas da coluna da esquerda, digitaremos “Dividendo:” e “Divisor”. Na coluna da direita, na primeira linha, adicionaremos um TextBox (Toolbox > aba Standard), mudando sua propriedade ID para “txtDividendo”. Na segunda linha, adicionaremos outro TextBox mudando seu ID para “txtDivisor”. Na terceira linha da coluna da direita, vamos adicionar um Button (Toolbox > Aba Standard), mudando seu ID para “btnCalcularDivisao” e sua propriedade Text para “Calcular Divisão”. O layout da aplicação deve ficar conforme a figura abaixo.
Agora, vamos adicionar o controle CustomValidator (Toolbox > Aba Validation) na frente do TextBox “txtDivisor” para fins de organização. Após inserir o controle na página, mude a propriedade ClientValidationFunction para “CalcularDivisaoNumerica”, que foi a função JavaScript que nós criamos e mude a propriedade ControlToValidate para “txtDivisor”.
Rode a página, digite os números nos TextBoxes e clique no botão para efetuar o cálculo. Experimente digitar o número 0 (zero) no divisor para verificar a funcionalidade da função.
O projeto desenvolvido pode ser encontrado aqui para estudos posteriores.
Assim, encerramos nossa série “Validação de Dados no ASP.NET”, onde vimos o básico dos controles de validação e o funcionamento dos mesmos. Espero ter ajudado nos estudos de vocês, prezados leitores.
Um abraço e até a próxima!
Validação de Dados no ASP.NET – Parte II
Olá pessoal!
Hoje vamos dar continuidade à série de artigos sobre os controles de validação do ASP.NET. Na segunda parte da nossa série, vamos desenvolver um pequeno exemplo, que tem como objetivo mostrar os controles de validação em funcionamento na página. Você pode acessar a primeira parte da série por aqui.
Então, vamos começar?
Nesse tutorial foi utilizado o Visual Studio 2008, o que não o impede de usar outra versão da ferramenta. Crie um novo Web Site (File > New > Web Site), escolhendo o diretório onde deseja salvar os arquivos. Fique atento também para a linguagem escolhida (em nosso caso o C#).
Ao clicar no botão “Browse…” da tela acima, você é direcionado à próxima imagem, onde poderá escolher o diretório do site de modo mais detalhado. O botão em destaque no canto superior direito cria uma nova pasta, caso seja a sua vontade.
Agora, adicione uma tabela com 5 (cinco) linhas e 2 (duas) colunas (Menu Table > Insert Table). Na área “Size”, escolha o número de linhas (Rows) e de colunas (Columns) e clique em OK.
Digite nas colunas da esquerda os seguintes campos: “Nome:”, “Idade:”, “e-Mail:”, “Senha:” e “Confirmar Senha:”.
Nas colunas da direita, adicione 5 (cinco) controles TextBox, que estão localizados na ToolBox, aba Standard.
Mude a propriedade ID dos TextBoxes para txtNome, txtIdade, txtEmail, txtSenha e txtConfirmarSenha na aba Properties. Para isso, clique sobre o TextBox em questão uma vez e aperte F4. Nos TextBoxes txtSenha e txtConfirmarSenha, mude a propriedade TextMode para Password.
Adicione um Button (aba Standard) abaixo da tabela. Mude a propriedade ID para btnSalvar e a propriedade Text para “Salvar”. Ao clicar nesse botão, será feito o processo de validação, pois a propriedade CausesValidation está configurada para true. Essa propriedade é responsável por habilitar o processo de validação de dados. Caso você não queira que o seu botão execute uma validação, mude o valor dessa propriedade para false.
Em frente ao TextBox txtNome, adicione um RequiredFieldValidator e mude as seguintes propriedades: ControlToValidate para txtNome, Text para “*” e ErrorMessage para “Informe um nome!”
Em frente ao TextBox txtIdade, adicione um RangeValidator e mude as seguintes propriedades: ControlToValidate para txtIdade, Text para “*”, ErrorMessage para “Idade deve estar entre 18 e 100 anos!”, Type para “Integer”, MinimumValue para 18 e MaximumValue para 100.
Em frente ao TextBox txtEmail, adicione um RegularExpressionValidator e mude as seguintes propriedades: ControlToValidate para txtEMail, Text para “*” e ErrorMessage para “Informe um formato de e-mail válido!” e em ValidationExpression, escolha na janela que se abrirá a opção “Internet e-mail address.
É possível aplicar mais de uma validação em um mesmo controle. Para comprovar, adicione, em frente ao TextBox txtEMail, um controle RequiredFieldValidator e mude as seguintes propriedades: ControlToValidate para txtEMail, Text para “*” e ErrorMessage para “Preenchimento do e-mail é obrigatório!”
Em frente ao TextBox txtConfirmarSenha, adicione um CompareValidator e mude as seguintes propriedades: ControlToValidate para txtConfirmarSenha, ControlToCompare para txtSenha, Text para “*” e ErrorMessage para “As senhas não conferem!”
Por último, adicione um controle ValidationSummary embaixo do botão btnSalvar tabela e mude a propriedade ShowMessageBox para True.
Experimente rodar a página e digitar alguns dados inválidos para ver os controles de validação em funcionamento.
Assim, finalizamos nosso pequeno exemplo de demonstração dos controles de validação. Em nosso próximo artigo da série, vamos desenvolver um pequeno exemplo visando mostrar o funcionamento do controle CustomValidator.
É possível fazer o download do projeto clicando aqui. Lembrando que ele foi desenvolvido no Visual Studio 2008, sendo necessário possuir essa versão ou versão mais recente para abrí-lo.
Um abraço e até a próxima!!!
Validação de Dados no ASP.NET – Parte I
Olá, pessoal!
Hoje vamos iniciar uma pequena série sobre os controles de validação do ASP.NET. Serão 3 (três) artigos de nível básico, onde iremos abordar, respectivamente, os controles de validação presentes no Visual Studio e suas principais propriedades, desenvolveremos um exemplo prático apenas para mostrarmos o funcionamento dos controles e, por último, estudaremos um pouco mais do controle CustomValidator.
No artigo de hoje, iremos tratar de algo presente em 11 de cada 10 cadastros que desenvolvemos em nossas aplicações web: a validação de dados (o 11 em cada 10 foi de propósito, rsrs). Vamos conhecer os controles utilizados no ASP.NET para a validação de dados e suas principais propriedades para que você possa iniciar a inclusão da validação de dados em seus cadastros. Você verá o quão produtivo, rápido e fácil é validar dados com ASP.NET.
No Visual Studio, os controles responsáveis pela validação dos dados estão localizados na aba Validation (aba disponível quando se está desenvolvendo um projeto do tipo Web Site ou Web Application). São eles: CompareValidator, CustomValidator, RangeValidator, RegularExpressionValidator, RequiredFieldValidator e ValidationSummary.
O controle CompareValidator é responsável por comparar um valor de um controle com outro, ou então, compara o valor de um controle específico com um valor definido em suas propriedades. Por exemplo, podemos usar o CompareValidator quando pedimos a confirmação da senha digitada em um cadastro de usuário. As principais propriedades desse controle são as seguintes:
- ControlToCompare: controle com o qual o valor será comparado.
- ControlToValidate: controle que será validado.
- ErrorMessage: mensagem a ser exibida quando for usado o ValidationSummary.
- Text: texto exibido pelo controle na página, quando a validação não for aprovada.
- Operator: condição de validação a ser avaliada.
- ValueToCompare: é um valor constante. É usado quando se deseja comparar o valor informado no controle com o que foi informado nesta propriedade. Vale salientar que essa propriedade é usada em conjunto com a propriedade Operator.
O controle CustomValidator é usado quando há a necessidade de criar uma regra de validação personalizada, através de código JavaScript. Suas principais propriedades são:
- ControlToValidate: controle que será validado.
- ErrorMessage: mensagem a ser exibida quando for usado o ValidationSummary.
- Text: texto exibido pelo controle na página, quando a validação não for aprovada.
- ClientValidationFunction: função de script do lado do cliente (JavaScript ou similares) utilizada na validação do registro.
O RangeValidator é usado quando precisamos comparar se um valor se encontra dentro de um intervalo específico. Um exemplo de validação usado nessa situação seria uma verificação de um intervalo entre datas informadas. Suas principais propriedades são:
- ControlToValidate: controle que será validado.
- ErrorMessage: mensagem a ser exibida quando for usado o ValidationSummary.
- Text: texto exibido pelo controle na página, quando a validação não for aprovada.
- MaximumValue: valor máximo que será aceito pelo controle.
- MinimumValue: valor mínimo que será aceito pelo controle.
- Type: tipo de valor que será levado em conta para comparação do registro informado.
O componente RegularExpressionValidator é responsável por validar os dados que são digitados de acordo com uma expressão regular. Um bom exemplo disso é a validação de um e-mail informado (se ele possui o arroba(@), se ele começa com caracteres inválidos, entre outros). As principais propriedades do RegularExpressionValidator são:
- ControlToValidate: controle que será validado.
- ErrorMessage: mensagem a ser exibida quando for usado o ValidationSummary.
- Text: texto exibido pelo controle na página, quando a validação não for aprovada.
- ValidationExpression: expressão regular que irá determinar a validação do registro. Pode ser uma expressão informada pelo usuário (Custom) ou qualquer outra que já vem disponível para uso (demais expressões regulares).
O controle RequiredFieldValidator é um dos controles mais usados para a validação de dados e sua função é exigir a digitação de um valor em um campo específico. Suas principais propriedades são:
- ControlToValidate: controle que será validado.
- ErrorMessage: mensagem a ser exibida quando for usado o ValidationSummary.
- Text: texto exibido pelo controle na página, quando a validação não for aprovada.
- InitialValue: valor inicial a ser contado para a validação. É bom para utilizar em conjunto com o controle DropDownList, por exemplo, quando a seleção de um valor é item obrigatório para a realização de um processo.
Enfim, chegamos ao ValidationSummary. Sua função é criar um resumo que mostra quais são os itens que não foram aprovados no processo de validação, para que fique claro para o usuário quais são os dados que ele deve preencher corretamente. Suas principais propriedades são:
- DisplayMode: modo de exibição dos itens do sumário (parágrafo, lista ou lista com marcadores).
- ShowMessageBox: usada para exibir a lista de erros na forma de caixa de mensagens.
- ShowSummary: usada para mostrar a lista de erros na própria página.
E assim chegamos ao fim do primeiro artigo da nossa série sobre validação de dados com ASP.NET. Lembrando que na parte II, iremos desenvolver um tutorial passo a passo de uma página de cadastro para que possamos ver a funcionalidade dos controles de validação.
Um forte abraço e fique com Deus!!!
Introdução aos Padrões de Projeto (Design Patterns)
Os Padrões de Projeto (Design Patterns) são um conjunto de soluções documentadas com a finalidade de resolver determinados tipos de problema e/ou ajudar na organização de um produto/serviço. Surgiram na década de 1970, quando seu conceito foi criado pelo arquiteto Cristopher Alexander (pois é, eles não são coisas nativas da Informática).
Os Padrões de Projeto só começaram a ser implantados no Desenvolvimento de Software em 1987, quando Kent Beck e Ward Cunningham (pioneiros da Extreme Programming – XP) começaram a implementar os primeiros padrões, tomando como referência os conceitos defendidos por Alexander, a partir de um projeto de construção de janelas na linguagem Smalltalk.
Mas, em 1995, Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides, conhecidos como “A Gangue dos Quatro” (Gang of Four ou GoF) publicaram a obra Design Patterns: Elements of Reusable Object-Oriented Software, que fez com que o tema passasse a ganhar cada vez mais popularidade na comunidade dos Desenvolvedores de Software.
Nessa obra, o GoF catalogou vinte e três Padrões de Projeto, que se dividem em três grupos: os Criacionais (relacionados à criação de objetos), Estruturais (relacionados às associações entre classes e objetos) e os Comportamentais (relacionados à interação e divisão de responsabilidades entre classes e objetos).
Os Padrões de Projeto Criacionais são compostos pelos seguintes padrões:
- Abstract Factory
- Builder
- Factory
- Prototype
- Singleton
Os Padrões de Projeto Estruturais são compostos pelos padrões:
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
Os Padrões de Projeto Comportamentais são compostos pelos padrões:
- Chain of Responsability
- Command
- Interpreter
- Iterator
- Mediator
- Memento
- Observer
- State
- Strategy
- Template Method
- Visitor
O principal objetivo dessa série será abordar cada um dos 23 padrões GoF, mas, sempre que possível, irei trazer mais assuntos que possam ser encaixados dentro do estudo dos Padrões de Projeto. Em cada um dos artigos, vou explicar as características do Padrão em questão, mostrarei o diagrama de classes desse padrão e a codificação para implementação do padrão por meio de exemplos simples, que podemos tirar do nosso cotidiano. A linguagem que utilizarei para essa finalidade é o C# (C Sharp).
Será uma jornada longa, onde espero que todos nós possamos crescer muito em termos técnicos e como pessoas, por meio do feedback.
Um forte abraço e fiquem com Deus!!!
Resumo da Visita Técnica a Belo Horizonte
Olá, pessoal!
Devido aos compromissos da faculdade, infelizmente não pude postar o tanto quanto queria. Desculpem-me por essa falha, pessoal.
Espero que, de agora em diante, eu possa comparecer mais ao blog para poder postar mais conteúdos e opiniões que possam ajudar a todos.
O objetivo desse post é compartilhar com vocês a experiência que pude viver em uma visita técnica na qual alunos e professores da FATEC da UNIVALE participaram em Belo Horizonte nos dias 01 e 02 de junho.
Eu fui um dos privilegiados em participar desta visita, onde visitamos a UFMG (Pampulha) para conhecermos o mais novo supercomputador adquirido pela mesma e uma das sedes da empresa de desenvolvimento de software TOTVS. Não tenho palavras para descrever a experiência vivida nessa visita, não só tecnicamente, mas, principalmente, como pessoa. Por viajar pouco e estar acostumado com a rotina diária da nossa “cidade maravilhosa”, tive certo choque ao poder ver Belo Horizonte “mais de perto”. Das outras poucas vezes em que fui à capital mineira, ou foi em uma breve passagem (ainda menor que essa) ou eu era muito criança, ou seja, não tinha a visão que tenho hoje para construir uma opinião válida. O tamanho da cidade, das empresas e comércios lá presentes e suas variedades me fazem crer mais ainda que Governador Valadares seja uma cidade que “parou no tempo”.
A parte da manhã foi dedicada à visita do Campus da UFMG, localizado na Pampulha. Tivemos a oportunidade de conhecer o novo supercomputador adquirido pela universidade. Foi uma ótima experiência. Na saída da UFMG, uma sessão de fotos para guardar as lembranças do passeio.
Para mim, a melhor parte da visita foi a parte da tarde. Tivemos oportunidade de almoçar em um belo restaurante da capital, o Raja Grill, de onde podemos ter uma vista maravilhosa da capital, além das pistas de pouso e decolagem de helicópteros bem próximas do restaurante. Fora de série!!!
Depois do almoço, mais uma sessão de fotos (rsrs) para então caminharmos rumo a TOTVS, que fica a alguns metros do Raja Grill. Fiquei impressionado com a infra-estrutura da empresa, sua recepção, suas divisões, nível alto de qualidade.
Na TOTVS, assistimos a três palestras. A primeira, com o objetivo de apresentar a empresa, sua história, visão e missão. A segunda palestra teve como destaque a apresentação de um de seus produtos, o ERP que era produzido pela RM antes de ser adquirida pela TOTVS. Após um intervalo para o coffee break, assistimos à terceira palestra, que mostrou como é a metodologia de trabalho empregada na TOTVS.
Ao final da visita, fizemos um passeio pelos setores da empresa, onde podemos ver a área de suporte, desenvolvimento e help desk, a área de serviço de atendimento ao cliente, entre outros. Sem sombra de dúvida, para mim foi nessa visita à TOTVS que pude realmente conhecer a empresa e ver o seu potencial (ao contrário da palestra desastrosa que tivemos em nossa universidade, mas isso é um outro assunto…).
Mas, como tudo que é bom dura pouco, a hora de partir chegou e voltamos para nossa vida rotineira de cidade do interior, rsrs…
Uma das coisas mais importantes para mim foi a convivência mais próxima com os professores e os outros colegas da FATEC dos cursos de Ciência da Computação, Sistemas de Informação, Tecnologia em Análise e Desenvolvimento de Sistemas e Tecnologia em Sistemas para Internet.
Sem sombra de dúvidas, essa visita técnica foi a melhor coisa que me aconteceu nesse período letivo. Pelo menos houve algo de bom em relação ao período tecnicamente horroroso que foi dentro das salas de aula e laboratórios. Mas essa é uma outra história…
Clique aqui para visualizar algumas fotos da visita.
Um forte abraço e fique com Deus!!!
Uma breve comparação entre a Modelagem Orientada a Objetos e Modelagem Estruturada Relacional
Olá, pessoal!
O conteúdo desse artigo é fruto de um trabalho da disciplina Banco de Dados II, no qual foi pedido uma resenha sobre o artigo “Comparação entre a modelagem orientada a objeto e a modelagem estruturada relacional”, escrito por Marcos Leandro Figueiredo e Hélio Rubens Soares, estudantes do Curso de Especialização em Banco de Dados da UNITRI.
O artigo expõe de forma clara e objetiva as características, vantagens e desvantagens da Modelagem Orientada a Objetos e da Modelagem Estruturada Relacional, por meio de exemplos ilustrados e de fácil entendimento e como utilizar cada uma delas no contexto do seu projeto.
A Modelagem Orientada a Objetos tem como sua principal característica o uso dos paradigmas da Orientação a Objetos na construção do Diagrama de Classes, que é a estrutura que contém os elementos do sistema e seus atributos, propriedades, métodos e inter-relacionamentos. Por usar esse paradigma, o resultado da composição do Diagrama de Classes é uma estrutura baseada nos conceitos do mundo real.
A Modelagem Estruturada Relacional tem como o produto final do Diagrama Entidade-Relacionamento (DER) que, assim como o Diagrama de Classes, é uma estrutura composta por elementos que se inter-relacionam e são compostos por atributos, entidades e relacionamentos. Seu objetivo é ser um meio mais simples de representar o armazenamento dos dados de um sistema de informação, acrescentando um estágio intermediário ao projeto lógico do banco de dados. O DER é construído tendo por base uma análise feita para a solução de um determinado problema de forma abstrata.
Assim, tanto o Diagrama de Classes como o DER são formas de se projetar uma solução de um problema específico, sendo a elaboração de ambos um passo importantíssimo na construção do software, pois um erro mínimo a ser cometido pode ter conseqüências terríveis no projeto, como atraso nos prazos de entrega, alteração nos custos, entre outros. Ambos são muito eficazes, mas é imprescindível que o analista de sistemas saiba o que está fazendo no momento em que está modelando o software, pois o conhecimento prévio aliado à sua experiência é o que mais importa no final das contas.
E você, caro leitor? Tem alguma preferência sobre qual tipo de diagrama utilizar? Tem dicas, opiniões e experiências referentes ao assunto para passar? Aproveite, pois esse é seu espaço.
Espero que esse artigo possa contribuir na construção do seu conhecimento.
Um forte abraço e fique com Deus!!!
