Also, the subtle differences between the Delphi and Oxygene languages are annoying (even if logically i may agree with them). Why is the compiler not a bit more forgiving in picking up these differences for Delphi converts?

IDE:
- IntelliSense (“Resolve” /SHIFT+ALT+F10/, “Remove unused usings”, etc.)
- code refactoring
- entity framework designer
- class view (or object browser)
- WCF config editor

Language features:
- collection initializers
- volatile fields (ok, it is not so important)
- XML comments (///)

Frankly, Visual C# IDE is much more richer.

I’m not from Codegear or RemObjects, but I worked A LOT with VCL.NET and Delphi.NET.

The great problem with explicit destructors on Delphi.Net is the fact that IDisposable implementation MUST be called by the programmer. On Delphi.Net, it means that you must call TObject.Free (and correlated like FreeAndNil and the like) explicitly.

Since WPF, Winforms and such things does not call Dispose automatically it means that your classes cannot rely on it being called as the object zero it’s references and/or go out of scope.

IF .Net Framework would call Dispose automatically if supported when the Garbage Collector destroy the object, explicit destructors would be a real nice and useful compiler magic. But, until today, that won’t happens and explicit destructors are just more one thing to clutter code.

Delphi.NET (combined with VCL.NET) tried to bring the native programming style to .NET. It failed, because .NET is another completely different beast (I liked Delphi.NET BUT it have a lot of traps because it doesn’t follow the .NET way of doing things).

Oxygene compiler, on the other way, was designed from scratch to bring Object Pascal to .NET – FOLLOWING the .NET programming model and conventions.

It’s all my very humble opinion, of course.

Best regards!

The language compiled by Oxygene differs in many respects to the Delphi language. Many of the differences are additive, forming a superset of Delphi that natively supports many very useful .NET features and other enhancements.

However, many of the differences are not additive, they are incompatible, such as ‘unit’ vs ‘namespace’, and ‘:=’ instead of ‘=’ in default var value assignments. These sorts of differences are catered for by the Delphi -> Oxygene conversion tool, but not all!

A particular case that is not (I think) dealt with is the conversion tool is the prohibition of explicit destructors, but rather classes requiring this are forced to implement the .NET pattern. Dephi provided compiler magic to convert explicit destructors into the .NET pattern, whereas Oxygene does not.

Considering the enormous amounts of compiler magic being performed by Oxygene to support many other language features, I imagine this would not be hard to do.

Are there plans to support explicit destructors in Oxygene (like Delphi does)?

Raymond.

method MainForm.button2_Click(sender: System.Object; e: System.EventArgs);
var
LCustomers: Table;
LDBMain: DataContext;
LConnectionString:String;
begin
LConnectionString := ‘Data Source=.\SQLEXPRESS;Initial Catalog=DBDEMOS;Integrated Security=True’;
LDBMain := new DataContext(LConnectionString);
LCustomers := LDBMain.GetTable();
var USCustomers := from Customer in LCustomers where Customer.Country = ‘US’ select Customer;

for each Customer in USCustomers do begin
listBox1.Items.Add(Customer.Name);
end;
end;

method MainForm.button1_Click(sender: System.Object; e: System.EventArgs);
var
lCustomer: Customer;
LCustomers : List;
begin
LCustomers := new List;

lCustomer := new Customer;
lCustomer.Name := ‘Olaf’;
lCustomer.Country := ‘Germany’;
LCustomers.Add(lCustomer);

lCustomer := new Customer();
lCustomer.Name := ‘Jim’;
lCustomer.Country := ‘USA’;
LCustomers.Add(lCustomer);

var GermanCustomers :=
from Customer in LCustomers
where Customer.Country.Equals(‘Germany’);

for Customer in GermanCustomers do begin
listBox1.Items.Add(Customer.Name);
end;
end;