Aqui está um resumo:

Um comboio do metrô de Nova Iorque transporta 1.200 pessoas. Este blog foi visitado cerca de 5.700 vezes em 2011. Se fosse um comboio, eram precisas 5 viagens para que toda gente o visitasse.

Clique aqui para ver o relatório completo

public class Endereco
{
    private string _numero;

    public string Numero
    {
        get { return _numero; }
        set { _numero = value; }
    }
}

Porém podemos neste caso escrever este código da seguinte forma:

public class Endereco
{
    public string Numero { get; set; }
}

Muito mais simples não? Caso queiram declarar uma propriedade como read-only é só fazer da seguinte forma.

public class Endereco
{
    public string Numero { get; private set; }
}

Bom pessoal é isto espero que tenham gostado. Para quem quiser ter mais detalhes teóricos segue o link msdn.microsoft.com. Até a próxima.

E para não ficar apenas em um exemplo de como utilizar o Event Viewer com Delphi, desenvolvi toda uma estrutura de logs de mensagens utilizando Interfaces, onde ficará fácil caso queiram mudar a forma de gravação dos logs das aplicações de vocês, e também, estou utilizando neste exemplo uma arquitetura onde será fácil aplicar IoC (Inversão de Controle) e DI (Injeção de Dependências), vou deixar para falar deste dois Padrões em outro post.

O primeiro código é o nosso enumerator, que irá conter os tipos possíveis de log das mensagens da aplicação. Não é necessário separar este enumerator da unit que irá conter a nossa interface descrita abaixo, fiz está separação apenas para organizar melhor os arquivos da aplicação.

unit LogType;

interface

type
  TLogType = (Information, Warning, Error);

implementation

end.

O segundo código é a nossa Interface (Contrato), onde todas as classes que irão realizar logs deverão. Note que estou utilizando summary, ele é usado para descrever informações sobre o tipo ou membros do tipo, para quando formos utilizar já venha à definição do tipo no Intellisense como tipos próprio Delphi e também é uma forma de documentação do código fonte.

unit Logger;

interface

uses
  LogType;

type
  ILogger = interface
    /// <summary>
    /// Registra os logs.
    /// </summary>
    /// <param name="message">Mensagem que será registrada.</param>
    /// <param name="logType">Tipo do log.</param>
    procedure Write(message: string; logType: TLogType);
  end;

implementation

end.

Abaixo a implementação da nossa classe que será responsável por registrar os logs no Event Viewer do Windows. Não há muito que comentar do código apenas que estou utilizando um arquivo *.ini, localizado no path da aplicação para guardar as configurações do sistema e que não estou usando Strategy Pattern, vou deixar o código da forma que está para refatorar ele e explicar melhor este Pattern em outro artigo.

unit LoggerEventViewer;

interface

uses
  Forms, IniFiles, SysUtils, SvcMgr, Windows, Logger, LogType;

type
  TLoggerEventViewer = class(TInterfacedObject, ILogger)
  public
    { Public declarations }
    procedure Write(message: string; logType: TLogType);

  end;

implementation

{ TEventView }

procedure TLoggerEventViewer.Write(message: string; logType: TLogType);
var
  iniFiles: TIniFile;
  eventLogger: TEventLogger;

begin
  iniFiles := TIniFile.Create(Format('%s%s', [ExtractFilePath(Forms.Application.ExeName), 'Config.ini']));
  eventLogger := TEventLogger.Create(iniFiles.ReadString('Application', 'LoggerEventSource', ''));
  try
    case logType of
      TLogType.Error:
        eventLogger.LogMessage(message, EVENTLOG_ERROR_TYPE, 0, 0);

      TLogType.Warning:
        eventLogger.LogMessage(message, EVENTLOG_WARNING_TYPE, 0, 0);

      TLogType.Information:
        eventLogger.LogMessage(message, EVENTLOG_INFORMATION_TYPE, 0, 0);
    end;
  finally
    iniFiles.Free();
    FreeAndNil(eventLogger);
  end;
end;

end.

Abaixo a implementação da nossa classe que será responsável por registrar os logs em arquivo texto. A única consideração é que estou utilizando o método WriteAllText da classe TFile contida na nova unit IOUtils para IO (input/output) do Delphi, este método sempre sobrescreve o conteúdo do arquivo (não é recomendado o uso para realizar logs já que não grava a informação que já existia no arquivo, estou utilizando apenas como exemplo), também verifica se existe criado no disco caso não existe ele já cria automaticamente.

unit LoggerFileText;

interface

uses
  Forms, IniFiles, IOUtils, TypInfo, SysUtils, Logger, LogType;

type
  TLoggerFileText = class(TInterfacedObject, ILogger)
  public
    { Public declarations }
    procedure Write(message: string; logType: TLogType);

  end;

implementation

{ TEventView }

procedure TLoggerFileText.Write(message: string; logType: TLogType);
var
  iniFile: TIniFile;

begin
  message := Format('%s - %s', [GetEnumName(TypeInfo(TLogType), Integer(logType)), message]);
  iniFile := TIniFile.Create(Format('%s%s', [ExtractFilePath(Application.ExeName), 'Config.ini']));
  try
    TFile.WriteAllText(iniFile.ReadString('Application', 'LoggerFilePath', ''), message);
  finally
    iniFile.Free();
  end;
end;

end.

Caso queiram gravar os logs também em banco de dados ou deixar já uma classe que permita está ação, é necessário apenas implementar a forma de acesso e gravação no banco de dados dentro do método Write, vocês irão notar mais abaixo que a forma de utilização da classe não irá mudar.

unit LoggerDatabase;

interface

uses
  Logger, LogType;

type
  TLoggerDatabase = class(TInterfacedObject, ILogger)
  public
    { Public declarations }
    procedure Write(message: string; logType: TLogType);

  end;

implementation

{ TEventView }

procedure TLoggerDatabase.Write(message: string; logType: TLogType);
begin
  { Implementar a forma de acesso e gravação na base de dados. }
end;

end.

Abaixo o código da nossa classe que será responsável por gerenciar os logs da aplicação. Note que existem dois métodos Create, um está recebendo uma variável ILogger que é a nossa interface que contém os métodos responsáveis por fazer o log da aplicação, este é um exemplo de IoC. E o outro método Create irá chamar o método descrito acima passando a forma de autenticação que será utilizada na aplicação por padrão, este é um exemplo de DI. Da forma que foi desenvolvida está classe fica fácil usar um Container de Dependências que será assuntos de outro post.

unit LogManager;

interface

uses
  Logger, LogType;

type
  TLogManager = class
  private
    { Private declarations}
    _logger: ILogger;

  public
    { Public declarations }

    /// <summary>
    ///
    /// </summary>
    /// <param name="logger"></param>
    constructor Create(const logger: ILogger); overload;

    /// <summary>
    ///
    /// </summary>
    constructor Create(); overload;

    /// <summary>
    /// Registra os logs do tipo informação.
    /// </summary>
    /// <param name="message">Informação que será registrada.</param>
    procedure WriteInfo(message: string);

    /// <summary>
    /// Registra os logs do tipo atenção.
    /// </summary>
    /// <param name="message">Mensagem de atenção que será registrada.</param>
    procedure WriteWarning(message: string);

    /// <summary>
    /// Registra os logs do tipo erro.
    /// </summary>
    /// <param name="message">Erro que será registrado.</param>
    procedure WriteError(message: string);

  end;

implementation

uses
  LoggerEventViewer, LoggerFileText;

{ TLogManager }

constructor TLogManager.Create(const logger: ILogger);
begin
  _logger := logger;
end;

constructor TLogManager.Create();
begin
  Create(TLoggerFileText.Create());
end;

procedure TLogManager.WriteInfo(message: string);
begin
  _logger.Write(message, TLogType.Information);
end;

procedure TLogManager.WriteWarning(message: string);
begin
  _logger.Write(message, TLogType.Warning);
end;

procedure TLogManager.WriteError(message: string);
begin
  _logger.Write(message, TLogType.Error);
end;

end.

Para utilizar as nossas classes de log é necessário antes colocar no uses as units abaixo.

uses
  Logger, LogManager, LoggerEventViewer;

Existem duas formas de utilizar a nossa classe LogManager. A primeira forma, é apenas instanciar o nosso objeto logManager do tipo TLogManager sem passar nenhum objeto no construtor, sendo assim a nossa classe será responsável por instanciar a variável do tipo ILogger com a classe padrão de realizar logs do sistema. Segue abaixo um exemplo.

var
  logManager: TLogManager;

begin
  logManager := TLogManager.Create();
  try
    logManager.WriteInfo('Mensagem de info do projeto de estudo!');
    logManager.WriteWarning('Mensagem de warning do projeto de estudo!');
    logManager.WriteError('Mensagem de error do projeto de estudo!');
  finally
    FreeAndNil(logManager);
  end;
end;

A segunda forma é criar uma variável do tipo ILogger e depois instanciar este objeto com a classe na qual deseja realizar o log da aplicação, e passar como parametro no construtor do método Create da classe TLogManager. Note que a forma de utilização é a mesma para todos os casos, o que altera é apenas a classe que irá instanciar o nosso objeto, com isto, mudar a forma que se realiza o log e a manutenção do código se torna muito mais simples e fácil. Segue abaixo um exemplo.

var
  logger: ILogger;
  logManager: TLogManager;

begin
  logger := TLoggerEventViewer.Create();
  logManager := TLogManager.Create(logger);
  try
    logManager.WriteInfo('Mensagem de info do projeto de estudo!');
    logManager.WriteWarning('Mensagem de warning do projeto de estudo!');
    logManager.WriteError('Mensagem de error do projeto de estudo!');
  finally
    FreeAndNil(logManager);
  end;
end;

Abaixo as configurações do nosso arquivo de configuração Config.ini localizado junto ao executável do projeto.

[Application]
//Caminho que será gravado o arquivo de log.
LoggerFilePath='C:\EstudoDelphi.txt'

//Nome da fonte do Event Viewer.
LoggerEventSource='EstudoDelphi'

Para abrir o Event Viewer do Windows, basta ir no Executar e digitar: eventvwr.msc. A imagem abaixo mostrar como ficará o log registrado. Para melhor visualização clique na imagem.

Se quiserem o código fonte do exemplo, é só clicar aqui. Espero que tenham gostado deste artigo. Agradeço a visita.

Segue o código do nosso método responsável por fazer a requisição no servidor.

private static string HttpGet(string url)
{
    string result;

    try
    {
        //Faz a requisição a url montada acima.
        using (var resp = WebRequest.Create(url).GetResponse())
        {
            var reader = new StreamReader(resp.GetResponseStream());
            result = reader.ReadToEnd();
        }
    }
    catch
    {
        throw new Exception(@"Ocorreu um erro!");
    }

    return result;
}

Método responsável por fazer a validação dos dados antes de realizar a solicitação no servidor.

private bool Validacao()
{
    if (TxtCPF.Text.Trim() == string.Empty)
    {
        MessageBox.Show(@"Digite um CPF!");
        TxtCPF.Focus();
        return false;
    }

    return true;
}

Método principal da aplicação. Note que estou utilizando uma classe chamada JObject para fazer a conversão dos dados de retorno do servidor para um objeto em JSON, está classe está contida na Class Library Newtonsoft.Json.dll para trabalhar com dados em JSON. Segue o link do projeto para download Json.NET. Estou utilizando está classe pois achei bem simples a forma de utilização.

private void BtnValidar_Click(object sender, EventArgs e)
{
    //Verifica se o campo CPF foi digitado.
    if (!Validacao()) return;

    //Caminho do servidor de aplicação.
    const string servidor = @"http://localhost:8081/datasnap/rest/";

    //Método que será consumido.
    const string metodo = @"TServerFunctions/validateCPF/";

    //Parametros do método.
    var parametro = TxtCPF.Text.Trim();

    //URL que será processada.
    var url = string.Format("{0}{1}{2}", servidor, metodo, parametro);

    string pagina;
    try
    {
        //Faz a requisição a url montada acima.
        pagina = HttpGet(url);
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);

        return;
    }

    //Verifica se o método retornou algum valor.
    if (pagina == null) return;

    //Lê os dados de retorno do servidor passando para JSON.
    var obj = JObject.Parse(pagina);

    //Verifica o retorno do método. 
    //E mostra para o usuário.
    var array = (JArray)obj["result"];
    if ((bool)array[0])
        MessageBox.Show(@"CPF válido!");
    else
        MessageBox.Show(@"CPF inválido!");
}

Este foi mais um post de integração usando DataSnap espero que tenham gostado.

Em uma thread na lista de discução lista-delphi o membro Caique vez uma colocação perfeita do Garbage Collector no Delphi e como tinha prometido na thread vou compartilhar com vocês a explicação dele. Segue o link da thread.

O Delphi “não” tem Garbage Collector. Entende-se por Garbage Collector uma forma de destruir qualquer objeto fora de contexto como ocorre em plataformas gerenciadas. O que esta demonstrando no seu exemplo é o uso de interfaces e estas sim por definição destroem o objeto a qual estão associadas quando saem do contexto.

Primeiro desenvolvi uma classe que será responsável por coletar os objetos que não estão mais sendo utilizados.

unit GarbageCollector;

interface

uses
  SysUtils;

type
  ISafeGuard = type IUnknown;

type
  TSafeGuard = class(TInterfacedObject, ISafeGuard)
  private
    { Private declarations }
    FObj: TObject;

  public
    { Public declarations }
    constructor Create(obj: TObject);
    destructor Destroy(); override;

  end;

function Guard(out SafeGuard : ISafeGuard) : TObject;

implementation

{ TSafeGuard }

constructor TSafeGuard.Create(obj: TObject);
begin
  self.FObj := obj;
end;

destructor TSafeGuard.Destroy();
begin
  if (Assigned(self.FObj)) then
  begin
    try
      FreeAndNil(self.FObj);
    except
      on e : EInvalidPointer do
        { Objeto já liberado da memória. }
    end;
  end;

  inherited Destroy();
end;

function Guard(out SafeGuard: ISafeGuard): TObject;
begin
  Result := TObject.Create();
  SafeGuard := TSafeGuard.Create(Result);
end;

end.

Depois criei um Class Helper para a classe TObject do Delphi com isto garantimos que todos os objetos que herdam a classe TObject serão coletados pelo nosso Garbage Collector. Note que estou utilizando Generics para a nossa função New() já realizar o cast no objeto sem agente precisar se preocupar com isto.

unit HelperObject;

interface

uses
  SysUtils, Generics.Collections, GarbageCollector;

type
  THelperObject = class helper for TObject
  public
    { Public declarations }
    class function New<T>(out SafeGuard: ISafeGuard): T; static;

  end;

implementation

{ THelperObject }

class function THelperObject.New<T>(out SafeGuard: ISafeGuard): T;
begin
  Result := T(Guard(SafeGuard));
end;

end.

Agora a forma de utilização.

var
  SafeGuard: ISafeGuard;
  label1: TLabel;

begin
  label1 := TLabel.New<TLabel>(SafeGuard);
end;

Para garantir que a memória está sendo liberada, utilize a mesma propriedade do post anterior Garbage Collector no Delphi – Parte I, neste post está explicado detalhadamento como deve ser utilizada.

ReportMemoryLeaksOnShutdown := True;

Este foi mais um exemplo em Delphi XE. Espero que tenham gostado e que seja útil de alguma forma a vocês.

Segue o código da nossa página principal “index.htm“. O código é bem simples apenas para mostrar a integração do PHP com o DataSnap Server, a única observação é que estou utilizando o framework jQuery para JavaScript apenas para deixar o exemplo mais interessante. Segue o link para download jqueryui.com.

<html>
<head>
    <title>ClientPHP</title>
    
    <!--jQuery-->
    <link rel="stylesheet" type="text/css" href="includes/css/ui-lightness/jquery-ui-1.8.9.custom.css">
    <script type="text/javascript" src="includes/js/jquery-1.4.4.min.js"></script>
    <script type="text/javascript" src="includes/js/jquery-ui-1.8.9.custom.min.js"></script>
    
    <!--Aplicação-->
    <link rel="stylesheet" type="text/css" href="includes/css/style.css">
    <script type="text/javascript" src="includes/js/script.js"></script>
    
</head>
<body>
	<form id="form_index" name="form_index" action="" onSubmit="return false">
        <label for="txtCPF" class="label">CPF: </label>
        <br />
        <input id="txtCPF" name="txtCPF" type="text" value="" class="text ui-widget-content ui-corner-all"/>
        <button id="btnValidar">Validar</button>
        <img id="loading" src="includes/images/loading.gif" width="16" height="16">
    </form>
</body>
</html>

Abaixo o código do arquivo “style.css“.

body {
	font: 62.5% "Trebuchet MS" , sans-serif;
	margin: 50px;
}

.text {
	padding: .3em;
}

.label {
	font: 14px "Verdana", sans-serif;
}

Agora o codigo do arquivo “script.js“.

$(document).ready(function() {
	//Personaliza os botões da tela.
	$("button").button();
	
	//Esconde a imagem de loading.
	$("#loading").hide();
	
	//Evento do botão Validar.
	$("#btnValidar").click(function() {
		
		//Verifica se foi digitado um CPF.
		if ($.trim($("#txtCPF").val()) == "") {
			//Monstra a mensagem para o usuário.
			showMessage("Digite um CPF!");

			return false;
		}		
		
		//Mostra a imagem de loading.
		$("#loading").show();
		
		//Realiza uma requisição sem atualizar a página.
		$.ajax ({
			//Tipo da requisição.
			type : "post", 
			//Caminho da Página que irá processar a requisição.
			url : "index.source.php",
			//Serializa os campo do formulário e passa
			//como parametro para a página processar.
			data : $("#form_index").serialize(),
			//Caso não aconteça nenhum erro, apresenta a mensagem
			//de retorno da página.
			success : function(msg) {
				showMessage(msg);
				//Esconde a imagem de loading.
				$("#loading").hide();
			},
			error : function() {
				showMessage("Ocorreu um erro!");
				//Esconde a imagem de loading.
				$("#loading").hide();
			}
		});		
	});
})

function showMessage(message) {
	//Cria uma div em tempo de execução no body para mostrar
	//a mensagem ao usuário.
	$("body").append("<div id='message'>" + message + "</div>");

	//Configura e mostra a div criada acima.
	$("#message").dialog({
		bgiframe : true,
		modal : true,
		minimizable : false,
		resizable : false,
		closeOnEscape : true,
		title : "Mensagem",
		width : "300px",
		buttons : {
			Ok : function() {
				//Quando clicar em OK remove a div do html.
				$("#message").remove();
			}
		},
		close : function() {
			//Caso feche a div sem clicar em OK remove a div 
			//do html também.
			$("#message").remove();
		}
	});
}

E por fim o código da nossa página “index.source.php” que irá processar os dados.

<?php

	//Abilita apenas para aparecer os erros da aplicação.
	error_reporting(E_ERROR); 
	
	//Chama a função btnValidar()
	btnValidar();
	
	function btnValidar()
	{
		//Caminho do servidor de aplicação.
		define("servidor", "http://localhost:8081/datasnap/rest/");
		
		//Método que será consumido.
		define("metodo", "TServerFunctions/validateCPF/");
		
		//Parametros do método.
		$parametro = $_REQUEST["txtCPF"];
		
		//URL que será processada.
		$url = sprintf("%s%s%s", servidor, metodo, $parametro);
		
		$pagina;
		try
		{
			//Faz a requisição a url montada acima.
			$pagina = httpGet($url);
		}
		catch (Exception $e)
		{
			//Sai do método e apresenta a mensagem de erro
			//para ser capturada pela função sucess do jQuery.
			die($e->getMessage());
		}
		
		//Lê os dados de retorno do servidor passando para JSON.
		$obj = json_decode($pagina[0]);
		
		//Verifica o retorno do método. 
		//E printa para ser capturada pela função sucess do jQuery.
		if ($obj->{"result"}[0])
			echo("CPF Válido!");
		else
			echo("CPF Inválido!");
	}
		
	function httpGet($url)
	{
		//Faz a requisição a url montada acima.
		$result = file($url);
		if ($result == NULL)
			throw new Exception("Ocorreu um erro!");
		
		return $result;
	}
	
?>

Abaixo uma imagem de como deverá ser criada a estrutura de pastas dos arquivos citados acima.

E agora uma imagem de como ficará o exemplo.

Bom pessoal espero que tenham gostado e que seja útil de alguma forma. A idéia deste post foi mesmo apenas demonstrar como é fácil consumir um método usando PHP em um servidor DataSnap.