Oxygene (język programowania)

namespace HelloWorld;

interface

type
  HelloClass = class
  public
    class method Main;
  end;

implementation

class method HelloClass.Main;
begin
  System.Console.WriteLine('Hello World!');
end;

end.

namespace GenericContainer;

interface

type
  TestApp = class
  public
    class method Main;
  end;

  Person = class
  public
    property FirstName: String;
    property LastName: String;
  end;

implementation

uses
  System.Collections.Generic;

class method TestApp.Main;
begin
  var myList := new List<Person>; //lista obiektów typu Person
  myList.Add(new Person(FirstName := 'Boryslaw', LastName := 'Bob'));
  myList.Add(new Person(FirstName := 'Borys', LastName := 'Bob'));
  myList.Add(new Person(FirstName := 'BWB', LastName := 'Bob'));
  Console.WriteLine(myList[1].FirstName);
  Console.ReadLine;
end;

end.

namespace GenericMethodTest;

interface

type
GenericMethodTest = static class
public
  class method Main;
private
  class method Swap<T>(var left, right : T);
  class method DoSwap<T>(left, right : T);
end;

implementation

class method GenericMethodTest.DoSwap<T>(left, right : T);
begin
  var a := left;
  var b := right;
  Console.WriteLine('Type: {0}', typeof(T));
  Console.WriteLine('-> a = {0}, b = {1}', a , b);
  Swap<T>(var a, var b);
  Console.WriteLine('-> a = {0}, b = {1}', a , b);
end;

class method GenericMethodTest.Main;
begin
  var a := 23; //brak deklaracji typu!
  var b := 15;
  DoSwap<Integer>(a, b); //bez rzutowania uszczegóławiającego (ang. downcasting)
                         //czyli bez rzutowania zmiennej do pewnego typu pochodnego

  var aa := 'abc'; //brak deklaracji typu!
  var bb := 'def';
  DoSwap<String>(aa, bb); //bez rzutowania uszczegóławiającego w tej metodzie

  DoSwap(1.1, 1.2);  //brak deklaracji typu dla parametrów
  Console.ReadLine();
end;

class method GenericMethodTest.Swap<T>(var left, right : T);
begin
  var temp := left;
  left:= right;
  right := temp;
end;

end.

 Typ: System.Int32
 -> a = 23, b = 15
 -> a = 15, b = 23
 Typ: System.String
 -> a = abc, b = def
 -> a = def, b = abc
 Typ: System.Double
 -> a = 1,1, b = 1,2
 -> a = 1,2, b = 1,1

case aClassID.ToUpper of
   'XYZ': result := TMyXYZClass;
   'ABC': result := TMyOtherClass;
else raise new Exception('Invalid Class ID');
end;

case aClass type of
   TMyXYZClass: TMyXYZClass(aClass). DoSomething;
   TMyOtherClass: TMyOtherClass(aClass). DoSomethingElse;
else raise new Exception('Invalid Class Reference');
end;

unit; interface implementation const a='unit; interface implementation const a=';
method Main;const c='const ';const l=#13#10;const p='''';
const b='{0}{1}{0}{1};{3}method Main;{2}c={1}{2}{1};{2}l=#13#10;{2}p={1}{1}{1}{1};{3}';
const d='{2}b={1}{4}{1};{3}{2}d={1}{5}{1};{3}{2}e={1}{6}{1};{3}';
const e='begin System.Console.WriteLine(b+d+e,a,p,c,l,b,d,e);end;end.';
begin System.Console.WriteLine(b+d+e,a,p,c,l,b,d,e);end;end.