Last time, I had created an attribute which could only be attached to methods returning strings and used a home-made caching class, the Aspect looked like this:

namespace AOPCacheLibrary;

interface

uses
  RemObjects.Oxygene.Cirrus.*,
  RemObjects.Oxygene.Aspects;

type
   [AttributeUsage(AttributeTargets.Method)]
  MemCacheAttribute = public class(System.Attribute, IMethodImplementationDecorator)
  private
  public

    method HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
  end;

implementation

method MemCacheAttribute.HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
begin
  // Get a Reference to our Result Value
  var newResult := new ResultValue();

  // Get our MemCache Object
  var cacheType := Services.FindType('AOPCacheLibrary.MemCache');
  // Setup our static methods.
  var getDataProc := new ProcValue(new TypeValue(cacheType), 'getData', [new NamedLocalValue('cacheKey')]);

  // Assign the result of our cache request to a local variable.
  var getDataAssignment := new AssignmentStatement(new NamedLocalValue('strData'), getDataProc);

  // CACHE DATA USED: To assign our Cache'd data to the Method Result
  var useCacheData := new AssignmentStatement(newResult, new NamedLocalValue('strData'));
  // CACHE DATA NOT USED: To assign the result of our OriginalBody to the Method Result.
  var useOriginalMethodResult := new AssignmentStatement(new NamedLocalValue('resultOriginal'), newResult);

  aMethod.SetBody(Services,
    method begin
      var strData: String;
      // Get our Cache Key Name
      var cacheKey := MemCache.getKeyFromMethod(Aspects.MethodName, Aspects.GetParameters);

      try
        // See if we have anything in the cache for this key.
        unquote(getDataAssignment);
        // Replace this
        unquote(useCacheData);
      except
        on E: Exception do
        begin
          var resultOriginal: String;
          // No cache data found, execute the original method body.
          Aspects.OriginalBody;

          // Assign the result of the Original Method to a new variable.
          unquote(useOriginalMethodResult);
          // Send the result of the Original Method to the Cache for next time.
          MemCache.setData(cacheKey, resultOriginal);
        end;
      end;
    end);
end;

end.

Modifying my original code into working with the Microsoft Enterprise Caching black wasn’t particularly hard. If you haven’t worked with the Microsoft P&P Enterprise Library Caching Block before I highly recommend the Quickstart guide. The Enterprise Caching Block allows you to configure your cache using configuration file and change the backing store to suit own your needs. I would certainly recommend tweaking the expiration time and frequency of cache cleaning times before you begin.

Whilst rewriting the code of my Aspect I found it absolutely invaluable to have the Cirrus documentation wiki open and a piece of paper next to my keyboard with the approximate psuedo-code that I was intending to build with Cirrus written on it. I did actually find that despite the fact that the code I was building was not complicated, I did require a reminder of the statements and structure of it.

One additional problem that I did encounter very quickly on my modification was that I had a method which would generate a string key from the method name being called and its parameters which looked like this:

class method CacheKeyFactory.GetKeyFromMethod(aName: String; Args: Array of object): String;
begin
  var argConcat: String;

  argConcat := aName;
  for argTemp in Args do
  begin
    argConcat := argConcat + argTemp.ToString();
  end;

  Result := argConcat;
end;

Which I had intended to inject into the target class using the AutoInjectIntoTargetAttribute which as the name suggests creates the method tagged within the class you are targetting with your attribute. The problem I encountered was that I used this Attribute on a method within an IMethodImplementationDecorator attribute which meant that it worked perfectly when I applied my attribute to just one method within a class but applying my attribute to more than one meant that the AutoInjected method got injected more than once – causing a conflict (Is this a bug? I was told not but it seems odd to me).

[Update: 22/11/2009] I have reported this issue as QC: 79705. [/Update]

Therefore as a workaround, I was forced to move this key generating method into a static class elsewhere in the assembly but maybe someone can work out a way around this limitation.

I also encountered an annoying trait of the Cirrus Framework which is that some errors produce a fairly unhelpful message and lead you to a line in the Project’s build file which whilst being logical can be infuriating when you’re presented with this:

A rather confusing exception and causal code identification.

After a tiny bit of tweaking, My next iteration of the Caching Attribute looks like this:

type
  [AttributeUsage(AttributeTargets.Method)]
  MethodCacheAttribute = public class(System.Attribute, IMethodImplementationDecorator)
  private
  public
    method HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
  end;

implementation

method MethodCacheAttribute.HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
begin
  // Get a Reference to our Result Value
  var methodResult := new ResultValue();

  // Get a reference to our Static Key Factory.
  var cacheKeyGen := Services.FindType('CirrusCachingAspect.CacheKeyFactory');
  // Generate our cache key from the method name and it's parameters
  var getCacheKey := new AssignmentStatement(new NamedLocalValue('cacheKey'), new ProcValue(new TypeValue(cacheKeyGen), 'GetKeyFromMethod', [aMethod.Name, aMethod.GetParameterArrayValue()]));

  // Get our CacheManager Type and our CacheFactory Type
  var cacheType := Services.FindType('Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager');
  var cacheFactoryType := Services.FindType('Microsoft.Practices.EnterpriseLibrary.Caching.CacheFactory');

  // Get a Reference to our Cache Instance.
  var getCacheInstance := new AssignmentStatement(new NamedLocalValue('methodCache'), new ProcValue(new TypeValue(cacheFactoryType), 'GetCacheManager'));

  // Get data from our cache.
  var getDataFromCache := new ProcValue(new NamedLocalValue('methodCache'), 'GetData', [new NamedLocalValue('cacheKey')]);

  // Cast our result from the Cache to the Result Type.
  var valueCastToResultType := new UnaryValue(new NamedLocalValue('cacheData'), UnaryOperator.Cast, aMethod.Result);

  // Assign the result of our cache request to a local variable.
  var getDataAssignment := new AssignmentStatement(new NamedLocalValue('cacheData'), getDataFromCache);

  // Assign our Cache'd data to the Method Result
  var useCacheData := new AssignmentStatement(methodResult, valueCastToResultType);

  // Add our data to the Cache for next time
  var addDataToCache := new StandAloneStatement(new ProcValue(new NamedLocalValue('methodCache'), 'Add', [new NamedLocalValue('cacheKey'), methodResult]));

  // Key not found in the cache, insert the original body and add a call to the Cache.Add() method.
  var notFoundInCache := new BeginStatement();
  notFoundInCache.Add(new PlaceHolderStatement());
  notFoundInCache.Add(addDataToCache);

  // If found in the cache.
  var ifCacheResult := new IfStatement(new BinaryValue(new NamedLocalValue('cacheData'), new NilValue(), BinaryOperator.Equal), notFoundInCache, useCacheData);

  aMethod.SetBody(Services,
    method begin
      var cacheData: Object;
      var methodCache: CacheManager;
      var cacheKey: String;

      // Get out cache instance
      unquote(getCacheInstance);

      // Generate a key for this method call.
      unquote(getCacheKey);

      // Try to retrieve the data from the cache.
      unquote(getDataAssignment);

      // If data from cache = nil then
      //    call original method
      //    add to cache
      // else
      //    return the data from the cache
      unquote(ifCacheResult);

    end);
end;

Which may look quite complex at first but when you look at the actual statements and values being passed around, you can quickly get a feel for how the code works. We can then easily apply this attribute and cache the result of any method in a class automatically like this:

type
  Flickr = public class
  private
    _username: string;
  public
    method Flickr(username: String);
    [Aspect:MethodCache]
    method GetPhotos: XmlDocument;
    [Aspect:MethodCache]
    method GetUsername: String;
    [Aspect:MethodCache]
    method GetAuthLevel(user: String): Integer;
  end;

Where GetPhotos, GetUsername and GetAuthLevel will all have their results cached automatically by our Aspect. You can see the resulting AOP’d code disassembled in the reflector below:

The RedGate .NET Reflector showing our Cirrus doctored caching code.

There is still one slight limitation in our method of key generation which is that it will currently only generate a unique key for a method with parameters if the Types of the methods parameters provide a proper implementation of ToString() that identifies them. Before you mention it, I had considered using the GetHashCode() method for this purpose but the default implementation of the GetHashCode method does not guarantee unique return values for different objects which makes it no more useful than relying on the user to implement the ToString() method.

I have made my implementation available on GitHub as the CirrusCachingAttribute where you can feel free to download and play with the source but please note that you will need to download and install the Enterprise Library from Microsoft first. I have also added a stub to the Code section on my site for the Cirrus Caching Attribute.

There is also a Standard Library of Aspects over on code.remobjects.com which provides a good set of Aspects from which you can learn more about how Cirrus works.

So, I decided to do something about it. Some of you might have seen some of the marvellous single purpose websites floating around the internet such as:

• Lets turn this f***ing website yellow
• Is the Apple Store Down?
• Do websites need to look the same in every browser?
• Is Lost a repeat?
• and Yet another useless website.

All are simple, single purpose websites, which generally do exactly what they say on the tin (or in the URL as is the case here) and as we know: The information they give must be true after all: “I read it on the internet, so it must be true”. So, late last night I got thinking..

May I proudly introduce to you, the Delphi community’s new and hopefully favourite single serving sites:

• www.isdelphidead.com
• www.isdelphidying.com

Next time you see someone on a forum, in the newsgroups or on stackoverflow asking the most dull and tedious of all the questions I could possibly hear: Is Delphi Dying? or Is Delphi Dead?,  point them to one of these sites.

Is Delphi Dead? Is Delphi Dying?

I should point out that the people who like to bring up this particular topic are normally quite persistent. In order to dissuade them from rehashing the same tedious and dull discussions time and time again I have cunningly built in an API.

People who are concerned that that answer might change without them being informed can build an application based on the API which spits out your choice of XML or JSON. This way, the aforementioned doom mongerers can simply build an application (in Delphi, of course) that sits in their tray and periodically polls the service and reassures those greatly concerned of the answer.

The API is very simple, you merely need to append

/API

to the isdelphidead.com or isdelphidying.com domain of your choice and then request either format by querying for XML (default):

/API?xml

or JSON:

/API?json

It’s that simple.  So go now and spread the word so that the rest of us can carry on in peace.

[Update 01/11/09]: Russian Delphi programmer Valerian Kadyshev has posted below to inform us that he has in fact made a tray monitoring application (in Delphi of course!) so that concerned people can download his pre-made one if they don’t even want to goto the trouble of making it themselves. You can find version 1 of his “Is Delphi Dying Monitor” over on his site. Marvellous Work Valerian!

Before you get too hasty with building your own class generators it’s also worth noting that Microsoft’s xsd.exe tool can also be used with Delphi Prism (thanks to Jeroen Pluimers and Peter Nowotnick for sharing this tip with us).

Getting Started

In Order to get started you’ll need to reference the RemObjects.Oxygene.CodeModel.dll and add the CodeDom namespace from this plus System.CodeDom to your uses.

It is worth noting that automated code generation is like our work with the Delphi Prism AOP Cirrus framework in that the code required to create a small amount of target output code can become quite hard to read at a glance so organise it well.

We’re going to start off by creating a basic class for Saying Hello (highly innovative you understand! ) and then generating the code and writing it to a new .pas file. Our basic first steps in generating a class involve setting up the unit (with a CodeCompileUnit), the namespace (with a CodeNamespace) and the class itself (with a CodeTypeDeclaration):

namespace CodeDomGeneration;

interface

uses
  System.Linq,
  System.Reflection,
  System.IO,
  System.CodeDom,
  System.CodeDom.Compiler,
  RemObjects.Oxygene.CodeDom;

type
  ConsoleApp = class
  public
    class method Main;
  end;

implementation

class method ConsoleApp.Main;
const
  outputFile = 'uMyClass.pas';
var
  uNewUnit: CodeCompileUnit;
  MyHelloNS: CodeNamespace;
  MyNewClass: CodeTypeDeclaration;
  provider: CodeDomProvider;

begin
  uNewUnit := new CodeCompileUnit;

  MyHelloNS := new CodeNamespace('Hello');
  MyHelloNS.Imports.Add(new CodeNamespaceImport('System'));

  MyNewClass := new CodeTypeDeclaration('TSayHelloClass');
  MyNewClass.IsClass := true;
  MyNewClass.TypeAttributes := TypeAttributes.Public + TypeAttributes.Sealed;
  MyNewClass.Comments.Add(new CodeCommentStatement('This is our CodeDom created class  '));

  MyHelloNS.Types.Add(MyNewClass);
  uNewUnit.Namespaces.Add(MyHelloNS);

  // Get our CodeDomProvider
  provider := CodeDomProvider.CreateProvider('Oxygene');

  // Options.
  var options: CodeGeneratorOptions := new CodeGeneratorOptions();

  // Create our output filestream.
  var sourceWriter: StreamWriter;
  sourceWriter := new StreamWriter(outputFile);

  // Generate our code.
  provider.GenerateCodeFromCompileUnit(uNewUnit, sourceWriter, options);

  // Close our output filestream
  sourceWriter.Close();

  Console.WriteLine('Press Enter to exit..');
  Console.ReadLine;
end;

end.

If you run this code, you’ll find a new uMyClass.pas file has been generated in the output directory which contains little more than a class shell and a couple of comments: One to note that the source file was auto-generated by a tool and another to which is our own comment on the TSayHelloClass. You’ll also note that unlike the previous article, we’re using:

 CodeDomProvider.GenerateCodeFromCompileUnit();   

To Generate code from the Code Document Object Model rather than the Compile method we used last time. You could also compile directly from a CodeDom object as alluded to in my previous post on Dynamically compiling Delphi Prism code using the CodeDomProvider.CompileAssemblyFromDom method.

The Next step is to add a private field (CodeMemberField) and a public property (CodeMemberProperty) to our class with its own getter and setter methods:

  var MyNameProperty: CodeMemberProperty;
  var MyNameField: CodeMemberField;

 // Add our private field.
  MyNameField := new CodeMemberField;
  MyNameField.Name := 'fFullName';
  MyNameField.Type := new CodeTypeReference('System.String');
  MyNameField.Attributes := MemberAttributes.Private;

  // Add the public property with a Getter and Setter
  MyNameProperty := new CodeMemberProperty;
  MyNameProperty.Name := 'FullName';
  MyNameProperty.Type := new CodeTypeReference('System.String');
  MyNameProperty.Attributes := MemberAttributes.Public;
  MyNameProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), 'fFullName')));
  MyNameProperty.SetStatements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), 'fFullName'), new CodePropertySetValueReferenceExpression()));

  // Add our two new objects to the parent code tree
  MyNewClass.Members.Add(MyNameField);
  MyNewClass.Members.Add(MyNameProperty);

It could very easy to get carried away creating an initialising your new class, methods, fields or properties and forget to .Add() them to the target CodeStatementCollection so if your new objects do not show up in the generated code, check that you have actually added them. We can now add a public SayHello method to our class which will greet the previously named entity:

  var MySayHello: CodeMemberMethod;

  // Our public method to say "Well Hi there <fFullName>"
  MySayHello := new CodeMemberMethod();
  MySayHello.Name := 'SayHello';
  MySayHello.ReturnType := new CodeTypeReference(typeof(System.String));
  MySayHello.Attributes := MemberAttributes.Public;
  MySayHello.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new CodePrimitiveExpression('Well Hi there '), CodeBinaryOperatorType.Add, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), 'fFullName'))));

  // Add our new method to the parent class.
  MyNewClass.Members.Add(MySayHello);

The Method statements that I have added here have been created on the fly and not been structured well for readability at all. As I mentioned at the beginning, you will need to structure your code carefully to ensure readability. If you run this code again now, you should see our SayHello Method as below:

method TSayHelloClass.SayHello: System.String;
begin
    exit(('Well Hi there ' + self.fFullName));
end;

You can also add statements from “snippets“, which allows you to essentially inject code as a string using the CodeSnippetExpression class:

  var snippetSayHelloMethod:  CodeSnippetExpression  := new CodeSnippetExpression('Result := Self.fFieldName');
  //Convert the snippets into Expression statements.
  var stmtSayHelloResult: CodeExpressionStatement := new CodeExpressionStatement(snippetSayHelloMethod);
  // Add it to our SayHello Method
  MySayHello.Statements.Add(stmtSayHelloResult);

Warning: Adding method statements from snippets in this manner should be used with great care as you have very little protection against a typo causing a mal-formed code output and I would not recommend generating complex code statements from the CodeSnippetExpression.

There is a Code object representation of anything that you could want to generate, you simply need to find the right class. For example, if we wanted to add a class entry point to our class then we could create one with the CodeEntryPointMethod class:

  var MyMain: CodeEntryPointMethod := new CodeEntryPointMethod();
  MyMain.Name := 'Main';
  MyMain.Attributes := MemberAttributes.Public + MemberAttributes.Static;
  var cs1: CodeMethodInvokeExpression  := new CodeMethodInvokeExpression(
        new CodeTypeReferenceExpression('System.Console'), 'WriteLine',
        new CodePrimitiveExpression('Hello World!') );
  MyMain.Statements.Add(cs1);

  MyNewClass.Members.Add(MyMain);

Conclusion

The System.CodeDom space is a very very powerful tool and one that developers used to developing native Win32 Delphi might not be aware of. You will probably be able to dream up of a number of cases where generating some of your Delphi Prism code dynamically could save you time. Use it wisely.

It is my intention that this post should introduce you to the process of dynamically compiling code and that the next part will hopefully be an introduction to the process of dynamically generating and compiling code using the .NET CodeDom.

To begin with, create a New Console Application in Delphi Prism and Add a Reference to the RemObjects.Oxygene.CodeModel assembly. For my installation, this was found in the Bin directory of the Delphi Prism program files directory.

Once you’ve done this you can use the following code:

namespace DynamicCompilation;

interface

uses
  System.Collections,
  System.CodeDom.Compiler,
  RemObjects.Oxygene.CodeDom;

type
  ConsoleApp = class
  public
    class method Main;
  end;

implementation

class method ConsoleApp.Main;
var
  provider: CodeDomProvider;
  strFileOut: string;
  results: CompilerResults;
  cp: CompilerParameters;
  strSource: String;
begin

strSource := "namespace HelloWorld;

interface

type
  ConsoleApp = public class
  public
    class method Main;
  end;

implementation

class method ConsoleApp.Main;
begin
  Console.WriteLine('Hello World.');
end;
end.";

  // Get our CodeDomProvider
  provider := CodeDomProvider.CreateProvider('Oxygene');

  cp := new System.CodeDom.Compiler.CompilerParameters;
  cp.CompilerOptions := '';
  // Defaults to false which creates a dll instead.
  cp.GenerateExecutable := true;
  strFileOut := 'C:\test.exe';
  cp.OutputAssembly := strFileOut;

  // Compile our code.
  results := provider.CompileAssemblyFromSource(cp, [strSource]);

  Console.WriteLine('Number of Errors Encountered: {0}', results.Errors.Count);
  for error: CompilerError in results.Errors do
      begin
        Console.WriteLine('{0}: {1}', [error.ErrorNumber, error.ErrorText]);
      end;
  if (Assigned(results.PathToAssembly)) then
     begin
       Console.WriteLine('Path to Assembly: {0}', results.PathToAssembly);
     end;

  Console.WriteLine('Press Enter to exit..');
  Console.ReadLine;
end;

end.

Our Test Console Output

This code should be fairly straight forward to understand but there are a few parts that are worth drawing attention to. The first is this line:

provider := CodeDomProvider.CreateProvider('Oxygene');

I originally tried to create a new instance of the RemObjects.Oxygene.CodeModel.OxygeneCodeProvider as you can when creating a CSharpCodeProvider:

            var provider_options = new Dictionary
                         {
                             {"CompilerVersion","v3.5"}
                         };
            var provider = new Microsoft.CSharp.CSharpCodeProvider(provider_options);

However in my experience calling the constructor on the OxygeneCodeProvider class merely causes a Null Reference Exception when you actually try to use a Compile method on the resulting class. It is worth noting that by replacing the string ‘Oxygene’ above with ‘VisualBasic’ or ‘CSharp’ you can obtain an instance of other language providers.

The next part worth paying careful attention to is the setup of the CompilerParameters:

  cp := new System.CodeDom.Compiler.CompilerParameters;
  cp.GenerateExecutable := true;
  strFileOut := 'C:\test.exe';
  cp.OutputAssembly := strFileOut;

This part of the code, configures the Provider to generate an executable instead an assembly (which is the default configuration) and tells the Provider where to output the resulting executable. This should be relatively straightforward and for a full reference of CompilerParameters – see the MSDN documentation on System.CodeDom.Compiler.Compilerparameters.

Those sharp-eyed amongst you may have noticed that the code that I’m compiling above does not contain any uses declarations. First we need to Reference the relevant assemblies using the CompilerParameters.ReferencedAssemblies StringCollection:

  cp := new System.CodeDom.Compiler.CompilerParameters;
  // Clear our Assembly List
  cp.ReferencedAssemblies.Clear;
  // Add a few usual suspects
  cp.ReferencedAssemblies.Add('System.dll');
  cp.ReferencedAssemblies.Add('System.Core.dll');

You can then “uses” any namespace in the referenced assemblies (be careful: There is no official .NET assembly called System.Linq.dll for example).

The final part which is worth drawing attention to is the actual compile command:

   results := provider.CompileAssemblyFromSource(cp, [strSource]);

For reference, the relevant parts of the declaration for a CodeDomProvider might look something like the following:

public CodeDomProvider = class abstract(Component)
    public function CompileAssemblyFromDom(options: CompilerParameters; [ParamArray] compilationUnits: CodeCompileUnit[]): CompilerResults; virtual;
    public function CompileAssemblyFromFile(options: CompilerParameters; [ParamArray] fileNames: string[]): CompilerResults; virtual;
    public function CompileAssemblyFromSource(options: CompilerParameters; [ParamArray] sources: string[]): CompilerResults; virtual;

You can feed the CompileAssemblyFrom methods several different files, strings, or Dom structures which might represent different .pas files that you would create when you created a project in Delphi Prism. The example below includes an additional class:

namespace DynamicCompilation;

interface

uses
  System.Collections,
  System.CodeDom.Compiler,
  RemObjects.Oxygene.CodeDom;

type
  ConsoleApp = class
  public
    class method Main;
  end;

implementation

class method ConsoleApp.Main;
var
  provider: CodeDomProvider;
  strFileOut: string;
  results: CompilerResults;
  cp: CompilerParameters;
  strSource: String;
begin

strSource := "namespace HelloWorld;

interface

type
  ConsoleApp = public class
  public
    class method Main;
  end;

implementation

class method ConsoleApp.Main;
var
  PingPong: TPingPong;
begin
  PingPong := new TPingPong;
  Console.WriteLine(PingPong.Ping);
  Console.WriteLine('Hello World.');
end;
end.";

var strSource2 := "namespace HelloWorld;

interface

type
  TPingPong = public class
  public
    method Ping: string;
  end;

implementation

method TPingPong.Ping: string;
begin
  Result := 'PONG!';
end;
end.";

  // Get our CodeDomProvider
  provider := CodeDomProvider.CreateProvider('Oxygene');

  cp := new System.CodeDom.Compiler.CompilerParameters;

  cp.CompilerOptions := '';
  // Defaults to false which creates a dll instead.
  cp.GenerateExecutable := true;
  strFileOut := 'C:\test.exe';
  cp.OutputAssembly := strFileOut;

  // Clear our Assembly List
  cp.ReferencedAssemblies.Clear;
  // Add a few usual suspects
  cp.ReferencedAssemblies.Add('System.dll');
  cp.ReferencedAssemblies.Add('System.Data.dll');

  // Compile our code.
  results := provider.CompileAssemblyFromSource(cp, [strSource2, strSource]);

  //Console.WriteLine('Generated assembly name: ' + results.CompiledAssembly.FullName);
  Console.WriteLine('Number of Errors Encountered: {0}', results.Errors.Count);
  for error: CompilerError in results.Errors do
      begin
        Console.WriteLine('{0}: {1}', [error.ErrorNumber, error.ErrorText]);
      end;
  if (Assigned(results.PathToAssembly)) then
     begin
       Console.WriteLine('Path to Assembly: {0}', results.PathToAssembly);
     end;

  Console.WriteLine('Press Enter to exit..');
  Console.ReadLine;
end;

end.

And voila.. the output from our dynamically compiled executable can be seen as below:

The output from our dynamically generated executable

If the other compiler methods available with our CodeProvider caught your eye then this leads me nicely onto my intended next steps. While generating code from a string containing your code is nice and easy, sometimes it may not be the best way to approach Code Generation.

I realise that the end result of the above could have been achieved by simply writing a file out and then executing the command line compiler but where’s the fun in that? Next time I intend on looking at generating a CodeDom tree and providing this to the Compiler (no more potentially troublesome string manipulation required).

I would probably describe it more as a nuisance than malicious because of it’s limited payload but worth keeping an eye on. I wonder about the motives of it’s author.

For full details see the F-Secure blog post titled 0wn1ng Delphi.

Now to me, if you’re still using Delphi versions 4-7 then you can now promptly rush into your Boss’s office and use that magic word: “security” as an excuse to get approved budget to upgrade yourself to the upcoming Delphi 2010, which looks to contain a whole bunch of fantastic features and upgrades.

[Update: Apparently the problem was initially discovered by the Russian programmer who runs the Russian Language Gunsmoker blog.]

LangPop.com - Yahoo Search Results - Searches took the form "language programming"

What is different about LangPop, however, is the other graphs that it presents later on which searches different data sources and tries to present different angles of a particular programming language community. For those who like their summaries like an icicle, cold and to the point: Delphi doesn’t appear to pull the weight we owe it in certain areas.

What does this all mean?

Absolutely Nothing much but also something.

Absolutely Nothing Much?

This is not a popularity contest, nor should it be. Critics of the data sampling methods used in on LangPop and the TIOBE index can argue that they are inaccurate, flawed, biased and any number of other ways of describing why the data should not be relied upon. In the end, the business case for the language used in your projects can only be considered by you based on a huge number of project specific factors and whilst this chart can hint at an economic condition it can also be argued to be a fairly superficial reason amongst others. These charts didn’t change the way I saw any one particular language.

But also something?

What interested me about this particular page wasn’t where Delphi was ranked in comparison to other languages but where it ranked in comparison to itself when compared to the other sources of data. By looking at Data sources where Delphi programming has slid a long way down or up when compared with the nominal position that both TIOBE and the initial chart on LangPop.com (Roughly 11th) we can see where the Delphi is lacking in the eyes of an outsider who has no experience with the Delphi community.

This means that we can effectively see in what areas Delphi maintains a low profile (and can be improved). These are the areas where maybe with some improvement we could begin to lure new programmers, fresh blood and begin to change the perception of Delphi. Lets look at the other data sources presented in these charts:

Craigslist: Used to search for job availability specifying a certain language. Arguments aside over Craigslist not being representative of the job market. At least it’s occasionally used to post some seriously funny job listings. Delphi produces a disappointing score on this test and slips below Assembly, Shell Scripting and Cobol. There must be better data on the number of Delphi jobs out there so I’m not too focussed on this.

Slips -7 places.

Amazon: Used to assess the number of books written about a particular language. Delphi appears to have relatively few books, especially when compared to languages that are both younger and older, languages that jump up the list here include Fortran, Cobol and Ada. As anecdotal backup for this: the number of Delphi books released each year in the past 10 years seems to be in decline.

Slips -7 places.

Google Code & Freshmeat: Used to assess the volume of Open Source projects created with a language. Before this I had a mis-guided impression that there was a relatively small number open source projects using Delphi but on Google Code Delphi actually holds it’s own nicely. I attribute the slip in its form on the Freshmeat comparison because Freshmeat declares itself to be an index of Unix and cross-platform software (which Delphi isn’t really cut out for just yet – but will be).

Equal & Slips -7 places respectively.

Del.icio.us: Gives us an indicator of what programmers are bookmarking and therefore indicates a rough measure of how interesting and “desirable” a language is. This is where the table of results differed most from the index TIOBE results. Delphi programmers are clearly not adopting social-bookmarking tools because this is we see that the number of Delphi bookmarks is disappointingly low (I’m doing my part, fwiw). You can’t read too much into this measurement except that it also indicates that not many people outside the Delphi community bookmark & tag delphi links (whereas many up and coming languages are researched by people wanting to learn it).

Slips 10 places.

Ohloh: Olhloh provides information and statistics about various open source projects and the developers that contribute to them. On Ohloh Delphi appears to be underrepresented and it is here that Olhloh actually measures more registered developers contributing to Pascal Projects (such as Lazarus and fpc) than Delphi developers. This doesn’t necessarily mean that there are more pure Pascal developers than Delphi developers but that there are more Pascal developers contributing to large open source projects.

Slips 7 places.

There are also other measurements such as the number of times it is mentioned on programming.reddit.com and Slashdot where it represents almost a zero presence in the selection of languages that they’ve chosen to sample.

LangPop.com - programming.reddit.com Results

This might be linked to the same reason why it doesn’t rank highly in the del.icio.us index either. Delphi also appears to be under represented in the FreeNode IRC network chart as well being pitifully under represented in the “Normalized Discussion Site” results (although it’s interesting to note that they don’t mention which discussion sites they monitor). IRC use in general could be considered to have experienced better days but I have spent a lot of time helping in the #delphi room of a  Top 5 IRC network and would always love to see more people sharing and helping others.

[Updated 9th July: Dave Welton from LangPop.com has since notified me in a comment below that the Normalised Discussion Site results are a combination of the section with  programming.reddit.com and slashdot etc. My fault!]

Should we be concerned?

No. There are good reasons why some of these measurements do not accurately represent the picture that they claim to portray. It does give us food for thought because this represents how outsiders see the Delphi community and the Delphi Language as a whole. It is interesting though, why do we have an apparent shortage of Delphi Programming books being published? Although some authors are still producing excellent books (such as the Delphi 2009 HandBook by Marco Cantu which you can currently get for free if you buy or try Delphi 2009) there does appear to be a very small number published in the last few years. I’m not sure why this is, I’ve always thought that there is certainly room for a several books on Delphi 2009, Delphi Prism and I personally would like to see a book solely on recipes for Delphi Prism Cirrus Aspects.

What of the open source projects? As a commercial tool Delphi isn’t a terribly good offering for open source projects at present which might explain why it doesn’t feature that strongly in Open source offerings. I’ve long campaigned for a renewed focus on the Turbo Delphi’s or Delphi Personal editions for exactly this reason.

I did find it interesting that as a community we seem to be quite bad at making “noise” in bookmarking sites, programming news sites and discussion boards leading those outside the community to believe that Delphi Developers are fewer in numbers than they actually are. Some may scorn these as useless activities however I do feel that general publicity, interesting news, projects and cool links do have a huge impact on how outsiders view a language community. I do also feel that the planned releases of Delphi containing Cross platform Delphi and 64 Bit Delphi will pull Delphi back up on these metrics as it begins to be used in new and interesting ways.  I’m not sure if it’s just me but I have noticed a renewed vigour in the Delphi community of late.

What now?

Personally, I feel that the Delphi Community is beginning the fight back, with more high profile projects, more unusual projects and fresh users are increasingly making the case for Delphi (and we’re also seeing some great evangelism posts from within the community, not to mention great new initiatives like Delphi Podcasts). The kind of community growth that will highlight delphi to an outsider can only be built organically with hard work and we can take small steps to begin on that path. Delphi itself is also in great hands, it seems to me to be going from strength to strength since CodeGear splitting away from a certain troubled parent company that rhymes with Morland. Think about this: In the last 12 months we’ve seen significantly revived confidence in the community, A superb .NET offering with Delphi Prism and news of a renewed attack force with Cross Platform Delphi and 64-Bit Delphi applications for extra-strength apps.

What do you think of my reaction to these graphs? What other ways can we, the community, evangelise Delphi and change an unfamiliar programmers perspective of Delphi and the Delphi Community? What makes you excited about a particular language? (in both a professional and a personal setting)

And to pre-empt the inevitable naysayers out there: Delphi is neither dead nor dying.

Why would you need  to use AOP?

Many people don’t really understand why they would need to use AOP in any way. It’s true that nearly all programming paradigms support some form of separation and modularity but to see where this can quickly fall down, you simply have to look at the classic logging example which has been the staple diet of coverage of the Cirrus framework. Logging is a good example because it is likely that if your application implements logging features, then you probably have logging code mixed up in your beautifully designed business objects at various places tainting the implementation of your once clean object.

A Simple Example

For the purposes of those people who weren’t convinced on it’s usefulness from the example given. Imagine we have a very important Business object of a Type called TCustomer. We’ve been told that we need to log everything done to our Customer objects for audit purposes (and you wouldn’t want to get on the wrong side of the Internal Audit team..).  We could easily add our logging calls into every function of TCustomer but this going to require a lot of CTRL+C, CTRL+V and is a lot of identical code-repetition and shouldn’t we be striving to avoid code repetition? This might also get your local overly-sensitive Anti Copy-Paste mafia up in arms. There is another problem with simply inserting our code into each method: What happens if later on, another programmer adds another method for updating, deleting or even just saving a copy of our Customer. Internal Audit are not going to be happy. Of course, you could blame it on your inexperienced colleague but that’s not going to make much difference, it’s a team failure after all.

Had we used AOP we could have used something as simple as the Cirrus Introduction LogToMethod code, tagged our TCustomer class with a single attribute and been saved from this potential oversight:

// For the full code for this example, please see the original introductory tutorial at:
// http://prismwiki.codegear.com/en/Cirrus_Introduction
namespace MyLogToMethodAspect;

interface
uses
  RemObjects.Oxygene.Cirrus;

type
  [AttributeUsage(AttributeTargets.Class or AttributeTargets.Struct)]
  LogToMethodAttribute = public class(System.Attribute, IMethodImplementationDecorator)
  public
    [Aspect:AutoInjectIntoTarget]
    class method LogMessage(aEnter: Boolean; aName: String; Args: Array of object);

    method HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
  end;

implementation

class method LogToMethodAttribute.LogMessage(aEnter: Boolean; aName: String;
  Args: Array of object);
begin
  if aEnter then
    Console.WriteLine('Entering ' + aName)
  else
    Console.WriteLine('Exiting ' + aName);
end;

method LogToMethodAttribute.HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
begin
  if String.Equals(aMethod.Name, 'LogMessage',
    StringComparison.OrdinalIgnoreCase) then exit;
  if String.Equals(aMethod.Name, '.ctor',
    StringComparison.OrdinalIgnoreCase) then exit;

  // Cool use of anonymous methods here....
  aMethod.SetBody(Services,
    method begin
      LogMessage(true, Aspects.MethodName, Aspects.GetParameters);
      try
        Aspects.OriginalBody;
      finally
        LogMessage(false, Aspects.MethodName, Aspects.GetParameters);
      end;
    end);
end;

end.

Of course, you don’t need Aspect Oriented Programming in the same way as you don’t need Object Oriented Programming, we could just revert to procedural programming but as programmers we strive to separate various concerns cleanly and this is another step towards that.

What’s the catch?

The problem with separating our code in such a way is that potentially, it could be hard for a programmer unfamiliar with AOP to understand the code as the only clue of any logging activity for our target class might be a single attribute in our interface section. Our Aspect might also rely upon the underlying method in which case we could run into problems if we restructure or  move our methods around causing unintended consequences. There is also a concern that a serious bug in our Aspect code could lead to a more widespread failure in the program (as it has the potential to be applied to large swathes of code easily).

However, with careful testing and implementation these potential drawbacks can be mitigated.

Apart from Logging, what else can I use it for?

Typical uses include logging, authentication, caching and dependency injection. John Moshakis has been blogging some elegant real-life uses of the Cirrus framework such as Implementing Dependency Injection, allowing him to switch seamlessly between test and production services in an app.

My Own Journey to AOP

After the Cirrus Framework was released I wanted to try to build my own Aspect which wasn’t the logging sample provided. I had a service that retrieved a string of XML from a REST Web Service at frequent intervals which I felt could be improved with caching functionality. The Code for the Web Service and for the Cache were just test classes for the purpose of this experiment but I would imagine that you could extend this to use the The Caching Application Block from the Microsoft Enterprise Library if you wished. Normally, I could add caching to each method by modifying it like so:

method TFlickr.GetUserInformation(username: String): String;
begin
  // Do we have this information in our cache?
  if (MyCache.HasData('UserInfo_' + username)) then
  begin
    // We do, use the cache'd data.
    Result := MyCache.GetData('UserInfo_' + username);
  end
  else
  begin
    // No cache'd version, retrieve a new set of data.
    { Open our TCP Socket, call the webservice with the
      correct parameters and return the result.     }
    // Add our newly retrieved data to the cache.
    MyCache.SetData('UserInfo_' + username, Result);
  end;
end;

This method of implementation would lead to me having to put this code into each method and would lead to code repetition and possibly bugs being introduced (for example, if I forgot to update the cache key string on one method). I wondered if I could have a CacheString attribute that would allow me to automaticaly add my generic “do we have cache’d data? if so use it else carry on”  code to each method.

First of all, I tried essentially moving this code into a Method Aspect and adding a generic key function which takes the method name and method arguements and turns it into a consistent string using the Aspects.MethodName and Aspects.GetParameters methods:

WARNING! BROKEN CODE:

class method MyCache.getKeyFromMethod(aName: String; Args: Array of object): String;
begin
  var argConcat: String;

  argConcat := aName;
  for argTemp: String in Args do
  begin
    argConcat := argConcat + argTemp;
  end;

  Result := argConcat;
end;

method MyCacheAttribute.HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
begin
  aMethod.SetBody(Services,
    method begin
	  var cacheKey := MyCache.getKeyFromMethod(Aspects.MethodName, Aspects.GetParameters);
	  // Do we have this information in our cache?
	  if (MyCache.HasData(cacheKey)) then
	  begin
		// We do, use the cache'd data.
		Result := MyCache.GetData(cacheKey);
	  end
	  else
	  begin
        Aspects.OriginalBody;

        // Send the result of the Original Method to the Cache for next time.
        MyCache.setData(cacheKey, Result);
      end;
    end);
end;

Unfortunately it is not quite as simple as just placing your code into the AMethod.SetBody Anonymous method. Luckily it turned out that the Cirrus documentation on the Wiki had recently been updated and I discovered the Cirrus Statements and Cirrus Values namespaces after a bit of helpful guidance from John Moshakis on StackOverflow and Twitter (thank-you for that John!). I discovered that what you are required to do in most cases is to construct your code in an almost compiler like fashion using the Statement and Values namespaces.

Eventually after playing around with the Cirrus API, I eventually ended up with the following code:

method MemCacheAttribute.HandleImplementation(Services: IServices; aMethod: IMethodDefinition);
begin
  // Get a Reference to our Result Value
  var newResult := new ResultValue();

  // Get our MemCache Object
  var cacheType := Services.FindType('AOPCacheLibrary.MyCache');
  // Setup our static methods.
  var getDataProc := new ProcValue(new TypeValue(cacheType), 'getData', [new NamedLocalValue('cacheKey')]);

  // Assign the result of our cache request to a local variable.
  var getDataAssignment := new AssignmentStatement(new NamedLocalValue('strData'), getDataProc);

  // CACHE DATA USED: To assign our Cache'd data to the Method Result
  var useCacheData := new AssignmentStatement(newResult, new NamedLocalValue('strData'));
  // CACHE DATA NOT USED: To assign the result of our OriginalBody to the Method Result.
  var useOriginalMethodResult := new AssignmentStatement(new NamedLocalValue('resultOriginal'), newResult);

  aMethod.SetBody(Services,
    method begin
      var strData: String;
      // Get our Cache Key Name
      var cacheKey := MyCache.getKeyFromMethod(Aspects.MethodName, Aspects.GetParameters);

      try
        // See if we have anything in the cache for this key.
        unquote(getDataAssignment);
        // Replace this
        unquote(useCacheData);
      except
        on E: Exception do
        begin
          var resultOriginal: String;
          // No cache data found, execute the original method body.
          Aspects.OriginalBody;

          // Assign the result of the Original Method to a new variable.
          unquote(useOriginalMethodResult);
          // Send the result of the Original Method to the Cache for next time.
          MyCache.setData(cacheKey, resultOriginal);
        end;
      end;
    end);
end;

According to the Red Gate .NET Reflector and Disassembler, this produces the following code:

    function TFlickr.GetUserInformation(username: String): String;
    var
        Result: string;
    begin
        cacheKey := MyCache.getKeyFromMethod('GetUserInformation', New(array[1] of TObject, ( ( userid ) )));
        try
            Result := MyCache.getData(cacheKey)
        except
            on E: Exception do
            begin
                // This is where we do our _ORIGINAL_ function
                resultOriginal := Result;
                MyCache.setData(cacheKey, resultOriginal)
            end
        end;
        begin
            Result := Result;
            exit
        end
    end;

This means that I can now add caching to any of my string returning web service methods in my class by simply tagging the methods that I want cached with a code attribute:

  TFlickr = public class
  private
	{code}
  public
    {more code etc, etc}
    [Aspect:MyStringCache]
    method TFlickr.GetUserInformation(username: String): String;
  end;

This works perfectly but there are a few problems with this code:

• As you can see: constructing statements using the Cirrus API (in the statements before the aMethod.setBody) doesn’t exactly make for readable code. You may wish to consider outlining each statement with psuedocode so that it is clearer at a glance what the API calls produce.
• I should be using the Cirrus Procedure Value calls for all three calls to the Static “MyCache” class but am not because I couldn’t quite get this working. Please be aware that John informs me that the method I use in the first and third instance is not the correct way to go about this.
• This exact method only currently works for System.String returning methods. There must be a way of abstracting this function to apply it to almost a method returning almost any type (if anyone has any suggestions about how this might be accomplished then, by all means post a link in the comments).

Please note that the code above is NOT intended to be a reference implementation for AOP or Application Caching but is merely intended to show you my own learning path with Cirrus and AOP. The Cirrus API is quite difficult to work with at first and can give you frustrating compiler errors but it’s worth keeping an eye on the documentation pages and as more examples appear online it will become easier to work with. You should have the Red Gate .NET Reflector on hand with its disassemble function to confirm exactly what the resulting code in your Output assemblies looks like.

If you have any constructive suggestions for my code above then please let me know. Additionally, if you think it would be useful for me to post the downloadable Delphi Prism project then please also let me know in the comments below.

Starting your own journey to Cirrus/AOP

• Delphi Prism Wiki – Cirrus Documentation – The Definitive Reference.
• Jim McKeeth’s DelphiLive! Presentation on AOP – A Good Introduction and Overview to AOP.
• Delphi Prism Wiki – Cirrus Introduction – An Introductory guide to Cirrus and AOP that will guide you into building the logging example shown in this post.
• John Moshakis’s Blog - Some Excellent Examples of real applications of the Cirrus Framework.

Did you see it? ..ISVs, VARs, Consultants and Hobbyists.. I jumped at the phrase and asked Jim whether any of the Product Roadmaps he’d seen at DelphiLive had revealed any plans for a renewed focus on Turbo or Hobbyist editions of Delphi however it seems that they did not specifically mention anything. Luckily Jim had noticed the significance of this typo phrase too and was kind enough to pose my question to the new Delphi Product Manager, Michael Rozlog:

I should make it entirely clear that this should not be read as a statement of intent from Michael or Embarcadero but merely an indication of Michael’s personal thoughts on Turbo or Personal Delphi editions. This is encouraging news though, as many of you will know I wrote a long Open letter to Codegear on the subject of the sadly neglected Turbos and received a lot of feedback indicating that many of you felt the same way.

So what now?

Personally I’m thrilled that there seems to be at least some internal support for a renewed Turbo or Personal Delphi Edition but as usual, the devil is in the detail, How can we get a great home/hobbyist product (as opposed to a crippled and essentially useless product) without costing Codegear precious sales/revenue?

There are several different facets to this problem:

• What type of audience is the product is actually targetting? (Home users, Small ISVs, commercial vs strictly hobbyists?)
• How should product be limited for that audience without damaging it’s viability or sales of the full product (As Delphi’s fate is intertwined with that of Codegear – not something we want).

There are three different potential products in my mind:

1. A Purchasable Commercial Product which is essentially a step down from Delphi Professional SKU in both price and features made for smaller software shops and developers that don’t need the features of the full versions.
2. A Non-commercially licensed product equivalent to the educational edition (which If I remember correctly is the Professional SKU?) where the price is a token amount to cover the cost of the bandwidth and packaging cost of the product.
3. A Commercially licensed but absolutely free product which is crippled in its functionality and features even more than the current Turbo Explorer Editions.

As you might have guessed from my use of mildly emotive language in the 3rd point above and in my Open Letter to Codegear regarding the Turbos I consider the 3rd Option to be a non-offering. Sadly, previous statements from the former Delphi Product Manager, Nick Hodges, hinted that this was also the way he felt it might go.

I would be interested to see how the previous editions of Delphi impacted Sales (there must be paperwork, come on?) as I felt that these were always an amazing offering for Hobbyists and Home users wanting to take up the language (I remember finding Delphi 6 Personal on a magazine cover disc – presumably thanks to the always excellent Tim Anderson).

I would ideally like to see something in between the 2nd and 3rd options option a reality, I am not qualified to make a factual assertion on this but I don’t think it would hurt sales if strictly limited to non-commercial use in the license. Massive Feature limiting such as removing the ability to use 3rd Party VCL components as the Turbo Editions persued removes some of the most well-known and advantageous reasons for using Delphi in my opinion and is therefore unsuitable for an ambassador product (which these editions would be). I won’t rehash my argument about why the product needs to be both free and well featured (see my Turbo Delphi Open Letter) but I will say this:

Whether it is fair or not, Microsoft and the Eclipse foundation have forced their hand – a reasonably useful free IDE for home and hobbyist users wanting to experiment with a language is now a minimum requirement for competitiveness in the programming language market.

It is worth noting that the Updated Personal or Turbo delphi is currently only number 8 on the list requests at the Delphi Uservoice page, we really need people to vote for it and also to discuss their thoughts on the potential product in the comments over there.

Michael suggested that he was looking for feedback, so I’m looking for feedback. Firstly: What would your Turbo or Personal Product look like and secondly: what would you do if you were the Delphi Product Manager? How do the results of these two views differ? Please think about it and then either put it in the comments below or on the Delphi Uservoice page.

Jim is planning another session for the DelphiLive conference (which I really wish I could go to, check it out if you haven’t already). However when running the last tournament we encountered a number of fatal bugs in the .NET UT3 Bot library which was originally put together by Andy Sterland & James Lissiak. As a result Jim and I had been discussing the idea of porting the original library to Delphi Prism so that we could fix a few of the more serious bugs, it would also allow potential Prism Developers who were not familiar with C# to dig into the library itself. This is a project conversion diary which will outline the approaches I tried, any hurdles I encountered and a few tips for trying to avoid them when converting your own project.

I started by running the C#ToOxygene Tool on all of the source files within the project, It’s a very simple and easy to use tool that as its name implies aims to convert C# source files to Delphi Prism files. I was able to run the tool without issue on every C# source file except for 3 where for some reason it exited producing the error:  ”Error during processing: Index was out of range” (Issue logged (rather clumsily) as #37).

Having started on the basics of the translation using the conversion tool to do the grunt work I then dived into the code with the Prism Wiki and MSDN C# documentation open to make a start on correcting the 600-odd errors that the resulting project produced upon an attempted Build.

At first glance I felt that the resultant code was a little bit visually “messy” in places and I felt it might be easier to prettify the code using a Code Formatter such as the JEDI Code Format tool to clean up the auto generated code and highlight any mismatched parenthesis or similar errors. However unfortunately the JEDI tool is not compatible with Prism and therefore refused to help me. If anyone knows of a Code Formatting tool which is compatible with Delphi Prism then please let me know in the comments below.

A few other issues which I encountered with the generated code or more generally are outlined below:

Internal Keyword

The C# internal (msdn doc) keyword was not correctly translated – for this I took a trip to the Prism Wiki and looked up the Class Member Visibility Levels page to find that the equivalent level assembly is listed there (Issue #42). Note that in Delphi Prism you can also have assembly or protected or assembly and protected depending upon whether you wish the class to be visible to descendants.

The C# “this” Keyword

The C# this. (msdn doc) keyword was not correctly translated to the Delphi Prism Self. equivalent that we’re all accustomed to. This isn’t hard to spot when going through the generated code and the issue had already been logged by Anton Kasyanov (Issue #39) and should be fixed shortly.

Float Types

One class made extensive use of the float type (msdn doc) which doesn’t exist as is a built-in type for Delphi Prism so you’ll need to convert it to one of the two Float types depending upon the precision you require.

Operator Overloading

Operator Overloading is not something that Delphi developers may be traditionally used to but Delphi Prism supports this nicely. However instead of using the sign operator that C# Developers use you’ll need to lookup the operator name and declaration on the Operator Overloading Wiki Page. eg. The Equals operator is declared as so:

class operator Equal(obj1, obj2: UTIdentifier): boolean;

Differences between return, Result and exit

This should be obvious to any C# Developer but it could be easy to forget about. Don’t forget that the return C# method (msdn doc) terminates execution of the method in which it is being executed and returns to the calling method and therefore be wary of using Result blindly in an identical manner, particularly with boolean statements that rely upon this fact. Eg. Consider the following C# Code:

public override bool Equals(object obj)
{
	if (obj is UTVector)
	{
		if (this._x == ((UTVector)obj)._x &&
			this._y == ((UTVector)obj)._y &&
			this._z == ((UTVector)obj)._z)
		{
			return true;
		}
	}
	return false;
}

Clearly, if you simply replace the return false; with Result := False; you will end up with a method that always returns False because the expression will always be executed no matter what Result is set to earlier in the method. In this case I simply moved the Result := false; to the top of the method. Delphi Prism also supports the Exit keyword which also allows you to Return a result parameter. This method is a lot closer to the C# return keyword and usage but the Exit page on the Prism Wiki warns against using too many exit keywords to avoid making the code harder to maintain.

Constructors are not named

This is a rare example of where the original C# code actually looks much closer to the end Delphi Prism code than a traditional Delphi programmer might think. In C# you might have a class and constructor that might look like this:

public class UTIdentifier
{
	internal UTIdentifier(string Id)
	{
	}
}

In Prism, we have nameless constructors which means that the equivalent Delphi Prism constructor implementation might look like this:

  constructor UTIdentifier(id: String);
  begin
  end;

It is important to note that in your class interface should adhere to this rule too. eg constructor(id: String);

This was something that the C#ToPas tool also generated incorrectly. (Issue #44)

Short-Circuit Boolean Expressions

I came across the C# || operator which performs a short-circuited OR boolean evaluation of the operands. I wasn’t sure that the Delphi Prism or operator produces the same behaviour but if I read the Expression Evaluation page correctly then I believe it does (In Delphi 2009, at least, this behaviour is set through the {$B+/-} compiler flag) .

Event Assignment

The Event Assignment routine for multicast delegate type events is slightly different in Delphi Prism from what we’re used to in Delphi Win32. Looking at the Event Assignment page in the wiki we can see that the actual method for assignment is much closer to the C# equivalent and uses the same C# += and -= operators. The C#ToPas tool converted this code a little too literally converted this C# code:

this._connection.OnDataReceived += new EventHandler(DataReceived);
this._connection.OnErrorOccurred += new EventHandler(ErrorOccurred);

to this:

Self._connection.OnDataReceived := Self._connection.OnDataReceived + new EventHandler(DataReceived);
Self._connection.OnErrorOccurred := Self._connection.OnErrorOccurred + new EventHandler(ErrorOccurred)

Which produces a compiler Error that Events in Delphi Prism don’t allow access to the underlying field. You should use the += operator instead as seen on the Wiki. (C#ToPas Issue logged as Issue #45).

UPDATE: I’ve just noticed (after logging my own issue) that the event assignment issue has already been reported and has been marked as Won’t Fix (Issue #27) so it looks like you’ll need to check _every_ event assignment in your project manually.

Switch and Case Statements

The C#ToPas tool did not appear to react well at all to use of the C# switch and case statements. I can’t give you any specific advice on how to fix these because each case statement was generated slightly differently in my converted code and therefore I can only advise that you check these manually or rewrite each of these methods by hand.

Reserved Keywords

Sadly this isn’t an issue that is related to the C#ToPas tool but more of an intrinsic difficulty when converting interoperable code between languages. I encountered at least one class that made use of a few reserved words in Delphi such as begin and end – I’m still not sure what to do with these for now.

Overall Impression

Despite a few early bugs the C#ToPas Tool is a good platform to begin converting your C# code to Delphi Prism although you may wish to ensure that you have some extensive Unit Tests for your code before the main code is converted so as to ensure that any bugs introduced can be picked up on quickly (which you have anyway right?). It is also worth noting that the Delphi Prism Wiki (which now authenticates via your CDN login) has excellent coverage and is an absolutely invaluable reference for anyone working with Delphi Prism.

By the time this entry is published I suspect that Carlo will be very close to fixing some or most of the above bugs in the C#ToPas tool.

The code is nowhere near complete yet and most of the files are still straight out of the Automatic conversion and therefore will not compile in any way but I’ve put what we have so far up on the rather smooth Github site at the PrismUT3RemoteBot project which anyone can fork and push changes back to. Git is a little strange to work with at first because it’s a different mindset to SubVersion/CVS but it’s worth checking out if you haven’t already.

[UPDATE: The Prism UT3 Remote Bot conversion project has been completed since this original post and may be used during Jim McKeeth's session at DelphiLive! Germany Sept 28 - Oct 2 2009.]

(Items marked with an Asterisk * are non-free)

Delphi Tools

GExperts – Every Delphi Developer should have GExperts, adding a fantastic selection of features to the Delphi IDE and Editor.

cnWizard IDE – Quite a few commenters suggested adding cnWizard IDE here, I’ve never actually tried it but did consider it against GExperts. What put me off was the relatively uninformative website (yes, shallow of me but I can’t help it!).

DelphiCodeToDoc Options

DelphiCodeToDoc – Generate documentation from your Delphi Source comments, including JavaDoc compatible comments. DelphiCodeToDoc is open source and can generate Windows Help Files or HTML Documentation (or both).

SmartInspect* - This is a commercial product which gives you amazing code logging features for Delphi, .NET and Java applications (and even PHP too now which I also find useful). No more inserting breakpoints, watches and spurious ShowMessages()’s just to track the variables in an application. Even allows Remote Logging when an executable is deployed on a different machine. Saved me from a particuarly frustrating problem in a remote app recently.

SmartInspect Console

Innosetup – A Free installer which allows you to create fully customisable installers which support nearly every version of windows and even 64 bit architectures. I’ve also found it to be just as functional and much easier to use than some of it’s expensive competitors.  Did I mention it’s also free?

MemCheck – Not really an application per se. Not fully Delphi 2009 compatible yet but this is a useful little unit that means adding a single line to your project file and then creates a log file of the memory leaks in your application.

WAnt –  A Delphi specific Build Automation tool in the same fashion as the Java Ant tool. I looked into this tool recently because I wanted a way to automatically Checkout, Build and Test the Dwitterphi project that I’m working on so I know when the SVN Trunk has been broken.

Editors / IDEs

Programmers Notepad 2 – A General Purpose Notepad replacement which includes Syntax highlighting support, bookmarks, code folding, project and project group support and all the usual gubbins which you would expect from a lightweight notepad replacement.

Zend Studio* – My copy is a few years old, before they switched to Eclipse. I’m actually looking at replacing this with something newer and free.

Zend Development Environment (older version)

Eclipse – Needs no real introduction. A Base for so many tools. I also use the RadRails package for Rails and Ruby Development.

Version Control / File Comparison

Beyond Compare 3* – An amazing File Comparison utility with 3 way merge capability, folder sync capabilities, specialised viewers for various file types and remote comparison tools. I’ve mentioned it many times before but this is an essential tool for developers.

Beyond Compare 3

Toroise SVN – Easy to use interface for Subversion which integrates beautifully with the Windows Shell. My only gripe with this particular tool is that it seems to bug you often to download the latest updates when they should by now have implemented an auto-update feature.

SVNMonitor – Only Recently suggested to me by @dmiliam via Twitter. I installed it and found it tremendously useful for keeping tabs on whats happening with a SVN Repository.

Internet

SmartFTP* – There are a million FTP Clients out there, some are free with comparable features to SmartFTP but none come close to the overall package and polish that SmartFTP represents including support for FTPS and SFTP and very smooth transfer queues and folder sync features.

FeedDemon – Developed in Delphi by Nick Bradbury. It’s considered very cool to use Google Reader nowadays but you can’t beat the stability and power of a Desktop Reader and FeedDemon has it all. Fast and efficient, especially good when combined with the NewsGator Online Sync Service that allows me to sync unread/read items to my Work PC or even my Blackberry with NewsGator Go! and catch up with news on the go. Sync with Google Reader is also on the way. FeedDemon FTW.

FeedDemon 3

twhirl – I prefer twhirl as my Twitter client of choice as it isn’t as big and bulky as TweetDeck but all that will change when there is a great native win32 twitter client.

Browser

FireFox – No explaination neccessary really.

• Web Developer Toolbar – Simply indispensable for those who spend a great deal of time crafting Browser content or applications.
• YSlow – I’ll be honest: I’ve never had a site that is big enough to need the level of optimisation that Yahoo.com does but the advice this tool gives is sound and it will help you to identify bottlenecks in your sites performance.
• FireBug - Edit, debug, and monitor HTML, CSS and JavaScript live in any web page.

Google Chrome – Used for Day to Day browsing because it’s an order of magnitude faster than almost any other browser out there in general browsing (Just my opinion).

SuperPreview – A fabulous tool from Microsoft unveiled at Mix09 which allows you to view web pages in Internet Explorer 6, 7 and 8 as well as your other browsers whilst allowing you to super-impose expected layouts on top of one another to see how the renderings differ. No more hefty VMs required for testing layouts.. great success!

Shell / Miscellaneous

Open Command Window Here shortcute

Command Prompt Here - A hugely underrated and disarmingly simple shell extension which adds an “Open Command Prompt Here” sub-item to the context menu in Windows Explorer. No more cd “C:really really really long path name” for these users.

UltraMon* – This improves the Multi-Monitor support in Windows hugely, something that if you haven’t tried it, try it now! Monitor specific task bars, extra system buttons on each window, wallpaper and desktop icon management. Ultramon is so useful that I’m suprised it hasn’t already been acquired by Microsoft like the SysInternals team were.

ProcessExplorer from SysInternals

SysInternals – From by Mark Russinovich and Bryce Cogswell, The best set of power user utilities available out there, Acquired by Microsoft a few years ago. My personal favourites are:

• Process Explorer – Think of the windows task manager on steroids, double it and then add more.
• Autoruns – Comprehensive lists of everything starting up when your computer does.
• ps* Utils – Lightweight remote versions of your favourite windows commands.

VirtualBox – A Free and Open Source VM competitor to Microsoft VirtualPC and VMWare etc. Not as polished as VMWare in some parts of the user interface or networking features but very usable and getting much better with every release.

Window Clippings* – Recommended to me by marc hoffman (although how he knew about it – primarily being a mac user I’m not sure). A very easy Screenshot and Window Clipping tool. Great features, addons available and inexpensive. Everyone has their own preference for a Screenshot tool so whilst I would completely recommend this, I wouldn’t push for you to change over any other.

Power Toys – An amazing set of utilities that add to windows.

SyncToy 2 - A File and Folder Synchronisation tool that I use to keep files backed up to my home servers and which I will use to Sync important indispensable files (music!) to my NetBook when I finally purchase it!

This isn’t a completely comprehensive list (I’m not going to dump a list of everything from Windows Add/Remove Programs!) but I’d love to hear if you think I’m missing out on any spectacularly useful utilities for Delphi or Web Development. Hopefully you found at least one utility in this list that you’ve been putting off trying and have realised why I found it to be useful.