As Delphi enthusiast coder, I like to send you my source code porting of
Christopher benchmark http://www.osnews.com/story.php?news_id=5602&page=3.

In Delphi5 I use native Integer64 CPU type, they are treated as floating
point, but are Int64 signed into CPU (just use Round/Trunc/Format to obtain
INT results).

These are the numbers of CSharp against Delphi5 on my Athlon Barton
2500+ (seeing these numbers you take the responsability on legal statements about benchmarks comparative results for both mentioned platforms). 

From the grabbed screen: http://www.dellapasqua.com/DelphiBenchV2.gif 

CSharp_1 : 6359
Delphi5_1 : 6187

CSharp_2 : 8125
Delphi5_2: 8672

CSharp_3 : 19000
Delphi5_3: 12522

CSharp_4 : 2734
Delphi5_4: 2891

CSharp_5: 4562
Delphi5_5: 2250

Overall CSharp: 40768
Overall Delphi5: 32422

Delphi5 is 21% faster than C#.

---
You can download a compiled Delphi5 executable (it's checked antivirus free): http://www.dellapasqua.com/DelphiBenchV2.exe
---
This is my ported source code:

program DelphiBenchV2;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  classes,
  Windows,
  Math;

type
  TBenchMarkDelphi = class
  private
    startTime: Integer;
    stopTime: Integer;
    elapsedTime: Integer;
    function intArithmetic(const IntMax: Integer): Int64;
    function doubleArithmetic(const doubleMin, doubleMax: Double): Int64;
    function longArithmetic(const longMin, longMax: comp): Int64;
    function trig(const trigMax: double): Int64;
    function io(const ioMax: Integer): Int64;
    procedure Run;
  end;

function TBenchMarkDelphi.intArithmetic(const IntMax: Integer): Int64;
var
  intResult: Integer;
  i: Integer;
begin
  startTime := GetTickCount;
  intResult := 1;
  i := 1;

  while (i < intMax) do begin
    inc(i);
    dec(intResult, i);
    inc(i);
    inc(intResult, i);
    inc(i);
    intResult := intResult * i;
    inc(i);
    intResult := intResult div i;
  end;

  stopTime := GetTickCount;
  elapsedTime := stopTime - startTime;

  Writeln('Int arithmetic elapsed time: ' + IntToStr(elapsedTime) +
    ' ms with max of ' + IntToStr(intMax));
  Writeln(' i: ' + IntToStr(i));
  Writeln(' intResult: ' + IntToStr(intResult));
  Result := Int64(elapsedTime);
end;

function TBenchMarkDelphi.doubleArithmetic(const doubleMin, doubleMax: Double): Int64;
var
  doubleResult: double;
  i: double;
begin
  startTime := GetTickCount;
  doubleResult := doubleMin;
  i := doubleMin;

  while (i < doubleMax) do begin

    i := i + 1;
    doubleResult := doubleResult - i;
    i := i + 1;
    doubleResult := doubleResult + i;
    i := i + 1;
    doubleResult := doubleResult * i;
    i := i + 1;
    doubleResult := doubleResult / i;

  end;

  stopTime := GetTickCount;
  elapsedTime := stopTime - startTime;

  Writeln('Double arithmetic elapsed time: ' + IntToStr(elapsedTime) +
    ' ms with min of ' + FloatToStr(doubleMin) + ', max of ' + FloatToStr(doubleMax));
  Writeln(' i: ' + FloatToStr(i));
  Writeln(' doubleResult: ' + FloatToStr(doubleResult));
Result:=Int64(elapsedTime);end;

function TBenchMarkDelphi.longArithmetic(const longMin, longMax: comp): Int64;
var
  longResult: comp;
  i: comp;
begin
  startTime := GetTickCount;
  longResult := longMin;
  i := longMin;
  while (i < longMax) do begin

    i := i + 1;
    longResult := longResult - i;
    i := i + 1;
    longResult := longResult + i;
    i := i + 1;
    longResult := longResult * i;
    i := i + 1;
    longResult := longResult / i;

  end;

  stopTime := GetTickCount;
  elapsedTime := stopTime - startTime;

  Writeln('Long arithmetic elapsed time: ' + IntToStr(elapsedTime) +
    ' ms with min of ' + FloatToStr(longMin) + ', max of ' + FloatToStr(longMax));
  Writeln(' i: ' + FloatToStr(i));
  Writeln(' longResult: ' + FloatToStr(longResult));
  Result := Int64(elapsedTime);
end;

function TBenchMarkDelphi.trig(const trigMax: double): Int64;
var
  sine, cosine, tangent, logarithm, squareRoot, i: double;
begin
  startTime := GetTickCount;
  sine := 0;
  cosine := 0;
  tangent := 0;
  logarithm := 0;
  squareRoot := 0;
  i := 0;

  while (i < trigMax) do begin
    i := i + 1;
    sine := Sin(i);
    cosine := Cos(i);
    tangent := Tan(i);
    logarithm := Log10(i);
    squareRoot := Sqrt(i);
  end;

  stopTime := GetTickCount;
  elapsedTime := stopTime - startTime;


  Writeln('Trig elapsed time: ' + IntTostr(elapsedTime) +
    ' ms with max of ' + FloatToStr(trigMax));
  Writeln(' i: ' + FloatToStr(i));
  Writeln(' sine: ' + FloatToStr(sine));
  Writeln(' cosine: ' + FloatToStr(cosine));
  Writeln(' tangent: ' + FloatToStr(tangent));
  Writeln(' logarithm: ' + FloatToStr(logarithm));
  Writeln(' squareRoot: ' + FloatToStr(squareRoot));
  Result := Int64(elapsedTime);
end;

function TBenchMarkDelphi.io(const ioMax: Integer): Int64;
const textLine='abcdefghijklmnopqrstuvwxyz1234567890abcdefghijklmnopqrstuvwxyz1234567890abcdefgh';
var
  myLine: string;
  i: integer;
  F: textfile;
begin
  startTime := GetTickCount;
  i := 0;

  try

    AssignFile(F, 'c:\TestDelphi.txt');
    Rewrite(F);

    while (i < ioMax) do begin
      Writeln(F, textLine);
      Inc(i);
    end;
    CloseFile(F);

    i := 0;

    AssignFile(F, 'c:\TestDelphi.txt');
    Reset(F);

    while (i < ioMax) do begin
      Readln(F, myLine);
      inc(i);
    end;

    CloseFile(F);

  except
    on e: exception do Writeln(e.Message);
  end;

  stopTime := GetTickCount;
  elapsedTime := stopTime - startTime;

  Writeln('IO elapsed time: ' + IntToStr(elapsedTime) +
    ' ms with max of ' + IntToStr(ioMax));
  Writeln(' i: ' + IntToStr(i));
  Writeln(' myLine: ' + myLine);
  Result := Int64(elapsedTime);
end;

procedure TBenchMarkDelphi.Run;
var
  intArTime, doubleArTime, longArTime, trigTime, ioTime, totalTime: Int64;
begin
  Writeln('Start Delphi silly benchmark');

  intArTime := intArithmetic(1000000000);
  doubleArTime := doubleArithmetic(10000000000, 11000000000);
  longArTime := longArithmetic(10000000000, 11000000000);
  trigTime := trig(10000000);
  ioTime := io(1000000);
  totalTime := intArTime + doubleArTime + longArTime + trigTime + ioTime;

  Writeln('Total Delphi benchmark time: ' + IntToStr(totalTime) + ' ms');
  Writeln('End Delphi benchmark');
end;

var MyBench: TBenchMarkDelphi;

begin
  Set8087CW($133F and $FCFF); //->> 32bit precision as Visual Studio and GCC compilers sets by default
  MyBench := TBenchMarkDelphi.Create;
  MyBench.Run;
  MyBench.Free;
end.