Se você pretende adquirir novas licenças ou ainda não atualizou para Delphi XE2, C++Builder XE2, RAD Studio XE2, agora é hora. Ao adquirir uma das seguintes edições você pode levar até 4 ferramentas grátis, além de um voucher para a Certificação Delphi Developer para cada licença adquirida.

Recentemente publiquei o artigo em inglês “Razões para migrar para o Delphi XE2 | O que você pode ter perdido desde o Delphi 7″, que pode lhe ajudar na decisão sobre migrar.

Aproveita porque essa promoção, pois acaba dia 24 de dezembro de 2011, você pode obter mais informações neste aqui ou contactar a E do Brasil nosso parceiro no Brasil.

É hora de seguir em frente

Posts relacionados

• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Conectando ao PostgreSQL com dbExpress ODBC driver
• Disponibilizado Update 2 para Delphi XE2, C++Builder XE2 e RadPHP XE2
• Monitoramento e controle de conexões em DataSnap XE2
• Disponibilizado o Trial, Datasheet, Matriz de Recursos e FAQ para as versões XE2
• Delphi Conference 2011 – chamada para submissão de palestras

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Se você ainda continua usando Delphi 7 ou alguma das versões anteriores, recomendo que você reserve um tempo na sua agenda e leia este artigo (em inglês), estou trabalhando na versão em português para o final deste ano. Delphi tem crescido muito e a cada ano tem trazido diversas novidades muito interessantes desde a sua versão Delphi 7.

Este artigo traz várias razões para migrar, além de uma visão geral de todos os novos recursos incorporados desde a versão 7, onde Delphi era um IDE para desenvolvimento de aplicações Windows 32-bit e se tornou um IDE para desenvolvimento Windows 64-bit, Mac e iOS.

Se você já leu o meu artigo “Razões para migrar do Delphi 7 para o Delphi 2009” em português ou o artigo em inglês “Reasons to migrate to Delphi XE”, este artigo é uma atualização que inclui os novos recursos das versões Delphi 2010, XE e XE2.

Gostaria de lembrar que ao migrar para o Delphi XE2 você recebe as versões anteriores sem custo adicional. Por exemplo, comprando Delphi XE2 você recebe Delphi 7, Delphi 2007, Delphi 2009, Delphi 2010 e Delphi XE.

Eu espero que esse artigo responda a todas as suas dúvidas, caso ainda fique alguma dúvida comente aqui no post que estarei respondendo.

Faça o download do artigo aqui.

Posts relacionados

• Hora de seguir em frente
• Apresentações do Delphi Conference 2011 disponíveis para download
• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Conectando ao PostgreSQL com dbExpress ODBC driver
• Vagas esgotadas para o Delphi Conference 2011
• Disponibilizado Update 2 para Delphi XE2, C++Builder XE2 e RadPHP XE2

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

A partir do Delphi XE2 Update 2 isso não é mais problema, o suporte a blob no método CopyReaderToClientDataSet foi implementando.

Para saber como utilizar o método CopyReaderToClientDataSet na prática leia o artigo “Copiando estrutura e dados de um DBXReader para ClientDataSet  - DataSnap“

Posts relacionados

• Conectando ao PostgreSQL com dbExpress ODBC driver
• Monitoramento e controle de conexões em DataSnap XE2
• Implementando cache de dados em servidores DataSnap
• Exemplos e slides do Delphi Meeting 2011
• Vídeos sobre DataSnap para 2011 – o que você gostaria de ver?
• Apresentações do Delphi Conference 2010 disponível para download

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Para mostrar na prática como funciona, criei uma aplicação FireMonkey que conecta a uma base de dados PostgreSQL.

Como requisito, você precisa instalar na máquina onde a aplicação será executada o driver ODBC do PostgreSQL, que pode ser baixado aqui. Vale lembrar que aplicações compiladas como 32-bit requerem a versão 32-bit do driver ODBC da base de dados a ser utilizada, para aplicações 64-bit será necessário o driver ODBC 64-bit.

Após instalado o driver, crie e configure o User DSN ou System DSN no ODBC Data Source Administrator (odbcad32.exe):

Instruções para windows 64-bit

• Para aplicações 32-bit use o c:\Windows\SysWOW64\odbcad32.exe
• Para aplicações 64-bit use o c:\Windows\system32\odbcad32.exe

Instruções para windows 32-bit

• Use o c:\Windows\system32\odbcad32.exe

O próximo passe é criar um alias dbExpress ODBC no Data Explorer, onde Database Name é o nome do Data Source criado anteriormente, no meu exemplo este Data Source se chama PostgreSQL35W. Todas as informações relacionada a qual base de dados conectar, usuário e senha já foram configuradas no Data Source, você pode sobrescrever o usuário e senha na conexão dbExpress.

Supondo que você já saiba como utilizar os componentes SQLConnection, DataSetProvider e ClientDataSet ou SimpleDataSet e DataSource, basta conectá-los da mesma forma que você sempre fez com aplicações que utilizam os componentes dbExpress. A configuração do SQLConnection será configurada conforme abaixo:

  object SQLConnection1: TSQLConnection
    ConnectionName = 'PostgreSQLOdbc'
    DriverName = 'ODBC'
    LoginPrompt = False
    Params.Strings = (
      'drivername=ODBC'
      'Database=PostgreSQL35W')
  end

Além de poder utilizar os componentes dbExpress em aplicações VCL e FireMonkey, você pode utilizar o dbExpress framework para conectar a bancos de dados que não tenham um driver nativo. A figura abaixo mostra a aplicação FireMonkey conectada a PostgreSQL através do dbExpress ODBC driver.

Download do código fonte disponível aqui.

Posts relacionados

• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Vídeo: Delphi XE2 e FireMonkey app no Windows, Mac e iOS
• Usando expressões regulares em aplicações FireMonkey com C++Builder
• Usando dbExpress Framework no Windows e Mac com C++Builder
• Hora de seguir em frente
• Apresentações do Delphi Conference 2011 disponíveis para download

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Você pode efetuar o download do Update 2 para Delphi e C++Builder através da opção “Check for Updates”.

RAD Studio XE2 Update 2

• Update 2 para Delphi, C++Builder e RAD Studio XE2 – http://cc.embarcadero.com/item/28597
• ISO do Delphi XE2 e C++Builder XE2 (inclui Update 2) – http://cc.embarcadero.com/item/28616
• Lista de bugs resolvidos no Delphi XE2 e C++Builder XE2 Update – http://edn.embarcadero.com/article/41750

RAD Studio XE2 Help Update 1 – http://cc.embarcadero.com/item/28613

RadPHP XE2 Update 2

Update 2 para o RadPHP – http://cc.embarcadero.com/item/28614
Lista de bugs resolvidos no RadPHP XE2 Update 2 – http://edn.embarcadero.com/article/41756

Posts relacionados

• Disponibilizado o Trial, Datasheet, Matriz de Recursos e FAQ para as versões XE2
• Delphi Conference 2011 – chamada para submissão de palestras
• Delphi Tour 2011
• RAD Studio XE2 uma nova era para desenvolvedores Delphi e C++Builder
• Hotfix 2 e Help Update 2 para Delphi XE, C++Builder XE e RAD Studio XE
• Hotfix 1 para Delphi XE, C++Builder XE e RAD Studio XE

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Você pode ler os artigos que antecedem estas sequência nos links abaixo, é importante ler estes artigos para melhor entendimento deste artigo:

• Shell Extension para Windows 32-bt and 64-bit com Delphi XE2
• CloudAPI – Envio de arquivos para Amazon S3 e Windows Azure – Parte 1

Na primeira parte do artigo descrevo como obter sua conta no Amazon e os significados do Bucket e Blog, considerando que você leu os artigos anteriores nos resta saber como funciona o CloudAPI para envio de arquivos para o Amazon S3, que é bem parecido ao do Windows Azure.

Envio de arquivos para Amazon S3

A implementação do Shell Extension utiliza o método UploadtoAmazon (CloudDM.pas) para o envio de arquivos para o Amazon S3, antes de enviar o arquivo temos definir em qual pasta (Bucket) será armazenado este arquivo.

Como o bucket pode não existir, ou o usuário pode querer criar um novo, implementei um formulário que permite o usuário selecionar um bucket já existente ou criar um novo.

Abaixo parte do código responsável pelo envio do arquivo, as linhas em destaque refletem o código que irá listar e criar ou selecionar o bucket.

Ao fazer uma solicitação ao Amazon S3 através do CloudAPI a maioria dos métodos retorna um objeto do tipo TCloudResponseInfo, este objeto contém o status do retorno referente a sua solicitação, todas estas solicitações são chamadas REST.

Para obter a lista de buckets utilizamos o método ListBuckets que é parte do objeto StorageService instanciando anteriormente, todos os serviços relacionados a Storage fazem parte desta classe, assim como a criação do bucket através do método CreateBucket.

Amazon e Windows Azure diferem no que diz respeito ao suporte a metadata na criação do container/bucket, Amazon não suporta metadata enquanto Windows Azure sim.

function TCloud.UploadtoAmazon(FileName: String): TCloudResponseInfo;
var
  StorageService: TAmazonStorageService;
  BucketList, Metadata: TStrings;
  Content: TBytes;
  ResponseList: TCloudResponseInfo;
  FrmList: TFrmContainerList;
  Act: TContainerAction;
  BucketName: String;
  I: Integer;
begin
  Result := TCloudResponseInfo.Create;

  if (FileName = EmptyStr) then
    Exit;

  StorageService := TAmazonStorageService.Create(AmazonConnection);

{$REGION 'Define the Bucket'}
  ResponseList := TCloudResponseInfo.Create;
  BucketList := StorageService.ListBuckets(ResponseList);

  if ResponseList.StatusCode = 200 then
  begin

    // Amazon return date/time information for each Bucket
    // this for is required to remove that information
    for I := 0 to BucketList.Count - 1 do
      BucketList[I] := BucketList.Names[I];

    FrmList := TFrmContainerList.Create(nil, BucketList, TClouds[AmazonIndex]);
    try
      FrmList.ShowModal;
      Act := FrmList.Action;

      case Act of
        caCreate:
          begin
            if StorageService.CreateBucket(FrmList.Container, amzbaNotSpecified,
              amzrNotSpecified, Result) then
              BucketName := FrmList.Container;
          end;
        caUpload:
          begin
            BucketName := FrmList.Container;
          end;
      end;
    finally
      FrmList.Free;
    end;

    if Act = TContainerAction.caNone then
      Exit;

  end;

Com o bucket definido podemos adiante e preparar o envio do arquivo.

Para o envio do arquivo utilizamos o método StorageService.UploadObject que contém diversos parâmetros como: nome e o conteúdo do arquivo em TBytes, metadata e alguns outros que não são necessários para este exemplo. Você deve utilizar alguma função para fazer o encode do nome do arquivo, por exemplo  TIdURI.URLEncode(str).

Podemos adicionar metadata ao arquivo, neste exemplo adiciono o nome do computador\usuário e a localização original do arquivo a ser enviado.

    Metadata.Clear;
    Metadata.Values[SMDPath] := ExtractFilePath(FileName);
    Metadata.Values[SMDFrom] := GetComputerandUserName;

    Content := ContentOf(FileName);
    BlobName := ExtractFileName(FileName);

O método ContentOf retorna o conteúdo do arquivo em TBytes.

function TCloud.ContentOf(const FileName: String;
  RequiredSizeMod: Integer): TBytes;
var
  fs: TFileStream;
begin
  if FileName <> EmptyStr then
  begin
    fs := TFileStream.Create(FileName, fmOpenRead);
    try
      if RequiredSizeMod < 1 then
        SetLength(Result, fs.Size)
      else
        SetLength(Result, ((fs.Size div RequiredSizeMod) + 1) *
          RequiredSizeMod);
      fs.ReadBuffer(Result[0], fs.Size);
    finally
      fs.Free;
    end;
  end
  else
    SetLength(Result, 0);

end;

O resultado do envio será um parâmetro de saída do tipo TCloudResponseInfo, este contém a propriedade StatusCode, requisições realizadas com sucesso retornam o código 200 ou 201.

    StorageService.UploadObject(BucketName, ExtractFileName(FileName), Content, False, Metadata, nil, amzbaPublicRead, Result);
    ShowResponseInfo(TClouds[AmazonIndex], Result);

Clique aqui para visualizar o código fonte da unit CloudDM.pas.

O código fonte completo está disponível no repositório do RAD Studio XE2 no sourceforge e as informações para efetuar o download dos fontes completo estão disponíveis aqui.
Nesta sequência de artigos você pode aprender a criar Shell Extensions, compilar pra 32-bit e 64 bit e utilizar o CloudAPI, vale lembrar que o ClouAPI traz muitas outras API’s para interagir com as nuvens

Posts relacionados

• CloudAPI – Envio de arquivos para Amazon S3 e Windows Azure – Parte 1
• Shell Extension para Windows 32-bit e 64-bit com Delphi XE2
• Microsoft Windows Azure por 30 dias GRÁTIS
• Apresentações do Delphi Conference 2010 disponível para download
• Teste nosso servidor DataSnap XE instalado no Amazon Cloud
• DataSnap XE e Windows Azure – RAD Studio XE Preview #3

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

O Cloud API é um conjunto de API’s que permite a interação com os serviços de tabela, armazenamento e mensagens do Amazon S3 e Windows Azure, está disponível para Delphi e C++Builder.

Utilizando o exemplo do artigo anterior como ponto inicial, foi implementado no mesmo um DataModule (CloudDM.pas) que contém a configuração para acesso as nuvens através dos componentes AmazonConnection e AzureConnection, além disso os métodos responsáveis pelo envio de arquivos para as nuvens, assim sendo você precisa ter uma conta no Amazon e no Azure para utilizar este exemplo, a baixo um resumo breve para obter sua conta a qual não é gratuita, o custo é bem baixo e baseado no quanto você utiliza.

Criando uma conta Windows Azure Storage

Através do link http://windows.azure.com você pode criar sua conta Azure Storage seguindo os passos fornecidos na página, abaixo um screenshot da minha conta e onde estão localizados os dois parâmetros (AccountName e AccountKey) requeridos pelo componente AzureConnection.

Criando uma conta Amazon  (AWS)

Criar uma conta no Amazon também é bem simples, acesse o site https://console.aws.amazon.com/s3/home e siga os passos, para obter o AccountKey e AccountName a ser utilizado no componente AmazonConnection, acesse https://aws-portal.amazon.com/gp/aws/developer/account/index.html?action=access-key, abaixo um screenshot.

Arquivo INI para configuração da DLL

As configurações de acesso as respectivas nuvens estão sendo armazenadas no arquivo ini CloudUpload-Extension.ini localizado no diretório Home de cada usuário, eu não vou detalhar como utilizar arquivos ini aqui, você pode estudar esta parte após baixar os código fonte do exemplo aqui utilizado.

Bucket vs Container e Object vs Blob

Todo arquivo enviado para as nuvens será armazenado em uma pasta, Amazon chama pasta de Bucket e Windows Azure de Container, no final das contas Bucket e Container são pastas, cada nuvem tem suas regras e limitações de como nomear as pastas, por exemplo o nome de uma pastas no Amazon deve ser único em toda a nuvem, isso mesmo não único na sua conta, ou seja, criar um diretório imagens esquece, alguém certamente já criou um.

A diferença de nomenclatura também ocorre para arquivos, que na Amazon é chamado do Object e no Windows Azure chama-se Blog.

Cloud API respeita essas diferenças, assim para criar um Bucket no Amazon usamos o método CreateBucket, para criar um Container no Windows Azure utilizamos o método CreateContainer.

Envio de arquivos para Windows Azure

A implementação do Shell Extension utiliza o método UploadtoAzure (CloudDM.pas) para o envio de arquivos para o Windows Azure, antes de enviar o arquivo temos definir em qual pasta (Container) será armazenado este arquivo.

Como o container pode não existir, ou o usuário pode querer criar um novo, implementei um formulário que permite o usuário selecionar um container já existente ou criar uma nova.

Abaixo parte do código responsável pelo envio do arquivo, as linhas em destaque refletem o código que irá listar e criar ou selecionar o container.

Ao fazer uma solicitação ao Windows Azure através do CloudAPI a maioria dos métodos retorna um objeto do tipo TCloudResponseInfo, este objeto contém o status do retorno referente a sua solicitação, todas estas solicitações são chamadas REST.

Para obter a lista de containers utilizando o método ListContainers que é parte do objeto BlobService instanciando anteriormente, todos os serviços relacionados a Blob fazem parte desta classe, assim como a criação do container através do método Create Container.

No caso da criação do container, podemos passar informações adicionais a qual chamamos de metadata, no exemplo abaixo passamos o nome do computador utilizado para solicitar a criação deste container, esta informação estará disponível como parte do metadata deste container, você pode definir várias outras informações e adiciona-las como parte do seu metadata que é do tipo TStringList;

function TCloud.UploadtoAzure(FileName: String): TCloudResponseInfo;
var
  BlobService: TAzureBlobService;
  SList, Metadata: TStrings;
  ContainerList: TList;
  ContainerObj: TAzureContainer;
  Content: TBytes;
  BlobName, ContainerName: String;
  ResponseList: TCloudResponseInfo;
  FrmList: TFrmContainerList;
  Act: TContainerAction;
begin

  Result := TCloudResponseInfo.Create;

  if (FileName = EmptyStr) then
    Exit;

  BlobService := TAzureBlobService.Create(AzureConnection);
  try
    ResponseList := TCloudResponseInfo.Create;
    ContainerList := BlobService.ListContainers(nil, ResponseList);
    Metadata := TStringList.Create;

    if ResponseList.StatusCode = 200 then
    begin

      SList := TStringList.Create;
      for ContainerObj in ContainerList do
        SList.Add(ContainerObj.Name);
      ContainerList.Free;

      FrmList := TFrmContainerList.Create(nil, SList, TClouds[AzureIndex]);
      try
        FrmList.ShowModal;
        Act := FrmList.Action;

        case Act of
          caCreate:
            begin
              Metadata.Values[SMDCreateby] := GetComputerandUserName;

              if BlobService.CreateContainer(FrmList.Container, Metadata,
                bpaBlob, Result) then
                ContainerName := FrmList.Container;
            end;
          caUpload:
            begin
              ContainerName := FrmList.Container;
            end;
        end;
      finally
        SList.Free;
        FrmList.Free;
      end;

      if Act = TContainerAction.caNone then
        Exit;

    end;

Com a definição do container podemos seguir para o próximo passo que é o envio do arquivo.

Para o envio do arquivo utilizamos o método BlobService.PutBlockBlob que contém diversos parâmetros como: nome e o conteúdo do arquivo em TBytes, metadata e alguns outros que não são necessários para este exemplo.

Assim como para containers podemos adicionar metadata ao arquivo, neste exemplo adiciono o nome do computador\usuário e a localização original do arquivo a ser enviado.

    Metadata.Clear;
    Metadata.Values[SMDPath] := ExtractFilePath(FileName);
    Metadata.Values[SMDFrom] := GetComputerandUserName;

    Content := ContentOf(FileName);
    BlobName := ExtractFileName(FileName);

O método ContentOf retorna o conteúdo do arquivo em TBytes.

function TCloud.ContentOf(const FileName: String;
  RequiredSizeMod: Integer): TBytes;
var
  fs: TFileStream;
begin
  if FileName <> EmptyStr then
  begin
    fs := TFileStream.Create(FileName, fmOpenRead);
    try
      if RequiredSizeMod < 1 then
        SetLength(Result, fs.Size)
      else
        SetLength(Result, ((fs.Size div RequiredSizeMod) + 1) *
          RequiredSizeMod);
      fs.ReadBuffer(Result[0], fs.Size);
    finally
      fs.Free;
    end;
  end
  else
    SetLength(Result, 0);

end;

O resultado do envio será um parâmetro de saída do tipo TCloudResponseInfo, este contém a propriedade StatusCode, requisições realizadas com sucesso retornam o código 200 ou 201.

    BlobService.PutBlockBlob(ContainerName, BlobName, Content, '', nil,
      Metadata, Result);
    ShowResponseInfo(TClouds[AzureIndex], Result);

Abaixo a implementação completa da unit CloudDM.pas.

unit CloudDM;

interface

uses
  System.SysUtils, System.Classes, Data.Cloud.AzureAPI, Data.Cloud.CloudAPI,
  Data.Cloud.AmazonAPI, Winapi.Windows, IniFiles, IOUtils,
  System.Generics.Collections;

type
  TCloud = class(TDataModule)
    AzureConnection: TAzureConnectionInfo;
    AmazonConnection: TAmazonConnectionInfo;
  private
    { Private declarations }
    FHandle: HWND;
    function GetComputerandUserName: String;
    function UploadtoAmazon(FileName: String): TCloudResponseInfo;
    function UploadtoAzure(FileName: String): TCloudResponseInfo;
    function ContentOf(const FileName: String;
      RequiredSizeMod: Integer = 0): TBytes;
    procedure ShowResponseInfo(Title: String; Response: TCloudResponseInfo);
  public
    { Public declarations }

    function LoadConfiguration: Boolean;
    function Upload(FileName: String; Cloud: Integer): TCloudResponseInfo;

    class procedure SaveLog(s: String);
    constructor Create(AOWner: TComponent; Handle: HWND); reintroduce; overload;
  end;

var
  Cloud: TCloud;

Const
  AmazonIndex = 0;
  AzureIndex = 1;
  TClouds: Array [0 .. 1] of PWideChar = ('Amazon S3', 'Microsoft Azure');

implementation

uses CloudContainerList;

Const
  SMyAzureKey = 'MyAzureKey'; // do not translate
  SMyAmazonKey = 'MyAmazonKey'; // do not translate
  SInternetConfig = 'Internet Access Configuration'; // do not translate

  SAccountName = 'AccountName'; // do not translate
  SAccountKey = 'AccountKey'; // do not translate
  SProxyHost = 'ProxyHost'; // do not translate
  SProxyPort = 'ProxyPort'; // do not translate

  SStorageEndpoint = 'StorageBlobEndpoint'; // do not translate

  SMDPath = 'originalfilepath';
  SMDFrom = 'uploadfrom';
  SMDCreateby = 'createdby';

{$R *.dfm}
  { TCloudContainer }

function TCloud.ContentOf(const FileName: String;
  RequiredSizeMod: Integer): TBytes;
var
  fs: TFileStream;
begin
  if FileName <> EmptyStr then
  begin
    fs := TFileStream.Create(FileName, fmOpenRead);
    try
      if RequiredSizeMod < 1 then
        SetLength(Result, fs.Size)
      else
        SetLength(Result, ((fs.Size div RequiredSizeMod) + 1) *
          RequiredSizeMod);
      fs.ReadBuffer(Result[0], fs.Size);
    finally
      fs.Free;
    end;
  end
  else
    SetLength(Result, 0);

end;

constructor TCloud.Create(AOWner: TComponent; Handle: HWND);
begin
  inherited Create(AOWner);
  FHandle := Handle

end;

function TCloud.GetComputerandUserName: String;
var
  cName, uName: array [0 .. 255] of char;
  c: DWORD;
begin
  c := SizeOf(cName);

  GetComputerName(cName, c);
  GetUserName(uName, c);

  Result := StrPas(cName) + '\' + StrPas(uName);
end;

function TCloud.LoadConfiguration: Boolean;
var
  IniFile: string;
  Ini: TIniFile;
  Port: Integer;
  SUrl: String;
begin

  IniFile := GetHomePath + '\CloudUpload-Extension.ini';
  Ini := TIniFile.Create(IniFile);

  try
    // The ini file will be created in case it doesn't exist
    if not FileExists(IniFile) then
    begin
      // Azure parameters
      Ini.WriteString(SMyAzureKey, SAccountName, EmptyStr);
      Ini.WriteString(SMyAzureKey, SAccountKey, EmptyStr);
      Ini.WriteString(SMyAzureKey, SStorageEndpoint, EmptyStr);

      // Amazon parameters
      Ini.WriteString(SMyAmazonKey, SAccountName, EmptyStr);
      Ini.WriteString(SMyAmazonKey, SAccountKey, EmptyStr);
      Ini.WriteString(SMyAmazonKey, SStorageEndpoint, EmptyStr);

      // Internet access configuration
      Ini.WriteString(SInternetConfig, SProxyHost, EmptyStr);
      Ini.WriteString(SInternetConfig, SProxyPort, EmptyStr);

      Ini.UpdateFile;
      Result := False;
    end
    else
    begin

      TryStrToInt(Ini.ReadString(SInternetConfig, SProxyPort, '0'), Port);

      with AzureConnection do
      begin
        AccountName := Ini.ReadString(SMyAzureKey, SAccountName, EmptyStr);
        AccountKey := Ini.ReadString(SMyAzureKey, SAccountKey, EmptyStr);

        RequestProxyHost := Ini.ReadString(SInternetConfig, SProxyHost,
          EmptyStr);
        RequestProxyPort := Port;

        SUrl := Ini.ReadString(SMyAzureKey, SStorageEndpoint, EmptyStr);

        UseDefaultEndpoints := SUrl = EmptyStr;
        BlobEndpoint := SUrl;
      end;

      with AmazonConnection do
      begin
        AccountName := Ini.ReadString(SMyAmazonKey, SAccountName, EmptyStr);
        AccountKey := Ini.ReadString(SMyAmazonKey, SAccountKey, EmptyStr);

        RequestProxyHost := Ini.ReadString(SInternetConfig, SProxyHost,
          EmptyStr);
        RequestProxyPort := Port;

        SUrl := Ini.ReadString(SMyAmazonKey, SStorageEndpoint, EmptyStr);

        UseDefaultEndpoints := SUrl = EmptyStr;
        StorageEndpoint := SUrl;
      end;
      Result := True;
    end;

  finally
    Ini.Free;
  end;
end;

class procedure TCloud.SaveLog(s: String);
var
  LogFile: TextFile;
begin
  { open the log file }
  AssignFile(LogFile, 'c:\Shell.txt');
  if FileExists('c:\Shell.txt') then
    Append(LogFile)
  else
    Rewrite(LogFile);

  WriteLn(LogFile, s + #13#10);

  { write and close the logfile }
  CloseFile(LogFile);
end;

procedure TCloud.ShowResponseInfo(Title: String; Response: TCloudResponseInfo);
begin
  case Response.StatusCode of
    200, 201:
      MessageBox(FHandle, 'File Uploaded', PWideChar(Title), MB_OK);
  else
    MessageBox(FHandle, PWideChar('Error ' + Response.StatusMessage),
      PWideChar(Title), MB_ICONWARNING);
  end;
end;

function TCloud.Upload(FileName: String; Cloud: Integer): TCloudResponseInfo;
begin
  case Cloud of
    AmazonIndex:
      Result := UploadtoAmazon(FileName);
    AzureIndex:
      Result := UploadtoAzure(FileName);
  else
    Result := TCloudResponseInfo.Create;
  end;
end;

function TCloud.UploadtoAmazon(FileName: String): TCloudResponseInfo;
var
  StorageService: TAmazonStorageService;
  BucketList, Metadata: TStrings;
  Content: TBytes;
  ResponseList: TCloudResponseInfo;
  FrmList: TFrmContainerList;
  Act: TContainerAction;
  BucketName: String;
  I: Integer;
begin
  Result := TCloudResponseInfo.Create;

  if (FileName = EmptyStr) then
    Exit;

  StorageService := TAmazonStorageService.Create(AmazonConnection);

{$REGION 'Define the Bucket'}
  ResponseList := TCloudResponseInfo.Create;
  BucketList := StorageService.ListBuckets(ResponseList);

  if ResponseList.StatusCode = 200 then
  begin

    // Amazon return date/time information for each Bucket
    // this for is required to remove that information
    for I := 0 to BucketList.Count - 1 do
      BucketList[I] := BucketList.Names[I];

    FrmList := TFrmContainerList.Create(nil, BucketList, TClouds[AmazonIndex]);
    try
      FrmList.ShowModal;
      Act := FrmList.Action;

      case Act of
        caCreate:
          begin
            if StorageService.CreateBucket(FrmList.Container, amzbaNotSpecified,
              amzrNotSpecified, Result) then
              BucketName := FrmList.Container;
          end;
        caUpload:
          begin
            BucketName := FrmList.Container;
          end;
      end;
    finally
      FrmList.Free;
    end;

    if Act = TContainerAction.caNone then
      Exit;

  end;
{$ENDREGION}
  try

    Metadata := TStringList.Create;
    Metadata.Values[SMDPath] := ExtractFilePath(FileName);
    Metadata.Values[SMDFrom] := GetComputerandUserName;

    Content := ContentOf(FileName);

    FileName := StringReplace(FileName, ' ', '%20', [rfReplaceAll, rfIgnoreCase]);

    StorageService.UploadObject(BucketName, ExtractFileName(FileName), Content,
      False, Metadata, nil, amzbaPublicRead, Result);
    ShowResponseInfo(TClouds[AmazonIndex], Result);

  except
    on E: Exception do
    begin
      MessageBox(FHandle, PWideChar('Error ' + E.Message),
        TClouds[AmazonIndex], MB_OK);
    end;
  end;

  FreeAndNil(Metadata);
  FreeAndNil(StorageService);
end;

function TCloud.UploadtoAzure(FileName: String): TCloudResponseInfo;
var
  BlobService: TAzureBlobService;
  SList, Metadata: TStrings;
  ContainerList: TList;
  ContainerObj: TAzureContainer;
  Content: TBytes;
  BlobName, ContainerName: String;
  ResponseList: TCloudResponseInfo;
  FrmList: TFrmContainerList;
  Act: TContainerAction;
begin

  Result := TCloudResponseInfo.Create;

  if (FileName = EmptyStr) then
    Exit;

  BlobService := TAzureBlobService.Create(AzureConnection);
  try

{$REGION 'Define the container'}
    ResponseList := TCloudResponseInfo.Create;
    ContainerList := BlobService.ListContainers(nil, ResponseList);
    Metadata := TStringList.Create;

    if ResponseList.StatusCode = 200 then
    begin

      SList := TStringList.Create;
      for ContainerObj in ContainerList do
        SList.Add(ContainerObj.Name);
      ContainerList.Free;

      FrmList := TFrmContainerList.Create(nil, SList, TClouds[AzureIndex]);
      try
        FrmList.ShowModal;
        Act := FrmList.Action;

        case Act of
          caCreate:
            begin
              Metadata.Values[SMDCreateby] := GetComputerandUserName;

              if BlobService.CreateContainer(FrmList.Container, Metadata,
                bpaBlob, Result) then
                ContainerName := FrmList.Container;
            end;
          caUpload:
            begin
              ContainerName := FrmList.Container;
            end;
        end;
      finally
        SList.Free;
        FrmList.Free;
      end;

      if Act = TContainerAction.caNone then
        Exit;

    end;
{$ENDREGION}

    Metadata.Clear;
    Metadata.Values[SMDPath] := ExtractFilePath(FileName);
    Metadata.Values[SMDFrom] := GetComputerandUserName;

    Content := ContentOf(FileName);
    BlobName := ExtractFileName(FileName);

    BlobService.PutBlockBlob(ContainerName, BlobName, Content, '', nil,
      Metadata, Result);
    ShowResponseInfo(TClouds[AzureIndex], Result);

  except
    on E: Exception do
    begin
      MessageBox(FHandle, PWideChar('Error ' + E.Message),
        TClouds[AzureIndex], MB_OK);
    end;
  end;

  FreeAndNil(ResponseList);
  FreeAndNil(Metadata);
  FreeAndNil(BlobService);

end;

end.

O código fonte completo está disponível no repositório do RAD Studio XE2 no sourceforge, no artigo anterior você pode obter as informações de como obter os fontes.
Até o próximo artigo que irá abordar o envio de arquivos para Amazon S3.

Posts relacionados

• CloudAPI – Envio de arquivos para Amazon S3 e Windows Azure – Parte 2
• Shell Extension para Windows 32-bit e 64-bit com Delphi XE2
• Microsoft Windows Azure por 30 dias GRÁTIS
• Apresentações do Delphi Conference 2010 disponível para download
• Teste nosso servidor DataSnap XE instalado no Amazon Cloud
• DataSnap XE e Windows Azure – RAD Studio XE Preview #3

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

A solução para este problema é bem simples, basta registrar a classe TDSProviderDataModuleAdapter, a qual é usada internamente para permitir que o Provider esteja visível para os clientes DataSnap. TDSProviderDataModuleAdapter atua como um proxy entre TProviderDataModule no lado servidor e o TDSProviderConnection no lado cliente.

Poderíamos apenas mudar a implementação do método GetDSClass conforme abaixo, isso funcionaria, mas não seria a melhor implementação visto que estariamos sempre publicando os métodos da interface IAppServer utilizados pelo Provider e ClientDataSet, não faz sentido publicar esta interface se não há provider no ServerModule.

Tornar a publicação parametrizável traz maior flexbilidade e controle para a aplicação e para o desenvoldedor, fica a seu critério quando publicar ou não os providers, assim sendo precisamos apenas de um novo parâmetro na classe TSimpleServerClass.

function TSimpleServerClass.GetDSClass: TDSClass;
begin
  Result := TDSClass.Create(FPersistentClass, False);
  Result := TDSClass.Create(TDSProviderDataModuleAdapter, Result)
end;

Abaixo temos o código atualizado, a única alteração foi no constructor que recebeu o novo parâmetro ExposeProvider, desta forma você decide se quer ou não publicar os providers.

type

unit SimpleServerClass;

interface

uses DSServer, Classes, DSCommonServer, DSReflect;

type

  TSimpleServerClass = class(TDSServerClass)
  private
    FPersistentClass: TPersistentClass;
    FExposeProvider : Boolean;
  protected
    function GetDSClass: TDSClass; override;
  public
    constructor Create(AOwner: TComponent; AServer: TDSCustomServer;
      AClass: TPersistentClass; ExposeProvider: Boolean; ALifeCycle: String);
      reintroduce; overload;
  end;

implementation

constructor TSimpleServerClass.Create(AOwner: TComponent;
  AServer: TDSCustomServer; AClass: TPersistentClass; ExposeProvider: Boolean;
  ALifeCycle: String);
begin
  inherited Create(AOwner);
  FPersistentClass := AClass;
  FExposeProvider  := ExposeProvider;
  Self.Server := AServer;
  Self.LifeCycle := ALifeCycle;

end;

function TSimpleServerClass.GetDSClass: TDSClass;
var
  isAdapted : Boolean;
begin
  isAdapted := FPersistentClass.InheritsFrom(TProviderDataModule);
  Result := TDSClass.Create(FPersistentClass, isAdapted);
  if FExposeProvider and isAdapted then
     Result := TDSClass.Create(TDSProviderDataModuleAdapter, Result)
end;

end.

Abaixo um exemplo onde são registradas 3 classes e somente uma delas expõe os Providers:

procedure RegisterServerClasses(AOwner: TComponent; AServer: TDSServer);
begin
  Assert(AServer.Started = false, 'Não é possível adicionar classes com o servidor ativo');

  TSimpleServerClass.Create(AOwner, AServer, TGlobal, False, TDSLifeCycle.Server);
  TSimpleServerClass.Create(AOwner, AServer, TCustomer, True, TDSLifeCycle.Session);
  TSimpleServerClass.Create(AOwner, AServer, TObjectPool, False, TDSLifeCycle.Invocation);
end;

Posts relacionados

• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Monitoramento e controle de conexões em DataSnap XE2
• Implementando cache de dados em servidores DataSnap
• Exemplos e slides do Delphi Meeting 2011
• Vídeo: Threads e DataSnap – otimizando um servidor de aplicação – Delphi Conference 2010 Brasil
• Vídeo: Conectando aplicações Android com DataSnap Server no Delphi Conference 2010 Brasil

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Abaixo o conteúdo do email em inglês enviado pela Digital Metaphors o qual traz todas as informações sobre esta nova versão.

Subject: Digital Metaphors Corporation announces the release of ReportBuilder 14.0!

ReportBuilder 14.0 includes VCL support for Delphi XE2, Delphi XE, Delphi 2010, 2009, 2007, 2006, and Delphi 7.

Overview: http://www.digital-metaphors.com/rbwiki/General/What’s_New/RB_14

New Feature List: http://www.digital-metaphors.com/PDF/NewFeatures.pdf

Pricing: http://www.digital-metaphors.com/order

Upgrade here! https://www.digital-metaphors.com/secure

Version 14.0 – 10/21/2011
————————-
- Delphi XE2 support for VCL Win32
- Delphi XE2 support for VCL Win64

Design Layers
————-
- separate layout elements into logical layers
- load/save design layers (example std header/footer or watermark)
- prevent users from adding, selecting, moving, deleting elements
- prevent users from seeing, selecting, deleting layers
- LayerTypes: Band, Page
- Inactive Layers draw alpha blended behind active layer
- ComponentOptions: Add, Delete, Select, Move
- LayerOptions: Select, Rename, Visible, Delete, Load, Save

Preview
——-
- continuous page scrolling
- single and two-up page display
- background thread report generation
- hand scrolling
- PreviewFormSetings.PageDisplay property
- PreviewFormSettings.PageIncrement propery (control page generation)
- PreviewFormsSettings.SinglePageOnly (forces use of old screen device)
- Viewer.DeadSpace property (control amount of space outside of page)

Output Devices
————–
- HTML file device
- PDF/A device (http://en.wikipedia.org/wiki/PDF/A)
- PDFSettings.PDFA boolean property (force PDF to PDF/A standard)
- PDF image compression (automatic jpeg compression)
- PDF image scaling (PDFSettings.ImageCompressionLevel)
- PDF, high quality metafile to bitmap conversion
- DocForm device (exact positioning of lines and text)
- RTFSettings.UseTextBoxes boolean property (exact text positioning)
- RTF/Doc device, support for CodePage and Font.CharSet
- XLS support for AppName, Author, Subject, Title (XLSSEttings)
- Email, Extended Mapi plug-in
- avoid security warnings, Unicode and Html support
- Email, support for HTML messages via Indy 10 Extended Mapi
- Email, EmailSettings.HtmlBody, BodyHtmlAttachments properties
- Email, EmailSettings.StreamAttachments option
- Email, Unicode message body (Unicode VCL w/Indy 10 or Extended Mapi)
- new ScrollableScreenDevice, used by Viewer to implement continuous scrolling
- PrintToFile enhancements
- DefaultFileDeviceType defaults to PDF
- default TextFileName, ArchiveFileName ($MyDocuments)\Report.pdf
- Change default file device, auto-changes default file name
- change output format in print dialog, auto-changes default file name
- support for wildcards in default FileName, ($MyDocuments) is resolved
by print dialog for display to end-user
- change the extension in the print dialog, changes the file

International Language support
——————————
- added 64-bit language modules

TeeChart support
—————-
- enhanced TeeChart Package Builder for 64-bit

RCL
—
- Variable support for Int64 via dtLargeInt data type
- Groups, PreventOrphans
- prevent group header with no detail at bottom of page
- prevent group footer with no detail at top of page
- Columns, ColumnBalancing
- generate vertical columns in min number of rows
- ColumnFooter, AlignToBottom boolean
- enables column footer to generate immediately after detail
- Band.Background property for all bands
- DrawCommand.AsMetaFile feature for simpler RCL add-on support
- SummaryBand enhanced to print on same page as columns

Engine
——
- enhanced group generation – PreventOrphans management
- enhanced horizontal and vertical Column generation

EndUser
——-
- DesignLayers
- LayerOptions: use to lock layers, hide layers
- for example, create a visible/invisible water mark layer
- ComponentOptions: prevent users from moving, deleting etc.
- new OnCustomSaveQueryDoc event
- new ShowHelp method – fires Designer.OnHelp event
- ReportExplorer, invokes Help via new Designer.ShowHelp

RAP
—
- new Int64 data type
- compiler/parser support for // comments
- enhanced object ref scoping: childreport can access parent report objects
- File functions: FileExists, DirectoryExists, ExtractFileName, etc.
- RTTI for PrintDialog
- RTTI for FileDevice
- RTTI for ObjectList
- RTTI enhanced for Picture, Graphic
- enhanced run-time exception message to display subreport name

Server
——
- added 64-bit windows service (ReportBuilder Services)

*features may vary by ReportBuilder Edition and Delphi version
*RB 14 includes support for seven Delphi versions:
D7, D2006. D2007, D2009, D2010, DXE, DXE2.

Posts relacionados

• Hora de seguir em frente
• Apresentações do Delphi Conference 2011 disponíveis para download
• White Paper: Razões para migrar para o Delphi XE2 | O que você pode ter perdido desde o Delphi 7
• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Conectando ao PostgreSQL com dbExpress ODBC driver
• Vagas esgotadas para o Delphi Conference 2011

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Criando o CloudUpload Shell Extension

Para criar um shell extension em Delphi o primeiro passo é criar um projeto ActiveX Library e em seguinda criar um Automation Object. O exemplo utilizado neste artigo tem como nome de projeto CloudUpload e o Automation Object se chama TCloudUploadContext. Para integrar menus de contexto ao Windows Explorer a classe TCloudUploadContext terá de  implementar as interfaces IShellExtInit e IContextMenu e seus respectivos métodos.

    { IShellExtInit Methods }
    { Initialize the context menu if a files was selected}
    function IShellExtInit.Initialize = ShellExtInitialize;
    function ShellExtInitialize(pidlFolder: PItemIDList; lpdobj: IDataObject;
      hKeyProgID: HKEY): HResult; stdcall;

    { IContextMenu Methods }
    { Initializes the context menu and it decides which items appear in it,
      based on the flags you pass }
    function QueryContextMenu(Menu: HMENU; indexMenu, idCmdFirst, idCmdLast,
      uFlags: UINT): HResult; stdcall;

    { Execute the command, which will be the upload to Amazon or Azure}
    function InvokeCommand(var lpici: TCMInvokeCommandInfo): HResult; stdcall;
    { Set help string on the Explorer status bar when the menu item is selected }
    function GetCommandString(idCmd: UINT_PTR; uFlags: UINT; pwReserved: PUINT;
      pszName: LPSTR; cchMax: UINT): HResult; stdcall;

O ShellExtInitialize define se o menu de contexto será exibido ou não no Windows Explorer. Neste exemplo o menu de contexto aparece apenas e somente quando um arquivo for selecionado, a partir dai armazenamos o nome do arquivo na variável FFileName.

function TCloudUploadContextMenu.ShellExtInitialize(pidlFolder: PItemIDList;
  lpdobj: IDataObject; hKeyProgID: HKEY): HResult;
var
  DataFormat: TFormatEtc;
  StrgMedium: TStgMedium;
  Buffer: array [0 .. MAX_PATH] of Char;
begin
  Result := E_FAIL;

  { Check if an object was defined }
  if lpdobj = nil then
    Exit;

  { Prepare to get information about the object }
  DataFormat.cfFormat := CF_HDROP;
  DataFormat.ptd := nil;
  DataFormat.dwAspect := DVASPECT_CONTENT;
  DataFormat.lindex := -1;
  DataFormat.tymed := TYMED_HGLOBAL;

  if lpdobj.GetData(DataFormat, StrgMedium) <> S_OK then
    Exit;

  { The implementation now support only one file }
  if DragQueryFile(StrgMedium.hGlobal, $FFFFFFFF, nil, 0) = 1 then
  begin
    SetLength(FFileName, MAX_PATH);
    DragQueryFile(StrgMedium.hGlobal, 0, @Buffer, SizeOf(Buffer));
    FFileName := Buffer;
    Result := NOERROR;
  end
  else
  begin
    // Don't show the Menu if more then one file was selected
    FFileName := EmptyStr;
    Result := E_FAIL;
  end;

  { http://msdn.microsoft.com/en-us/library/ms693491(v=vs.85).aspx }
  ReleaseStgMedium(StrgMedium);

end;

Depois de inicializado o handle do menu de contexto através da interface IShellExiInit, o Windows utilizar a interface IContextMenu para chamar os outros métodos do handle do menu de contexto, neste caso irá chamar QueryContextMenu, GetCommandString e InvokeCommand.

As opções do menu de contexto (Amazon S3, Microsoft Azure) serão criadas através do método QueryContextMenu.

function TCloudUploadContextMenu.QueryContextMenu(Menu: HMENU;
  indexMenu, idCmdFirst, idCmdLast, uFlags: UINT): HResult;
var
  CloudMenuItem: TMenuItemInfo;
  MenuCaption: String;
  SubMenu: HMENU;
  uId: UINT;
begin
  { only adding one menu CloudMenuItem, so generate the result code accordingly }
  Result := MakeResult(SEVERITY_SUCCESS, 0, 3);

  { store the menu CloudMenuItem index }
  FMenuItemIndex := indexMenu;

  { specify what the menu says, depending on where it was spawned }
  if (uFlags = CMF_NORMAL) then // from the desktop
    MenuCaption := 'Send file from Desktop to the Cloud'
  else if (uFlags and CMF_VERBSONLY) = CMF_VERBSONLY then // from a shortcut
    MenuCaption := 'Send file from Shourtcut to the Cloud'
  else if (uFlags and CMF_EXPLORE) = CMF_EXPLORE then // from explorer
    MenuCaption := 'Send file from Explorer to the Cloud'
  else
    { fail for any other value }
    Result := E_FAIL;

  if Result <> E_FAIL then
  begin

    SubMenu := CreatePopupMenu;

    uId := idCmdFirst;
    InsertMenu(SubMenu, AmazonIndex, MF_BYPOSITION, uId, TClouds[AmazonIndex]);

    Inc(uId);
    InsertMenu(SubMenu, AzureIndex, MF_BYPOSITION, uId, TClouds[AzureIndex]);

    FillChar(CloudMenuItem, SizeOf(TMenuItemInfo), #0);
    CloudMenuItem.cbSize := SizeOf(TMenuItemInfo);
    CloudMenuItem.fMask := MIIM_SUBMENU or MIIM_STRING or MIIM_ID;
    CloudMenuItem.fType := MFT_STRING;
    CloudMenuItem.wID := FMenuItemIndex;
    CloudMenuItem.hSubMenu := SubMenu;
    CloudMenuItem.dwTypeData := PWideChar(MenuCaption);
    CloudMenuItem.cch := Length(MenuCaption);

    InsertMenuItem(Menu, indexMenu, True, CloudMenuItem);
  end;
end;

Quando o usuário estiver no Windows Explorer e passar o mouse sobre um dos menus criados, uma mensagem será exibida na barra de status do Windows Explorer, isso acontece devido a implementação do método GetCommandString, o qual retorna a string a ser exibida pelo Windows Explorer.

function TCloudUploadContextMenu.GetCommandString(idCmd: UINT_PTR; uFlags: UINT;
pwReserved: PUINT; pszName: LPSTR; cchMax: UINT): HResult;
begin
  Result := E_INVALIDARG;

  { Set help string on the Explorer status bar when the menu item is selected }
  if (idCmd in [AmazonIndex, AzureIndex]) and (uFlags = GCS_HELPTEXT) then
  begin
    StrLCopy(PWideChar(pszName), PWideChar('Copy the selected file to ' +
      TClouds[idCmd]), cchMax);
    Result := NOERROR;
  end;

end;

Assim que usuário clicar no menu referente a nuvem que deseja enviar o arquivo, o método InvokeCommand será chamado e dará inicio o processo para fazer o upload do arquivo selecionado. Neste ponto já temos o nome do arquivo e com base nos parâmetros lpici podemos identificar o qual dos items de menu o usuário clicou.

function TCloudUploadContextMenu.InvokeCommand(var lpici: TCMInvokeCommandInfo): HResult;
var
  Item: Word;
begin
  Result := E_FAIL;

  if HiWord(Integer(lpici.lpVerb)) <> 0 then
    Exit;

  { if the index matches the index for the menu, show the cloud options }
  Item := LoWord(Integer(lpici.lpVerb));

  if Item in [AmazonIndex, AzureIndex] then
  begin
    try
      Upload(lpici.HWND, Item, FFileName);
    except
      on E: Exception do
        MessageBox(lpici.hwnd, PWideChar(E.Message), 'Cloud Upload', MB_ICONERROR);

    end;
    Result := NOERROR;
  end;

end;

Para que o objeto COM seja criado sempre que o CloudUpload é carregado, é necessário criar uma instância da classe factory o qual irá criar uma instância do objeto shell extension. A instância da classe factory será criada na seção initialization conforme o código abaixo, veja que o código original criado pelo Delphi será substituido por este.

initialization
  TCloudUploadObjectFactory.Create(ComServer, TCloudUploadContextMenu, CLASS_CloudUploadContextMenu, ciMultiInstance, tmApartment);
end.

Uma vez que a classe factory será responsável por registrar/desregistrar a DLL, os métodos ApproveShellExtension e UpdateRegistry serão chamados, isso vai acontecer quando você usar o regsvr32.exe.

  { the new class factory }
  TCloudUploadObjectFactory = class(TAutoObjectFactory)
  protected
    procedure ApproveShellExtension(&Register: Boolean; const ClsID: string);
    function GetProgID: string; override;
  public
    procedure UpdateRegistry(Register: Boolean); override;
  end;

{ TCloudUploadObjectFactory }

{ Required to registration for Windows NT/2000 }
procedure TCloudUploadObjectFactory.ApproveShellExtension(&Register: Boolean;
  const ClsID: string);
Const
  WinNTRegKey =
    'SOFTWARE\Microsoft\Windows\CurrentVersion\Shell Extensions\Approved';
var
  Reg: TRegistry;
begin
  Reg := TRegistry.Create;

  try
    Reg.RootKey := HKEY_LOCAL_MACHINE;

    if not Reg.OpenKey(WinNTRegKey, True) then
      Exit;

    { register the extension appropriately }
    if &Register then
      Reg.WriteString(ClsID, Description)
    else
      Reg.DeleteValue(ClsID);
  finally
    Reg.Free;
  end;

end;

function TCloudUploadObjectFactory.GetProgID: string;
begin
  { ProgID not required for shell extensions }
  Result := '';
end;

procedure TCloudUploadObjectFactory.UpdateRegistry(Register: Boolean);
Const
  ContextKey = '*\shellex\ContextMenuHandlers\%s';
begin
  { perform normal registration }
  inherited UpdateRegistry(Register);

  { Registration required for Windows NT/2000 }
  ApproveShellExtension(Register, GUIDToString(ClassID));

  { if this server is being registered, register the required key/values
    to expose it to Explorer }
  if Register then
    CreateRegKey(Format(ContextKey, [ClassName]), '', GUIDToString(ClassID),
      HKEY_CLASSES_ROOT)
  else
    DeleteRegKey(Format(ContextKey, [ClassName]));

end;

Compilar para plataformas 32-bit ou 64-bit

A partir daqui preciamos apenas compilar o projeto, neste exemplo as API’s do Windows e os métodos da RTL são os mesmos para as plataformas 32-bit e 64-bit, assim sendo não precisamos fazer implementações específicas para cada plataforma. Você pode definir para qual plataforma deseja compilar utilizando o Project Manager, o default é 32-bit Windows, use o botão direito do mouse na opção Target Platforms para adicionar 64-bit Windows.

Você não pode registrar dll 32-bit em sistema operacional 64-bit, assim como não pode registrar dll 64-bit em sistema operacional 32-bit. Se você desenvolve, compila e teste seus projeto na sua máquina de desenvolvimento, compile para a plataforma compatível com o sistema operacional em uso.

Registrando o Shell Extension CloudUpload

Primeiro, você tem que executar em modo “Run as Administrator” a aplicação que será utilizada para registrar o shell extension, mesmo que seu usuário tenha direitos de Administrador.

Shell extensions 32-bit pode ser registradas através do IDE, linha de comando (cmd) pode ser usada para registrar 32-bit e 64-bit.

Abaixo os passos para registrar e cancelar o registro através de linha de comando:

- “Run as Administrator” o cmd;

- Registre a extensão utilizando a linha de comando: regsvr32 <DIRETÓRIO ONDE ESTÁ A DLL>CloudUpload.dll

- Para desregistrar a extensão utilize a seguinte linha de comando: regsvr32 <DIRETÓRIO ONDE ESTÁ A DLL >CloudUpload.dll /u

Efetuado o registro da DLL abra o Windows Explorer, selecione um arquivo e utilize o botão direito do mouse, você verá um novo menu “Send file from Explorer to the Cloud”. No screenshot abaixo você pode ver a extensão no Windows 7 64-bit.

Você pode obter o código fonte do exemplo aqui utilizado de duas formas:

• Usando o IDE do RAD Studio XE2, no menu File selecione a opção “Open from Version Control” e configure a URL para https://radstudiodemos.svn.sourceforge.net/svnroot/radstudiodemos/branches/RadStudio_XE2/Delphi/CloudAPI/CloudUpload
• Atualizando o repositório local de demos do RAD Studio XE2, case você use TortoiseSVN com o botão direito sobre a pasta C:\Users\Public\Documents\RAD Studio\9.0\Samples\Delphi selecione a opção Update;

Posts relacionados

• CloudAPI – Envio de arquivos para Amazon S3 e Windows Azure – Parte 2
• CloudAPI – Envio de arquivos para Amazon S3 e Windows Azure – Parte 1
• Microsoft Windows Azure por 30 dias GRÁTIS
• Apresentações do Delphi Conference 2010 disponível para download
• Teste nosso servidor DataSnap XE instalado no Amazon Cloud
• DataSnap XE e Windows Azure – RAD Studio XE Preview #3

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Aproveitando a oportunidade, dia 30 de Novembro acontece o Delphi Conference 2011, o maior evento de Delphi do Brasil, um dia inteiro para aprimorar seus conhecimento em Delphi e ir a fundo nas mais recentes novidades. Todas as informações no site do evento HTTP://www.delphiconference.com.br

Pra começar, toda a implementação do monitoramento e controle foi implementada para protocolo TCP/IP o que permite monitorar e derrubar qualquer conexão, assim sendo o componente TDSTCPServerTransporter recebeu dois novos eventos OnConnect e OnDisconnect, estes eventos são muito importantes, pois através deles gerenciamos a lista de conexões no servidor podendo fazer o que quiser com as mesmas. Além disso toda conexão está associado a um Session ID que é único, o Session ID já está disponível desde as versões anteriores do DataSnap.

Para exemplificar o funcionamento e implementação do monitoramento definimos uma lista (collection) conforme abaixo para armazenar as instâncias de cada conexão (TIdTCPConnection) e protocolo (TDSTCPChannel)

FConnections: TObjectDictionary<TIdTCPConnection,TDSTCPChannel>;

A partir dai implementamos os eventos OnConnect e OnDisconnect no TDSTCPServerTransporter. Implementar o evento OnConnect é bem simples, você tem apenas que armazenar as informações referente a conexão na sua lista e caso tenha alguma interface para atualizar com as informações referentes a esta conexão, assim faze-lo.

O código abaixo adiciona a nova conexão utilizando os métodos TMonitor.Enter e TMonitor.Exit para assegurar que nenhuma outra thread irá tentar atualizar esta lista.

Após adicionar a lista utilizamos o método EnableKeepAlive que irei explicar em seguida.

procedure TCMServerForm.CMServerTransportConnectEvent(Event: TDSTCPConnectEventObject);
begin
  System.TMonitor.Enter(FConnections);
  try
    FConnections.Add(TIdTCPConnection(Event.Connection), Event.Channel);
  finally
    System.TMonitor.Exit(FConnections);
  end;

  //Enable Keep-alive for this new connection.
    Event.Channel.EnableKeepAlive(10000);
end;

A implementação do método OnDisconnect terá que localizar a instância da conexão e remove-la da lista, OnDisconnect será executado quando a aplicação cliente desconectar do servidor, seja de forma natural, queda de rede, etc.

Por padrão, o evento OnDisconnect não será notificado se o cliente de forma abrupta perde sua conexão internet. Isso acontece porque a conexão Socket permanece aberta até que ocorra alguma chamada e esta falhe. Se o sistema operacional está configurado para usar pacotes keep-alive para todas as conexões TCP/IP e com base na sua configuração, você verá o evento OnDisconnect ser notificado. Se você desejar controlar este comportamento para cada conexão, então use os métodos EnableKeepAlive e DisableKeepAlive para cada instância do TDSTCPChannel.

No código acima foi definido para cada conexão o KeepAlive em 10 segundos, isso quer dizer que o server irá enviar um pacote (fazer um ping) no cliente quando o mesmo estiver inativo por mais de 10 segundos, se o cliente não responder o server irá tentar novamente, a quantidade de tentativas é baseada no sistema operacional, por exemplo Windows 7 tenta 10 vezes. Você ainda pode definir o intervalo entre os pings, basta configurar o KeepAliveInterval.

O código abaixo demonstra como remover a instância da conexão da lista e como atualizar a interface do usuário utilizando TThread.Synchronize.

procedure TCMServerForm.CMServerTransportDisconnectEvent(Event: TDSTCPDisconnectEventObject);
var
  Index: Integer;
begin
  if (FConnections = nil) or (Event.Connection = nil) then
    Exit;

  //This is called when a TCP connection is closed, for whatever reason.
  System.TMonitor.Enter(FConnections);
  try
    FConnections.Remove(TIdTCPConnection(Event.Connection));

    TThread.Synchronize(nil, procedure
      begin
        //update the connection list box, removing the connection that was just closed
        Index := ConnectionsList.Items.IndexOfObject(Event.Connection);
        if Index > -1 then
        begin
          ConnectionsList.Items.Delete(Index);

          if ConnectionsList.SelCount = 0 then
            SessionIdList.ClearSelection;
        end;
      end);
  finally
    System.TMonitor.Exit(FConnections);
  end;

Até aqui sabemos quem está conectado ao servidor, a partir dai podemos derrubar qualquer conexão, visto que temos a instância de cada TDSTCPChannel e este contém o método close que encerra a conexão cliente, ao ser desconectado o lado cliente recebe uma exception quando tentar executar qualquer operação no servidor.
No exemplo abaixo encerramos a conexão selecionada em um ListBox, o método GetSelectedChannel busca a instância do Channel baseado na conexão selecionada no ListBox.

Quando executamos o método Channel.Close o evento OnDisconnect será notificado.

procedure TCMServerForm.ButtCloseSelectedClick(Sender: TObject);
var
  Channel: TDSTCPChannel;
begin
  //Find the selected connection's channel, and then close it.
  Channel := GetSelectedChannel;

  //after calling close, the CMServerTransportDisconnectEvent event will be notified.
  if Channel <> nil then
  begin
    Channel.Close;
  end;
end;
function TCMServerForm.GetSelectedChannel(Conn: TIdTCPConnection): TDSTCPChannel;
begin
  Result := nil;

  //Finds the selected connection
  if Conn = nil then
    Conn := GetSelectedConnection;

  //uses the selected connection to look up the associated channel.
  if Conn <> nil then
    FConnections.TryGetValue(Conn, Result)
end;

O RAD Studio XE2 traz um exemplo completo sobre o assunto e se você já usa a versão XE2 pode encontrá-lo em C:\Users\Public\Documents\RAD Studio\9.0\Samples\Delphi\DataSnap\DataSnapMonitor ou fazer o download direto do repositório de demos do RAD Studio XE2 aqui.

Posts relacionados

• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Implementando cache de dados em servidores DataSnap
• Exemplos e slides do Delphi Meeting 2011
• Vídeos sobre DataSnap para 2011 – o que você gostaria de ver?
• Vídeo de lançamento da familia XE do Delphi, C++Builder, RadPHP e Delphi Prism
• Hora de seguir em frente

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Nos planejamos disponibilizar todas as informações no site em breve. O anúncio oficial das ferramentas e do FireMonkey será feito em breve também. Nós achamos que vocês iriam gostar de ter acesso aos softwares um pouco mais cedo.

Agora é hora de se divertir com as novidades!!!

Posts relacionados

• Delphi Conference 2011 – chamada para submissão de palestras
• RAD Studio XE2 uma nova era para desenvolvedores Delphi e C++Builder
• Exemplos e slides do Delphi Meeting 2011
• Vídeo de lançamento da familia XE do Delphi, C++Builder, RadPHP e Delphi Prism
• Disponibilizada nova versão do Delphi XE, C++Builder XE, Delphi Prism XE e RadPHP XE
• Desenvolvimento Ágil = Delphi XE + C++Builder XE + Delphi Prism XE + RadPHP XE

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Existem inúmeras possibilidades com FireMonkey e todos os novos recursos do RAD Studio XE2, todas estas novidades estão sendo apresentadas no RAD Studio XE2 World Tour, no Brasil será realizado o Delphi Tour 2011 como parte do World Tour, garanta já o seu lugar no Delphi Tour 2011, fazendo sua inscrição o quanto antes.

Para que você tenha uma idéia das novidades do RAD Studio XE2 e mate um pouquinho da curiosidade, preparei um vídeo de 5 minutos (em inglês) com um preview do Delphi XE2 e aplicações HD no FireMonkey rodando em Windows (64-bit), Mac e iOS, além de usar componentes 3D e animações.

Registre-se hoje mesmo para o Delphi Tour 2011

Posts relacionados

• Conectando ao PostgreSQL com dbExpress ODBC driver
• Vídeo de lançamento da familia XE do Delphi, C++Builder, RadPHP e Delphi Prism
• Usando expressões regulares em aplicações FireMonkey com C++Builder
• Usando dbExpress Framework no Windows e Mac com C++Builder
• Hora de seguir em frente
• Apresentações do Delphi Conference 2011 disponíveis para download

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Exceções (exceptions em inglês) são condições que requerem um tratamento especial, o tratamento de exceção fornece uma maneira padrão de lidar com erros, quando utilizado permite que você gerencie os erros quando eles aconteçam e decida o que fazer.

A documentação do RAD Studio tem um tópico específico que trata de Exception Handling, invista algum na leitura deste tópico, lendo este tópico você estará melhor preparado para responder as perguntas sobre este tema durante a prova..

Além disso, você pode pensar que pelo fato de usar try..except..end no seu desenvolvimento diário é suficiente para responder as perguntas da prova, a resposta é NÃO. O programa de certificação tem um banco de dados com muitas perguntas, a prova irá trazer perguntas sobre diferentes aspectos do tratamento de exceção, como: Propagando (Re-raising) exceções, Exceções silenciosas (Silent Exceptions) e mais.

Exceção silenciosa é uma forma de levantar (raise) uma exceção sem mostrar a mensagem de erro, o método padrão para levantar uma exceção mostra a mensagem de erro, mas não é só isso.

• Todas as exceções silenciosas descendem da exceção padrão EAbort.
• Delphi tem uma procedure chamada Abort, o qual automaticamente cria e levanta a exception EAbort

function GetFileList(const Path: string): TStringList;
var
  I: Integer;
  SearchRec: TSearchRec;
begin
  Result := TStringList.Create;
  try
    I := FindFirst(Path, 0, SearchRec);
    while I = 0 do
      begin
          Result.Add(SearchRec.Name);
          I := FindNext(SearchRec);
      end;
  except
      Result.Free;
      raise;
  end;
end;

GetFileList cria um objeto TStringList e então usa as funções FindFirst e FindNext para inicializá-lo. Se a inicialização falhar, por exemplo porque o diretório é inválido ou porque não há memória suficiente para preencher o string list – será necessário que GetFileList se desfaça do novo string list. Por esta razão, a inicialização do string list ocorre em um bloco try…except..statement. Se a exceção ocorrer, a parte do código do except irá destruir o string list e assim propagar a exceção com um raise.

A prova irá além dos aspectos que aqui mencionei. A seguir cinco links que irá lhe ajudar a aprender mais sobre tratamento de exceções:

• Try..Except..Finally – Parte 01
• Try..Except..Finally – Parte 02
• Try..Except..Finally – Parte 03
• RAD Studio documentation – Exception Handling
• Delphi Basic – Exception handling in your code
• Delphi Basic – Raise

Posts relacionados

• Vídeo: Preparatório para a Certificação Delphi
• Webinar preparatório para a Certificação Delphi
• Dicas para a Certificação Delphi Developer #2
• Dicas para a Certificação Delphi Developer #1
• Nova Certificação Delphi – Anúncio oficial
• Hora de seguir em frente

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Todo desenvolvedor Delphi deveria saber que toda class teem um método construtor (Constructor), o qual é used para criar objects. A documentação do RAD Studio descreve Constructor assim:

A constructor is a special method that creates and initializes instance objects. The declaration of a constructor looks like a procedure declaration, but it begins with the word constructor.

A convenção do Delphi nomeia o construtor como Create por padrão, uma classe pode ter mais de um construtor, mas na maioria das vezes vemos apenas um. Assim sendo está claro que a palavra chave constructor define o construtor, assim sendo você pode nomeá-lo como quiser. Existem várias situações onde será necessário o uso de mais de um construtor, e usar múltiplos nomes ajuda a ter um código mais legível e fácil de manter. O exemplo abaixo tem 7 construtores usando três nomes diferentes: Create, New e Update:

  TMyClass = class
  public
    name   : string;
    constructor Create; overload;   // Este constructor é o default
    constructor Create(name : string); overload;
    constructor Create(name : string; age : Integer); overload;
    constructor New(name : string);overload;
    constructor New(name : string; age : Integer);overload;
   constructor Update(name : string);overload;
   constructor Update(name : string; age : Integer);overload;

  end;

A class TMyClass pode ser instanciada através de um dos construtores abaixo:

  TMyClass.Create;
  TMyClass.Create('Mike');
  TMyClass.Create('Mike', 50);
  TMyClass.New('Mike');
  TMyClass.New('Mike', 50);
  TMyClass.Update('Mike');
  TMyClass.Update('Mike', 30);

Há mais que aprender sobre construtores, para começar sugiro os seguintes links:

• Documentação do RAD Studio – tópico Method
• Delphi Basic – Constructor

Posts relacionados

• Dicas para a Certificação Delphi Developer #3
• Vídeo: Preparatório para a Certificação Delphi
• Webinar preparatório para a Certificação Delphi
• Dicas para a Certificação Delphi Developer #1
• Nova Certificação Delphi – Anúncio oficial
• Hora de seguir em frente

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

A fim de motivar outros desenvolvedores, decidi começar a publicar aqui no blog dicas para o programa de certificação, o qual tem o objetivo lhe ajudar na preparação para as provas. O guia de estudo (Study Guide) para a certificação Developer é o guia oficial e traz todas as informações que você precisa para estar preparado para a prova. As dicas que começarei a publicar devem ser consideradas como um material complementar e não substituirá os Study Guides.

Eu não estarei publicando perguntas e/ou resposta relacionadas a prova, o objetivo é ajudar você a se preparar para a prova, aprender mais sobre Delphi, melhorar suas qualidades como desenvolvedor e aumentar suas chances de se tornar um profissional Delphi Developer Certified.

A prova é inglês, assim sendo é necessário o conhecimento do idioma, estarei obviamente trazendo explicações em português, mas também apontando para materiais em ambos idiomas, especialmente para a documentação do Delphi que é uma das principais fontes de estudo.

Para começar, vamos aprender sobre o tipo de dado System.RawByteString e aprimorar seus conhecimentos sobre o suporte a Unicode, você poderá ser questionado na prova de forma direta ou indireta sobre este tema.

System.RawByteString

RawByteString é um dos novos tipos de String incorporados no Delphi 2009 por causa do suporte a Unicode. RawByteString é um AnsiString que não tem code page (código de página) definido como padrão, cada string em Delphi esta asociada a um code page. A runtime library usa esta informação para converter e manipular de forma segura conjuntos de caracteres internacionais. RawByteString pode ser usado como um tipo de variável para armazenar BLOB e deve ser usado como code page agnóstico em parâmetro métodos.

A documentação do RAD Studio (em inglês) descreve RawByteString assim:

Enables the passing of string data of any code page without doing any codepage conversions.

RawByteString enables the passing of string data of any code page without doing any codepage conversions. The purpose of RawByteString is to reduce the need for multiple overloads of procedures that read string data. This means that parameters of routines that process strings without regard for the string’s code page should typically be of type RawByteString.

RawByteString should only be used as a parameter type, and only in routines which otherwise would need multiple overloads for AnsiStrings with different codepages. Such routines need to be written with care for the actual codepage of the string at run time.

In general, it is recommended that string processing routines should simply use “string” as the string type. Declaring variables or fields of type RawByteString should rarely, if ever, be done, because this practice can lead to undefined behavior and potential data loss.

Abaixo, 4 links que eu recomendo para leitura:

• Recursos Avançados do Delphi 2009 – Capitulo sobre Unicode
• Delphi Unicode Migration for Mere Mortals: Stories and Advice from the Front Lines
• Using RawByteString Effectively
• RAD Studio Documentation – String Types (Delphi) – already mentioned on the Study Guide

Com estas informações você estará preparado para responder perguntas relacionadas a RawByteString e Unicode, e o mais importante aprender mais sobre Delphi.

Posts relacionados

• Dicas para a Certificação Delphi Developer #3
• Vídeo: Preparatório para a Certificação Delphi
• Webinar preparatório para a Certificação Delphi
• Dicas para a Certificação Delphi Developer #2
• Nova Certificação Delphi – Anúncio oficial
• Hora de seguir em frente

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Hoje é um dia muito importante para a comunidade Delphi, hoje nós da Embarcadero anunciamos o novo Programa de Certificação Delphi tão esperado pela comunidade Delphi. Milhões de desenvolvedores Delphi terão a oportunidade de demonstrar suas habilidades e conhecimento aos seus pares, a comunidade de desenvolvedores e potenciais empregadores.

O novo programa de certificação é muito mais acessível que a certificação anterior, teve a colaboração de vários experts em Delphi ao redor do mundo e difere da certificação anterior onde tinhamos apenas um nível de certificação – o novo programa de certificação está dividido em dois níveis, conhecidos como Developer e Master Developer.

Já estão disponíveis os Study Guides (guias de estudos) para ambas as certificações; o study guide traz informações sobre os tópicos que serão avaliados durante a prova, links para recursos online e uma lista de livros recomendados para a preparação. Para cada prova você terá 60 minutos para responder 60 perguntas, ao final você saberá qual foi sua pontuação e se passar, receberá o certificado em formato PDF no seu email.

A prova para se tornar Delphi Developer pode ser adquirida através da loja online da Embarcadero a um custo de US$49 e não é moderada, ou seja, você pode fazer a prova de qualquer lugar. Já a prova para se tornar Delphi Master Developer custa US$149 e deve ser adquirida através de um de nossos parceiros. Você terá de agendar a sua prova em um dos Centros de Certificação, pois esta prova deverá ser assistida por um dos nossos parceiros.

Certificação Delphi Developer

A prova para se tornar Delphi Certified Developer testa conhecimentos gerais na linguagem delphi, incluindo sintaxe da linguagem, técnicas de programação e conceitos relacionados ao desenvolvimento de aplicações para banco de dados.

Se você possui uma licença registrada do Delphi XE ou RAD Studio XE, você poderá fazer uma prova Developer gratuitamente, mais informações na página do Certification Center.

A prova está organizada em 12 seções:

Certificação Delphi Master Developer

A prova para se tornar Delphi Certified Master Developer testa conhecimento avançados na linguagem Delphi, seus fundamentos e sintaxe avançada da linguagem, técnicas avançadas de programação, uso do IDE, construção de projetos e grupo de projetos, uso e desenvolvimento de componentes, experiência em arquitetura e conhecimento na construção de aplicações desktop, cliente/servidor, Internet e multi-camadas.

A prova é organizada em 12 seções:

Guias de Estudo para a certificação (Study Guides)

Minha recomendação para os interessados em se tornar Delphi Certified é começar lendo o Study Guide, ele é o seu ponto de partida na preparação para se tornar Delphi Certified Developer ou Master Developer.

Caso você esteja em dúvida qual certificação tentar primeiro, eu recomendo que você comece pela certificação Developer, ao final você terá uma boa idéia de como funciona todo o processo, desde a preparação até a prova. Se você preferir, pode ir direto a certificação Master Developer, que requer conhecimento avançado em diversos aspectos do desenvolvimento Delphi e isso requer conhecimento adicional e maior tempo de preparação.

Em ambos os casos, os nossos parceiros de treinamento oferecem vários treinamentos que lhe ajudarão na preparação para a certificação.

Ao passar na prova, você poderá usar o logo “Delphi Certified” da respectiva certificação em sua assinatura de email, website, cartão de visita, etc., além de outros benefícios.

Certification Center

A página Certification Center contém todas as informações que você precisa. Eu convido você a visitar os links abaixos e por favor leia o Study Guides e FAQ (Perguntas frequentes), caso após ler as informações do Certification Center você ainda tiver alguma dúvida, por favor envie sua pergunta para certification@embarcadero.com.

• Certification Center Home Page
  • Delphi Developer Certification Page
  • Delphi Master Developer Certification Page
  • Delphi Certification – Perguntas frequentes
  • Onde comprar

Webinar sobre a certificação

Em breve estaremos divulgando a data do webinar em português sobre o Programa de Certificação Delphi, onde estarei comentando sobre:

• Visão geral do programa de certificação
• Níveis da certificação: Delphi Developer e Delphi Master
• Preparação para a prova
• Dicas para passar na prova
• Benefícios ao se tornar um desenvolvedor certificado
• Tirando dúvidas ao vivo para aqueles que estiverem participando do webinar

Enquanto isso, comece a se preparar para a certificação, divirta-se e boa sorte na prova.

Posts relacionados

• Dicas para a Certificação Delphi Developer #3
• Vídeo: Preparatório para a Certificação Delphi
• Webinar preparatório para a Certificação Delphi
• Dicas para a Certificação Delphi Developer #2
• Dicas para a Certificação Delphi Developer #1
• Hora de seguir em frente

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Recentemente devido a mudanças no Facebook mudamos a comunidade Delphi Brasil no Facebook, com isso o endereço da comuniade passou a ser http://www.facebook.com/DelphiBrasil.

Esta URL personalizada facilita a divulgação da comunidade para os desenvolvedores Delphi brasileiros.

Outra forma de ajudar é curtindo a página, conforme abaixo.

E não esqueça o novo link da comunidade Delphi Brasi no Facebook é http://www.facebook.com/DelphiBrasil.

Posts relacionados

• Hora de seguir em frente
• Apresentações do Delphi Conference 2011 disponíveis para download
• White Paper: Razões para migrar para o Delphi XE2 | O que você pode ter perdido desde o Delphi 7
• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Conectando ao PostgreSQL com dbExpress ODBC driver
• Vagas esgotadas para o Delphi Conference 2011

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

O arquivo readme.html que está localizado no diretório onde o Delphi foi instalado, documenta as versões de MySQL e dos outros bancos suportados pelo dbExpress. No caso do MySQL o arquivo inclui as combinações de versões de server e bilbiotecas clientes suportadas, infelizmente o MySQL a cada nova versão traz inúmeras alterações nas API’s e acabe dificultando uma pouco nosso trabalho.

Abaixo informações que você deve saber.

Versões de servidores MySQL oficialmente suportadas e testadas.

MySQL 5.1, 5.0.27, 4.1 (Todas) (Driver dbxMYS.dll, Client libmysql.dll)

Combinação das versões de servidores e clientes MySQL que foram testadas

• LibMySQL.dll (5.1.XX) Client  - DBXMys.dll MySQL 4.0.XX Server
• LibMySQL.dll (5.1.XX) Client  - DBXMys.dll MySQL 5.0.XX Server
• LibMySQL.dll (5.1.XX) Client  - DBXMys.dll MySQL 5.1.XX Server

Em resumo, você tem que instalar a versão do cliente do MySQL 5.1.xx para que sua aplicação cliente funcione com servidores MySQL 4.0.XX, 5.0.XX e 5.1XX

O que fazer caso você tenha outras versões do Delphi na mesma máquina?

Caso isso aconteça o IDE poderá carregar uma das versões antigas do driver dbExpress para MySQL, isso acontece porque o diretório bin da versão anterior do Delphi está a frente na variável de sistema PATH, para resolver este problema, no menu Tools -> Options -> Environment Variables adicione o PATH da versão atual do Delphi a frente de todas as variáveis. Lembre-se que casa você use a versão anterior instalada na sua máquina, você deverá atualiza a variável de ambiente PATH novamente.

Espero que essas dicas tenham ajudado.

Posts relacionados

• Hora de seguir em frente
• Apresentações do Delphi Conference 2011 disponíveis para download
• White Paper: Razões para migrar para o Delphi XE2 | O que você pode ter perdido desde o Delphi 7
• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Conectando ao PostgreSQL com dbExpress ODBC driver
• Vagas esgotadas para o Delphi Conference 2011

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse

Durante os últimos 3 meses temos trabalhando em um importante projeto que irá ajudar os desenvolvedores Delphi a aprimorar seus conhecimentos e habilidades, assim como ser reconhecidos no mercado. Estou falando do programa de Certificação Delphi.

O programa irá começar com dois níveis de certificação:

• Developer – A certificação Delphi XE Developer testa seus conhecimentos nos fundamentos da linguagem Delphi, assim como os fundamentos no acesso a banco de dados em Delphi. O teste foi desenhado para que você possa demonstrar as competências básicas usando Delphi.
• Master – A certificação Delphi XE Master testa o seu verdadeiro domínio em Delphi, você será testado em técnicas complexas de programação Delphi, desenvolvimento de componentes, e outros tópicos avançados.

Neste momento estamos abrindo o beta tester para a certificação Master, nosso objetivo é validar o teste para a certificação “Delphi Master”.

Nós solicitamos pelo menos dois anos de experiência em desenvolvimento de software com Delphi e que esteja familiarizado com as melhorias em Delphi desde a versão 7, a fim de ser qualificado para participar neste programa beta.

As perguntas do teste estão agrupadas de acordo com as seguintes áreas de conhecimento:

O objetivo nesta fase de validação não é testar se você passou ou não no teste. O objetivo aqui é eliminar qualquer pergunta não bem formulada ou questionável. Isto significa que se todos ou quase todos errarem uma pergunta – por definição ela é ruim e precisa ser revista.

Se você está interessado em participar, registre-se aqui

Posts relacionados

• Hora de seguir em frente
• Apresentações do Delphi Conference 2011 disponíveis para download
• White Paper: Razões para migrar para o Delphi XE2 | O que você pode ter perdido desde o Delphi 7
• CopyReaderToClientDataSet, Blob e a mensagem “Feature not implemented”
• Conectando ao PostgreSQL com dbExpress ODBC driver
• Vagas esgotadas para o Delphi Conference 2011

Andreano Lanusse | Tecnologia e Desenvolvimento de Software
Follow me on Twitter: @andreanolanusse