Reasons to migrate to Delphi XE
3 likes37,030 views
The document provides a comprehensive overview of the reasons to migrate from Delphi 7 to Delphi XE, detailing numerous enhancements in usability, IDE features, and coding capabilities. Key updates include subversion integration, improved project management tools, enhanced resource management, and support for new programming paradigms such as generics and anonymous methods. The document serves as a technical guide highlighting the increased productivity and quality of application development available in Delphi XE compared to its predecessors.
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 48 -
It can’t be overemphasized that simply by compiling your applications in Delphi 2006 or
later, you experience performance gains, while also being able to detect memory
leakages.
SOAP 1.2 CLIENT SUPPORT
Delphi 2010 introduced the SOAP 1.2 client support through the THTTPRIO component.
In Delphi XE THTTPRIO exposes new properties to allow the developer to select a Client
Certificate at design-time.
REGULAR EXPRESSION
Delphi XE introduces RTL support for regular expressions (unit RegularExpressions).
Regular expressions provide a concise and flexible means for matching strings of text,
such as particular characters, words, or patterns of characters.
The following example shows how to use regular expression to validate IP address.
program RegExpIP;
{$APPTYPE CONSOLE}
uses
SysUtils,
RegularExpressions;
var
ipRegExp : String;
begin
try
ipRegExp := 'b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).’ +
‘(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).(25’ +
‘[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).(25[0-5]’ +
‘|2[0-4][0-9]|[01]?[0-9][0-9]?)b';
if TRegEx.IsMatch(paramstr(1), ipRegExp) then
Writeln('Text DOES match the regular expression')
else
Writeln('Text DOES NOT match the regular expression');
except
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
end;
end.
Passing the parameter 200.100.2.21 (valid IP) the result will be:
Text DOES match the regular expression](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-49-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 49 -
Passing the parameter 200.100.2.263 (invalid IP) the result will be:
Text DOES NOT match the regular expression
OBJECT-ORIENTED FILE AND DIRECTORY I/O CLASSES
Delphi 2010 brings a new unit IOUtils contains three static classes: TDirectory, TPath and
TFile. These classes expose a number of static methods useful for I/O tasks. Most methods
are functionally and signature compatible with .NET classes System.IO.Directory,
System.IO.Path and System.IO.File.
The follow code shows how to read all files from specific folder.
procedure TForm2.Button2Click(Sender: TObject);
var
Path : string;
begin
if not TDirectory.Exists(edtPath.Text) then
Caption := 'Invalid Path'
else
Caption := edtPath.Text;
ListBox1.Clear;
for Path in TDirectory.GetFiles(edtPath.Text, ‘*.*’) do
Listbox1.Items.Add(Format('Name = %s', [Path]));
end;
100% UNICODE
One of the greatest challenges faced by our R&D team was incorporating Unicode
support throughout the Delphi language, VCL, RTL, and the IDE and the Delphi ecosystem
of tool and component partners..
As part of the Unicode development process we had meetings with customers, authors,
consultants and technology partners Working directly with our tool and component
partners proved essential in allowing third-party components to be available to support
the latest version of Delphi, as well as in keeping developers updated about how to work
with Unicode.
Unicode is a standard that allows computers to consistently represent and handle text from any
existing system of writing.
- The Unicode Standard: Version 5.0. 5. ed. Addison-Wesley Professional, 2006. 1472 p
Many character sets – like Chinese, Japanese, and Russian, along with others of Asian
background – are represented by means of Unicode. The most commonly used encodings](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-50-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 61 -
myInnerField: Integer;
procedure innerProc;
end;
procedure outerProc;
end;
This is how the method is implemented:
procedure TOuterClass.TInnerClass.innerProc;
begin
...
end;
To access the method within the Nested class, see the next example:
var
x: TOuterClass;
y: TOuterClass.TInnerClass;
begin
x := TOuterClass.Create;
x.outerProc;
...
y := TOuterClass.TInnerClass.Create;
FINAL METHODS
The Delphi compiler also supports the concept of a final virtual method. When the
keyword final is applied to a virtual method, no descendent class can override that
method. Use of the final keyword is an important design decision that can help document
how the class is intended to be used. It can also give the compiler hints that allow it to
optimize the code it produces.
STATIC CLASS METHOD
When these classes are declared as Static they do not need to be instantiated.
FOR … IN
Delphi 2007 brought support for element-in-collection (collections, arrays, string
expressions and set-type expressions) style iteration over containers.
Example: Iteration in an Array
var
IArray1: array[0..9] of Integer = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-62-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 66 -
of DataSnap authentication, so that a call that comes in from the network can still be
checked as its code flow spreads throughout the graph of objects.
Anyhow, here's a simple example to get started:
uses SysUtils, Rtti;
{$apptype console}
type
TFoo = class
// Frob doubles x and returns the new x + 10
function Frob(var x: Integer): Integer; virtual;
end;
function TFoo.Frob(var x: Integer): Integer;
begin
x := x * 2;
Result := x + 10;
end;
procedure WorkWithFoo(Foo: TFoo);
var
a, b: Integer;
begin
a := 10;
Writeln(' before: a = ', a);
try
b := Foo.Frob(a);
Writeln(' Result = ', b);
Writeln(' after: a = ', a);
except
on e: Exception do
Writeln(' Exception: ', e.ClassName);
end;
end;
procedure P;
var
foo: TFoo;
vmi: TVirtualMethodInterceptor;
begin
vmi := nil;
foo := TFoo.Create;
try
Writeln('Before hackery:');
WorkWithFoo(foo);
vmi := TVirtualMethodInterceptor.Create(foo.ClassType);
vmi.OnBefore := procedure(Instance: TObject; Method: TRttiMethod;
const Args: TArray<TValue>; out DoInvoke: Boolean; out Result: TValue)
var
i: Integer;
begin
Write('[before] Calling ', Method.Name, ' with args: ');
for i := 0 to Length(Args) - 1 do](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-67-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 67 -
Write(Args[i].ToString, ' ');
Writeln;
end;
// Change foo's metaclass pointer to our new dynamically derived
// and intercepted descendant
vmi.Proxify(foo);
Writeln('After interception:');
WorkWithFoo(foo);
finally
foo.Free;
vmi.Free;
end;
end;
begin
P;
end.](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-68-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 68 -
Here's what it outputs:
Before hackery:
before: a = 10
Result = 30
after: a = 20
After interception:
before: a = 10
[before] Calling Frob with args: 10
Result = 30
after: a = 20
[before] Calling BeforeDestruction with args:
[before] Calling FreeInstance with args:
You'll notice that it intercepts all the virtual methods, including those called during destruction, not
just the one I declared. (The destructor itself is not included.)
NEW $POINTERMATH {ON – OFF } DIRECTIVE
The $POINTERMATH directive enables mathematic operations with pointers.
NEW WARNINGS
When you compile your application with Delphi XE, four new warnings might appear in
your IDE’s message window. These messages regard the use of the new UnicodeString
type. These new warnings include:
• 1057 Implicit string cast from '%s' to '%s'
• 1058 Implicit string cast with potential data loss from '%s' to '%s'
• 1059: Explicit string cast from '%s' to '%s'
• 1060 Explicit string cast with potential data loss from '%s' to '%s'](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-69-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 71 -
Writeln( 'Number of Columns: ' + IntToStr(aColCount) );
while aReader.Next do
begin
Writeln( aReader.Value['Country'].GetAnsiString );
end;
Writeln( '====================================================' );
Writeln( '' );
end;
// Commit transaction
aDBXConn.CommitFreeAndNil(aDBXTrans);
Readln;
aReader.Free;
aCmnd.Free;
aDbxConn.Free;
end;
end.
DBEXPRESS METADATA
The new metadata support is used extensively by the Data Explorer pane of the Delphi
IDE, but can also be used by any application. In short, you'll not only be able to browse the
database structure, but also be able to use classes and objects to modify it, rather than
relying directly on the native database SQL commands for creating and modifying data
structures. Not only will the code look more object-oriented, but it will be also easier to
target different database servers with the same code, as dbExpress abstracts the metadata
capabilities of each server.
The unit DBXMetaDataNames has been provided to read metadata. The dbExpress class
TDBXMetaDataCommands provides a set of constants to read various types of metadata.
Set the TDBXCommand.CommandType property to DBXCommandTypes.DBXMetadata
and set TDBXCommand.Text to one of the constants in TDBXMetaDataCommands to
acquire the designated metadata TDBXCommand.ExecuteQuery returns a TDBXReader to
access the metadata. The new classes in DBXMetaDataNames describe and provide
access to this metadata's columns. Below a list of metadata you can read using dbExpress:
• Data types
• Tables
• Columns (from tables, views, etc.)
• Indexes
• Fields from those indexes
• Foreign key](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-72-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 74 -
Delphi 2010 brought a dbExpress driver for Firebird, which was the number one request at
that time. The dbExpress driver for Firebird supports Firebird version 1.5 and 2.x, and not
only that, the DBX Framework is fully compatible with Firebird so you can create tables,
primary keys, foreign keys, indexes and more through the framework. Data Explorer fully
supports Firebird as well.
BIGINT fields are 100% supported and are mapped as TLargeIntField in the VCL, and the
BLOB type is mapped as TBlobField.
Certainly the question arises, support for the blob and bigint as it gets. BIGINT fields are
100% supported and are mapped as TLargintField the VCL, the BLOB works perfectly and
are mapped as TBlogField.
New concepts, called “Delegate Driver” and “Pools Connections”, are available in
dbExpress and require simple parameter configuration.
You can also extend the dbExpress framework to write delegation drivers, which provide
an extra layer between the application and the actual driver. Delegate drivers are useful
for connection pooling, driver profiling, tracing, and auditing DBXTrace is a delegate
driver used for tracing.
Below you see the log result generated by the Delegate in Delphi language. It’s easy to
read, understand, and even execute operations once again.
Trace configuration. The following example captures events according to the TraceFlags
parameter, saving the log file at c:dbxtrace.txt. The dbExpress connection has a
parameter to indicate the trace configuration; for instance: DelegateConnection=
DBXTraceConnection
[DBXTraceConnection]
DriverName=DBXTrace
TraceFlags=EXECUTE;COMMAND;CONNECT
TraceDriver=true
TraceFile=c:dbxtrace.txt
Generated log result:
Log Opened ==========================================
{CONNECT } ConnectionC1.Open;
{COMMAND } CommandC1_1 := ConnectionC1.CreateCommand;
{COMMAND } CommandC1_1.CommandType := 'Dbx.SQL';
{COMMAND } CommandC1_1.CommandType := 'Dbx.SQL';
{COMMAND } CommandC1_1.Text := 'select * from employee';
{PREPARE } CommandC1_1.Prepare;
{COMMAND } ReaderC1_1_1 := CommandC1_1.ExecuteQuery;
{COMMAND } CommandC1_2 := ConnectionC1.CreateCommand;
{COMMAND } CommandC1_2.CommandType := 'Dbx.MetaData';](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-75-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 75 -
{COMMAND } CommandC1_2.Text := 'GetIndexes "localhost:C:
databaseemployee.ib"."sysdba"."employee" ';
{COMMAND } ReaderC1_2_1 := CommandC1_2.ExecuteQuery;
{READER } { ReaderC1_2_1 closed. 6 row(s) read }
{READER } FreeAndNil(ReaderC1_2_1);
{COMMAND } FreeAndNil(CommandC1_2);
You can also use connection pools with dbExpress natively. Below you see an alias
(Pool_DelegateDemo) passing to DBXPoolConnection the control over the connection
pool (where the maximum number of connections is set).
[DBXPoolConnection]
DriverName=DBXPool
MaxConnections=16
MinConnections=0
ConnectTimeout=0
[Pool_DelegateDemo]
DelegateConnection=DBXPoolConnection
DriverName=Interbase
DriverUnit=DBXDynalink
DriverPackageLoader=TDBXDynalinkDriverLoader
DriverPackage=DBXCommonDriver110.bpl
DriverAssemblyLoader=Borland.Data.TDBXDynalinkDriverLoader
DriverAssembly=Borland.Data.DbxCommonDriver,Version=11.0.5000.0,Culture=neutra
l,PublicKeyToken=a91a7c5705831a4f
Database=localhost:C:databaseemployee.ib
RoleName=RoleName
User_Name=sysdba
Password=masterkey
ServerCharSet=
SQLDialect=3
BlobSize=-1
CommitRetain=False
WaitOnLocks=True
ErrorResourceFile=
Interbase TransIsolation=ReadCommited
Trim Char=False](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-76-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 83 -
Log('>>' + Msg);
if Session.UserFlag = 1 then
Raise Exception.Create('Backup session cannot be redirected once more.' +
Msg);
DBXProperties := TDBXDatasnapProperties.Create(nil);
DBXProperties.Values[TDBXPropertyNames.DriverName] := 'Datasnap';
DBXProperties.Values[TDBXPropertyNames.HostName] := 'localhost';
DBXProperties.Values[TDBXPropertyNames.Port] := '213';
try
try
Session.Reopen(DBXProperties);
Session.UserFlag := 1;
Msg := 'Flow commuted to alternate resource.';
Log('>>' + Msg);
except
Raise Exception.Create(Msg + '. Commuting to alternate resource failed.');
end;
finally
DBXProperties.free;
end;
end;
In case you want to run the sample code on your machine, here are the steps you need for
that.
The sample includes two projects: Failover Server and DataSnap Server. We will use
DataExplorer as our client application. Using the follow steps you will be able to see the
Failover Server in action.
• Open and execute the Failover server, the sample use HTTP protocol and port 8080
• Execute the DataSnap Server twice, one using port 211 and other one port 213. The
server using the port 213 will work as the backup server
• Create a DataSnap alias in your Data Explorer, remembering to configure it to use
HTTP as protocol and port 8080
• On the Stored Procedure node, find the method EchoString, pass the value Delphi
2010 as parameter and execute. The return value will be Delphi 2010 (Server 211)
• Close the DataSnap Server that runs on the port 211
• Repeat the step 4 and look the return value, which should be Delphi 2010 (Server
213)
• Now look the log on the Failover Server, you will see the exception error and the
redirection log information](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-84-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 84 -
You can download the source code at http://cc.embarcadero.com/Item/27391.
DATASNAP – SECURITY
Once you have a server created with some server methods you will probably want to add
in some logic to control who can invoke those methods. For this you can use the
new/improved functionality in the Authentication Manager component.
To get started you simply drop this component onto your form and set it as the
authentication manager to use in the TDSHTTPWebDispatcher, TDHTTPService or
TDSTCPServerTransport component, depending on your server’s configuration.
The authentication manager has two events; OnUserAuthenticate and OnUserAuthorize. It
also has a ‘Roles’ collection.
The OnUserAuthenticate event is called when a user tries to connect (invoke a method) for
the first time, and takes as input parameters connection info such as the user’s name and
password, and allows you to set a value for the in/out parameter “valid”. By default this is
set to true, but you can decide, based on the user information or anything else you wish, if
you want to set valid to true or false. Setting it to false will deny the user connection, and
therefore also deny any invocation they may have been attempting.
You can define Roles in several different ways. You can go to your server methods class
and add a TRoleAuth attribute to the code (requires DSAuth unit.) This attribute can either
be added at class level, or at method level, like this:
[TRoleAuth('admin')]
TServerMethods1 = class(TComponent)
public
function EchoString(Value: string): string;
function ReverseString(Value: string): string;
end;
Or this:
TServerMethods1 = class(TComponent)
public
[TRoleAuth('admin')]
function EchoString(Value: string): string;
function ReverseString(Value: string): string;
end;
In the first example both ‘EchoString’ and ‘ReverseString’ would require the user to have
the “admin” role to invoke the method. In the second example, only the ‘EchoString’
method has the admin role associated with it. Note that the TRoleAuth attribute has an
optional second parameter, which is the ‘denied roles’ list which behaves as you would
expect. Both of these parameters can be a comma-separated list of roles.](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-85-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 87 -
The fifth step asks you to select the root location for the REST web application. This is the
output directory of the project executable and the location of the web application files
such as .js, .html and .css files.
DATASNAP CLIENT – DBEXPRESS
Since Delphi 2007 - when the dbExpress Framework was first created - our goal was to
build an infrastructure for many technologies, databases and platforms, extending the
existing multi-layer support and enabling Java, .NET, PHP, and other clients to connect to
DataSnap servers.
DbxClient is now being used to connect the client to the DataSnap server, as well. This
means that in order to connect to a DataSnap server you must use an SQLConnection,
informing that the connection driver is DataSnap and providing the hostname (server) and
port
There are many ways to execute the server methods. Let’s assume the server holds a class
that contains the HelloWorld and GetEmployee methods.
function TDMServerDB.HelloWorld(IncommingMessage : WideString ): WideString;
begin
Result := 'Hello World';
end;
function TDMServerDB.GetEmployee(ID : Integer): TDBXReader;
begin
SQLDataSet1.Close;
SQLDataSet1.Params[0].AsInteger := ID;
SQLDataSet1.Open;
Result := TDBXDataSetReader.Create(SQLDataSet1, False);
end;
The HelloWorld method is quite simple. It sends a string and returns another. Method
GetEmployee, in turn, sends an ID and receives a TDBXReader. In other words, it’s a cursor
that can be read client-side either as a DBXReader or as a ClientDataSet.
Still working with the HelloWorld method, you’ll now execute it using the
SQLServerMethod component. See below:
begin
DMDataSnapClient.DSServerConnect.Open; // opens the connection by means of
SQLConnection
SMHelloWorld.SQLConnection := DMDataSnapClient.DSServerConnect;
SMHelloWorld.Params[0].AsString := 'Message sent from Client';
SMHelloWorld.ExecuteMethod;
ShowMessage(SMHelloWorld.Params[1].AsString); // shows the result
End;](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-88-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 89 -
FGetServerDateTimeCommand := FDBXConnection.CreateCommand;
FGetServerDateTimeCommand.CommandType := TDBXCommandTypes.DSServerMethod;
FGetServerDateTimeCommand.Text := 'TDSServerMethods.GetServerDateTime';
FGetServerDateTimeCommand.Prepare;
end;
FGetServerDateTimeCommand.ExecuteUpdate;
Result := FGetServerDateTimeCommand.Parameters[0].Value.AsDateTime;
end;
function TDSServerMethodsClient.ExecuteJob(JobId: Integer): Integer;
begin
if FExecuteJobCommand = nil then
begin
FExecuteJobCommand := FDBXConnection.CreateCommand;
FExecuteJobCommand.CommandType := TDBXCommandTypes.DSServerMethod;
FExecuteJobCommand.Text := 'TDSServerMethods.ExecuteJob';
FExecuteJobCommand.Prepare;
end;
FExecuteJobCommand.Parameters[0].Value.SetInt32(JobId);
FExecuteJobCommand.ExecuteUpdate;
end;
constructor TDSServerMethodsClient.Create(ADBXConnection: TDBXConnection);
begin
inherited Create;
if ADBXConnection = nil then
raise
EInvalidOperation.Create('Connection cannot be nil. '
+ 'Make sure the connection has been opened.');
FDBXConnection := ADBXConnection;
end;
destructor TDSServerMethodsClient.Destroy;
begin
FreeAndNil(FGetServerDateTimeCommand);
FreeAndNil(FExecuteJobCommand);
inherited;
end;
How do you access the DataSetProvider from the server, from a remote data module, or
from a conventional data module? That’s simple: on the client-side you use the new
DSProviderConnection component, which is connected to your SQLConnection
(DataSnap). The ServerClassName property indicates the class name (DataModule/RDM,
usually) where the providers are located in the server. The ClientDataSet then can use the
DSProviderConnection as its ProviderName.
The new DataSnap and dbExpress Framework provide greater flexibility, not limited by
what’s presented in this section. It’s possible to dynamically access a list of methods along
with their parameters, which allows developers to create components that control user
access to the server and define access rights specific to each of the server’s methods and
classes. You can take a look at a more complete DataSnap application samples by visiting](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-90-320.jpg)
![Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7
Embarcadero Technologies - 99 -
INDEX OUT OF BOUNDS (IOB)
This is a common message for when you try to access an array position that does not exist.
The snippet below generates this warning.
var
nloops,
i,
j :integer;
matriz : array of integer;
somatorio : double;
begin
for i := 0 to nloops do
begin
somatorio := 0;
for j := 0 to High(matriz) do
somatorio := somatorio + matriz[i];
end;
end;
Figure 43. Audits
The audit has located the error, informing you that the code in line 25 tries to access a
variable that is not part of the 2nd
loop. Drilling down a little:
In variable J’s ‘for’ statement I’m trying to access one of the positions in array ARR, aiming
at position I of the previous loop, while variable J’s ‘for’ statement is the place where array
ARR is being read.
Delphi XE allows you to execute audits through command line, making easy the
integration with automated build process.](https://image.slidesharecdn.com/reasonstomigratetodelphixewhitepaper-101116235519-phpapp01/85/Reasons-to-migrate-to-Delphi-XE-100-320.jpg)
Reasons to migrate to Delphi XE
- 1. Americas Headquarters EMEA Headquarters Asia-Pacific Headquarters 100 California Street, 12th Floor San Francisco, California 94111 York House 18 York Road Maidenhead, Berkshire SL6 1SF, United Kingdom L7. 313 La Trobe Street Melbourne VIC 3000 Australia Reasons to Migrate to Delphi XE What you might have missed since Delphi 7 Andreano Lanusse November 2010
- 2. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 1 - TABLE OF CONTENTS Table of Contents...........................................................................................................................................- 1 - Introduction.....................................................................................................................................................- 5 - What’s new in the IDE....................................................................................................................................- 7 - Subversion Integration – Version Insight...................................................................................................- 7 - Project Manager.........................................................................................................................................- 7 - Gallery........................................................................................................................................................- 8 - New Project Options ..................................................................................................................................- 9 - Build Configurations...................................................................................................................................- 9 - IDE Insight ...............................................................................................................................................- 10 - Component Creation Wizard ...................................................................................................................- 11 - COM.........................................................................................................................................................- 11 - New Resource Manager ..........................................................................................................................- 12 - Managing the menu Reopen Files...........................................................................................................- 13 - Use Unit – Interface/Header ....................................................................................................................- 13 - Class Explorer..........................................................................................................................................- 14 - Component Search in the Tool Palette....................................................................................................- 15 - The old Component Toolbar is back........................................................................................................- 15 - Code Editor..............................................................................................................................................- 16 - Source Code Formatter ...........................................................................................................................- 18 - Source Code Editor SEARCH .................................................................................................................- 20 - Search in File...........................................................................................................................................- 20 - Change History ........................................................................................................................................- 22 - Refactoring...............................................................................................................................................- 23 - Unit Testing..............................................................................................................................................- 23 - Data Explorer...........................................................................................................................................- 24 -
- 3. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 2 - SQL Window - Query Builder...................................................................................................................- 25 - Background Compilation..........................................................................................................................- 26 - Debugger .................................................................................................................................................- 26 - What’s new in the VCL and RTL..................................................................................................................- 29 - VCL Direct2D and Windows 7 .................................................................................................................- 29 - Touch and Gestures ................................................................................................................................- 30 - Ribbon Controls .......................................................................................................................................- 32 - Windows Vista and Windows 7 support ..................................................................................................- 33 - New and enchanced VCL Components ..................................................................................................- 34 - New memory manager and new RTL functions ......................................................................................- 47 - SOAP 1.2 client support ..........................................................................................................................- 48 - Regular Expression .................................................................................................................................- 48 - Object-oriented file and directory I/O classes..........................................................................................- 49 - 100% Unicode..........................................................................................................................................- 49 - New language features and compiler resources..........................................................................................- 52 - Enhanced RTTI........................................................................................................................................- 52 - Attributes..................................................................................................................................................- 52 - Exit Function ............................................................................................................................................- 53 - Inline Directive .........................................................................................................................................- 54 - Operator Overloading ..............................................................................................................................- 55 - Class Helpers...........................................................................................................................................- 57 - Strict private and Strict protected.............................................................................................................- 59 - Records support methods........................................................................................................................- 59 - Class abstract, Class sealed, Class const, Class type, Class var, Class property .................................- 60 - Nested classes.........................................................................................................................................- 60 - Final methods ..........................................................................................................................................- 61 - Static class method..................................................................................................................................- 61 -
- 4. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 3 - For … in ...................................................................................................................................................- 61 - Generics...................................................................................................................................................- 62 - Anonymous Methods ...............................................................................................................................- 64 - Virtual Method Interception......................................................................................................................- 65 - New $POINTERMATH {ON – OFF } Directive ........................................................................................- 68 - New Warnings..........................................................................................................................................- 68 - dbExpress ....................................................................................................................................................- 69 - Framework...............................................................................................................................................- 69 - dbExpress Metadata................................................................................................................................- 71 - dbExpress Drivers ...................................................................................................................................- 73 - Cloud Computing .........................................................................................................................................- 76 - Microsoft Windows Azure ........................................................................................................................- 76 - Amazon EC2............................................................................................................................................- 76 - DataSnap .....................................................................................................................................................- 77 - Concepts..................................................................................................................................................- 77 - DataSnap Server – Server Container......................................................................................................- 78 - DataSnap Server – Server Module..........................................................................................................- 79 - DataSnap Server – Filters .......................................................................................................................- 80 - DataSnap Server – HTTP Tunneling.......................................................................................................- 81 - DataSnap – Security................................................................................................................................- 84 - DataSnap REST Server...........................................................................................................................- 85 - DataSnap Client – dbExpress..................................................................................................................- 87 - DataSnap – Sending and Receiving objects ...........................................................................................- 90 - Delphi translation tools – Localizing your Applications ................................................................................- 93 - UML modeling, audits, metrics, and documentation....................................................................................- 94 - UML Modeling..........................................................................................................................................- 94 - Audits .......................................................................................................................................................- 97 -
- 5. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 4 - Metrics ...................................................................................................................................................- 100 - Documentation.......................................................................................................................................- 102 - Third-party Tools and components ............................................................................................................- 103 - AQtime – Performance Profiling ............................................................................................................- 103 - FinalBuilder – Build Automation.............................................................................................................- 104 - CodeSite – advanced Logging System .................................................................................................- 105 - IP*Works................................................................................................................................................- 105 - TeeChart 2010.......................................................................................................................................- 106 - Rave Reports 9......................................................................................................................................- 106 - Beyond Compare...................................................................................................................................- 106 - VCL for the Web ....................................................................................................................................- 106 - Delphi XE Editions – Professional, Enterprise and Architect.....................................................................- 107 - Conclusion..................................................................................................................................................- 107 - About The Author .......................................................................................................................................- 108 -
- 6. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 5 - INTRODUCTION Many Delphi users wonder whether they’ll find compelling reasons to migrate to Delphi XE. Here they are: a plethora of new features allied to unparalleled developer productivity, all aimed at your ability to create higher-quality applications with improved performance. This article gives a few good reasons to migrate, along with an overview of all the new features added to Delphi product releases since version 7. The following table gives a quick snapshot of the new, top level, capabilities in each of the Delphi product releases since Delphi 7. This paper provides the deep technical information for all of these features and more. Delphi 2005 • Multi-unit namespaces, for ... in ... do loops, inline functions and other code optimizations. • Heterogeneous database access, multi-tier database applications • Refactoring, Source code History view • Unit testing Delphi 2006 • Code block completion/Surround, Editor Change Bars • Live Code Templates • UML Modeling, Audits, Metrics, Doc Gen • Design Patterns Delphi 2007 • MSBuild, Build Configurations • VCL - AJAX, Vista compatibility • Vista and XP Themes for applications • dbExpress - new framework, delegate drivers, Unicode database support Delphi 2009 • Unicode throughout the language, library and IDE • Generics and Anonymous Methods • Resource Editor, Class Explorer • DataSnap multi-tier
- 7. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 6 - • VCL – new components, Custom Hints, Ribbon Controls • Localization – Integrated Translation Environment, External Translation Manager Delphi 2010 • Windows 7, Multi-Touch and Gesture support, Direct-2D • IDE Insight, Source Code Formatter, Search task bar • Background compilation • Enhanced RTTI • Breakpoints in threads, freeze/thaw threads • DataSnap – HTTP protocol support Delphi XE • DataSnap – HTTPS, JavaScript, REST support • Subversion integration • Regular Expression library • AQTime, CodeSite, Beyond Compare, Final Builder • Cloud Services and Cloud Deployment We understand that developers are busy creating software, and that spending time to migrate to a new version is not always possible since you always have to deliver new projects. Possibly the best reason for you to migrate to Delphi XE, C++Builder XE or RAD Studio XE, is that buying those versions gets you earlier versions at no extra cost. For example buying Delphi XE also gets you Delphi 7, Delphi 2007, Delphi 2009 and Delphi 2010.
- 8. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 7 - WHAT’S NEW IN THE IDE SUBVERSION INTEGRATION – VERSION INSIGHT With Delphi XE you can easily use the popular Subversion version control system to manage source code revisions for your own code or among your team. Features include: • Integration into the project manager and history manager • Support for common version control tasks like import, update, commit and show log. • Difference and merge viewer • Source code for the integration using the Open Tools API available as an open source project This integration is Open Source and is hosted on SourceForge (http://sourceforge.net/projects/radstudioverins/), but there’s actually an easier way to access it if you already have XE. We ship a version of the source in the RAD Studio samples directory (which is at C:UsersPublicDocumentsRAD Studio8.0Samples). PROJECT MANAGER The new Project Manager introduces a lot of new capabilities, which will bring more productivity like: • Sorting the Contents of the Project Manager: The new Sort By toolbar button enables you to sort the items in the Project Manager by name, timestamp, path name, or file type. You can also specify Auto Sort, which means that future additions to the project or project group are to be added in the current specified sort order. See Project Manager. o Compile All From Here and Build All From Here: The project context menu on the Project Manager contains a new From Here command that enables you to perform the following: o Compile All From Here o Build All From Here o Clean All From Here These three commands start a compile, a build, or a clean operation, respectively, beginning at the selected node in the project. These commands are described in Project Context Menu.
- 9. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 8 - • Compile All, Build All, and Clean All: These new context menu commands are available for Project Groups that contain more than one project. See Project Group Context Menu. • The Project context menu on the Project Manager contains a new Install|Uninstall command that enables you to either install or uninstall a design-time package. GALLERY The Gallery has been augmented with a search feature. And as an extra productivity enhancement, all gallery items show up but the ones that used to be invisible are grayed out. This should really help those customers migrating from Delphi 7 where all COM wizards were visible but you had to know the order in which to create them. Now, you can run any wizard that is enabled and there won't be any question of where the COM wizards went. Figure 1. New project Gallery, search integrated
- 10. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 9 - NEW PROJECT OPTIONS We’ve changed the IDE in many different ways in order to make development faster and easier. The project compilation options are now displayed in columns and grouped by categories in a friendly manner. It’s also now possible to save your project’s configuration options, or build configurations, as you’ll see in Figure 2. Figure 2. Build Configurations BUILD CONFIGURATIONS Compiling and debugging projects are regular tasks for developers. However, the project options that are used to run the final version (release) are not always the same project options you use when debugging. Having to constantly change your project’s options is a time-consuming task that you can now avoid, never again being forced to spend lots of time working with the Project Manager. In Delphi XE the build configuration options are seamlessly integrated to the Project Manager. In addition, project configurations can be saved in XML-format OPTSET files. Working with these files you're able to reuse project options from previous projects, no longer having to set them each time a new project is started. Named option sets and further configure build configuration files.
- 11. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 10 - IDE INSIGHT The new IDE Insight search box enables you to type in a string and then select from a list of all the matching items in the IDE and in your current project environment. The IDE Insight box contains a list of categories such as Commands, Files, Components, Project Options, and so forth. As you type your search string, IDE Insight performs an incremental search: the IDE Insight box displays only the categories that contain matching items, along with the one "best" match from each category. You can press Alt+A or a button on the IDE Insight dialog box to toggle between showing all categories (with one "best" match per category) or all matches (which might require you to scroll through the list to find the match you seek). Figure 3. IDE Insight When you double-click an item in the IDE Insight box, the IDE automatically invokes or performs the associated action. For example, if you type "open", the list displays all the currently available items that contain the string "open". If you double-click the name of a dialog box, the dialog box is invoked. If you double-click a component (such as TOpenDialog), the component is automatically added to the active form.
- 12. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 11 - COMPONENT CREATION WIZARD The Component Creation and Import Wizards have been redesigned to include type libraries, ActiveX controls and assemblies. Both wizards can now install into an existing package or in a new package. As you see in Figure 4, a new field was added to filter components, making it easier for you to locate the component you want to inherit. Figure 4. Ancestor Component COM COM wizards and the entire type library have been restructured. In fact, the COM Object Creation Wizards are all brand new. What has changed? A new file type - RIDL (Restricted Interface Definition Language) – was added to the COM architecture. RIDL files work as recording devices projects use to save type libraries. Therefore, the Type Library (.TLB) binary file becomes an intermediary file, like .DCU, .RES, .OBJ, and so on. This means developers are now able to recompile tlb
- 13. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 12 - files using the command line prompt, and even edit a tlb file using a text editor, while still keeping track of its version. The type library now uses a text file (the RIDL file), not TLB. This is beneficial because: • You no longer need to check the tlb file in. It’s now automatically generated based on the last RIDL file. • Different developers can work with the same type library. This is so because the text file can now be merged, something that couldn’t be done with the binary file used previously. • The RIDL format provides the Type Library editor with much higher flexibility. • You can easily compare different RIDL files. NEW RESOURCE MANAGER The Resource Compiler allows you to choose between compiling your resources with BRCC32.exe or RC.exe (Microsoft Platform SDK resource compiler). RC supports the use of Unicode characters in resource files and file names. It also supports the new Windows Vista types (e.g., icons and alpha channel). When you use RC you must define #include <winresrc.h> explicitly both for Delphi and C++. The New Resource Manager allows you to add many resource files (bitmaps, icons, fonts…) to your project. Figure 5. Resource Editor
- 14. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 13 - MANAGING THE MENU REOPEN FILES It is now possible to control the number of files and projects that appear on the File Reopen menu. You can now specify the amount of projects and files that you want to appear in the list, as well as clean up old files/projects you no longer want in the list. USE UNIT – INTERFACE/HEADER Until Delphi 2009 the Use Unit option declared the unit on the section Implementation, now you can define where it will be declared, Interface or Implementation for Delphi code. In addition, our projects bring tens, hundreds or even thousands of Units, when we need to declare the unit in the code it becomes difficult to do through the Use Unit option, not anymore, now you can use masks to Filter the units and make it easy to find the unit as shown in Figure 6. Figure 6. New Use Unit window
- 15. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 14 - CLASS EXPLORER The Class Explorer is a very useful tool that enables you to visualize a project’s class hierarchy and its interfaces, as well as add properties, methods and variables to it. These operations can be performed by means of UML, through the use of class models. UML is one of the many resources that were incorporated to Delphi. Figure 7. Class Explorer
- 16. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 15 - COMPONENT SEARCH IN THE TOOL PALETTE In Delphi 2006 you could filter components typing the first couple of letters of their names in the Tool Palette. In Delphi 2007 this feature was enhanced and you were then able to type in any portion of the component name. In Delphi XE an Edit field is used to achieve the same result, making this feature clearer and easy to recognize at first glance. Users who prefer Delphi 7’s layout (i.e., components displayed at the upper portion of the IDE) will be glad to know Delphi XE’s IDE can look just like Delphi 7’s. However, before switching to the old Delphi 7 layout, give the Tool Palette in the new version a try. Locating components with ease, the orderly arrangement of categories, etc., can provide great productivity gains. Figure 8. Component Search THE OLD COMPONENT TOOLBAR IS BACK We have heard that a lot of developers liked the old Component Toolbar as it was in Delphi 7, and consider that one of the reasons not to move to the new release. In Delphi 2010 (and later versions) you can use the old Component Toolbar and/or the new Tool Palette. To activate the Component Toolbar just right click on the main toolbar and select Component. After that you can right click on the Component Toolbar to see the list of all categories available or just navigate through the tabs and chose one.
- 17. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 16 - The configuration of the Tool Palette and Component Toolbar are independent, and you can for example reorder the categories. There is also a search box for the components on the Component Toolbar. Figure 9. Delphi IDE using Delphi 7 layout CODE EDITOR The new Live Templates feature implemented in Delphi 2006 extends your ability to create code templates in Delphi. These are created as XML files, and help you program with less code. Block completion is one of the resources involved in enabling automatic begin and end. And who can honestly say he’s never had a hard time with begin..end?
- 18. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 17 - Consider this context: you want to change the name of all variables in a selected part of the code. Find..Replace is not a good practice for this situation. It doesn’t guarantee only variable names will be changed in the process. Since Delphi 8 you can use Sync Edit to edit different portions of code simultaneously, provided they share the same identifier. Taking the code below as an example, you could select the entire block, make sure sync edit is active and then change the “Comm” variable a single time. Figure 10. Live Templates, sync edit, code folding and other source code editor features Alongside the code block you see yellow and green marks. The yellow ones are shown for lines that have changed since the last Save. Green marks, in turn, indicate lines that were recently changed and saved. You also see the smart code line numbering. And you’re able to either expand or collapse a method or a class right within the block. Think about a unit with tens of methods. You hope one day you’ll have enough time to stop and set it in order, but never really find time to do so. The code above holds a region called “Methods for enabling/blocking user access”. This region has two methods for either enabling or blocking users. You can’t see those methods, unless their region is expanded. A question remains: wouldn’t it be easier to organize and visualize the code with the assistance of such features?
- 19. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 18 - Help from within the code (Help Insight): Press F1 in order to see the documentation of a method, type, class, etc. As you can see, the code above displays the CreateCommand method help info. The same thing happens with any method, type or class, provided it has a description available. Find references for a method, class, variable, or any other specific item. Imagine your code holds a class named TCGC, which you want to rename to TCNPJ. Assuming you’re a careful developer, tell me where the TCGC class is referenced in the project. Find..Replace won’t work this time. Instead, try pressing Shift + CTRL + Enter over class TCGC. The IDE then looks for all references in the project, as seen below. Figure 11. Find References with Live Template If you’re now wondering how to rename all classes to TCNPJ, wait until we discuss Refactoring. Another useful feature is named Surround. It works basically by allowing you to add begin/end, if/begin/end, try/finally, try/except, etc., to a block of code. SOURCE CODE FORMATTER Delphi has its default formatting code, but we all know that many developers follow this pattern and many have their own style, this is cause for great discussion, but that is no longer a problem. The IDE now provides a fully customizable code formatter for accessible via CTRL + D. This allows you to have your unit formatted according to the desired settings. Furthermore, you can use the Project Manager to format all units included in the project.
- 20. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 19 - The IDE Insight Formatter (Figure 12) allows you to set your own options for Indentation, Spaces, Line breaks and Capitalization, and your code will be formatted according to these options when you invoke the code formatter. Figure 12. Code Formatter configuration window There is also Profile support, which allows you to maintain and switch between several sets of formatting options used by the source code formatter. The formatting options are stored in configuration files. By selecting a profile you activate the set of formatting options stored in this profile. To create a configuration file use the Save As command button. By default, configuration files have the .config extension. Profiles are special kinds of configuration files. Profiles have the following additional properties: • Profiles should match the Formatter_*.config file mask (profile mask). • Profiles should be located in the RAD Studio working directory. By default, this is the "%APPDATA%EmbarcaderoRAD StudioVersionNumber" directory.
- 21. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 20 - SOURCE CODE EDITOR SEARCH The search feature in the code editor has been overhauled and is based on other popular search implementations (e.g. Firefox and Internet Explorer).Now when you press CTRL + F and type a search word you will see results as shown in Figure 13, where the first content from the cursor will be highlighted in black and the remaining orange. Figure 13. Searching for the word “function”, yields the above result. SEARCH IN FILE Find content in files is a common task and take time, almost time we try to find content in directories that are not part of the project, repeating this operation many times is stressful.
- 22. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 21 - In Delphi 2010 we added a feature to enable you to select directories for “Find in files” easier. You can now save groups of directories that you use on a regular basis in conjunction with “Find in Files” (See Figure 14). Figure 14. Search in File window
- 23. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 22 - CHANGE HISTORY Files are locally versioned whenever they’re changed, even in the absence of version control, thus allowing you to make comparisons between them. Figure 15. Change History If your project is integrated with Subversion, the Change History will list the file revisions from your version control system.
- 24. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 23 - REFACTORING Delphi 7 users will surely love to try this resource. Refactoring is a technique you can use to restructure and modify your existing code in such a way that the intended behavior of your code stays the same. Refactoring allows you to streamline, simplify, and improve both performance and readability of your application code. Delphi includes a refactoring engine that evaluates and executes the refactoring operation. The engine also displays a preview of the changes that will occur in a refactoring pane that appears at the bottom of the Code Editor. The potential refactoring operations are displayed as tree nodes, which can be expanded to show additional items that might be affected by the refactoring, if they exist. Warnings and errors also appear in this pane. You can access the refactoring tools from the Main menu and from context-sensitive drop down menus. UNIT TESTING Delphi integrates an open-source testing framework, DUnit, for developing and running automated test cases for your applications. This framework simplifies the process of developing tests for classes and methods in your application. Using unit testing in combination with refactoring can improve your application’s stability. Running a standard set of tests every time a small change is made throughout the code makes it more likely that you will catch any problems early in the development cycle.
- 25. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 24 - DATA EXPLORER It’s now easier to retrieve data from databases. Using the Data Explorer along with drag- and-drop capabilities you can access tables, views, stored procedures and other database items. Besides that, you can also search for data using SQL. Connections are established through dbExpress. This means Data Explorer supports every database dbExpress supports. Each connection is assigned an alias which is saved in the dbxconnections.ini file (dbExpress’ configuration file). Aliases are treated as shared information, thus facilitating the use of Data Explorer. Figure 16. Data Explorer
- 26. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 25 - SQL WINDOW - QUERY BUILDER The Data Explorer allows developers to easily build complex SQL queries via an intuitive visual query builder interface. Figure 17. SQL Window
- 27. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 26 - BACKGROUND COMPILATION Since Delphi 2010 you can perform background compilation — that is, you can start a compile running as a separate and parallel thread and continue working in the IDE while the compiler compiles your project. You can continue to work in the IDE while a background compilation runs. For example, you can edit files, even the files you are compiling, and you can set and modify breakpoints. Figure 18. Compiler dialog transparent during the compiler process running in background DEBUGGER The debugger now comes with the “Thread View and Wait Chain Traversal” feature, available only for Windows Vista and Windows 7. This resource helps you locate deadlocks and thread contentions.
- 28. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 27 - During the debug process it is helpful to visualize the content of variables. The Watch List comes in handy for that, but the higher the number of items added the more confusing the visualization gets. Developers can now group Watch List variables based on custom names. Custom variable groups are then represented as tabs in the Watch List. After the debug is finished, all units that are opened during the process are automatically closed; only units that remain open are the ones that were open before the debug process was started. There are a lot of improvements with the visualization and usability of local variable window, call stack and others. There is also a new tree view for the content of objects that are being debugged, shown in Figure 19: Figure 19. Debugger Starting with Delphi 2010 it’s much easier to debug a multi-threaded application. New features in the debugger allow for step-by-step debugging in threads, as well as freezing and thawing of threads. This way you can isolate only the threads that want to debug,
- 29. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 28 - freezing all irrelevant ones. There are options in the “Thread Status View” to "Freeze" "Freeze All Other Threads", "Thaw" and "Thaw All Threads". Also, there is now a breakpoint option to only break on a specific thread. Debugger Visualizers make it much easier to debug your data. How many times have you needed to debug a variable of type TDate, TTime TDateTime? The IDE now shows these as you would expect – human readable dates and times, instead of floating point values. Similarly for TStringLists – the list of strings is shown in plain text . Furthermore, you can add your own Debugger Visualizers for your own custom types. Figure 20. Data Visualizer for TStrings data type
- 30. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 29 - WHAT’S NEW IN THE VCL AND RTL Since Delphi 7, the VCL and RTL have been continuously enhanced. Besides complete support to Windows XP, 2000, Vista, Windows 7 and Unicode, new components have been added and existing components have been improved by the addition of new functionalities. All these add up to better component usability, easy creation of rich interfaces and the ability to use Windows Vista and Windows 7 new functionalities, as well the full support for touch and gesture. In this section, we focus on what’s new in existing components and the changes in RTL classes. VCL DIRECT2D AND WINDOWS 7 Microsoft Windows 7 introduces Direct2D a hardware-accelerated, immediate-mode, 2-D graphics API that provides high performance and high-quality rendering for 2-D geometry, bitmaps, and text. The Direct2D API is designed to interoperate well with GDI, GDI+, and Direct3D. Direct2D forwards all drawing operations to the GPU (Graphics Processing Unit) instead of the CPU and that means more resource available to your application. This topic discusses how to take advantage of the new screen Direct2D Delphi in your application. Direct2D is only supported on Windows 7, along with Delphi 2010 (or later) is 100% compatible with Windows 7 and it uses several features of the new Microsoft operating system, Direct2D is one. To make sure you're developing your application using Direct2D, you must include the following units in your application: • Direct2D, which exposes the wrapper classes as TDirect2DCanvas VCL. • D2D1, which contains the header translations to Microsoft Direct2D API The follow example shows how to override the Paint method of the form, using the class TDirect2Canvas. procedure T2D2Form.FormPaint(Sender: TObject); var LCanvas: TDirect2DCanvas; begin LCanvas := TDirect2DCanvas.Create(Canvas, ClientRect); LCanvas.BeginDraw; try { Drawing goes here } LCanvas.Brush.Color := clRed; LCanvas.Pen.Color := clBlue; LCanvas.Rectangle(100, 100, 200, 200); finally LCanvas.EndDraw; LCanvas.Free;
- 31. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 30 - end; end; Direct2D will be the natural replacement of Canvas, the difference in graphics quality is very high, as shown in Figure 21. Figure 21. Graphic using Direct2D TOUCH AND GESTURES The application development market is not the same after the year of 2009, today the emergence of applications for cameras, phones, GPS-based Touch and Gesture is very large and growing rapidly. Windows 7 introduce the support for Multi-Touch where users can interact with the application by two or more taps on the screen. Before start developing touch applications is important to understand the 3 kinds of touch: • Basic Touch already used in the market, fingers replace the right mouse button, e.g. ATMs, point of sale, etc. • Multi-touch Application elements with extensive interactions via touch, example: movie Minority Report and iPhone. Only supported by Windows 7 and newer hardware. • Gestures Act with the movement of a finger or mouse, firing an event. May be intuitive, allowing customization, more inputs and is supported by almost all systems touch.
- 32. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 31 - Delphi has an architecture that allows users to plug other gesture engine and it will runs on all supported versions of Windows, not only Windows 7. It’s also backwards compatible with the available hardware and enables users to emulate mouse movements or touch. The VCL brings more than 30 standard pre-defined gestures, as well the gesture editor for writing, testing and reproduction of recorded GESTURE. In addition, Delphi includes a component to simulate a virtual keyboard, the TTouchKeyboard. All visual components have a Touch property, which has a sub-property, named Gesture Manager, which will be connected to the respective component. The Gesture Manager will manage all the gestures made in the application, it triggers an action for each gesture, all actions are managed by the Action Manager, so even if you use Action Manager simply connect their Actions to the Gesture Manager. Figure 22 shows the Gesture Designer that allows recording, playback and testing of the generated motion, the movement associated with the VCL component will trigger an action by the Action Manager, the movement has to be close as possible, and you can adjust sensitivity for each gesture. Figure 22. The Gesture Designer, allow developers to create and test gesture
- 33. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 32 - RIBBON CONTROLS Most of you already know about the new Ribbon interface (used in Office 2007). Such interfaces are designed to facilitate user access to your application’s menu options. The VCL now comes with Ribbon Controls, a group of components that allows you to create Ribbon-style Delphi interfaces. Ribbon Controls integrate with the Action Manager, which means that applications with Actions and the traditional menus can be easily migrated to Ribbon. The architecture behind Ribbon Controls is very simple. From a Ribbon control you are able to add a Tab (which contains groups). Each of these groups contains buttons with customized appearance. Additionally, the Ribbon control includes the Quick Access Toolbar and the Application Menu. Figure 23 provides an example application with Ribbon Controls. Figure 23. Ribbon Controls
- 34. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 33 - WINDOWS VISTA AND WINDOWS 7 SUPPORT Applications compiled with Delphi 2007 (or later) are 100% compatible with Windows Vista and Windows 7. The VCL has been updated to support the new characteristics of this OS, while new components were also added: TFileOpenDialog, TFileSaveDialog and TTaskDialog. New classes have also been created; for instance: • TCustomFileDialog • TFileTypeItems • TCustomFileOpenDialog • TTaskDialogBaseButtonItem • TCustomFileSaveDialog • TTaskDialogButtonItem • TCustomTaskDialog • TTaskDialogButtons • TFavoriteLinkItem • TTaskDialogButtonsEnumerator • TFavoriteLinkItems • TTaskDialogProgressBar • TFavoriteLinkItemsEnumerator • TTaskDialogRadioButtonItem • TFileTypeItem Dialog box components are now displayed in a Vista-like fashion. You are now probably wondering what happens to applications when you run them on Windows XP. There’s no reason to be concerned about it. VCL recognizes the OS, using its specific resources and the appropriate interface. The TaskMessageDlg function was designed to support Windows Vista. It has the same functionality seen in MessageDlg, with additional parameters that support Windows Vista’s characteristics. When you run your application on Windows XP, MessageDlg is automatically executed. VCL is there to ensure it. The UseLatestCommonDialogs global variable defines that all dialog components (TOpenDialog, TSaveDialog, TOpenPictureDialog and TSavePictureDialog) should follow Windows Vista’s design whenever it receives a TRUE statement. For example, this is how Open and Save Dialogs look in Windows Vista and Windows 7:
- 35. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 34 - Figure 24. Open Dialog in Windows Vista Figure 25. Save Dialog in Windows Vista The units below were enhanced to support Window’s new APIs. • UxThemes – new • DwnApi – new • ActiveX – updated • Windows – updated • Messages – updated • CommCtrl – updated • ShlObj - updated NEW AND ENCHANCED VCL COMPONENTS TACTIONMANAGER New properties - DisabledImages, LargeImages and LargeDisabledImages - that allow you to define large and disabled images, based on the TImageList component. PNG SUPPORT The Image component supports the PNG format natively. TBITMAP Support to 32-bit alpha bitmaps, along with the addition of the AlphaFormat property. TBUTTONGROUP This component allows you to group many different buttons in a panel. TBUTTONEDIT The new TButtonEdit component allows you to add images within the Edit field. Images can be placed either at the right or left side. You can also use events to control image clicking – by means of the onLeftClick and onRightClick events.
- 36. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 35 - TLINKLABEL LinkLabel allows you to add HTML tags that affect the appearance of the component. TPOPUPACTIONBAR Now supports ActionBar styles. THEADERCONTROL AND THEADERSECTION New checkbox support.
- 37. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 36 - TBUTTON Windows Vista now has two new button styles, both supported by Delphi with its TButton class. CommandLink has a different, friendlier design. You can use it to add a more detailed description of the button functionality. SplitButton opens a list of options when clicked. This list is presented as a PopMenu. You can also assign images to the items. Figure 26 New Button Styles TLISTVIEW AND TTREEVIEW TListView now allows you to define basic and advanced groups. The advanced group support enables deeper customization of groups (requires Vista), allowing you to define images for each of them. TTreeView allows enabling/disabling nodes and images for expanded items. Figure 27. TListView
- 38. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 37 - TBALLOONHINTS Hints now come in Windows Vista style and allow the addition of titles, descriptions and images, which will make your user notifications much friendlier. Figure 28. Balloon Hints TCATEGORYPANELGROUP This new component is very useful. It works like an Outlook bar, to which you can add many different panels. Each of these panels can contain any VCL component. You can define a title, an image, the alignment and an icon for each of the panels, being able to expand and collapse them. Figure 29. Panel Group
- 39. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 38 - NEW PANELS The traditional TPanel is a visual container for other components. Within TPanel you are able to accommodate visual controls wherever you want. In other words, it works with absolute positioning (the Top and Left coordinates of the control refer to the panel’s upper left corner). Inspired by similar Java concepts (namely, the Layout Manager, which defines how controls are distributed within the container) we can say we now have three kinds of layout managers: • TPanel : absolute type, or XY. Components are placed in fixed, precise positions. • TFlowPanel : components are placed in a sequence, according to a given order (similar to an HTML page, neither using tables nor CSS stylesheets). o The flow is determined by the FlowStyle property, which accepts the options you see below. In order to understand the naming convention, keep in mind that components are accommodated according to the direction defined by the first pair (e.g., LeftRight). When there’s no space left in the panel, the direction is redefined by the second pair (e.g., TopBottom): fsLeftRightTopBottom: left to right, top down (default) fsRightLeftTopBottom: right to left, top down fsLeftRightBottomTop: left to right, bottom up fsRightLeftBottomTop: right to left, bottom up fsTopBottomLeftRight: top down, left to right fsBottomTopLeftRight: bottom up, left to right fsTopBottomRightLeft: top down, right to left fsBottomTopRightLeft: bottom up, right to left o Another relevant property is AutoWrap. When True, indicates the flow will be “broken” towards the other direction in case the panel runs out of space. When False, components outside the boundaries of the panel will not be visible. o You can use this panel to automatically generate forms, with fields being dynamically defined either in a database or a file. This way you do not need to be concerned about positioning each of the fields.
- 40. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 39 - Figure 30. Form Auto Generation • TGridPanel : the panel is partitioned by lines and columns, with each of the resulting cells holding a component (similar to the use of HTML tables). o Components are arranged according to the order of the lines (top down) and, within each line, column-wise (left to right). o The number of lines is determined by the RowCollection property, which can contain various objects of the TRowItem class. Each item has two properties: SizeStyle: determines the standard by which line height is specified in the Value property: • ssAbsolute: number of pixels • ssAuto: the number is disregarded, with line height being automatically calculated • ssPercent: percentage in comparison to the panel height Value: a number expressing the height, according to the SizeStyle property. o Similarly, the number of column is determined by the ColumnCollection property, which contains objects of the TColumnItem class. TColumnItem has the same properties TRowItem does, differing only in that they relate to the column width, not the row's. o The ExpandStyle property determines an action for whenever someone tries to add a component into a panel that is out of free cells. Its possible values are: emAddRows: a new line is added to the panel to accommodate the components emAddColumns: new columns are added to accommodate the components emFixedSize: an exception is raised when there’s no more free space to accommodate new components.
- 41. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 40 - Figure 31. Expand Property Style
- 42. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 41 - TCATEGORYBUTTONS This component allows you to create buttons and group them into categories, similar to what's seen in an Outlook bar. It helps you refine the design of your applications. Figure 32. TCategoryButtons TDRAWGRID, TSTRINGGRID, TDBGRID Themed and gradient styles have been added to the grid components. TTRAYICON Think of those icons you see beside the taskbar clock, in the Windows tray. What if you could place your application right there too? It’s now more than simple to do so. All you have to do is place a TTrayIcon component (Win32 tab) in the main form. Set just a few properties and you’re done: • Icon: Stores the icon that is displayed in the tray. You can use your application’s icon or an icon that describes a status or situation. This icon can be changed at anytime. • Icons: references a TImageList containing a bunch of bitmaps or icons which will be used in the animation. • Animate: When True, keeps swapping the icons in the Icons list. The index of the icon that is being currently displayed can be either retrieved or changed using the IconIndex property. • AnimateInterval: millisecond interval of the icon swapping process. The OnAnimate event is generated after each iteration, allowing you to define an action to be taken. • BalloonTitle and BalloonHint: Title and text for the balloon, displayed by the ShowBalloonHint method. The balloon can be closed by a simple click (either on it or over the dialog’s X). However, it goes away automatically after the interval predefined in the BalloonTimeout property (milliseconds).
- 43. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 42 - • PopupMenu: it’s common to associate a popup menu to the application’s icon; enabling users to quickly access the most commonly used commands. All it takes for you to do so is reference the menu in this property. To access it, left-click the icon. You can hide the main form (using methods Hide or Visible := False) without halting the application. In this case it’s essential to provide the tray icon with a menu or event (OnMouseClick, for instance) to ensure the control is passed back to you right after. Figure 33. Tray Icon VCL – MARGINS AND PADDING Three seems to be a magic number these days… Besides three new visual components, the VCL has also been improved with three additional classes: • TMargins • TPadding • TCustomTransparentControl The TControl class now has an additional property (Margins, of TMargins class). TMargins is used in the Margins property of TControl and its descendants. TMargins helps define the relative position between components on a form, and between the edges of the form and the component. For example, when you set the left margin for a component to 10 pixels, the component will not come closer than 10 pixels to the edge of the container or to another component on the left edge. The number of pixels by which two components are separated is the sum of the pixels of both components. The TWinControl class adds an extra property – Padding, of TPadding class: a TMargins descendent. a Padding adds space along the edge the control. Child controls that are aligned to the parent are positioned inside the control according to this spacing. Padding does not affect
- 44. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 43 - child controls which are not aligned to the parent control, nor does it affect the size of the ClientArea. Padding is the opposite of Margins. Margins affects the positioning of the control itself inside the parent control, but Padding affects how all aligned child controls are positioned with respect to the parent control. TRANSPARENT CONTROLS The new TCustomTransparentControl class can be used for components that need to be there while pretending they’re not. Uh oh. Well... think of it as the glass of a window or door. You know it’s there, although you’re unable to visually perceive it. To see the difference, you can do this test: create a new VCL application (File | New | VCL Forms Application – Delphi for Win32). Place two TButtons and two TLabels in it, see Error! Reference source not found. Figure 34. Transparent Controls Set both buttons' Top property to 40; Button 1 and 2’s Left properties to 30 and 210, respectively. When you’re done, type the code as below. Note that the form implements the events OnCreate, OnDestroy and OnClick, with both buttons sharing the same OnClick event. I’ve created a TCustomTransparentControl descendent – TTransparentControl – and a TCustomControl descendent - TOpaqueControl. They are dynamically created by the form’s OnCreate event, being positioned right above the other existing controls. I’ve also added an OnClick event to our customized controls for you to observe their behavior. The result can be seen in Figure 35.
- 45. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 44 - Figure 35. Transparent Control Example
- 46. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 45 - type TTransparentControl = class(TCustomTransparentControl) protected procedure Paint; override; end; TOpaqueControl = class(TCustomControl) protected procedure Paint; override; end; TfCustomTransparentControl = class(TForm) Button1: TButton; Button2: TButton; Label1: TLabel; Label2: TLabel; procedure Button1Click(Sender: TObject); procedure FormClick(Sender: TObject); procedure FormCreate(Sender: TObject); private InvCon : TTransparentControl; VisCon : TOpaqueControl; procedure ControlClick(Sender: TObject); end; var fCustomTransparentControl: TfCustomTransparentControl; implementation {$R *.dfm} { TTransparentControl } procedure TTransparentControl.Paint; const txt = 'Transparent'; begin Canvas.Ellipse(0,0,Width,Height); Canvas.TextOut((Width - Canvas.TextWidth(txt)) div 2, Height div 2, txt); end; { TOpaqueControl } procedure TOpaqueControl.Paint; const txt = 'Opaque'; begin Canvas.Ellipse(0,0,Width,Height); Canvas.TextOut((Width - Canvas.TextWidth(txt)) div 2, Height div 2, txt); end; { Form } procedure TfCustomTransparentControl.FormCreate(Sender: TObject); begin InvCon := TTransparentControl.Create(Self);
- 47. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 46 - InvCon.Parent := Self; InvCon.SetBounds(10,10,100,100); InvCon.OnClick := ControlClick; VisCon := TOpaqueControl.Create(Self); VisCon.Parent := Self; VisCon.SetBounds(200,10,100,100); VisCon.OnClick := ControlClick; end; procedure TfCustomTransparentControl.FormDestroy(Sender: TObject); begin InvCon.Free; VisCon.Free; end; procedure TfCustomTransparentControl.Button1Click(Sender: TObject); begin ShowMessage('You have clicked on ' + (Sender as TButton).Caption); end; procedure TfCustomTransparentControl.ControlClick(Sender: TObject); begin ShowMessage('You have clicked on control ' + (Sender as TControl).ClassName); end; procedure TfCustomTransparentControl.FormClick(Sender: TObject); begin ShowMessage('Form clicked!'); end; The custom message CM_INPUTLANGCHANGE was added to the VCL components for notification when the operating system language has changed, so you can reflect changes in language in its application without restarting the system. Icons can now be associated with bitmaps using TIcon.AssignTo, moreover the TImage component supports TIFF. New Month Calendar drop down box to define dates of properties in the Object Inspector define as Date data type, in addition to the new Property Editor added to the Object Inspector, which allows users to use checkbox for Boolean properties. Other new features was implemented in Delphi adding the capability to rename TCategoryButtons components, method CheckAll (cbUnchecked, True, True) for TCheckListBox, function PtInCircle added to unit "Types" (similar to "PtInRect"), ActiveLineNo property which returns the correct position of the cursor TRichEdit component and the new unit IOUtils.pas which implement 3 new statics classes,
- 48. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 47 - TDirectory, and TPath TFile, these classes expose many statics methods useful for interacting with I/O. Although there are dozens of improvements in VCL not here mentioned, but you can get a complete list of these improvements through help system. To conclude this topic, several VCL methods have become inline methods, and hence the performance of these methods when used improved, as result the VCL gain in speed. INTELLIMOUSE SUPPORT IntelliMouse is how we refer to support for mouse-wheel scrolling in your application. Support for this technology was first introduced to VCL in Delphi 2006. In order to use it, simply declare the IMOUSE unit in your application. TOBJECT The father of all components in Delphi has also been enhanced: • New methods o class function UnitName : string o function Equals(Obj : TObject) : Boolean;virtual o function GetHashcode : Integer; virtual o function ToString ; String;virtual • A few additional Overloads for the following methods: o MethodAddress o FieldAddress • The type of return of the functions below has changed from ShortString to String in order to support Unicode o ClassName o MethodName Other components - TPanel, TProgressBar, TTrayIcon, TScreen, and TRadioGroup – also provide a lot of improvements. NEW MEMORY MANAGER AND NEW RTL FUNCTIONS Many RTL functions have been updated to improve the application performance. FASTMM is the most relevant of such improvements. A new memory manager aimed at Win32 applications, FASTMM enables applications to have better performance by performing the compilation in Delphi 2006, and identifies memory leaks just declaring ReportMemoryLikeonShutdown := True in any part of your program, in general I recommend to add at the initialization section.
- 49. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 48 - It can’t be overemphasized that simply by compiling your applications in Delphi 2006 or later, you experience performance gains, while also being able to detect memory leakages. SOAP 1.2 CLIENT SUPPORT Delphi 2010 introduced the SOAP 1.2 client support through the THTTPRIO component. In Delphi XE THTTPRIO exposes new properties to allow the developer to select a Client Certificate at design-time. REGULAR EXPRESSION Delphi XE introduces RTL support for regular expressions (unit RegularExpressions). Regular expressions provide a concise and flexible means for matching strings of text, such as particular characters, words, or patterns of characters. The following example shows how to use regular expression to validate IP address. program RegExpIP; {$APPTYPE CONSOLE} uses SysUtils, RegularExpressions; var ipRegExp : String; begin try ipRegExp := 'b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).’ + ‘(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).(25’ + ‘[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).(25[0-5]’ + ‘|2[0-4][0-9]|[01]?[0-9][0-9]?)b'; if TRegEx.IsMatch(paramstr(1), ipRegExp) then Writeln('Text DOES match the regular expression') else Writeln('Text DOES NOT match the regular expression'); except on E: Exception do Writeln(E.ClassName, ': ', E.Message); end; end. Passing the parameter 200.100.2.21 (valid IP) the result will be: Text DOES match the regular expression
- 50. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 49 - Passing the parameter 200.100.2.263 (invalid IP) the result will be: Text DOES NOT match the regular expression OBJECT-ORIENTED FILE AND DIRECTORY I/O CLASSES Delphi 2010 brings a new unit IOUtils contains three static classes: TDirectory, TPath and TFile. These classes expose a number of static methods useful for I/O tasks. Most methods are functionally and signature compatible with .NET classes System.IO.Directory, System.IO.Path and System.IO.File. The follow code shows how to read all files from specific folder. procedure TForm2.Button2Click(Sender: TObject); var Path : string; begin if not TDirectory.Exists(edtPath.Text) then Caption := 'Invalid Path' else Caption := edtPath.Text; ListBox1.Clear; for Path in TDirectory.GetFiles(edtPath.Text, ‘*.*’) do Listbox1.Items.Add(Format('Name = %s', [Path])); end; 100% UNICODE One of the greatest challenges faced by our R&D team was incorporating Unicode support throughout the Delphi language, VCL, RTL, and the IDE and the Delphi ecosystem of tool and component partners.. As part of the Unicode development process we had meetings with customers, authors, consultants and technology partners Working directly with our tool and component partners proved essential in allowing third-party components to be available to support the latest version of Delphi, as well as in keeping developers updated about how to work with Unicode. Unicode is a standard that allows computers to consistently represent and handle text from any existing system of writing. - The Unicode Standard: Version 5.0. 5. ed. Addison-Wesley Professional, 2006. 1472 p Many character sets – like Chinese, Japanese, and Russian, along with others of Asian background – are represented by means of Unicode. The most commonly used encodings
- 51. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 50 - are UTF (Unicode Transform Format) and UCS (Universal Character Set). To learn more about Unicode, visit: http://en.wikipedia.org/wiki/Unicode. The result of all this is a Delphi that is 100% Unicode. You’re now probably wondering if the migration is that easy. Definitely yes, the VCL and the compiler handle many things. In case you want more detailed information about Unicode techniques I recommend that you to read the white paper, “Delphi Unicode Migration for Mere Mortals”, available at http://edn.embarcadero.com/article/40307. One of the most relevant changes in this version is that String types are now based on UNICODE. Previously based on the ANSI standard, the AnsiString and WideString types still work the same way, except regarding their data size in bytes. Unicode changes, in short: • String maps UnicodeString, no longer AnsiString • Char now maps WideChar (2 bytes, not 1 byte) being a UTF-16 character • PChar maps PWideChar • AnsiString maps the old String type No changes were applied to: • AnsiString • WideString • AnsiChar, PAnsiChar • Short String contains AnsiChar elements • Implicit conversions still work. The user's active code page controls the mode (ANSI vs. Unicode), so that ANSI strings are still supported. Operations that do not depend on character size: • String concatenation • Standard String functions. E.g., Length, Copy, Pos, and so on. • Operators. E.g., <string> < comparison> <string>, CompareStr(), CompareText(), etc. • FillChar ( <struct or memory> ) • Windows API Operations involving the character size (measured in bytes) may require a few changes. Nothing too complicated, but here’s a tip: pay special attention to code in which you: 1. Assume Sizeof (Char) is 1. 2. Assume the size of a string equals the number of bytes in the string. 3. Handle String or PChars directly. 4. Saves or reads a string from/to a file.
- 52. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 51 - Items 1 and 2 do not apply to Unicode, because in Unicode the Sizeof (Char) is 2 bytes and the size of a string is twice as big as the number of bytes. Besides, the code that reads and saves files must understand the right number of bytes to perform those operations, for a character is no longer represented as 1 byte. As you can see, migrating is very easy. The benefit of having Unicode support is that of allowing Delphi developers to distribute their applications worldwide. Brazil is currently one of the most relevant software developers in the global market. Many Brazilian companies distribute their applications and/or interchange information with China, Japan, Russia and other countries where Unicode is crucial. In 2007, the Russian government acquired 1 million Delphi licenses to be used in teaching primary and high school students to develop software with Delphi. Therefore, Unicode support is vital for that country.
- 53. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 52 - NEW LANGUAGE FEATURES AND COMPILER RESOURCES ENHANCED RTTI The RTTI is largely responsible for providing us with information about our objects, thereby allowing the application and interaction of objects. One great example of the use of RTTI is the Delphi IDE itself, where we use the Object Inspector, code editor, modeling and other resources. The evolution and development in other languages have changed the way we do programming. Java and. NET applications are good examples in this direction, where the language is now offering a high level of dynamic interaction. With the enhanced RTTI support added in Delphi 2010, Delphi for Win32 now has the same power of reflection that. NET and Java have. The new RTTI (RTTI.pas) is fully object oriented and allows the creation and interaction with the applications in a much more dynamic way. ATTRIBUTES How many times have you heard your fellow users of Java and. NET comment on attributes, I believe that many, actually attributes is a very interesting feature, often used in frameworks such as Hibernate, .NET and Java. Attributes let you define classes and features for their respective elements. There are several examples that show the usefulness of the attributes. The best example for attributes is to create framework object relational (O/R Mapping). Attributes are defined through mandatory classes, they inherit from TCustomAttribute. Example: TableAttribute – a class that will be used to map the application classes to the database, the TableName property defines the name of the table.
- 54. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 53 - Set the attribute mapping table, and use it in their classes. Example: A class is mapping TClient to the CUSTOMER (CLIENTE) table. In this example we use attributes to map only the class, but we can also map methods, variables, properties, method parameters, etc. Attributes added in Delphi 2010 takes the language to another level and undoubtedly enables us to provide great improvement in the future, as well as allow you to implement several new features in your applications TODAY. EXIT FUNCTION The Exit function can take a parameter specifying a result. The parameter of the System.Exit function must be of the same type as the result. function doValidate( I : Integer) : boolean; begin if I = 0 then exit(False) else begin ….. // result something end; end;
- 55. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 54 - INLINE DIRECTIVE The Delphi compiler allows functions and procedures to be tagged with the inline directive to improve performance. If the function or procedure meets certain criteria, the compiler will insert code directly, rather than generating a call. Inlining is a performance optimization that can result in faster code, but at the expense of space. Inlining always causes the compiler to produce a larger binary file. The inline directive is used in function and procedure declarations and definitions, like other directives. program InlineDemo; {$APPTYPE CONSOLE} uses MMSystem; function Max(const X,Y,Z: Integer): Integer;inline begin if X > Y then if X > Z then Result := X else Result := Z else if Y > Z then Result := Y else Result := Z end; const Times = 10000000; // 10 million var A,B,C,D: Integer; Start: LongInt; i: Integer; begin Random; // 0 A := Random(4242); B := Random(4242); C := Random(4242); Start := TimeGetTime; for i:=1 to Times do D := Max(A,B,C); Start := TimeGetTime-Start; writeln(A,', ',B,', ',C,': ',D); writeln('Calling Max ',Times,' times took ',Start,' milliseconds.'); readln end. When the above code is executed, the Max method is called 10 million times. The numbers below vary depending on your machine. Using a Pentium M 1.8GHz with 2GB RAM we’ve obtained the following results:
- 56. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 55 - With inline Without inline 25 milliseconds 68 milliseconds The inline directive is a suggestion to the compiler. There is no guarantee the compiler will inline a particular routine, as there are a number of circumstances where inlining cannot be done. The following list shows the conditions under which inlining does or does not occur: • Inlining will not occur on any form of late-bound method. This includes virtual, dynamic, and message methods. • Routines containing assembly code will not be inlined. • Constructors and destructors will not be inlined. • The main program block, unit initialization, and unit finalization blocks cannot be inlined. • Routines that are not defined before use cannot be inlined. • Routines that take open array parameters cannot be inlined. • Code can be inlined within packages, however, inlining never occurs across package boundaries. • No inlining will be done between units that are circularly dependent. This included indirect circular dependencies, for example, unit A uses unit B, and unit B uses unit C which in turn uses unit A. In this example, when compiling unit A, no code from unit B or unit C will be inlined in unit A. • The compiler can inline code when a unit is in a circular dependency, as long as the code to be inlined comes from a unit outside the circular relationship. In the above example, if unit A also used unit D, code from unit D could be inlined in A, since it is not involved in the circular dependency. • If a routine is defined in the interface section and it accesses symbols defined in the implementation section, that routine cannot be inlined. • If a routine marked with inline uses external symbols from other units, all of those units must be listed in the uses statement, otherwise the routine cannot be inlined. • Procedures and functions used in conditional expressions in while-do and repeat-until statements cannot be expanded inline. • Within a unit, the body for an inline function should be defined before calls to the function are made. Otherwise, the body of the function, which is not known to the compiler when it reaches the call site, cannot be expanded inline. If you modify the implementation of an inlined routine, you will cause all units that use that function to be recompiled. This is different from traditional rebuild rules, where rebuilds were triggered only by changes in the interface section of a unit. OPERATOR OVERLOADING Delphi allows certain functions, or "operators" to be overloaded within record declarations. The name of the operator function maps to a symbolic representation in
- 57. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 56 - source code. For example, the Add operator maps to the + symbol. The compiler generates a call to the appropriate overload, matching the context (i.e. the return type, and type of parameters used in the call), to the signature of the operator function. The following table shows the Delphi operators that can be overloaded: Operator Category Declaration Signature Symbol Mapping Implicit Conversion Implicit(a : type) : resultType; implicit typecast Explicit Conversion Explicit(a: type) : resultType; explicit typecast Negative Unary Negative(a: type) : resultType; - Positive Unary Positive(a: type): resultType; + Inc Unary Inc(a: type) : resultType; Inc Dec Unary Dec(a: type): resultType Dec LogicalNot Unary LogicalNot(a: type): resultType; not Trunc Unary Trunc(a: type): resultType; Trunc Round Unary Round(a: type): resultType; Round In Set In(a: type; b: type) : Boolean; in Equal Comparison Equal(a: type; b: type) : Boolean; = NotEqual Comparison NotEqual(a: type; b: type): Boolean; <> GreaterThan Comparison GreaterThan(a: type; b: type) Boolean; > GreaterThanOrEqual Comparison GreaterThanOrEqual(a: type; b: type): Boolean; >= LessThan Comparison LessThan(a: type; b: type): Boolean; < LessThanOrEqual Comparison LessThanOrEqual(a: type; b: type): Boolean; <= Add Binary Add(a: type; b: type): resultType; + Subtract Binary Subtract(a: type; b: type) : resultType; - Multiply Binary Multiply(a: type; b: type) : resultType; * Divide Binary Divide(a: type; b: type) : resultType; / IntDivide Binary IntDivide(a: type; b: type): resultType; div Modulus Binary Modulus(a: type; b: type): resultType; mod LeftShift Binary LeftShift(a: type; b: type): resultType; shl RightShift Binary RightShift(a: type; b: type): resultType; shr LogicalAnd Binary LogicalAnd(a: type; b: type): resultType; and LogicalOr Binary LogicalOr(a: type; b: type): resultType; or LogicalXor Binary LogicalXor(a: type; b: type): resultType; xor BitwiseAnd Binary BitwiseAnd(a: type; b: type): resultType; and BitwiseOr Binary BitwiseOr(a: type; b: type): resultType; or BitwiseXor Binary BitwiseXor(a: type; b: type): resultType; xor Here is an example that implements addition, subtraction, implicit and explicit operators: TMyClass = record class operator Add(a, b: TMyClass): TMyClass; // Addition
- 58. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 57 - class operator Subtract(a, b: TMyClass): TMyClass; // Subtraction class operator Implicit(a: Integer): TMyClass; // integer to TMyClass class operator Implicit(a: TMyClass): Integer; // TMyClass to integer class operator Explicit(a: Double): TMyClass; // Double to TMyClass end; // Method implementation example. Add class operator TMyClass.Add(a, b: TMyClass): TMyClass; begin // ... end; var x, y: TMyClass; begin x := 12; // Implicit conversion of Integer, executes Implicit method y := x + x; // Executes TMyClass.Add(a, b: TMyClass): TMyClass b := b + 100; // Executes TMyClass.Add(b, TMyClass.Implicit(100)) end; No operators other than those listed in the table may be defined on record. Overloaded operator methods cannot be referred to by name in source code. To access a specific operator method of a specific class or record, you must use explicit typecasts on all of the operands. Operator identifiers are not included in the class or record's list of members. No assumptions are made regarding the distributive or commutative properties of the operation. For binary operators, the first parameter is always the left operand, and the second parameter is always the right operand. Association is assumed to be left-to-right in the absence of explicit parentheses. Resolution of operator methods is done over the union of accessible operators of the types used in the operation (note this includes inherited operators). For an operation involving two different types A and B, if type A has an implicit conversion to B, and B have an implicit conversion to A, an ambiguity will occur. Implicit conversions should be provided only where absolutely necessary, and reflexivity should be avoided. It is best to let type B implicitly convert itself to type A, and let type A have no knowledge of type B (or vice versa). As a general rule, operators should not modify their operands. Instead, return a new value, constructed by performing the operation on the parameters. Overloaded operators are used most often in records (i.e. value types). CLASS HELPERS A class helper is a type that - when associated with another class - introduces additional method names and properties which may be used in the context of the associated class (or its descendants). Class helpers are a way to extend a class without using inheritance. A class helper simply introduces a wider scope for the compiler to use when resolving identifiers. When you declare a class helper, you state the helper name, and the name of
- 59. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 58 - the class you are going to extend with the helper. You can use the class helper any place where you can legally use the extended class. The compiler's resolution scope then becomes the original class, plus the class helper. Class helpers provide a way to extend a class, but they should not be viewed as a design tool to be used when developing new code. They should be used solely for their intended purpose, which is language and platform RTL binding. You can see an example below. type TMyClass = class procedure MyProc; function MyFunc: Integer; end; ... procedure TMyClass.MyProc; var X: Integer; begin X := MyFunc; end; function TMyClass.MyFunc: Integer; begin ... end; type TMyClassHelper = class helper for TMyClass procedure HelloWorld; function MyFunc: Integer; end; procedure TMyClassHelper.HelloWorld; begin Writeln(Self.ClassName); // Self refers to TMyClass, not TMyClassHelper end; function TMyClassHelper.MyFunc: Integer; begin ... end; var X: TMyClass; begin X := TMyClass.Create; X.MyProc; // Executes TMyClass.MyProc X.HelloWorld; // Executes TMyClassHelper.HelloWorld X.MyFunc; // Executes TMyClassHelper.MyFunc end.
- 60. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 59 - Note that the reference is always pointed to TMyClass. The compiler recognizes when it’s appropriate to execute the call in TMyClassHelper. STRICT PRIVATE AND STRICT PROTECTED In Delphi, you have two options for determining the visibility of a class’ attributes: strict private and strict protected. • Strict private: class attributes are visible only within the class in which it is declared. Those attributes can’t be seen by methods declared in the same unit, or by those that are not part of the class. • Strict protected: determines that class attributes and their descendents are visible. RECORDS SUPPORT METHODS Record data types in Delphi represent a mixed set of elements. Each element is called a field and the declaration of a record type specifies a name and type for each field. Records as of Delphi 2006 are even more powerful, bringing features supported only in class. Here's a list of the new record features in Delphi 2006: • Constructors • Operator overload • Non-virtual methods declaration • Static methods and properties The following example is the implementation of a record with the new characteristics: type TMyRecord = Record type TColorType = Integer; var pRed : Integer; class var Blue : Integer; Procedure printRed(); Constructor Create(Val : Integer); Property Red : TColorType Read pRed Write pRed; Class Property pBlue : TColorType Read Blue Write Blue; End; Constructor TMyRecord.Create(Val: Integer); Begin Red := Val; End; Procedure TMyRecord.printRed; Begin
- 61. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 60 - WriteLn('Red: ', Red); End; Now the record can use many of the functionalities that were exclusive to classes. However, records are not classes, meaning they still have many differences: • Records do not support inheritance. • Records may have variable parts; classes may not. • Records are data types and, as so, can be copied. Classes cannot. • Records have no destructors. • Records do not support virtual methods. CLASS ABSTRACT, CLASS SEALED, CLASS CONST, CLASS TYPE, CLASS VAR, CLASS PROPERTY There are many ways for you to declare classes, types, variables and properties. • Class abstract defines an abstract class • Class sealed classes cannot be extended through inheritance - such a class cannot be used as a base class for some other (derived) class • Class const defines a class constant that can be accessed without having to instantiate the class • Class type defines a class type that can be accessed without having to instantiate the class • Class var defines a variable from the scope of the class which you can access without having to instantiate the class • Class property grants access to the property without requiring the class to be instantiated NESTED CLASSES Nested types are used throughout object-oriented programming in general. They allow you to keep conceptually related types together, and to avoid name collisions. The same syntax for declaring nested types may be used with the Delphi compiler. Class sample below: type TOuterClass = class strict private myField: Integer; public type TInnerClass = class public
- 62. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 61 - myInnerField: Integer; procedure innerProc; end; procedure outerProc; end; This is how the method is implemented: procedure TOuterClass.TInnerClass.innerProc; begin ... end; To access the method within the Nested class, see the next example: var x: TOuterClass; y: TOuterClass.TInnerClass; begin x := TOuterClass.Create; x.outerProc; ... y := TOuterClass.TInnerClass.Create; FINAL METHODS The Delphi compiler also supports the concept of a final virtual method. When the keyword final is applied to a virtual method, no descendent class can override that method. Use of the final keyword is an important design decision that can help document how the class is intended to be used. It can also give the compiler hints that allow it to optimize the code it produces. STATIC CLASS METHOD When these classes are declared as Static they do not need to be instantiated. FOR … IN Delphi 2007 brought support for element-in-collection (collections, arrays, string expressions and set-type expressions) style iteration over containers. Example: Iteration in an Array var IArray1: array[0..9] of Integer = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
- 63. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 62 - I: Integer; begin for I in IArray1 do begin // do something here... end; Example: Iteration in a String var C: Char; S1, S2: String; OS1, OS2: ShortString; AC: AnsiChar; begin S1 := ’New resources in Delphi 2009'; S2 := ''; for C in S1 do S2 := S2 + C; if S1 = S2 then WriteLn('SUCCESS #1'); else WriteLn('FAIL #1'); OS1 := 'Migrating from Delphi 7 to Delphi 2009...'; OS2 := ''; for AC in OS1 do OS2 := OS2 + AC; if OS1 = OS2 then WriteLn('SUCCESS #2'); else WriteLn('FAIL #2'); end. GENERICS Support for generics was introduced in Delphi 2009. What are generics? ‘Generics’ is the defining term for generic types. It is a language construct that allows you to predefine any type of data from arrays, collections and other sorts of lists. Using Generics allows you to write code in a generic way and have it work
- 64. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 63 - with a specific type of data - classes or class methods. It’s also possible to define types at runtime. While using Generics, you will often also work with Collections. The Delphi RTL provides several pre-defined Collections (defined in the “Generics.Collections” unit) see the of data or objects including • TList • TQueue • TStack • TDictionary • TObjectList • TObjectQueue • TObjectDictionary • TThreadedQueue Items added to these classes are of TObject type, meaning you can only add a single type to the list. Whenever you need to read the items you must perform the type cast for each of them, leaving all processing for the compiler. This is nothing but additional effort for your application, or something that can potentially impact its performance. A relevant portion of our code can be adapted to work with generics. Below you see a sample class whose Key property should be a String and whose Value property should be an Integer. In this case you do not use Generics. type TSIPair = class private FKey: String; FValue: Integer; public function GetKey: String; procedure SetKey(Key: String); function GetValue: Integer; procedure SetValue(Value: Integer); property Key: TKey read GetKey write SetKey; property Value: TValue read GetValue write SetValue; end; Using generics it’s possible to define the Key and Value properties as being of any type. This is how you do so: type TPair<TKey,TValue>= class // declares the TPair type with 2 parameters private FKey: TKey; FValue: TValue;
- 65. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 64 - public function GetKey: TKey; procedure SetKey(Key: TKey); function GetValue: TValue; procedure SetValue(Value: TValue); property Key: TKey read GetKey write SetKey; property Value: TValue read GetValue write SetValue; end; You can now use this class in many different ways: type TSIPair = TPair<String,Integer>; // declares it with types String and Integer TSSPair = TPair<String,String>; // declares it with other types TISPair = TPair<Integer,String>; TIIPair = TPair<Integer,Integer>; You’ll find many uses for generics. Examples are provided here as a simple, limited reference. ANONYMOUS METHODS As the name suggests, an anonymous method is a procedure or function that does not have a name associated with it. An anonymous method treats a block of code as an entity that can be assigned to a variable or used as a parameter to a method. In addition, an anonymous method can refer to variables and bind values to the variables in the context in which the method is defined. Anonymous methods can be defined and used with simple syntax. They are similar to the construct of closures defined in other languages. Example: function MakeAdder(y: Integer): TFuncOfInt; begin Result := { START anonymous method } function(x: Integer) begin Result := x + y; end; { END anonymous method } end; The MakeAdder function returns a nameless function; that is, an Anonymous Method. Note that MakeAdder returns a value of TFuncOfInt type. The type of the Anonymous Method is declared as a reference to the method. Example: Executing the MakeAdder function var adder: TFuncOfInt; begin
- 66. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 65 - adder := MakeAdder(20); Writeln(adder(22)); // prints 42 end. type TFuncOfInt = reference to function(x: Integer): Integer; The above statement indicates this Anonymous Method: • Is a function • Receives an Integer value • Returns an Integer value You can declare both procedures and functions as Anonymous Methods. type TSimpleProcedure = reference to procedure; TSimpleFunction = reference to function(x: string): Integer; Anonymous Methods offer much more than just a simple execution point in code: • Binding in variables • Ease to use and define methods • Ease to parameterize the code VIRTUAL METHOD INTERCEPTION Delphi XE has a new type in Rtti.pas called TVirtualMethodInterceptor. It creates a derived metaclass dynamically at runtime that overrides every virtual method in the ancestor, by creating a new virtual method table and populating it with stubs that intercepts calls and arguments. When the metaclass reference for any instance of the "ancestor" is replaced with this new metaclass, the user can then intercept virtual function calls, change arguments on the fly, change the return value, intercept and suppress exceptions or raise new exceptions, or entirely replace calling the underlying method. In concept, it's somewhat similar to dynamic proxies from .NET and Java. It's like being able to derive from a class at runtime, override methods (but not add new instance fields), and then change the runtime type of an instance to this new derived class. Why would you want to do this? Two obvious purposes spring to mind: testing and remoting. Mock objects have been in vogue in the testing space in other languages for some time. By intercepting method calls, one may more easily verify that a particular subsystem is calling all the right methods, with the correct arguments, in the expected order; similarly, the subsystem can proceed with the return values from these method calls, without necessarily having to hit the database, the network, etc. for what should be a unit test. Remoting on the basis of method calls is somewhat less useful, especially when an unreliable and latency-prone network gets into the stack, but that's not the only usage point. The virtual method interceptor logic was originally implemented to be used as part
- 67. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 66 - of DataSnap authentication, so that a call that comes in from the network can still be checked as its code flow spreads throughout the graph of objects. Anyhow, here's a simple example to get started: uses SysUtils, Rtti; {$apptype console} type TFoo = class // Frob doubles x and returns the new x + 10 function Frob(var x: Integer): Integer; virtual; end; function TFoo.Frob(var x: Integer): Integer; begin x := x * 2; Result := x + 10; end; procedure WorkWithFoo(Foo: TFoo); var a, b: Integer; begin a := 10; Writeln(' before: a = ', a); try b := Foo.Frob(a); Writeln(' Result = ', b); Writeln(' after: a = ', a); except on e: Exception do Writeln(' Exception: ', e.ClassName); end; end; procedure P; var foo: TFoo; vmi: TVirtualMethodInterceptor; begin vmi := nil; foo := TFoo.Create; try Writeln('Before hackery:'); WorkWithFoo(foo); vmi := TVirtualMethodInterceptor.Create(foo.ClassType); vmi.OnBefore := procedure(Instance: TObject; Method: TRttiMethod; const Args: TArray<TValue>; out DoInvoke: Boolean; out Result: TValue) var i: Integer; begin Write('[before] Calling ', Method.Name, ' with args: '); for i := 0 to Length(Args) - 1 do
- 68. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 67 - Write(Args[i].ToString, ' '); Writeln; end; // Change foo's metaclass pointer to our new dynamically derived // and intercepted descendant vmi.Proxify(foo); Writeln('After interception:'); WorkWithFoo(foo); finally foo.Free; vmi.Free; end; end; begin P; end.
- 69. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 68 - Here's what it outputs: Before hackery: before: a = 10 Result = 30 after: a = 20 After interception: before: a = 10 [before] Calling Frob with args: 10 Result = 30 after: a = 20 [before] Calling BeforeDestruction with args: [before] Calling FreeInstance with args: You'll notice that it intercepts all the virtual methods, including those called during destruction, not just the one I declared. (The destructor itself is not included.) NEW $POINTERMATH {ON – OFF } DIRECTIVE The $POINTERMATH directive enables mathematic operations with pointers. NEW WARNINGS When you compile your application with Delphi XE, four new warnings might appear in your IDE’s message window. These messages regard the use of the new UnicodeString type. These new warnings include: • 1057 Implicit string cast from '%s' to '%s' • 1058 Implicit string cast with potential data loss from '%s' to '%s' • 1059: Explicit string cast from '%s' to '%s' • 1060 Explicit string cast with potential data loss from '%s' to '%s'
- 70. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 69 - DBEXPRESS FRAMEWORK One of the most significant changes in Delphi 2007, dbExpress architecture has been restructured, and you can now count on a framework that is totally written in Delphi. We have performed lab tests to simulate the most diverse situations with varied databases; in some of those tests the performance was improved by 100%. DbExpress 4 is also a milestone for applications developed in Delphi that require database connectivity. The new architecture was designed to support Win32 and .NET, enabling the same drivers to be used in both platforms, for example the dbExpress DataSnap driver can be used for Win32 and .NET, it allows developers to create DataSnap client applications in Delphi Win32 and Delphi Prism (.NET) Figure 36 dbExpress 4 Architecture Remember that applications developed in prior versions are 100% compatible with Delphi XE.
- 71. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 70 - The dbExpress Framework comes with a new group of classes that facilitate the task of accessing and otherwise handling databases. Now you can find all the information regarding the database within the framework. Previously you’d have to use components SQLConnection, SQLDataSet, SQLQuery, and others instead. The following example represents a console application that uses database connection resources, reads connections parameters, sends a query and displays its result – all in a single transaction. program DBX4Example; {$APPTYPE CONSOLE} uses SysUtils, DBXDynalink, Dialogs, DBXCommon; var aConnName: string; aDBXConn: TDBXConnection; aDBXTrans : TDBXTransaction; aCmnd: TDBXCommand; aReader: TDBXReader; i, aColCount: integer; begin aDBXConn := TDBXConnectionFactory.GetConnectionFactory.GetConnection( 'EMPLOYEE', 'sysdba','masterkey'); // Write the all connection parameters Writeln( '================= Connection Properties ============' ); WriteLn( aDBXConn.ConnectionProperties.Properties.Text); Writeln( '====================================================' ); Writeln( '' ); if aDBXConn <> nil then begin aCmnd := aDBXConn.CreateCommand; // Start transaction aDBXTrans:= aDBXConn.BeginTransaction(TDBXIsolations.ReadCommitted); // Prepare and execute the SQL Statement aCmnd.Text := 'SELECT * FROM Country'; aCmnd.Prepare; aReader := aCmnd.ExecuteQuery; aColCount := aReader.ColumnCount; Writeln( 'Results from Query: ' + aCmnd.Text );
- 72. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 71 - Writeln( 'Number of Columns: ' + IntToStr(aColCount) ); while aReader.Next do begin Writeln( aReader.Value['Country'].GetAnsiString ); end; Writeln( '====================================================' ); Writeln( '' ); end; // Commit transaction aDBXConn.CommitFreeAndNil(aDBXTrans); Readln; aReader.Free; aCmnd.Free; aDbxConn.Free; end; end. DBEXPRESS METADATA The new metadata support is used extensively by the Data Explorer pane of the Delphi IDE, but can also be used by any application. In short, you'll not only be able to browse the database structure, but also be able to use classes and objects to modify it, rather than relying directly on the native database SQL commands for creating and modifying data structures. Not only will the code look more object-oriented, but it will be also easier to target different database servers with the same code, as dbExpress abstracts the metadata capabilities of each server. The unit DBXMetaDataNames has been provided to read metadata. The dbExpress class TDBXMetaDataCommands provides a set of constants to read various types of metadata. Set the TDBXCommand.CommandType property to DBXCommandTypes.DBXMetadata and set TDBXCommand.Text to one of the constants in TDBXMetaDataCommands to acquire the designated metadata TDBXCommand.ExecuteQuery returns a TDBXReader to access the metadata. The new classes in DBXMetaDataNames describe and provide access to this metadata's columns. Below a list of metadata you can read using dbExpress: • Data types • Tables • Columns (from tables, views, etc.) • Indexes • Fields from those indexes • Foreign key
- 73. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 72 - • Fields from Foreign keys • Stored Procedures • Stored Procedures’ parameters • User list • Catalogs • Schemas • Views • Synonyms • Stored Procedures’ source code • Packaged Stored Procedures • Packaged Stored Procedures’ source code • Packaged Stored Procedures’ parameters • Roles • Reserved words Data Explorer includes support for creating SQL dialect sensitive CREATE, ALTER, and DROP statements. dbExpress also exposes a DbxMetaDataProvider class that surfaces this capability for applications. This slightly increases the size of application, since the metadata writers must be included. The ability to generically create tables is useful for many applications. The interface allows you to describe what a table and its columns look like and pass this description to the TdbxMetaDataProvider.CreateTable method. The following example on how to create tables, primary keys, foreign keys, and indexes using dbExpress Framework’s classes. var Provider: TDBXDataExpressMetaDataProvider; Country, State: TDBXMetaDataTable; IdCountryField, IdField: TDBXInt32Column; StrField : TDBXUnicodeVarCharColumn; begin Provider := DBXGetMetaProvider(conn.DBXConnection); // Country Writeln('Creating Table - Country ....................'); Country := TDBXMetaDataTable.Create; Country.TableName := 'COUNTRY'; IdCountryField := TDBXInt32Column.Create('COUNTRYID'); IdCountryField.Nullable := false; IdCountryField.AutoIncrement := true; Country.AddColumn(IdCountryField); StrField := TDBXUnicodeVarCharColumn.Create('COUNTRYNAME', 50); StrField.Nullable := False;
- 74. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 73 - Country.AddColumn(StrField); Provider.CreateTable(Country); end; // Defines COUNTRYID as Primary Key AddPrimaryKey(Provider, Country.TableName, IdCountryField.ColumnName); // Defines Unique Index as COUNTRYNAME AddUniqueIndex(Provider, Country.TableName, StrField.ColumnName); // State Writeln('Creating Table - State ....................'); State := TDBXMetaDataTable.Create; State.TableName := 'STATE'; IdField := TDBXInt32Column.Create('STATEID'); IdField.Nullable := false; IdField.AutoIncrement := true; State.AddColumn(IdField); StrField := TDBXUnicodeVarCharColumn.Create('SHORTNAME', 2); StrField.Nullable := False; State.AddColumn(StrField); StrField := TDBXUnicodeVarCharColumn.Create('STATENAME', 50); StrField.Nullable := False; State.AddColumn(StrField); State.AddColumn(IdCountryField); Provider.CreateTable(State); // Defines STATEID as Primary Key AddPrimaryKey(Provider, State.TableName, idField.ColumnName); // Defines Unique Index as STATENAME AddUniqueIndex(Provider, State.TableName, StrField.ColumnName); AddForeignKey(Provider, State.TableName, IdCountryField.ColumnName, Country.TableName, IdCountryField.ColumnName); FreeAndNil(Provider); FreeAndNil(Country); The source code for this example is available at http://cc.embarcadero.com/Item/26210. DBEXPRESS DRIVERS Support for the latest versions of databases: InterBase 2009, MySQL 5.1, Oracle 10g/11g, the new dbExpress SQL Server 2008 driver includes support the new data type datetime offset. Drivers for Oracle, InterBase and MySQL now come with Unicode support.
- 75. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 74 - Delphi 2010 brought a dbExpress driver for Firebird, which was the number one request at that time. The dbExpress driver for Firebird supports Firebird version 1.5 and 2.x, and not only that, the DBX Framework is fully compatible with Firebird so you can create tables, primary keys, foreign keys, indexes and more through the framework. Data Explorer fully supports Firebird as well. BIGINT fields are 100% supported and are mapped as TLargeIntField in the VCL, and the BLOB type is mapped as TBlobField. Certainly the question arises, support for the blob and bigint as it gets. BIGINT fields are 100% supported and are mapped as TLargintField the VCL, the BLOB works perfectly and are mapped as TBlogField. New concepts, called “Delegate Driver” and “Pools Connections”, are available in dbExpress and require simple parameter configuration. You can also extend the dbExpress framework to write delegation drivers, which provide an extra layer between the application and the actual driver. Delegate drivers are useful for connection pooling, driver profiling, tracing, and auditing DBXTrace is a delegate driver used for tracing. Below you see the log result generated by the Delegate in Delphi language. It’s easy to read, understand, and even execute operations once again. Trace configuration. The following example captures events according to the TraceFlags parameter, saving the log file at c:dbxtrace.txt. The dbExpress connection has a parameter to indicate the trace configuration; for instance: DelegateConnection= DBXTraceConnection [DBXTraceConnection] DriverName=DBXTrace TraceFlags=EXECUTE;COMMAND;CONNECT TraceDriver=true TraceFile=c:dbxtrace.txt Generated log result: Log Opened ========================================== {CONNECT } ConnectionC1.Open; {COMMAND } CommandC1_1 := ConnectionC1.CreateCommand; {COMMAND } CommandC1_1.CommandType := 'Dbx.SQL'; {COMMAND } CommandC1_1.CommandType := 'Dbx.SQL'; {COMMAND } CommandC1_1.Text := 'select * from employee'; {PREPARE } CommandC1_1.Prepare; {COMMAND } ReaderC1_1_1 := CommandC1_1.ExecuteQuery; {COMMAND } CommandC1_2 := ConnectionC1.CreateCommand; {COMMAND } CommandC1_2.CommandType := 'Dbx.MetaData';
- 76. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 75 - {COMMAND } CommandC1_2.Text := 'GetIndexes "localhost:C: databaseemployee.ib"."sysdba"."employee" '; {COMMAND } ReaderC1_2_1 := CommandC1_2.ExecuteQuery; {READER } { ReaderC1_2_1 closed. 6 row(s) read } {READER } FreeAndNil(ReaderC1_2_1); {COMMAND } FreeAndNil(CommandC1_2); You can also use connection pools with dbExpress natively. Below you see an alias (Pool_DelegateDemo) passing to DBXPoolConnection the control over the connection pool (where the maximum number of connections is set). [DBXPoolConnection] DriverName=DBXPool MaxConnections=16 MinConnections=0 ConnectTimeout=0 [Pool_DelegateDemo] DelegateConnection=DBXPoolConnection DriverName=Interbase DriverUnit=DBXDynalink DriverPackageLoader=TDBXDynalinkDriverLoader DriverPackage=DBXCommonDriver110.bpl DriverAssemblyLoader=Borland.Data.TDBXDynalinkDriverLoader DriverAssembly=Borland.Data.DbxCommonDriver,Version=11.0.5000.0,Culture=neutra l,PublicKeyToken=a91a7c5705831a4f Database=localhost:C:databaseemployee.ib RoleName=RoleName User_Name=sysdba Password=masterkey ServerCharSet= SQLDialect=3 BlobSize=-1 CommitRetain=False WaitOnLocks=True ErrorResourceFile= Interbase TransIsolation=ReadCommited Trim Char=False
- 77. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 76 - CLOUD COMPUTING MICROSOFT WINDOWS AZURE Components for working with Windows Azure accounts are shipped with Delphi XE. Windows Azure (not to be confused with SQL Azure) allows you to store and manage Blobs, Queues of messages, and Tables of data on the Azure cloud. Once you have created an account, you can use the corresponding components found under the Microsoft Azure section of the Tool Palette. The available Azure components are: • TAzureTableManagement Window Azure Tables; these provide scalable structured storage. Think NOSQL type tables where each entry stored in a table can have a different set of properties made up of different types, such as string or int. • TAzureQueueManagement unlike blobs and tables, which are used to store data, queues serve another purpose, a persistent asynchronous messaging, where each message is up to 8kb long • TAzureBlobManagement Windows Azure Blob Storage; Blob storage is unstructured storage as it is used for storing large pieces of data such as images, video, documents, etc inside a defined container. There is also a component called TAzureConnectionString, which takes into consideration information for connecting to your Windows Azure account. All these components use the Windows Azure REST API to manage the features that come with each of these services. Azure components are useful for any developer who wants to make an application that manages a Windows Azure account. If used programmatically, the application itself could use information from the end-user's Azure account. AMAZON EC2 Delphi XE introduces a wizard that is able to deploy files to a remote machine. The remote machine in this instance would be the Amazon EC2 infrastructure. Note that only EC2- and Windows-based instances are supported. In this way, Delphi XE provides a simple three- step process to allow a developer to deploy to a cloud infrastructure.
- 78. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 77 - DATASNAP Integration between DataSnap and dbExpress is among the most significant new features in Delphi 2009. Later releases added even more features. Based on feedback received from our customers and user groups, we created the new DataSnap. As usual, creating a multilayer application seemed easy. However, considering its continued use and the impressive number of DataSnap applications available, many opportunities for improvement have been identified. In this section, we explore the concepts surrounding the creation of multilayer applications with the new DataSnap. The DataSnap today is the core technology in Delphi for multi-tier development, in XE release DataSnap provide a open architecture for other technologies to execute the Server Methods (business roles implemented on the server side), languages like: C++Builder, .NET (Delphi, C#, VB.NET, etc.), PHP and JavaScript. Figure 37. DataSnap core technology in Delphi for multitier development CONCEPTS The new integration between DataSnap and dbExpress – which many are calling dbExpress remoting – brought great flexibility into the world of multi-layer application development. Before that, sending and receiving data by means of ClientDataSet was the practice. Working with remote functions was something that required the use of a Type Library, consequently making you dependent on COM (present in Remote Data Module). Developers requested that we remove the COM dependency. This is a main attribute of the new DataSnap: it does not depend on any COM technology. However, this technology
- 79. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 78 - was not disregarded and compatibility is maintained, allowing you to use it whenever you find appropriate. DataSnap integration with dbExpress allows dynamic execution of server methods using, for example, SQLDataSet or the new SqlServerMethod component. The parameter and the result of the method are defined using the Param properties. One way to execute the methods on the server is to use the new SqlServerMethod component. this component inherits from CustomSQLDataSet, which means you can execute server side methods using a DataSet, input/output parameters will be represented by Params property. DATASNAP SERVER – SERVER CONTAINER DataSnap servers are defined by two components: DSServer and DSTCPTransport or DSHTTPTransport. Add these two components to your application and you have a DataSnap server. The form/datamodule that hosts these components can be called Server Container. From now on we will start using a new naming convention. DSServer is your DataSnap server. When connected to DSTCPTransport – which is where you define the connection port, the maximum number of threads, etc. – it exposes your application as a server. DSTCPTransport transports information by means of TCP, thus enabling you to extend and create new transport methods (e.g., HTTPS, SSL, to name a few). DSTCPTransport currently uses Indy’s infrastructure for TCP connections. If you use BSS, your application will still work in Delphi XE. However, it’s recommended that you migrate to the new DataSnap.
- 80. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 79 - Figure 38. Server Container based on DataModule DATASNAP SERVER – SERVER MODULE You most probably have many classes that hold business rules which would otherwise be of better use in a multi-layer application. Using Server Methods you can easily expose all public methods to the client side. In order for a class to be made available as a Server Method, it must: • Descend from TPersistent • Have the {$MethodInfo ON} directive. This directive allows dbExpress to obtain information about the class from RTTI. • Be registered by means of the DSServerClass component. Finally, we use the term Server Module to define the location of the providers, Server Methods, etc. You can create a Server Module selecting File | New | Other | Delphi Files | Server Module. The Server Module is a DataModule that comes with the directive $MethodInfo ON by default. Each class you make available has an associated DSServerClass component. This component is responsible for registering the class and making it available to client applications. It’s recommended that you keep your DSServerClass components in the Server Module. You can have as many Server Modules as you wish, which helps you to have a better organized application.
- 81. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 80 - The various DSServerClass define the application lifetime, or the LifeCycle property: • Server One component instance is used per server (Singleton) • Session One component instance is used per DataSnapSession: (Statefull). • Invocation One component instance is used per invocation of a method (Stateless). Additionally, DSServerClass comes with a few events that require you to use the OnGetClass event to get the class registered. Below you see an example of it, with TServerMethods working as a datamodule that holds many methods: procedure TDMServerContainer.DSServerMethodsGetClass (DSServerClass : TDSServerClass; var PersistentClass : TPersistentClass); begin PersistenClass := TServerMethods end; Proceed the same way in case you have a Remote Data Module in your application. DATASNAP SERVER – FILTERS A suite of filters can intercept the communication between a DataSnap client and a DataSnap server. Each filter can perform transformations over the byte stream such as encryption and/or compression; the byte stream can be intercepted by more than one filter and such the output of one becomes the input of the next filter. The filters are attached to the byte stream at design time (or coded), by setting the Filters property of the DataSnap server transport components such as DSTCPServerTransport.TDSTCPServerTransport or DSService.TDSHTTPService. The filters are available at design time if they are present in a package registered with RAD Studio. The filter needs to be built into a package and the package needs to be installed into Delphi. Server-side design time support enables the filter to show up in the filter list editor. Client-side design time support enables design time connection using TSQLConnection. There is no need to associate filters at the client side, as they are automatically instantiated based on a handshake protocol between client and server. Hence it is important that the client code registers the filters before connecting to a filtered server either by adding the unit name to the uses clause or in an early stage, such as initialization time. Delphi XE has a filter based on zlib compression, where the data is compressed automatically. You can also define an encryption filter. You can find some samples of filters at Code Central http://cc.embarcadero.com/Author/38483.
- 82. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 81 - DATASNAP SERVER – HTTP TUNNELING DataSnap 2010 implemented a new feature, which allows developers to implement redundant solutions like Failover and Load Balancing in DataSnap applications. Questions about this subject are very frequent and this topic will give you an overview how to implement Failover. After reading this topic you will be able to understand how you can implement Failover in your DataSnap applications and then use that to implement other redundant solution, like Load Balancing. When we started to think about application servers as part of our N-tier development we had many goals like centralized processes, business rules, hardware investments, updates, etc. When we think about a centralized process, we also need to think about redundancy, which is the duplication of critical components of a system with the intention of increasing reliability , usually via a backup or fail-safe. Before Delphi 2010, failover or load balance was not easy to implement, but now it is another story. DataSnap 2010 brings a feature named HTTP Tunneling which allow you to have control of the data sent and received between the client and the server. HTTP Tunneling communicates through the HTTP protocol. Thus, you have to use that for the communication between client and server, which is not a problem. When you implement Load Balancing or Failover, you will need a middleware application to control things. This application will be responsible for receiving the data from the client application, analyzing it, and forwarding it to the appropriate Server. Translating that to the DataSnap world, the client application connects to the Failover Server that is our proxy and it will forward the connection to the appropriate DataSnap Server in case the primary connection fails. The below example will simulate a client application sending/receiving data, while at some point the main DataSnap Server will crash, and you will see the Failover Server redirecting the connection to a secondary DataSnap Server. You will only need to make two changes on the client application: • Define HTTP as connection protocol in your SQL Connection • Connect to the Failover Server and not directly to your DataSnap Server Besides this you need to create your Failover Server, and you can use this example code as a start. The Failover Server needs two components, the DSHTTPService which represent your server and is connected to the DSHTTPServiceAuthenticationManager for the authentication process, so that only authorized users can connect to the server.
- 83. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 82 - To enable the HTTP Tunneling feature you will need to implement the following events on the HTTP Service Tunnel Service: • DSHTTPService1.HttpServer.TunnelService.OnErrorOpenSession • DSHTTPService1.HttpServer.TunnelService.OnErrorWriteSession • DSHTTPService1.HttpServer.TunnelService.OnErrorReadSession • DSHTTPService1.HttpServer.TunnelService.OnOpenSession • DSHTTPService1.HttpServer.TunnelService.OnWriteSession • DSHTTPService1.HttpServer.TunnelService.OnReadSession • DSHTTPService1.HttpServer.TunnelService.OnCloseSession These events are executed during the communication process. The event names explain what they do, and this example implements all of them. The example has a log which will help you to see what is happening during the communication. In the case of the Failover solution, all the events need to be implemented. The events OnErrorXXX will be executed when something goes wrong. These events will allow you identify and decide what to do with the bytes transferred. I will focus on the event OnErrorOpenSession that will redirect the connection in case of error during the opening session. The follow code implements a method named Redirect which is associated with the event OnErrorOpenSession. You can see how the session data is represented by parameters on this method, and how it includes everything you need to redirect the data. In this sample we use the Session.UserFlag to control if the connection was already redirected.We are only allowing one redirection, and in case that the Sender parameter becomes anException, we will save the error message in our log. After that we created an instance of DBXProperties, which has the new redirection server information. I’m using the same HostName and changed the port to 213, differentiating it from the other DataSnap Server on the same machine, for demo purposes. After that just reopen the session passing the new properties as parameter and it’s done — that is all you need. Procedure TForm6.Redirect(Sender: TObject; Session: TDSTunnelSession; Content: TBytes; var Count: Integer); var DBXProperties: TDBXDatasnapProperties; Msg: String; begin if Sender is Exception then Msg := Exception(Sender).Message;
- 84. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 83 - Log('>>' + Msg); if Session.UserFlag = 1 then Raise Exception.Create('Backup session cannot be redirected once more.' + Msg); DBXProperties := TDBXDatasnapProperties.Create(nil); DBXProperties.Values[TDBXPropertyNames.DriverName] := 'Datasnap'; DBXProperties.Values[TDBXPropertyNames.HostName] := 'localhost'; DBXProperties.Values[TDBXPropertyNames.Port] := '213'; try try Session.Reopen(DBXProperties); Session.UserFlag := 1; Msg := 'Flow commuted to alternate resource.'; Log('>>' + Msg); except Raise Exception.Create(Msg + '. Commuting to alternate resource failed.'); end; finally DBXProperties.free; end; end; In case you want to run the sample code on your machine, here are the steps you need for that. The sample includes two projects: Failover Server and DataSnap Server. We will use DataExplorer as our client application. Using the follow steps you will be able to see the Failover Server in action. • Open and execute the Failover server, the sample use HTTP protocol and port 8080 • Execute the DataSnap Server twice, one using port 211 and other one port 213. The server using the port 213 will work as the backup server • Create a DataSnap alias in your Data Explorer, remembering to configure it to use HTTP as protocol and port 8080 • On the Stored Procedure node, find the method EchoString, pass the value Delphi 2010 as parameter and execute. The return value will be Delphi 2010 (Server 211) • Close the DataSnap Server that runs on the port 211 • Repeat the step 4 and look the return value, which should be Delphi 2010 (Server 213) • Now look the log on the Failover Server, you will see the exception error and the redirection log information
- 85. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 84 - You can download the source code at http://cc.embarcadero.com/Item/27391. DATASNAP – SECURITY Once you have a server created with some server methods you will probably want to add in some logic to control who can invoke those methods. For this you can use the new/improved functionality in the Authentication Manager component. To get started you simply drop this component onto your form and set it as the authentication manager to use in the TDSHTTPWebDispatcher, TDHTTPService or TDSTCPServerTransport component, depending on your server’s configuration. The authentication manager has two events; OnUserAuthenticate and OnUserAuthorize. It also has a ‘Roles’ collection. The OnUserAuthenticate event is called when a user tries to connect (invoke a method) for the first time, and takes as input parameters connection info such as the user’s name and password, and allows you to set a value for the in/out parameter “valid”. By default this is set to true, but you can decide, based on the user information or anything else you wish, if you want to set valid to true or false. Setting it to false will deny the user connection, and therefore also deny any invocation they may have been attempting. You can define Roles in several different ways. You can go to your server methods class and add a TRoleAuth attribute to the code (requires DSAuth unit.) This attribute can either be added at class level, or at method level, like this: [TRoleAuth('admin')] TServerMethods1 = class(TComponent) public function EchoString(Value: string): string; function ReverseString(Value: string): string; end; Or this: TServerMethods1 = class(TComponent) public [TRoleAuth('admin')] function EchoString(Value: string): string; function ReverseString(Value: string): string; end; In the first example both ‘EchoString’ and ‘ReverseString’ would require the user to have the “admin” role to invoke the method. In the second example, only the ‘EchoString’ method has the admin role associated with it. Note that the TRoleAuth attribute has an optional second parameter, which is the ‘denied roles’ list which behaves as you would expect. Both of these parameters can be a comma-separated list of roles.
- 86. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 85 - The OnUserAuthorize event is called whenever a user who has already been successfully authenticated tries to invoke a server method. You do not need to implement this event. If you add roles to the UserRoles list in the OnUserAuthenticate event, then those roles alone can be used to decide if the user has permission to invoke any given server method. However, if you wish to have more control over the process (such as allowing or denying invocation based on time of day,) then you can implement this event. Passed into the event is an object containing information such as the user name, the UserRoles populated in the authentication event, and the allowed/denied roles for the method being called. You can use this information, as well as anything else you like, to decide on if you want to set the value of “valid” to true or false, which will allow or deny the method invocation. DATASNAP REST SERVER Delphi XE provide REST support for DataSnap, in other words your DataSnap Server can expose all server methods as REST interfaces. The new DataSnap client proxy generation system included in XE has generators for the Delphi, C++, Delphi Prism, PHP and JavaScript programming languages. The proxy generator handles the complexity of communicating with and consuming REST services by translating the DataSnap methods and complex types into "native" implementations for the target client language. To create a DataSnap REST Server, Delphi XE provides a DataSnap REST Application Wizard which creates a project that is the starting point for building an AJAX-enabled web application. The communication protocol between server and client applications is HTTP and the architectural style is REST (Representational State Transfer). The DataSnap REST Application Wizard consists of four or five steps, depending on the type of REST Application you select (in the first step). In the first step, you are prompted to select the type of REST Application. The possible options are: • Stand-alone VCL application A stand-alone REST VCL application is a web server that displays a VCL form. It supports HTTP using an Indy HTTP server component. • Stand-alone console application A stand-alone REST console application is a web server that has a text-only user interface. It supports HTTP using an Indy HTTP server component. • ISAPI dynamic link library ISAPI and NSAPI Web server applications are shared objects that are loaded by the web server. Client request information is passed to the DLL as a structure and evaluated by TISAPIApplication. Each request message is handled in a separate execution thread. When you select this type of application, the library header of the
- 87. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 86 - project files and the required entries are added to the uses list. Also, the clause of the project file is exported. ISAPI libraries integrates with IIS. IIS has support for HTTP and HTTPS. • Web App Debugger executable Web Application Debugger provides an easy way to monitor HTTP requests, responses, and response times. Web Application Debugger takes the place of the web server. Once you have debugged your application, you can convert it to one of the other web application types and install it with a commercial web server. • Class Name Class Name is an identifier that will be used in the URL to connect to a particular Web App Debugger executable. The second step is available only if you choose Stand-alone VCL application or Stand- alone console application in the first step. You are prompted to enter the HTTP communication port. The wizard also allows you to test the availability of the port using the Test Port button. Clicking the Find Open Port button automatically completes theHTTP Port field with one of the auto-detected available ports. The third step asks for DataSnap REST server features. If you select the Authentication option, a TDSHTTPServiceAuthenticationManager component is placed on the server form. The TDSHTTPWebDispatcher component uses TDSHTTPServiceAuthenticationManager as the AuthenticationManager to allow the implementation of HTTP user authentication for the DataSnap server. The implementation consists of implementing the HTTPAuthenticate property. When Authentication is selected, the client must provide the DataSnap user name and password as SQL connection properties. Select the Server Methods Class option to add a TDSServerClass component to the server form and to allow defining a class on the server that will expose the server methods to the client applications. If you select the Sample Methods option, ServerMethodsUnit will contain the implementation of two simple methods called EchoString and ReverseString, which return the Value given as a parameter in normal respective reversed states. The fourth step of the DataSnap REST Application Wizard asks you for the ancestor type of the server method class. Choose TDSServerModule to expose the data sets from the server to the client applications. Choose TDataModule if you want to use nonvisual components in your server class. Choose TComponent if you want to entirely implement the server class.
- 88. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 87 - The fifth step asks you to select the root location for the REST web application. This is the output directory of the project executable and the location of the web application files such as .js, .html and .css files. DATASNAP CLIENT – DBEXPRESS Since Delphi 2007 - when the dbExpress Framework was first created - our goal was to build an infrastructure for many technologies, databases and platforms, extending the existing multi-layer support and enabling Java, .NET, PHP, and other clients to connect to DataSnap servers. DbxClient is now being used to connect the client to the DataSnap server, as well. This means that in order to connect to a DataSnap server you must use an SQLConnection, informing that the connection driver is DataSnap and providing the hostname (server) and port There are many ways to execute the server methods. Let’s assume the server holds a class that contains the HelloWorld and GetEmployee methods. function TDMServerDB.HelloWorld(IncommingMessage : WideString ): WideString; begin Result := 'Hello World'; end; function TDMServerDB.GetEmployee(ID : Integer): TDBXReader; begin SQLDataSet1.Close; SQLDataSet1.Params[0].AsInteger := ID; SQLDataSet1.Open; Result := TDBXDataSetReader.Create(SQLDataSet1, False); end; The HelloWorld method is quite simple. It sends a string and returns another. Method GetEmployee, in turn, sends an ID and receives a TDBXReader. In other words, it’s a cursor that can be read client-side either as a DBXReader or as a ClientDataSet. Still working with the HelloWorld method, you’ll now execute it using the SQLServerMethod component. See below: begin DMDataSnapClient.DSServerConnect.Open; // opens the connection by means of SQLConnection SMHelloWorld.SQLConnection := DMDataSnapClient.DSServerConnect; SMHelloWorld.Params[0].AsString := 'Message sent from Client'; SMHelloWorld.ExecuteMethod; ShowMessage(SMHelloWorld.Params[1].AsString); // shows the result End;
- 89. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 88 - Let’s look at the GetEmployee method. In this example the server method is executed through the dbExpress Framework. The same method could be executed through SqlServerMethod. 1 var 2 Command : TDBXCommand; 3 Reader : TDBXReader; 4 begin 5 DMDataSnapClient.DSServerConnect.Open; 6 With DMDataSnapClient.DSServerConnect.DBXConnection do begin 7 8 Command := DMDataSnapClient.DSServerConnect.DBXConnection.CreateCommand; 9 Command.CommandType := TDBXCommandTypes.DSServerMethod; 10 Command.Text := TDSAdminMethods.GetServerMethodParameters; 11 Reader := Command.ExecuteQuery; 12 13 TDBXDataSetReader.CopyReaderToDataSet(Reader, ClientDataSet1); 14 ClientDataSet1.Open; 15 end; Note that the execution is performed by TDBXCommand. The return of type DBXReader is copied to a ClientDataSet in line 13, thus allowing data to be visualized in the VCL. In cases where you don’t need to display the data, DBXReader can be read directly. You might be wondering… If this is all dynamic now, wouldn’t the compiler be able to detect when server methods change? The answer could be positive in case server methods were not represented by means of a client interface. SQLConnection includes an option called “Generete DataSnap Client Access”, that generates a client-side unit with all the methods available at server-side. Each method in the client class contains an implementation to execute the server method. See a sample class below: TDSServerMethodsClient = class private FDBXConnection: TDBXConnection; FGetServerDateTimeCommand: TDBXCommand; FExecuteJobCommand: TDBXCommand; public constructor Create(ADBXConnection: TDBXConnection); destructor Destroy; override; function GetServerDateTime: TDateTime; function ExecuteJob(JobId: Integer): Integer; end; implementation function TDSServerMethodsClient.GetServerDateTime: TDateTime; begin if FGetServerDateTimeCommand = nil then begin
- 90. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 89 - FGetServerDateTimeCommand := FDBXConnection.CreateCommand; FGetServerDateTimeCommand.CommandType := TDBXCommandTypes.DSServerMethod; FGetServerDateTimeCommand.Text := 'TDSServerMethods.GetServerDateTime'; FGetServerDateTimeCommand.Prepare; end; FGetServerDateTimeCommand.ExecuteUpdate; Result := FGetServerDateTimeCommand.Parameters[0].Value.AsDateTime; end; function TDSServerMethodsClient.ExecuteJob(JobId: Integer): Integer; begin if FExecuteJobCommand = nil then begin FExecuteJobCommand := FDBXConnection.CreateCommand; FExecuteJobCommand.CommandType := TDBXCommandTypes.DSServerMethod; FExecuteJobCommand.Text := 'TDSServerMethods.ExecuteJob'; FExecuteJobCommand.Prepare; end; FExecuteJobCommand.Parameters[0].Value.SetInt32(JobId); FExecuteJobCommand.ExecuteUpdate; end; constructor TDSServerMethodsClient.Create(ADBXConnection: TDBXConnection); begin inherited Create; if ADBXConnection = nil then raise EInvalidOperation.Create('Connection cannot be nil. ' + 'Make sure the connection has been opened.'); FDBXConnection := ADBXConnection; end; destructor TDSServerMethodsClient.Destroy; begin FreeAndNil(FGetServerDateTimeCommand); FreeAndNil(FExecuteJobCommand); inherited; end; How do you access the DataSetProvider from the server, from a remote data module, or from a conventional data module? That’s simple: on the client-side you use the new DSProviderConnection component, which is connected to your SQLConnection (DataSnap). The ServerClassName property indicates the class name (DataModule/RDM, usually) where the providers are located in the server. The ClientDataSet then can use the DSProviderConnection as its ProviderName. The new DataSnap and dbExpress Framework provide greater flexibility, not limited by what’s presented in this section. It’s possible to dynamically access a list of methods along with their parameters, which allows developers to create components that control user access to the server and define access rights specific to each of the server’s methods and classes. You can take a look at a more complete DataSnap application samples by visiting
- 91. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 90 - my blog at http://www.andreanolanusse.com/blogen/tag/datasnap/ and http://www.andreanolanusse.com/blogen/tag/dbexpress. DATASNAP – SENDING AND RECEIVING OBJECTS If you start to use, or migrate your application to, the new DataSnap one of the questions you’ll have is “how do I transfer objects between my DataSnap clients and servers”? In DataSnap 2009, only dbExpress data types could be transferred. In DataSnap 2010 you can transfer any kind of object between clients and servers. DataSnap 2010 adds support for JSON (JavaScript Object Notation), which is a lightweight data-interchange format, easy for humans to read/write and easy for machines to parse and generate. JSON is also independent of the programming language and platform. Let’s define the object we would like to transfer between a DataSnap client and server, class TCustomer. unit Customer; interface uses DBXJSON, DBXJSONReflect, SysUtils; type TMaritalStatus = (msMarried, msEngaged, msEligible); TCustomer = class private FName: string; FAge: integer; FMaritalStatus: TMaritalStatus; public property Name: string read FName write FName; property Age: integer read FAge write FAge; property MaritalStatus: TMaritalStatus read FMaritalStatus write FMaritalStatus; function toString : string;override; end; In DataSnap 2010, only objects that descend from TJSONObject can be transferred between client and server without any transformation. If your object does not descend from TJSONObject, then you have to use the TJSONMarshal and TJSONUnMarshal classes to convert those objects. The example below shows how to make this conversion. unit Customer; function CustomerToJSON(customer: TCustomer): TJSONValue; var m: TJSONMarshal;
- 92. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 91 - begin if Assigned(customer) then begin m := TJSONMarshal.Create(TJSONConverter.Create); try exit(m.Marshal(customer)) finally m.Free; end; end else exit(TJSONNull.Create); end; function JSONToCustomer(json: TJSONValue): TCustomer; var unm: TJSONUnMarshal; begin if json is TJSONNull then exit(nil); unm := TJSONUnMarshal.Create; try exit(unm.Unmarshal(json) as TCustomer) finally unm.Free; end; end; You don’t need to implement two transformation methods for every class. You can implement a generic method for a class that uses simple data types, strings, numbers, boolean. Due to the fact that some support classes can be quite complex and some types are fully supported by the current RTTI runtime converters can be added. The TCustomer class is now ready to cross between client and server. We just need to implement a Server Method which will return a TJSONValue after the TCustomer transformation. // protected function TServerMethods.GetCustomer: TCustomer; begin Result := TCustomer.Create; Result.Name := 'Pedro'; Result.Age := 30; Result.MaritalStatus := msEligible; end; // public function TServerMethods.GetJSONCustomer(): TJSONValue; var myCustomer: TCustomer; begin myCustomer := GetCustomer;
- 93. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 92 - Result := CustomerToJSON(myCustomer); myCustomer.Free; end; Executing the method GetJSONCustomer from the client side will be necessary to convert the method return from TJSONValue to TCustomer, using the method JSONToCustomer. var proxy: TServerMethodsClient; myJSONCustomer: TCustomer; begin try proxy := TServerMethodsClient.Create(SQLConnection1.DBXConnection); myJSONCustomer := JSONToCustomer(proxy.myJSONCustomer); Button1.Caption := myJSONCustomer.ToString; myJSONCustomer.Free; finally SQLConnection1.CloneConnection; proxy.Free; end; end; Much more can be done, for example return an Array of objects, complex classes, etc. You can download this sample source code at http://cc.embarcadero.com/Item/27361.
- 94. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 93 - DELPHI TRANSLATION TOOLS – LOCALIZING YOUR APPLICATIONS The IDE-integrated translation tool is now standalone. This means the professional responsible for translating your project can now use the same tool you do, without having to install Delphi himself/herself. For each new language a translation project is generated. It’s then much easier to edit language-specific DFM files. Figure 39. Translation Tool
- 95. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 94 - UML MODELING, AUDITS, METRICS, AND DOCUMENTATION UML MODELING Any final product is expected to be first-class. Quality concerns are no different when it comes to software (especially considering they’re a core element in supporting a company’s growth efforts). Keep in mind that whenever you deliver low-quality software you are compromising your client’s success. Since Delphi 2006 you can use UML and all of its diagrams. In addition, you can also use LiveSource, which allows you to synchronize class diagrams and code. Below you see a list of all diagrams available, along with their functionality: • Use Case it is a way to describe the interaction between a system and the real world. In this case, the actors (either persons or systems) represent the real world. • Class Diagram represents the classes of the system and the relationships they establish. • Collaboration used for modeling the dynamic aspects of a system or subsystem. • Activity allows you to represent dynamic situations by means of flows (using it you can represent the flow between different objects). • Component used in higher-level modeling, in cases where more complex structures are present. This diagram illustrates systems, embedded controls, etc. • State specifies the sequence of events of a given object. Figure 40. Use Case Diagram
- 96. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 95 - Visualizing a class diagram makes it much easier for you to understand the classes in it (as compared with doing the same with code). Let’s see an example in Delphi: the Buttons.pas unit has many components - TBitBtn, TSpeedButton, among others. Now imagine how hard it would be to decipher 1946 lines of code to learn which components are there and which relationships they established. Using reverse-engineering it’s not a big deal... Let's check the following figure: Figure 41. Class Diagram The Sequence Diagram can be generated directly from the source code. Sequence diagrams detail how methods are implemented in the source code: what messages are sent to which objects and when. Sequence diagrams are organized according to time. The objects involved in the method are listed from left to right according to when they take part in the message sequence.
- 97. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 96 - Delphi has full reverse engineering capabilities. Embarcadero is committed to helping developers evolve legacy code; a commitment that is reinforced by our efforts toward continuously providing technology that allows applications to move on.
- 98. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 97 - AUDITS When it comes to quality, people are always concerned about delivering high- performance software. Many even tell us they do not care about the way software is written, rather with its ability to work and meet their needs. In fact, this is a mistake with the potential to impact you in the not-so-distant future. When you write unstructured code you’re impairing your ability to extend the application in the future. It’s then all pieced together, and your application does not grow in a structured manner. Delphi’s audits and metrics help you locate flaws in your application while you’re still developing it. How many times have you defined best-practice guidelines for coding, hoping it would prevent your staff from making the kind of programming mistakes that turns your application into code that no one understands? Assuming your team uses a best-practices manual, the second question that comes to mind is: how can you ensure that the practices are being followed? The answer, again: code review. Now, think of a context where your project is coded in no less than thousands of lines. What you have here is a scheduled catastrophe. Using Delphi’s code audits (QA Audits), you can select from a group of best coding practices, making sure your team is following them. Audits can help you detect flaws in your code throughout the development process. • Arrays and References • Duplicated code • Superfluous content • Performance • Branches and Loops • Coding style • Naming style • Expressions • Design flaws • Possible Errors
- 99. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 98 - Each of the audits includes a descriptive note explaining the correct and incorrect ways of using it helping developers understand how to use each audit. You can set the audit severity level set to Info, Warning, or Error. LOOP BODY IS NEVER EXECUTED (LBNE) You often see routines that involve many loops, requiring you to us a debugger to make sure all of the loops are executed. The LBNE audit helps detect this type of coding style. The following code is a simple example of something LBNE would detect. Complex examples, which involve more conditions, are also easily detected. var x: boolean; begin x := false; while s do begin .... end; end; Categories Parameters Description of the selected item Items Figure 42. QA Audits
- 100. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 99 - INDEX OUT OF BOUNDS (IOB) This is a common message for when you try to access an array position that does not exist. The snippet below generates this warning. var nloops, i, j :integer; matriz : array of integer; somatorio : double; begin for i := 0 to nloops do begin somatorio := 0; for j := 0 to High(matriz) do somatorio := somatorio + matriz[i]; end; end; Figure 43. Audits The audit has located the error, informing you that the code in line 25 tries to access a variable that is not part of the 2nd loop. Drilling down a little: In variable J’s ‘for’ statement I’m trying to access one of the positions in array ARR, aiming at position I of the previous loop, while variable J’s ‘for’ statement is the place where array ARR is being read. Delphi XE allows you to execute audits through command line, making easy the integration with automated build process.
- 101. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 100 - METRICS Metrics help identify coding styles that might be violating defined best practices in object oriented design and programming. Who hasn’t come across code that has 10 constructors for a class, if statements nested 10 deep, methods with 20 parameters, and other practices that make code incomprehensible? Metrics can help you define standards, best practices and limits for your company to follow. An example: a class must not have more than 4 constructors and having no more than 400 lines of code. Each metric has defined lower and upper limits for a class, method and namespace. Each limit can be customized: Figure 44. QA Metrics
- 102. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 101 - After metrics are executed, their results can be analyzed with the assistance of the Kiviat chart. In a Kiviat chart, the red circle represents the predefined limits for the metrics. Points outside of this boundary denote code that is breaking one or more metric rules. Figure 45. Metrics Analysis You can analyze each of the classes separately. This way it’s easier to identify any metrics violations. Using audits and metrics, developers are able to deliver higher-quality applications, just as good externally as they are in their core. Like audits, you can execute the metrics using the command line as well. These are the things you are able to perform when your code is migrated from Delphi 7 to the most recent Delphi release.
- 103. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 102 - DOCUMENTATION Few things are as difficult as getting developers to document their applications. Developers develop, that’s what they do best. With the assistance of Delphi’s diagrams, developers, analysts, and architects learn how easy it can be to write code and document the entire application. It’s as simple as getting into the diagram and documenting. Taking a class diagram, as an example, you simply click on the class, variable, method, and other class attributes, then right mouse click and choose the Generate Documentation menu item. You can also generate documentation for the model from the Project Manager and from the command line. The documentation is generated as HTML, separated as project overview, diagram view and documentation details. Figure 46. Thorough Documentation
- 104. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 103 - THIRD-PARTY TOOLS AND COMPONENTS Many of the third-party tools and components packaged with Delphi have been updated and bring new resources and compatibility with existing applications. If you have any additional questions about specific third-party tools and components that you use, the Delphi product page has a list of many third tools and components available today (http://www.embarcadero.com/products/delphi/tools-and-components). AQTIME – PERFORMANCE PROFILING AQtime is an award-winning performance profiling, and memory/resource debugger. AQtime standard edition is integrated into the IDE giving you the power to optimize your code without leaving the IDE. As you optimize and improve your code, AQtime provides an exact and accurate “picture” of your application’s execution. Using AQtime you can profile your code to see how long each method takes to execute. You can use AQtime for code coverage analysis. AQtime will also detect memory leaks and resource allocation errors, With AQtime you can eliminate guesswork during development and deliver rock solid software products. Figure 47. AQtime results by method AQtime Pro helps you completely understand how your program performs during execution.
- 105. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 104 - FINALBUILDER – BUILD AUTOMATION Delphi XE Enterprise and Architect Edition includes FinalBuilder automated build and release management toolset to define and manage repeatable build processes Traditionally, batch files, XML and script have been used to automate builds. These methods create a build script that is difficult to maintain, difficult to understand and which suffers from a lack of proper error handling. A visual build tool with the breadth of functionality of FinalBuilder makes it easy to define, debug, maintain and run a reliable build process. FinalBuilder will: • Save you time - for any substantial software project, automated builds are much quicker than manual builds. • Allow anyone in the team to run a build - FinalBuilder is so easy to use, you'll no longer need a single build guru to create, maintain and run your builds. • Improve the quality of your releases - FinalBuilder cuts the human error factor substantially by automating tasks and running your tests every time your source code is built. • Record what was built and when - FinalBuilder logs the output from every action it performs and tools it calls. Logs from previous builds are archived and can be exported for better record keeping. Figure 48. FinalBuilder build automation in action
- 106. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 105 - CODESITE – ADVANCED LOGGING SYSTEM The CodeSite Logging System gives developers deeper insight into how their code is executing. This enables you to locate problems more quickly and ensure that your application is running correctly. CodeSite's logging classes let developers capture all kinds of information while their code executes and send that information to a live display or to a log file. Figure 49. CodeSite Live Viewer IP*WORKS IP*Works! is a comprehensive framework for Internet , it eliminates the complexity of Internet development providing easy-to-use, programmable components that facilitate tasks such as sending email, transferring files, managing networks, browsing the web, consuming web services, etc.
- 107. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 106 - TEECHART 2010 One of the components Delphi developers use the most, TeeChart, has been updated to version 2010. It now includes new resources aimed at working with Charts in Delphi. RAVE REPORTS 9 Delphi XE comes with Rave Reports, the famous report generator, now update to version 9 BEYOND COMPARE Beyond Compare allows developers to quickly and easily compare files and merge changes. By using simple, powerful commands you can focus on the differences you're interested in and ignore those you're not. Beyond Compare is integrated with Delphi XE IDE. VCL FOR THE WEB VCL for the Web - previously called IntraWeb - allows you to create Web 2.0 applications, with transparent AJAX integration in many VCL components, and the newly added Silverlight support.
- 108. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 107 - DELPHI XE EDITIONS – PROFESSIONAL, ENTERPRISE AND ARCHITECT Delphi XE is offered in three editions: Professional, Enterprise and Architect. You can check the list of features available in each edition and other product information at: http://www.embarcadero.com/products/delphi/product-editions. The Architect edition includes ER/Studio Developer Edition data modeling tool. Database modeling is vital for developers working with applications that rely on databases. ER/Studio includes support for reverse-engineering existing database and working with logical and physical database models. ER/Studio supports the following databases: DB2 LUW V9, Hitachi HiRDB, IBM® DB/2® , Informix, InterBase® , Microsoft® Access, SQL Server, Visual FoxPro, MySQL, NCR Teradata, Oracle, PostgreSQL, Sybase, SQL Anywhere. Other databases can also be accessed through ODBC. ER/Studio provides resources as reverse-engineering, logical and physical modeling. CONCLUSION Delphi’s IDE has been continually improved over the years. Delphi XE is no exception. The new IDE, Version Control integration, VCL components, Touch and Gesture support, RTL, Cloud support, generics, anonymous methods and the new DataSnap are sure to improve developers’ productivity, allowing you not only to evolve existing applications but also develop new ones with next-generation technologies. For additional detail drill down into what’s new in Delphi XE, please visit: http://www.embarcadero.com/products/delphi/whats-new.
- 109. Reasons to Migrate to Delphi XE – What you might have missed since Delphi 7 Embarcadero Technologies - 108 - ABOUT THE AUTHOR Andreano Lanusse is a software development expert and industry enthusiast. As a technical lead evangelist for Embarcadero worldwide, he spends a great deal of his time with developers, both onsite and at conferences and user groups, to ensure the company’s tools meet the expectations of customers. Prior to Embarcadero, Andreano worked at Borland for thirteen years in numerous roles including, support coordinator, engineer, product manager, and product line sales manager. He has also worked as a principal consultant for Borland Consulting Services on the development and management of critical applications. Previously, he served as chief architect for USS Tempo (formerly USS Soluções Gerenciadas). Andreano holds a bachelors degree in business administration from Sumare Institute and MBA in project management from FGV, and Certificate for Product Management Course from University of California, Berkeley. Andreano is also a certified SCRUM Master. You can read more about Andreano Lanusse on his blog, http://www.andreanolanusse.com/ and reach him at his e-mail address: [email protected]. Embarcadero Technologies, Inc. is the leading provider of software tools that empower application developers and data management professionals to design, build, and run applications and databases more efficiently in heterogeneous IT environments. Over 90 of the Fortune 100 and an active community of more than three million users worldwide rely on Embarcadero’s award-winning products to optimize costs, streamline compliance, and accelerate development and innovation. Founded in 1993, Embarcadero is headquartered in San Francisco with offices located around the world. Embarcadero is online at www.embarcadero.com.