The conference was held in Lazne Belohrad, which is a very beautiful, small spa in Czech mountains. In the past it was called "Delphi conference" and this was the 10th anniversary of this great event. I’m looking forward to the next year:-)

Share This | Email this page to a friend

In the early days of web services the HTTP protocol was the only mean for exchanging XML-encoded SOAP messages. Windows Communication Foundation (WCF) architecture introduced in .NET 3.0 decouples SOAP messaging from the underlying transport and introduces other then HTTP transports for exchanging SOAP messages. For example there is "NetTcpBinding" that uses TCP as transport protocol. With RESTful web services the underlying protocol is HTTP, however messages are not encoded as SOAP envelopes, and does not even need to be encoded in XML. It is more and more common to encode them in simpler JSON format instead, or even plain text. RESTful web services can be used to retrieve arbitrary MIME-types, not necessarily text, for example images.

Aaron Lerch in his "Creating RESTful Web Services with WCF 3.5" article points out that "Representational State Transfer" is a phrase that describes the generic principles that make up much of what we know to be the HTTP protocol. As it applies to web services, the primary concepts of interest are resources, and the actions that can be taken on a given resource. Resources are identified by Uniform Resource Identifiers (URIs), something that nearly everybody is familiar with. SOAP-based web services typically use a single URI to represent the service endpoint plus an operation. A RESTful web service uses a unique URI to reference every resource, and HTTP verbs to define actions on those resources. REST-based services are making heavy use of different HTTP verbs (GET, POST, PUT, DELETE), HTTP result status codes, and encoding request details inside the URI.

The .NET 3.5 Framework introduces support for this low-level "web programming" through new types defined in the "System.ServiceModel.Web" namespace. Specifically there is a new WCF binding for web programming called "WebHttpBinding", corresponding "WebHttpBehavior", new attributes for specifying HTTP GET or POST methods - "WebGet" and "WebInvoke", and also new "UriTemplate" custom attribute for mapping URIs to methods and their parameters.

Building basic Delphi 2007 WCF REST service

Let’s build a simple Delphi 2007 WCF REST service application. The structure of Delphi 2007 WCF 3.5 web application is very similar to the Delphi 2007 WCF 3.0 applications described in the "Introduction to WCF Programming in Delphi" CodeGear Developer Network article. To successfully build the service application make sure to have .NET 3.5 installed and CodeGear RAD Studio 2007 "December Update" installed.

The first step is to create a new "Console Application - Delphi for .NET" and save it for example as "DelphiRESTBasicSample_Service" project.

The second thing to do is to add appropriate project references. Right click on the "References" node in the "Project Manager" and select "Add Reference…". Click the browse button and add the following reference assemblies to the project:

• C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.0\System.ServiceModel.dll
• C:\WINDOWS\Microsoft.NET\Framework\v3.0\Windows Communication Foundation\System.Runtime.Serialization.dll
• C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.ServiceModel.Web.dll

The side effect of adding these references to the project is adding directories where these assemblies reside to the project’s search paths.

Now it is time to add two empty units to the project. One for the service interface and one for the implementation. I’m going to start from implementing a simple "calculator" service. This time using new WCF attributes introduced in the .NET 3.5.

unit uServiceIntf;  

interface  

uses
  System.ServiceModel,
  System.ServiceModel.Web;  

type
  [ServiceContract]
  IService = interface  

    [OperationContract]
    [WebGet(UriTemplate='Add?a={x}&b={y}')]
    function Add(x, y: integer): integer;  

    [OperationContract]
    [WebGet(UriTemplate='Sub?a={x}&b={y}', ResponseFormat=WebMessageFormat.Json)]
    function Subtract(x, y: integer): integer;  

  end;  

implementation  

end.

Note the usage of the new "WebGet" attribute. To invoke both methods declared in the "IService" interface HTTP GET method must be used. The "UriTemplate" is used to specify how the web method is going to be invoked. The "UriTemplate" class supports the matching or binding of a string template with name-value pairs. When defining an OperationContract, a UriTemplate is specified and it accomplishes two purposes. First, it provides the mapping between a request URI and an OperationContract, and second, it identifies the named values that are subsequently bound to matching OperationContract method parameters. By default responses are encoded in XML. The second "WebGet" attribute contains "ResponseFormat=WebMessageFormat.Json" to instructs the WCF runtime to encode response as JSON, instead of XML.

The implementation of the service is trivial:

unit uServiceImpl;  

interface  

uses
  uServiceIntf;  

type
  TService = class(TObject, IService)
  public
    function Add(x, y: integer): integer;
    function Subtract(x, y: integer): integer;
  end;    

implementation  

{ TService }  

function TService.Add(x, y: integer): integer;
begin
  Result := x + y;
end;  

function TService.Subtract(x, y: integer): integer;
begin
  Result := x - y;
end;  

end.

The last step is to add code to the project’s source code. To display project source in the editor select "View Source" option from "Project" menu. Here is the full source code of the project.

program DelphiRESTBasicSample_Service;  

{$APPTYPE CONSOLE}  

uses
  SysUtils,
  System.ServiceModel.Web,
  System.ServiceModel,
  uServiceIntf in 'uServiceIntf.pas',
  uServiceImpl in 'uServiceImpl.pas';  

var
  aBaseAddress: string;
  URIs: array of Uri;
  host: WebServiceHost;  

begin
  try
    aBaseAddress := 'http://localhost:8000/';
    SetLength(URIs, 1);
    URIs[0] := Uri.Create(aBaseAddress);  

    host := WebServiceHost.Create(typeof(TService), URIs);
    host.Open;  

    writeln('Service is running and listening at ' + aBaseAddress);
    writeln('Press any key to quit...');
    readln;  

    host.Close;  

  except
    on e: Exception do
    begin
      host.Abort;
      writeln(e.Classname, ': ', e.Message);
      readln;
    end;
  end;
end.

Note the new "WebServiceHost" class for hosting our RESTful service web service. The service is complete. After running it from inside the IDE you should see the following window. Press any key to stop the service application. Here we are hosting the WCF service in the console application, but it is also possible to host it inside the IIS.

To test the service application we can just start a web browser and type in the following URL:

http://localhost:8000/Add?a=2&b=3

Right-clicking on the browser window and selecting "View Page Source" reveals that the following string was returned from the "Add" method.

In order to consume RESTful web service an arbitrary HTTP client is required. Luckily Delphi 2007 comes with a number of Indy 10 components for low-level network programming. The "TIdHTTP" component implements an HTTP client and can be used to interact with our RESTful web application. In the CodeGear RAD Studio 2007 installation there is a demo Delphi for Win32 project that uses "TIdHTTP" component that can be used directly as a test client for our service application. In the default installation it can be found in the following location:

C:\Documents and Settings\All Users\Documents\RAD Studio\5.0\Demos\Indy10\HTTPVCLForm\IdHttpDemoVCL.dproj 

Now we can test both methods: "Add" and "Sub". I have compiled the "IdHttpDemoVCL" project and started it from outside the IDE. Because I keep changing the service application, it is more easy to run the service from within the IDE.

Summary

The .NET 3.5 introduced support for building RESTful web services that do not use SOAP for encoding messages. This simplifies building SOA applications and clients. In this article I have demonstrated building basic .NET 3.5 RESTful web services with Delphi 2007 for .NET and consuming them with TIdHTTP component from Delphi 2007 for Win32 VCL Forms application.

References

• CodeGear RAD Studio 2007
• "Introduction to WCF Programming in Delphi" by Pawel Glowacki, CodeGear Developer Network article
• Wikipedia: Windows Communication Foundation
• "WCF Syndication: HTTP Programming with WCF and the .NET Framework 3.5" by Justin Smith, MSDN Magazine, January 2008
• "Creating RESTful Web Services with WCF 3.5" by Aaron Lerch, www.developer.com
• "Architectural Styles and the Design of Network-based Software Architecture" by Roy Thomas Fielding, Doctor of Philosophy Dissertation, University of California, Irvine, 2000
• JSON Homepage
• The Indy Project

Share This | Email this page to a friend

I’m going to present the following 60 minutes Delphi webinars around Service Oriented Architecture and Web Services theme in April and I do invite you to register. It is going to be fun:-) See you online on Tuesdays at 11am and 3pm in April (CET, GMT +1).

In this webinar attendees will be introduced to basics of eXtensible Markup Language (XML). The following topics will be discussed:

• XML as a better HTML
• XML document structure
• Rules of well-formedness
• XML Namespaces
• Validating XML with DTD and XML Schema
• XSLT and XPath
• XML Parser Types

The "Understanding XML" session is designed as a programming language neutral introduction to XML and starting point for using XML in a programming language of your choice.

This webinar builds on “Understanding XML” session and covers Delphi XML programming using:

• TXMLDocument component
• Data Binding Wizard
• XML Mapper

Service Oriented Architecture (SOA) gains a lot of attention as a modern approach for building scalable and maintainable software systems. This session covers the following topics:

• Benefits of Service Oriented Architecture (SOA)
• Understanding Web Services Description Language (WSDL)

This session is designed as a programming language-neutral introduction to SOA and Web Services and starting point for building service-oriented application in programming language of your choice.

This webinar builds on the contents “Understanding Web Services and SOA” session and discusses Web Service development with Delphi for Win32. The following topics will be presented:

• Consuming Web Services in Delphi for Win32 with "Web Service Importer"
• Building Delphi for Win32 Web Services with "SOAP Server Wizard"

This webinar builds on the contents “Understanding Web Services and SOA” session and discusses Web Service development with Delphi for .NET. The following topics will be presented:

• Consuming Web Services in Delphi for .NET with "Add Web Reference" wizard
• Building Delphi ASP.NET Web Service Applications

This webinar builds on the contents “Understanding Web Services and SOA” session and discusses SOA development with Delphi using Windows Communication Foundation. The following topics will be presented:

• WCF Basics: understanding service descriptions, bindings, endpoints and channels
• Building interoperable WCF Service applications with Delphi for .NET 3.5
• Consuming WCF services in Delphi for .NET and Delphi for Win32

Share This | Email this page to a friend

This made me thinking if it would make sense to create "CodeGearBuntu"? What should go into Linux CodeGear distro? Maybe there should be more "codegearbuntus" like "CodeGearBuntu3rdRailDesktop" with Rails 2.0, "CodeGearBuntuJBuilderTeamInsight" with subversion, xplanner, bugzilla and continuum, and "CodeGearBuntuHardcoreDeveloper" with a trendy CodeGear wallpaper preinstalled?

Share This | Email this page to a friend

Morning…

Tuesday, March 4th, 11.00 CET (GMT +1), "What’s New in RAD Studio 2007 for Delphi Developers?"

Native Delphi AJAX web application with new VCL for the Web framework, parameterized types (generics) in Delphi compiler, new DBX4 database driver architecture, Visual Query Builder, ASP.NET 2.0, live templates for HTML tags inside integrated HTML Editor, adding projecs to "New Items" dialog through Template Libraries - new Delphi Repository mechanism.

Afternoon…

Tuesday, March 4th, 15.00 CET, "DBX4 for BDE Developers"

New Delphi DBX4 Database Driver Architecture, Data Explorer VCL Form Designer integration, unidirectional datasets and provider architecture, moving from BDE to DBX data-access components, programmatically reading BDE and DBX metadata, creating tables with DBX metadata classes and migrating data from BDE to DBX in code.

Any time…

http://www.codegear-events.eu/

Share This | Email this page to a friend

With the new DBX4 metadata classes it is possible to programmatically create database tables and indices in code against any database connection configured in the CodeGear RAD Studio 2007 Data Explorer.

One possible approach, as demonstrated by Dr. Bob during 2007 December SDE conference on "Migratie: van BDE naar BlackfishSQL via dbExpress" session, is to programmatically construct a SQL statement with appropriate "CREATE TABLE …" SQL code and pass it to "TSQLConnection.ExecuteDirect" method for immediate execution. One problem with this approach is the fact that there are subtle differences in SQL syntax accross different database products, so it is very difficult to create one SQL "create table" string good for all databases.

With Delphi DBX4 Metadata classes it is possible to create database tables and indices on the higher level of abstraction. You can now do it in Pascal code instead of low-level SQL statements.

Steps:

1. Start CodeGear RAD Studio 2007

2. In Data Explorer add a connection to a database where you want to programmatically create a new database table. I’m using sample CodeGear InterBase 2007 "Employee.gdb" database located in default installation under: "C:\Program Files\Common Files\CodeGear Shared\Data". Make sure that the name of the database in Data Explorer is "EMPLOYEE".

3. In the "New Items" dialog select "VCL Forms Application - Delphi for .NET". Save All.

4. Select "Add Reference" from "Project" menu. In the "Add Reference" dialog select "Borland.Data.DbxCommonDriver.dll", "Borland.Data.DbxReadOnlyMetaData.dll" and "Borland.Data.AdoDbxClient" assemblies. Click "Add Reference" button, and then OK.

5. Add an empty Delphi unit to project and save it as "dbxutils".

6. Replace new unit’s empty body with the following code and save.

unit dbxutils;      

interface      

uses
  System.Data.Common,
  Borland.Data.DBXMetaDataProvider,
  Borland.Data.AdoMetaDataProvider,      

  // database specific metadata writers
  Borland.Data.DBXInterbaseMetaData,
  Borland.Data.DBXDataStoreMetaData;      

type
  TDBXUtils = class
  public
    class function GetAdoConnection(aConnectionName: string): DBConnection;
    class function GetAdoMetaDataProvider(aConnection: DBConnection): TAdoMetaDataProvider;
    class function GetMetaDataProvider(aConnectionName: string): TDBXMetaDataProvider;
  end;      

implementation      

{ TDBXUtils }      

class function TDBXUtils.GetAdoConnection(
  aConnectionName: string): DBConnection;
var
  Factory: System.Data.Common.DbProviderFactory;
  Connection: System.Data.Common.DbConnection;
begin
  Factory := System.Data.Common.DbProviderFactories.GetFactory(
    'Borland.Data.AdoDbxClient');
  Connection := Factory.CreateConnection();
  Connection.ConnectionString := 'ConnectionName=' + aConnectionName;
  Connection.Open;
  Result := Connection;
end;      

class function TDBXUtils.GetAdoMetaDataProvider(
  aConnection: DBConnection): TAdoMetaDataProvider;
begin
  if aConnection = nil then
    raise Exception.Create('Connection is nil');      

  Result := TAdoMetadataProvider.Create;
  Result.Connection := aConnection;
  Result.Open;
end;      

class function TDBXUtils.GetMetaDataProvider(
  aConnectionName: string): TDBXMetaDataProvider;
begin
  Result := GetAdoMetaDataProvider(GetAdoConnection(aConnectionName));
end;      

end.

7. Add two "TEdit" and one "TButton" components to the main form of your application. In the Object Inspector change "Name" property of TEdit components to respectively "EditConnectionName" and "EditNewTableName".

8. Add "dbxutils" and "Borland.Data.DBXMetaDataProvider" to the form’s unit "uses" clause.

9. Add the following code in the button’s "OnClick" event:

procedure TFormMain.Button1Click(Sender: TObject);
var
  AMetaDataTable: TDBXMetaDataTable;
  AMetaDataProvider: TDBXMetaDataProvider;
begin
  AMetaDataTable := TDBXMetaDataTable.Create;      

  AMetaDataTable.TableName := EditNewTableName.Text;
  AMetaDataTable.AddColumn(TDBXInt32Column.Create('C1'));
  AMetaDataTable.AddColumn(TDBXDecimalColumn.Create('C2', 10, 2));
  AMetaDataTable.AddColumn(TDBXUnicodeCharColumn.Create('C3', 32));      

  AMetaDataProvider := TDBXUtils.GetMetaDataProvider(EditConnectionName.Text);
  AMetaDataProvider.CreateTable(AMetaDataTable);
end;

10. Run the application, and click on the button to execute database table creation code. Close the application.

11. In the Data Explorer right-click on "EMPLOYEE" database node and select "Refresh". When you expand "Tables" node you should see newly created database table. If you right-click on the new table and select "Alter Table" you should see the metadata information about the new table.

CONGRATULATIONS! You have just created the first database table in code with the new RAD Studio 2007 DBX4 Metadata classes. The complete project source code is available for download from CodeGear Developer Network CodeCentral.

If you now press "Ctrl" button and move mouse over "DBXMetaDataProvider" in "uses" clause

you will be able to step into the VCL DBX source code where types used in "dbxutils" unit are defined.

The "DBXMetaDataProvider" unit defines a number of interesting classes

• TDBXMetaDataProvider
• TDBXMetaDataTable
• TDBXMetaDataColumn
• TDBXMetaDataIndex
• TDBXMetaDataForeignKey

that can be used to programmatically created tables with indices and foreign keys in code. There is also a number of different convenience classes derived from "TDBXMetaDataColumn" that makes it easy to define columns of certain type. They contain a constructor only, so in reality you will be probably using properties of the base class to define different aspects of the database table column, like for example "AutoIncrement" or "Nullable".

• TDBXInt8Column
• TDBXInt64Column
• TDBXInt32Column
• TDBXInt16Column
• TDBXDoubleColumn
• TDBXDecimalColumn
• TDBXDateColumn
• TDBXBooleanColumn
• TDBXBinaryLongColumn
• TDBXBinaryColumn
• TDBXAnsiVarCharColumn
• TDBXAnsiLongColumn
• TDBXAnsiCharColumn
• TDBXObjectColumn
• TDBXSingleColumn
• TDBXTimeColumn
• TDBXTimestampColumn
• TDBXUInt16Column
• TDBXUInt32Column
• TDBXUInt64Column
• TDBXUInt8Column
• TDBXUnicodeCharColumn
• TDBXUnicodeLongColumn
• TDBXVarBinaryColumn
• TDBXWideVarCharColumn

Summary

In this example I’ve been using Delphi 2007 for .NET, but since RAD Studio 2007 December Update it is also possibly to write a similar application in Delphi 2007 for Win32.

The complete project source code is available for download from CodeGear Developer Network CodeCentral.

Share This | Email this page to a friend

"What’s New in CodeGear RAD Studio 2007 for Delphi Programmers?"

• CodeGear RAD Studio 2007 Overview
• New Language Features
• DBX4 Architecture
• Blackfish SQL Database Engine
• ASP.NET 2.0

"Agile Techniques for Building Quality into Delphi Applications"

• Introduction to Agile Programming
• Unit Testing and Refactoring
• Modelling and Design Patterns
• Audits and Metrics

The list of all CodeGear webinars planned for coming weeks is avaiable on the CodeGear European Event Calendar page. See You on "Effective DBX4 Database Programming" and "Advanced DBX4 Database Architecture" webinars next Tuesday same time (11am and 3pm CET).

Share This | Email this page to a friend

I will be hosting 10 Delphi webinars almost every Tuesday at 11AM and 3PM.

This time the focus is on database development and software quality.

• What’s New in RAD Studio 2007 for Delphi Developers?
• DBX4 for BDE Developers
• Agile techniques for building quality into Delphi applications
• Effective DBX4 database architecture programming
• Advanced DBX4 database architecture
• Database Part I : Unleash the power of ClientDataSet
• Database Part II : ClientDataSet use in disconnected multi-tier applications

All webinars are free, but you need to register first. All webinars are in InterWise iClass format. The calendar with all CodeGear European Events is available here.

Share This | Email this page to a friend

Do you know Charles Petzold? Yes. He is the one who authored classical "Programming Windows" book back in eighties. Last year Petzold wrote a very good guide to WPF programming under intriguing title "Applications = Code + Markup", which is a very obvious reference to another classical book written in 1975 by creator of Pascal programming language Niklas Wirth "Algorithms + Data Structures = Programs".
When I heard that Petzold is writing a book on "3D Programming for Windows", I knew that I needed to have this book on my bookshelf.

I was studying 3D visualization algorithms in Warsaw University of Technology, so quaternions, matrices and this type of mathematics do not scare me. Quite contrary I like it a lot. When operator overloading was introduced in Delphi 2006 for Win32 compiler, my first thought was to implement basic operations for quaternions like "add" and "subtract". At the end quaternions are just plain 4-D vectors, that happened to be very useful representations of arbitrary rotations in 3-D space.

Windows Presentation Foundation comes with the impressive number of specialized types for advanced 3D programming.
I like to think about these classes as a kind of standardization for abstractions used in 3D graphics.

Delphi for .NET Simple Scene in Code

"3D Programming for Windows" contains many useful examples of code, and I thought it would be fun to translate one of them to Delphi for .NET. I have decided to implement "Simple Scene In Code" example, that contains a simple scene with just one triangle, camera and a combo box to change the position of the camera and look at the triangle from different angles.

The steps to get started with Delphi for .NET WPF application were outlined in my post on template libraries a few weeks ago. In principle you need to create a new Delphi for .NET Console Application project, and add project references to .NET assemblies where WPF types are implemented. From this point it just a matter of adding correct namespace to "uses" clauses of your Delphi units and you should be up and running.

The program file looks like this:

program DelphiSimpleSceneInCode;      

// {$APPTYPE CONSOLE}      

uses
  System.Windows,
  uFormMain in ‘uFormMain.pas’;      

var
  app: Application;      

[STAThread]
begin
  try
    app := Application.Create;
    app.Run(TFormMain.Create);      

  except
    on E:Exception do
    begin
      Writeln(E.Classname, ‘: ‘, E.Message);
      Readln;
    end;
  end;
end.

Note that I have commented out the {$APPTYPE CONSOLE} directive, so the console window is not displayed.

The main program functionality is implemented inside the "TFormMain" class that represents the main window of my application. Below is the implementation of the "TFormMain" class.

unit uFormMain;      

interface      

uses
  System.Windows,
  System.Windows.Controls,
  System.Windows.Controls.Primitives,
  System.Windows.Media,
  System.Windows.Media.Media3D;      

type
  TFormMain = class(Window)
  strict private
    FCam: PerspectiveCamera;
    procedure ScrollBarOnValueChanged(Sender: TObject;
      args: RoutedPropertyChangedEventArgs);
  public
    constructor Create;
    destructor Destroy; override;
  end;      

implementation      

{ TFormMain }      

constructor TFormMain.Create;
var
  dock: DockPanel;
  scroll: ScrollBar;
  viewport: Viewport3D;
  mesh: MeshGeometry3D;
  indices: Int32Collection;
  geomod: GeometryModel3D;
  modvis: ModelVisual3D;      

begin
  inherited Create;      

  self.Title := ‘Delphi for .NET Simple 3D Scene in Code’;      

  // Make DockPanel content of window.
  dock := DockPanel.Create;
  self.Content := dock;      

  // Create Scrollbar for moving camera.
  scroll := ScrollBar.Create;
  scroll.Orientation := Orientation.Horizontal;
  scroll.Value := -2;
  scroll.Minimum := -2;
  scroll.Maximum := 2;      

  Include(scroll.ValueChanged, ScrollBarOnValueChanged);      

  dock.Children.Add(scroll);
  DockPanel.SetDock(scroll, System.Windows.Controls.Dock.Bottom);      

  // Create Viewport3D for 3D scene.
  viewport := Viewport3D.Create;
  dock.Children.Add(viewport);      

  // Define the MeshGeometry3D.
  mesh := MeshGeometry3D.Create;
  mesh.Positions.Add(Point3D.Create(0, 0, 0));
  mesh.Positions.Add(Point3D.Create(0, 1, -1));
  mesh.Positions.Add(Point3D.Create(0, 0, -2));
  indices := Int32Collection.Create;
  indices.Add(0);
  indices.Add(1);
  indices.Add(2);
  mesh.TriangleIndices := indices;      

  // Define the GeometryModel3D.
  geomod := GeometryModel3D.Create;
  geomod.Geometry := mesh;
  geomod.Material := DiffuseMaterial.Create(Brushes.Cyan);
  geomod.BackMaterial := DiffuseMaterial.Create(Brushes.Red);      

  // Create ModelVisual3D for GeometryModel3D.
  modvis := ModelVisual3D.Create;
  modvis.Content := geomod;
  viewport.Children.Add(modvis);      

  // Create another ModelVisual3D for light.
  modvis := ModelVisual3D.Create;
  modvis.Content := AmbientLight.Create(Colors.White);
  viewport.Children.Add(modvis);      

  // Create the camera.
  FCam := PerspectiveCamera.Create(
    Point3D.Create(-2,0,5),
    Vector3D.Create(0, 0, -1),
    Vector3D.Create(0, 1, 0),
    45);      

  viewport.Camera := FCam;
end;      

destructor TFormMain.Destroy;
begin
  inherited;
end;      

procedure TFormMain.ScrollBarOnValueChanged(Sender: TObject;
  args: RoutedPropertyChangedEventArgs);
begin
  FCam.Position := Point3D.Create(args.NewValue, 0, 5);
end;      

end.

Translating c# code to Delphi for .NET is very straightforward, however there are certain things you need to know. For example syntax for adding event handlers to events. .NET features multicast event handlers. This is different as compared to traditional Delphi for Win32 programs that sport singlecast events. In c# to add "ScrollBarOnValueChanged" event handler to "ValueChanged" event of the combobox overloaded "+=" operator is used. Delphi uses "Include" and "Exclude" standard routines to respectively add and remove an event handler from an event.

The source code for this post can be downloaded from CodeCentral. 

Happy 3D coding:-)

Merry Christmas and a Happy New Year for all of You!

Share This | Email this page to a friend

First of all it is my personal and subjective list, and second - english is not my native language so I hope that you would like the session anyway:-)

The written version of my "Leveraging What You Have: 10 Top Things Added to Delphi Since Delphi 7" is available as an article on the CodeGear Developer Network.

264 people at the CodeRage II at this moment in the InterWise room. Cool!

Share This | Email this page to a friend