ASP.NET MVC é um framework (presente no framework .Net 3.5 com SP1 e promete bastante evolução no framework.NET 4.0 que será lançado junto com o VS 2010) voltado para o desenvolvimento de aplicações web seguindo o padrão de arquitetura MVC Model-View-Controller que separa a aplicação em três (3) componentes principais: o modelo, a visão e controlador.
O framework MVC é definido no namespace System.Web.Mvc, suporta parte do namespace System.Web e permite o desenvolvimento de aplicações web utilizando a combinação dos dois tipos de abordagens Web Forms e MVC. Nenhuma abordagem exclui a outra.

O framework MVC inclui os seguintes componentes:

• Modelo (Model) – Objetos de modelo são partes da aplicação que implementam a lógica para as aplicações de domínio.
• Visão (Views) – Views são componentes de interface do usuário (UI).
• Controladores (Controllers) – Controladores são componentes que manipulam as interações dos usuários, trabalhando os dados com o model, e finalmente seleciona a view para “renderizar” os resultados de saída para mostrar no UI.

O padrão MVC permite separar os diferentes aspectos de uma aplicação web e fornece um baixo acoplamento entre elementos por especificar cada tipo de lógica que pode ser utilizada na aplicação. Esta separação permite um melhor gerenciamento de complexidade da aplicação, pois a concentração em um aspecto da programação de cada vez. Também possibilita o desenvolvimento guiado por teste (TDD) de uma forma mais fácil do que em Web Forms.
A perda de acoplamento entre os componentes de uma aplicação, MVC também promove desenvolvimento paralelo. Um desenvolvedor pode trabalhar em uma view, enquanto um segundo desenvolvedor pode trabalhar em uma lógica do contoller e um terceiro desenvolvedor pode focar na lógica de negocio do modelo.

Vantagens de uma aplicação baseada em MVC

A utilização do modelo MVC traz alguns benefícios ao desenvolvimento com relação ao antigo Web Forms como:

• Não utilize ViewState ou foms baseados em servidor (server).
• Maior liberdade para desenvolvedores que gostam do controle total sobre o comportamento de uma aplicação (HTML).
• Usa um padrão Front Controller que processa as requisições de uma aplicação web através de um simples controlador (controller). Isto possibilita o desenvolvimento de uma aplicação que suporta uma rica rota de infraestrutura.
• Fornece um suporte melhor para test-driven development (TDD).
• O ASP.NET MVC framework suporta Injeção de Dependência (ID) e Inversão de Controle (IC).
• Mapeamento de URL .
• Utilização das características existente com o uso de páginas (.aspx), user control (.ascx) e máster Page (.master ) no modelo MVC.

Até mais

O Framework.NET trouxe alguns benefícios referentes a utilização e gerenciamento de memória, permitindo mais liberdade de alocação e remoção de variáveis na memória em ordem aleatória, executado por meio de uma gerência complexa do espaço ocupado e identificação dos espaços livres.
Dessa forma vida de nós programadores se tornou muito mais fácil, pois não precisamos nos preocupar com o gerenciamento de memória (nada de malloc e free utilzados em C/C++), com isso temos menos erros relacionados ao vazamento de memória, bugs de ponteiros, entre outros.
O principal componente que realiza esse gerenciamento e liberação de memória é o Garbage Collector (Coletor de Lixo ou GC) existente na arquitetura do Common Language Runtime (CLR) e tem como princípio atividade de funcionamento:

1. Determinar quais objetos não mais será utilizado, ou seja, não estão mais acessíveis na aplicação;
2. Liberar os recursos (memória) utilizados por esses objetos

Entendendo o funcionamento do Garbage Collector

Basicamente o GC divide a memória disponível em 3 áreas distintas:

1. Maneged Heap
2. Pilha
3. Unmanaged Heap

O GC em conjunto com a CLR por meio de diversos algoritmos executa o gerenciamento da área de memória managed heap, que aloca reference types. Enquanto a pilha é utilizada para alocar value types. A unmanaged heap é utilizada para armazenar recursos não gerenciados de forma automática ou recursos nativos.
Mais detalhe da arquitetura do GC ficará para um próximo post, pois irá envolver alguns temas ainda não tratados.

Recursos Não Gerenciados

Um ponto importante é controle de recursos não gerenciados (recursos nativos, que pode ser um arquivo, janela, conexões de banco de dados, sockets, Win32, entre outros).
Implicitamente o Framework.NET mantém um controle das instâncias utilizadas pela aplicação, porem o mesmo não se repete para recursos não gerenciados. Para recursos não gerenciados deve-se fornecer uma maneira de liberar os recursos da memória depois que o aplicativo tiver terminado de usá-los, ou seja, deve ser um processo manual (codificado) executado pelo programador.
Há duas maneiras de se finalizar um recurso não gerenciado:

• Implicitamente utilizando o método Finalize();
• Explicitamente utilizando o método Dispose() do IDisposable;

Observação: Por padrão a Microsoft recomenda a implementar as duas formas de finalizar o objeto. Sendo que o método Finalize() serve de garantia de execução de liberação de memória impedindo que o recurso fique permanentemente vazando caso algum programador esqueça de chamar o método Dispose().

A primeira impressão que temos ao ver o finalizador (redefinindo ao método Finalize de System.Object) existente no .NET é que este atua como um destruidor (destructor) presente em linguagens com C/C++ é que são similares. Porem não se iluda pela aparência, pois são bem diferentes em suas características.

Caracteristicas do Finalizador:

• Execução nem sempre é não garantida;
• Execução não determinística (instante em que o método é executado não é conhecido);
• Chamada ao método ocorre desde que não existam ciclos infinitos;
• Quando chamado shutdown, sua execução só ocorre caso seu tempo de execução não seja superior a 2 segundos e o somatório não exceda 40 segundos (tempos aproximados);

Em resumo o CLR não garante a ordem de chamada dos métodos Finalize().

Exemplo de implementação do finalize:

Código C#.NET:

public class AlgumaClasse
{
   …
   ~AlgumaClasse() // finalizador
   {
      // código de limpeza
   }
   …
}

Codigo gerado pelo compilador:

public class AlgumaClasse
{
   …
   protected override void Finalize()
   {
      try { /* código de limpeza */ }
      finally { base.Finalize(); }
   }
   …
}

O método Dispose é uma implementação de um padrão conhecido como “padrão de descarte” e impõe uma ordem na vida de um objeto.
O método Dispose() deve liberar os recursos que ele possui assim como os recursos de propriedade de seus tipos base. Esse processo é executado através de uma hierarquia de tipos de base, ou seja, cada objeto irá chamar o método Dispose() da classe estendida ou implementada. Garantindo assim que os recursos são sempre limpos adequadamente.
Um característica particular do método Dispose() é que este pode ser chamado várias vezes sem lançar exceção.
É importante salientar que não há benefícios de desempenho na utilização do método Dispose() a objetos gerenciados pela CLR (tais como Arrays). Este método deve ser utilizado em objetos que utilizam recursos nativos e objetos COM que são expostas ao Framework.NET, como exemplo podemos citar a classe FileStream que implementa a interface IDisposable.

Exemplo de implementação do métiodo Dispose():

// Design pattern para uma classe base.
public class Base: IDisposable
{
   //Implementação da interface IDisposable.
   public void Dispose() 
   {
     Dispose(true);
      GC.SuppressFinalize(this); 
   }
 
   protected virtual void Dispose(bool disposing) 
   {
      if (disposing) 
      {
         // libera outros estados (managed objects).
      }
      // Libera sus próprios estados(unmanaged objects).
      // Define campos grandes como null.
   }
 
   // Sintaxe para finalização do código.
   ~Base()
   {
      //Chamada simples Dispose(false).
      Dispose (false);
   }
}
// Design pattern para a classe derived.
public class Derived: Base
{   
   protected override void Dispose(bool disposing) 
   {
      if (disposing) 
      {
         // Liberação de recursos gerenciados
      }
      // Liberação de recusos não gerenciados.
      // Define campos grandes como null.
      // Chama Dispose da classe base.
      base.Dispose(disposing);
   }
   // A classe derived não tem o método Finalize
   // ou um método Dispose com parametro pois herda da classe base.
}

Enjoy

Introdução

Primeiramente vamos conceiturar o que é socket, ou soquete em portugues. De uma visão geral um soquete pode ser definido como uma tomada que designa uma cavidade ou região usada para ligar algum artifício específico.

No mundo da computação, um socket é o elo de ligação entre os processos do servidor e do cliente. Ele é a “porta” na qual os processos enviam e recebem mensagens. De acordo com JAMES F KUROSE: “socket é a interface entre a camada de aplicação e a de transporte dentro de uma máquina”. Para quem não lembra, ou não sabe, camada de aplicação e transporte fazem parte do modelo OSI.
Através de um socket podemos estabelecer a comunicação entre máquinas possibilitando o envio e recebimento de dados.

A interface padronizada de sockets surgiu originalmente no sistema operacional Unix BSD (Berkeley Software Distribution). Tinha a função de suporte a comunicação em rede. Esta interface é a base para a maioria das interfaces entre protocolos de internet TCP/IP existente.

A identificação de um socket na rede é realizada por um IP e um porta. Comumente utiliza-se portas acima de 1000 pois as inferiores são utilizadas pelo sistema operacional. Sua comunicação é realizada pelos protocolos UDP ou TCP. Assim, é possível termos tanto comunicação orientada a conexão (via TCP), quanta não orientada a conexão (via UDP). O socket abstrai esse conceito, permitindo assim a utilização de qualquer um dos meios.

No C# para se trabalhar com sockets os recursos enconstram-se no namespace System.Net.Sockets.

Implementando uma aplicação com socket

Este é um simples código de uma aplicação Client/Server utilizando socket.
Abaixo o passo a passo de criação da aplicação:

Server App

1. Criar um projeto do tipo WindowsForm com o nome CommunicationSocket.
2. Incluir um botão que será utilizado para enviar mensagem do servidor para o cliente.

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Windows.Forms;
 
namespace CommunicationSocket
{
    public partial class ServerApp : Form
    {
        private Socket socket;
        private Thread thread;
 
        private NetworkStream networkStream;
        private BinaryWriter binaryWriter;
        private BinaryReader binaryReader;
 
        public ServerApp()
        {
            InitializeComponent();
            thread = new Thread(new ThreadStart(RunServer));
            thread.Start();
        }
 
        public void RunServer()
        {
            TcpListener tcpListener;
            try
            {
                IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2001);
                tcpListener = new TcpListener(ipEndPoint);
                tcpListener.Start();
 
                MessageBox.Show("Servidor habilitado e escutando porta...", "Server App");
 
                socket = tcpListener.AcceptSocket();
                networkStream = new NetworkStream(socket);
                binaryWriter = new BinaryWriter(networkStream);
                binaryReader = new BinaryReader(networkStream);
 
                MessageBox.Show("conexão recebida!", "Server App");
                binaryWriter.Write("\nconexão efetuada!");
 
                string messageReceived = "";
                do 
                {
                    messageReceived = binaryReader.ReadString();
                    MessageBox.Show("Mensagem: " + messageReceived, "Server App");
 
                } while (socket.Connected);
            } 
            catch (Exception ex) 
            {
                MessageBox.Show(ex.Message);
            } 
            finally 
            {
                binaryReader.Close();
                binaryWriter.Close();
                networkStream.Close();
                socket.Close();
 
                MessageBox.Show("conexão finalizada", "Server App");
            }
        }
 
        private void btnSendMsg_Click(object sender, EventArgs e)
        {
            try
            {
                binaryWriter.Write("Server respondendo: Houston, we have a problem!!!");
            }
            catch (SocketException socketEx)
            {
                MessageBox.Show(socketEx.Message, "Erro");
            }
        }
    }
}

Client App

1. Criar um projeto do tipo WindowsForm com o nome ClientApp.
2. Incluir botão que será utilizado para enviar mensagem do cliente para o servidor.

using System;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using System.Windows.Forms;
 
namespace ClientApplication 
{
    public partial class ClientAppForm : Form 
    {
        private NetworkStream networkStream;
        private BinaryWriter binaryWriter;
        private BinaryReader binaryReader;
        private TcpClient tcpClient;
 
        private Thread thread;
 
        public ClientAppForm() 
        {
            InitializeComponent();
            thread = new Thread(new ThreadStart(RunClient));
            thread.Start();
        }
 
        public void RunClient() 
        {
            try 
            {
                tcpClient = new TcpClient();
                tcpClient.Connect("127.0.0.1", 2001);
 
                networkStream = tcpClient.GetStream();
                binaryWriter = new BinaryWriter(networkStream);
                binaryReader = new BinaryReader(networkStream);
 
                String message = "";
                do 
                {
                    try 
                    {
                        message = binaryReader.ReadString();
                        MessageBox.Show(message, "Mensagem Recebida");
                    } 
                    catch (Exception ex) 
                    {
                        MessageBox.Show(ex.Message, "Erro");
                        message = "FIM";
                    }
                } while (message != "FIM");
 
                binaryWriter.Close();
                binaryReader.Close();
                networkStream.Close();
                tcpClient.Close();
            } 
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Erro");
            }
        }
 
        private void btnSendMsg_Click(object sender, EventArgs e) 
        {
            try 
            {
                binaryWriter.Write("Mensagem do cliente");
            } 
            catch (SocketException socketEx) 
            {
                MessageBox.Show(socketEx.Message, "Erro");
            }
        }
    }
}

Para realizar a comunicação o Servidor utiliza o objeto TcpListener que fica escutando toda requisição no IP “127.0.0.1″ porta 2001.
Na aplicação Cliente o objeto TcpClient é informado sobre o IP (ou DNS) e porta do servidor que irá se conectar. Após esse a realização toda a comunicação é feita por meio de stream através do objeto NetworkStream.

Repare que tanto Servidor quanto o Cliente trabalha com processamento em paralelo (Thread) para evitar que a aplicação fique travada até o término do processamento, ou para manter um processamento dedicado e contínuo que é o caso do servidor.

Nesse exemplo utilizei MessageBox para apresentar as mensagens, pois para inseri-las em um TextBox no Form é necessário utilizar delegates e reflections, senão teremos um erro de cruzamento de Threads (Cross-thread operation not valid).
Mas isso acho que é assunto para o nosso próximo post.

Até mais

Extension Methods é uma das muitas características que torna o LINQ possível .
Em resumo podemos dizer que Extension Methods é a possibilidade de inserir métodos em objetos já compilados. O método criado tem a característica de um método estático, porem só está acessível ao objeto associado.
Com esse recurso podemos adicionar aos .NET types novos métodos. Assim classes como StringHelpers, Util, entre outras, com uma variedade de métodos de auxílio, podem ser inseridos diretamente no fonte.
Exemplo de uma classe com validação:

using System.Text.RegularExpressions; 
namespace ExtensionMethodsExample
{
    public class Util
    {
        /// <summary>Verifica se o argumento do tipo string é um numérico</summary>
        /// <param name="arg">argumento a ser validado</param>
        /// <returns>True - se for numérico</returns>
        public bool IsNumeric(string arg)
        {
            return Regex.IsMatch(arg, @"^\d+$");
        }
    }
}

Com o uso do Extension Methods podemos inserir o método que verifica se a variável é numérica no próprio tipo string.
Abaixo um exemplo de seu uso, e depois vou explicar como o extension methods é declarado.

using System;
using System.Text.RegularExpressions;
 
namespace ExtensionMethodsExample
{
    public static class Extensions
    {
        public static bool IsNumeric(this string arg)
        {
             return Regex.IsMatch(arg, @"^\d+$");
        }
    }
} 
 
public class Program
{
    public static void Main(string[] args)
    {
        string codigo1 = "1234";
        string codigo2 = "ABCD";
 
        Imprime(codigo1);
        Imprime(codigo2);
    }
 
    private static void Imprime(string codigo)
    {
        if (codigo.IsNumeric())
        {
            Console.WriteLine("Codigo numerico: {0}", codigo);
        }
        else
        {
            Console.WriteLine("Codigo alphanumerico: {0}", codigo);
        }
    }
}

Para criarmos um extension methods precisamos de uma classe e método estático. Todo método extension sempre terá seu primeiro parâmetro a palavra reservada this, seguido do tipo ao qual o método será inserido, no exemplo o tipo string. Esse parâmetro representa a própria instância do objeto. Para os parâmetros subseqüentes serão utilizados na chamada do método. O nome da classe é de livre escolha, ela não interfere na implementação do extension methods, a única ressalva é que seja uma classe estática.

Compare a diferença da verificação de condição utilizando a classe Util e o extension methods

Util util = new Util();
if (util.IsNumeric(codigo))
{
    // faz algo
}

e

if (codigo.IsNumeric())
{
    // faz algo
}

O código torna-se mais legível e mais implícito seus métodos, tornando a linguagem muito mais dinâmica.
Enjoy

SQL Server sysobjects é uma tabela do SGBD SQL Server que armazena informações sobre os objetos criado no banco de dados. Contendo uma linha (registro) para cada objeto existente, como uma restrição, padrão, log, regra e procedimento armazenado.
No exemplo abaixo podemos encontrar informação sobre todos os objetos utilizados no banco de dados:
 

SELECT * FROM sysobjects
 

A coluna type e xtype possuem informação sobre o tipo de objeto. Tome cuidado para não confundir os valores das constantes. Há pequenas particularidades entre elas.
Para exibir todas as tabelas criadas pelo usuário executamos a seguinte instrução:
 

SELECT  * FROM sysobjects WHERE xtype='U'
 

Ou saber as trigger existentes em cada tabela:

 
SELECT
    Sys2.name           AS TableName,
    Sys1.name           AS TriggerName,
    CASE
        WHEN Sys1.deltrig > 0 THEN 'Delete'
        WHEN Sys1.instrig > 0 THEN 'Insert'
        WHEN Sys1.updtrig > 0 THEN 'Update'
    END
FROM
    sysobjects Sys1
    INNER JOIN sysobjects Sys2 ON
        Sys1.parent_obj = Sys2.id
WHERE
    Sys1.xtype = 'TR'
ORDER BY
    Sys2.name
 

Lista de possibilidades de valores para a coluna xtype:

• C = CHECK constraint 
• D = Default or DEFAULT constraint 
• F = FOREIGN KEY constraint 
• L = Log 
• P = Stored procedure 
• PK = PRIMARY KEY constraint (type is K) 
• RF = Replication filter stored procedure 
• S = System table 
• TR = Trigger 
• U = User table 
• UQ = UNIQUE constraint (type is K) 
• V = View 
• X = Extended stored procedure

 
A tabela syscolumns retorna uma linha para cada coluna de um objeto que tem colunas, como exibições ou tabelas. E pode ser um auxilio na obtenção de informação sobre as colunas das tabelas:

 
SELECT 
    *
FROM 
    sysobjects SysObj
    INNER JOIN syscolumns SysCol ON
        SysObj.id = SysCol.id
WHERE 
    SysObj.type='U'
    AND
    SysObj.name = 'tbl_cliente'
 

Referência:

• MSDN Microsoft

Observação: Os exemplos deste post foram criados para a versão 2005 do SQL Server, para versão 2000 do SQL Server consulte o artigo Mapeando tabelas do sistema do SQL Server 2000 para exibições do sistema do SQL Server 2005

Primeiramente vamos as definições:

• Literal é um controle que reserva um local da página para exibir um texto estático.
• Label é um controle de rótulo usado para mostrar textos na página.

Ambos os controles possuem a propriedade Text, que define o texto a ser exibido.
Não há um controle melhor ou pior. E sim saber quando e como utilizar esses controles corretamente. O mais importante é entender e saber o que é produzido em sua renderização.
É nesse momento que as diferenças ficam mais aparentes.

Criando um projeto para comparar os controles
Para exemplificar os controles criei um ASP.Net Web Site com o nome LabelTeste
Na página Default.aspx inclui o seguinte código interno a tag form:

<div id="teste">
        <h3>Controles ASP.Net</h3>
        <p><asp:Label ID="lblTeste1" runat="server"></asp:Label></p>
        <p><asp:Literal ID="ltrTeste1" runat="server"></asp:Literal></p>
        <p><asp:Label ID="lblTeste2" AssociatedControlID="txtTeste2" runat="server"></asp:Label><asp:TextBox ID="txtTeste2" runat="server"></asp:TextBox></p>
</div>

Ao executar a aplicação, teremos a seguinte tela:

Clique com o botão direito e selecione codigo-fonte e veja o código gerado 

<div id="teste">
        <h3>Controles ASP.Net</h3>
        <p><span id="lblTeste1">label 1</span></p>
        <p>literal 1</p>
        <p><label for="txtTeste2" id="lblTeste2">label 2</label><input name="txtTeste2" type="text" id="txtTeste2" /></p>
</div>

Repare no código gerado. O controle Label renderiza o texto interno das tags span, que na maioria das vezes é desnecessário. Isso aumenta a quantidade de código a ser trafego do servidor para o cliente. Neste caso que só queriamos a apresentação de um texto, damos preferência ao Literal, que renderiza somente o texto de uma forma estática sem geração de tags.
A principal vantagem do Label é quando necessitamos de associa-lo a um outro controle. Que é feito por meio do atributo AssociatedControlID.
Assim é gerado as tags label que são utilizadas para dar foco a um outro controle.

Até mais

Entre as utilização de reflection podemos citar a instânciação de classes ou a utilização de plugins (como os utilizados no firefox), que são definidos em tempo de execução.

Basicamente reflection é uma maneira de se descobrir dados de uma classe/objeto/interface em tempo de execução. Dessa forma podemos examinar os tipos em um assembly e interagir com eles ou instanciá-los. Também podemos criar tipos no momento de execução.

Neste post criarei um exemplo de instânciar objetos em tempo de execução (runtime) utilizando reflection.
Abaixo segue um diagrama de classe do modelo utilizado para o exemplo:

Utilizando reflection

using System;
using System.Collections.Generic;
using System.Reflection;
 
namespace UtilizandoReflection {
    public class Program {
        public static void Main(string[] args) {
 
            StateFactory factory = new StateFactory();
 
            // Cria 3 produtos em estado diferentes
            Product product1 = new Product();
            Product product2 = new Product();
            Product product3 = new Product();
 
            product1.State = factory.Create(1, "item pendente");
            product2.State = factory.Create(2, "item no estoque");
            product3.State = factory.Create(3, "item vendido");
 
            Console.WriteLine("Produto {0}: {1} -- Type {2}", product1.State.ID, product1.State.Description, product1.State.GetType().ToString());
            Console.WriteLine("Produto {0}: {1} -- Type {2}", product2.State.ID, product2.State.Description, product2.State.GetType().ToString());
            Console.WriteLine("Produto {0}: {1} -- Type {2}", product3.State.ID, product3.State.Description, product3.State.GetType().ToString());
        }
    }
 
    /// <summary>Classe responsável por criar intâncias de estado</summary>
    public class StateFactory {
        private Dictionary<int, string> states;
 
        public StateFactory(){
            states = new Dictionary<int, string>(3);
            states.Add(1, "Pending");
            states.Add(2, "Stock");
            states.Add(3, "Sold");
        }
 
        /// <summary>Cria uma instância de estado</summary>
        /// <param name="ID">Identificador da instância</param>
        /// <param name="description">descrição do estado</param>
        /// <returns>Estado</returns>
        public State Create(int ID, string description) {
 
            string baseName = "UtilizandoReflection";
 
            // cria array com os parâmetro utilizado no construtor do estado
            object[] args = new object[2];
            args.SetValue(ID, 0);
            args.SetValue(description, 1);
 
            //using System.Reflection
            Assembly assembly = Assembly.Load(baseName);
            return (State)assembly.CreateInstance(baseName + "." + states[ID], true, BindingFlags.CreateInstance, null, args, null, null);
        }
    }
 
    #region Domain
    public class Product {
        public State State;
    }
    public abstract class State {
        public int ID;
        public string Description;
        public State(int ID, string description) {
            this.ID = ID;
            this.Description = description;
        }
    }
    public class Pending : State { // estado pendente
        public Pending(int ID, string description) : base(ID, description) { }
    }
    public class Stock : State { // estado estoque
        public Stock(int ID, string description) : base(ID, description) { }
    }
    public class Sold : State { // estado vendido
        public Sold(int ID, string description) : base(ID, description) { }
    }
    #endregion
}

Resultado da execução:

Produto 1: item pendente -- Type UtilizandoReflection.Pending
Produto 2: item no estoque -- Type UtilizandoReflection.Stock
Produto 3: item vendido -- Type UtilizandoReflection.Sold


Observe que as classes a serem instanciadas por reflection estão na mesma solution ou project, assim utilizamos o método Load do Assembly, porem quando a classe a ser utilizada for de uma DLL, utilizamos o método LoadFile e informamos o nome completo da DLL.

Como mencionado no início do post, há outras utilizações de reflection, como manipular atributos e métodos, mas isso é assunto para um próximo post.

Enjoy

Validation é um plugin do framework jQuery que permite fazer a validação de formulários de várias maneiras.
Neste post vou demonstrar como realizar algumas validações em um formulário utilizando o este plugin.

Para é necessário fazer o download do jQuery plugin: Validation

Pronto agora que temos todos os arquivos necessário, devemos incluir na tag de nosso exemplo o seguinte trecho de código:

<script language="JavaScript" src="jquery/jquery-1.3.2.js" type="text/javascript"></script>
<script language="JavaScript" src="jquery-validate/jquery.validate.js" type="text/javascript"></script>

Ainda dentro da tag head, inserimos o trecho de código que fará a validação de nosso formulário:

$(document).ready( function() {
    $("#cadastro").validate({
        // Define as regras
        rules:{
            nomeCliente:{
                required: true, 
                minlength: 2
             }
         },
         // Define as mensagens de erro para cada regra
         messages:{
              nomeCliente:{
                  required: "Digite o seu nome.",
                  minLength: "O seu nome deve conter, no mínimo, 2 caracteres."
              }
          }
    });		
});

Agora é só inserir o código HTML do formulário a página:

<form id="cadastro" method="post" action="">
    <p><label>Nome:</label><input type="text" id="nome_cliente" name="nomeCliente" /></p>
     <input type="submit" value="Enviar" />
</form>

Observe que as regras e mensagens aplicadas a caixa de texto são referênciadas pelo nome do elemento (atributo name) e não pelo id.

Dessa forma, podemos fazer validações de formulário, de uma forma simples e rápida. Mais informações e métodos de valições podem ser entrados na documentação oficial do JQuery.

Para quem conhece css, o código gerado ao apresentar a mensagem contem o atributo class com o valor error, que pode ser usado para aprimorar o layout do formulário.

<form id="cadastro" action="" method="post">
    <p><label>Nome:</label><input id="nome_cliente" class="error" type="text" name="nomeCliente"/>
            <label class="error" for="nome_cliente" generated="true">O seu nome deve conter, no mínimo, 2 caracteres.</label>
     </p>
     <input class="submit" type="submit" value="Enviar"/>
</form>

Enjoy

O problema que o Ajax tenta resolver está enraizado no protocolo de comunicação HTTP. Isso porque esse protocolo é sem estado (stateless), assim o controle das ações executadas na aplicação cliente é controlado pelo código no servidor web. Ou seja, as alterações (ou entrada de dados) executadas na página web pelo usuário são enviadas para o servidor para que este atualize seu estado, e o servidor responde a alteração reenviado todo o HTML para o browser.

Mas o que é o Ajax?

Ajax é o acrônimo (da língua inglesa) de Asynchronous Javascript and XML, ele não é uma linguagem de programação e sim a combinação de tecnologias existentes (Javascript, XML e XmlHttpRequest) que nos permite realizar solicitações assíncronas ao servidor para busca de informações e/ou atualizar seu estado.
Em outras palavras o Ajax, é um objeto presente nos browser atuais que combinado com JavaScript pode se comunicar com o servidor Web sem recarregar e redesenhar a página inteira.

Utilizando do Ajax

O exemplo abaixo apresenta uma página chamada calcProduto.html, onde o usuário escolhe o tipo de produto e informa a quantidade de produto que gostaria de adquir. Ao clicar no botão calcular, é realizado via ajax uma requisição ao servidor web (arquivo calcProduto.php) que realiza o calculo necessário e sua reposta é renderizada sem recarregar a página html.

Abaixo o código do arquivo calcProduto.html:

<html>
    <head>
        <title>Produto</title>
        <script language="javascript" type="text/javascript">
 
            var request = null;
 
            // função que cria objeto de requisição
            function createRequest () {
                try {
                    // cria objeto XmlHttpRequest para os browser Firefox, Safari, Opera
                    request = new XMLHttpRequest();
                } catch( trymicrosoft ) {
                    try {
                        // cria objeto XmlHttpRequest para o browser IE
                        request = new ActiveXObject( "Msxm12.XMLHTTP" );
                    } catch( othermicrosoft ) {
                        try{
                            // cria objeto XmlHttpRequest para o browser IE
                            request = new ActiveXObject( "Microsoft.XMLHTTP" );
                        } catch( failed ) {
                            request = null;
                        }
                    }
                }
                if ( request == null ) {
                    alert( "Erro ao criar objeto Request!" );
                }
            }
 
            // função que executa chamada ao servidor para realizar o calculo
            function getPrice () {
 
                createRequest ();
 
                var prod = document.getElementById( "produto").value;
                var qtd = document.getElementById( "quantidade").value;
                var url = "calcProduto.php?produto=" + prod + "&quantidade=" + qtd;
 
                request.open( "GET", url, true );
                request.onreadystatechange = updatePage; // define função a ser chamada a obter resposta do servidor web
                request.send( null ); // null informa que não está sendo enviado nenhum dado na requisição
            }
 
            // função chamada ao obter retorno da requisição e atualiza interface
            function updatePage () {
 
                if( request.readyState == 4 ) {
                    if( request.status == 200 ){
                        var resultado = document.getElementById( "resultado" );
                        resultado.innerHTML = request.responseText;
                    }
                    else{
                        alert( "Erro: não foi possível obter resposta do servidor." );
                    }
                }
            }
 
        </script>
    </head>
    <body>
        <h1>Calculo de produto</h1>
        <p> Escolha um produto e informe a quantidade.</p>
        <form method="GET" action="calcProduto.php">
            <p> Produto: 
                <select name="produto" id="produto">
                    <option value="0">Caneta</option>
                    <option value="1">Borracha</option>
                    <option value="2">Giz</option>
                    <option value="3">Apagador</option>
                </select>
            </p>htm
            <p> Quantidade <input type="text" name="quantidade" id="quantidade"></p>
            <p><input type="button" value="Calcular" onClick="getPrice();"></p>
        </form>
        <div id="resultado">
        </div>
    </body>
</html>

O código utilizado no servidor web:

<?php
    $produto = $_REQUEST['produto'];
    $qtd = $_REQUEST['quantidade'];
 
    $prodName = '';
    $vlr = '';
 
    switch($produto){
        case "0":
            $prodName = 'Caneta';
            $vlr = 1;
            break;
        case '1':
            $prodName = 'Borracha';
            $vlr = 2;
            break;
        case '2':
            $prodName = 'Giz';
            $vlr = 3;
            break;
        case '3':
            $prodName = 'Apagador';
            $vlr = 4;
            break;
    }
    $total = $qtd * $vlr;
?>
<h3>Calculo:</h3>
<table  border=1 >
    <tr>
        <td>Produto</td>
        <td>Quantida</td>
        <td>Valor unidade</td>
        <td>Total</td>
    </tr>
    <tr>
        <td><?php print $prodName ?></td>
        <td><?php print $qtd ?></td>
        <td><?php echo "R$ " .number_format($vlr, 2, ',', '.'); ?></td>
        <td><?php echo "R$ " .number_format($total, 2, ',', '.'); ?></td>
    </tr>
</table>

Futuramente falarei um pouco mais sobre o componente XmlHttpRequest e seus recursos.
Enjoy

Olá pessoal,

No post anterior Requisição HTTP com Java Application Parte 1 , falei um pouco sobre como obter o conteúdo de uma página web. Mas nem sempre somente o conteúdo de uma página nos interessa.
Na maioria das vezes necessitamos que de uma interação com a página (ou páginas) por meio de troca de informação, ou seja, enviamos dados, a página processa os dados e nos retorna a informação.

Para isso iremos trabalhar com o objeto URLConnection, objeto existente no pacote java.net.
Veja o exemplo abaixo:

package teste.comunication;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
 
public class TesteComunicacao {
 
	public static void main(String[] args) 
			throws MalformedURLException, IOException {
 
		try{
			// monta estrutura de parametros a serem eviados
			String data = URLEncoder.encode( "nome", "UTF-8" ) + "=" + URLEncoder.encode( "Fernando", "UTF-8" );
 
		         URL url = new URL( "http://localhost/get_name.php" );
	                 URLConnection urlConnection = url.openConnection();
 
	                 // envia dados
	                 urlConnection.setDoOutput(true);
	                 OutputStreamWriter outputWriter = new OutputStreamWriter(urlConnection.getOutputStream());
	                 outputWriter.write(data);
	                 outputWriter.flush();
 
	                 // Obtem as respostas
	                 InputStreamReader inputReader = new InputStreamReader(urlConnection.getInputStream());
	                 BufferedReader bufferedReader = new BufferedReader( inputReader );
 
			System.out.println( "\n** retorno da página web **" );
			String linha = "";
			while ( (linha = bufferedReader.readLine()) != null){
				System.out.println(linha);
			}
 
		} catch (Exception e) {
			System.out.println( e.getMessage() );
		}
	}
}

Após instânciar o objeto URL, podemos obter o objeto URLConnection através do seu método openConnection.
O método urlConnection.setDoOutput(true); é executado para informar que será enviado parâmetros.
Depois obtemos o stream de saída e enviamos os dados (obs: esses dados são enviados via método POST).
O retorno é obtido através do método urlConnection.getInputStream que é tratado por meio do objeto InputStreamReader.

Para simular o processamento dos dados enviados gerei um arquivo PHP com o seguinte código:


<?php
$response = $_POST['nome'];

echo "Conteúdo recebido: ";
echo $response;
?>


Ele simplesmente lê o dado recebido e gera uma resposta apartir das informações obtidas.

Enjoy