The Oxygene language has its origins in Object Pascal in general and Delphi in particular, but was designed to reflect the guidelines of .NET programming and to create fully CLR-compliant assemblies. Therefore, some minor language features known from Object Pascal – Delphi have been dropped or revised, while many new and more modern features, such as Generics or Sequences and Queries have been added to the language. Oxygene is an
Object-oriented programming language. Thus, it uses classes, which can hold data and execute code, to design programs. Classes are "prototypes" for objects, like the idea of an apple is the prototype for the apple one can actually buy in a shop. It is known that an apple has a colour, and that it can be peeled: those are the data and executable "code" for the apple class. Oxygene provides language-level support for some features of parallel programming. The goal is to use all cores or processors of a computer to improve performance. To reach this goal, tasks must be distributed among several threads. The
.NET Framework's ThreadPool class offered a way to efficiently work with several threads. The
Task Parallel Library (TPL) was introduced in .NET 4.0 to provide more features for parallel programming. Operators can be overloaded in Oxygene using the class operator syntax: class operator implicit(i : Integer) : MyClass; Note, that for
operator overloading each operator has a name, that has to be used in the operator overloading syntax, because for example "+" would not be a valid method name in Oxygene.
Program structure Oxygene does not use "Units" like Delphi does, but uses .NET
namespaces to organize and group types. A namespace can span multiple files (and assemblies), but one file can only contain types of one namespace. This namespace is defined at the very top of the file: namespace ConsoleApplication1; Oxygene files are separated into an interface and an implementation section, which is the structure known from Delphi. The interface section follows the declaration of the namespace. It contains the uses clause, which in Oxygene imports types from other namespaces: uses System.Linq; Imported namespaces must be in the project itself or in referenced assemblies. Unlike in C#, in Oxygene alias names cannot be defined for namespaces, only for single type names (see below). Following the uses clause a file contains type declarations, like they are known from Delphi: interface type ConsoleApp = class public class method Main; end; As in C#, the Main method is the entry point for every program. It can have a parameter args : Array of String for passing command line arguments to the program. More types can be declared without repeating the type keyword. The implementation of the declared methods is placed in the implementation section: implementation class method ConsoleApp.Main; begin // add your own code here Console.WriteLine('Hello World.'); end; end. Files are always ended with end.
Types As a .NET language, Oxygene uses the .NET
type system: There are value types (like structs) and reference types (like arrays or classes). Although it does not introduce own "pre-defined" types, Oxygene offers more "pascalish" generic names for some of them, so that for example the System.Int32 can be used as Integer and Boolean (System.Boolean), Char (System.Char), Real (System.Double) join the family of pascal-typenames, too. The struct character of these types, which is part of .NET, is fully preserved. As in all .NET languages types in Oxygene have a visibility. In Oxygene the default visibility is assembly, which is equivalent to the internal visibility in C#. The other possible type visibility is public. type MyClass = public class end; The visibility can be set for every type defined (classes, interfaces, records, ...). An alias name can be defined for types, which can be used locally or in other Oxygene assemblies. type IntList = public List; //visible in other Oxygene-assemblies SecretEnumerable = IEnumerable; //not visible in other assemblies Public type aliases won't be visible for other languages.
Records Records are what .NET structs are called in Oxygene. They are declared just like classes, but with the record keyword: type MyRecord = record method Foo; end; As they're just .NET structs, records can have fields, methods and properties, but do not have
inheritance and cannot implement
interfaces.
Interfaces Interfaces are a very important concept in the .NET world, the framework itself makes heavy use of them. Interfaces are the specification of a small set of methods, properties and events a class has to implement when implementing the interface. For example, the interface IEnumerable specifies the GetEnumerator method which is used to iterate over sequences. Interfaces are declared just like classes: type MyInterface = public interface method MakeItSo : IEnumerable; property Bar : String read write; end; Please notice, that for properties the getter and setter are not explicitly specified.
Delegates Delegates define signatures for methods, so that these methods can be passed in parameters (e.g. callbacks) or stored in variables, etc. They're the type-safe NET equivalent to function pointers. They're also used in events. When assigning a method to a delegate, one has to use the @ operator, so the compiler knows, that one doesn't want to call the method but just assign it. Oxygene can create anonymous delegates; for example methods can be passed to the Invoke method of a control without declaring the delegate: method MainForm.MainForm_Load(sender: System.Object; e: System.EventArgs); begin Invoke(@DoSomething); end; An anonymous delegate with the signature of the method DoSomething will be created by the compiler. Oxygene supports polymorphic delegates, which means, that delegates which have parameters of descending types are assignment compatible. Assume two classes MyClass and MyClassEx = class(MyClass), then in the following code BlubbEx is assignment compatible to Blubb. type delegate Blubb(sender : Object; m : MyClass); delegate BlubbEx(sender : Object; mx : MyClassEx); Fields can be used to delegate the implementation of an interface, if the type they're of implements this interface: Implementor = public class(IMyInterface) // ... implement interface ... end; MyClass = public class(IMyInterface) fSomeImplementor : Implementor; public implements IMyInterface; //takes care of implementing the interface end; In this example the compiler will create public methods and properties in MyClass, which call the methods / properties of fSomeImplementor, to implement the members of IMyInterface. This can be used to provide mixin-like functionality.
Anonymous methods Anonymous methods are implemented inside other methods. They are not accessible outside of the method unless stored inside a delegate field. Anonymous methods can use the local variables of the method they're implemented in and the fields of the class they belong to. Anonymous methods are especially useful when working with code that is supposed to be executed in a GUI thread, which is done in .NET by passing a method do the Invoke method (Control.Invoke in WinForms, Dispatcher.Invoke in WPF): method Window1.PredictNearFuture; //declared as async in the interface begin // ... Calculate result here, store in variable "theFuture" Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, method; begin theFutureTextBox.Text := theFuture; end); end; Anonymous methods can have parameters, too: method Window1.PredictNearFuture; //declared as async in the interface begin // ... Calculate result here, store in variable "theFuture" Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, method(aFuture : String); begin theFutureTextBox.Text := aFuture ; end, theFuture); end; Both source codes use
anonymous delegates.
Property notification Property notification is used mainly for
data binding, when the
GUI has to know when the value of a property changes. The .NET framework provides the interfaces INotifyPropertyChanged and INotifyPropertyChanging (in .NET 3.5) for this purpose. These interfaces define events which must be fired when a property is changed / was changed. Oxygene provides the notify modifier, which can be used on properties. If this modifier is used, the compiler will add the interfaces to the class, implement them and create code to raise the events when the property changes / was changed. property Foo : String read fFoo write SetFoo; notify; property Bar : String; notify 'Blubb'; //will notify that property "Blubb" was changed instead of "Bar" The modifier can be used on properties which have a setter method. The code to raise the events will then be added to this method during compile time. == Code examples ==