Oxygene (język programowania)

Oxygene
Pojawienie się	2005
Aktualna wersja stabilna	10.0.0.2485; (18 lutego 2020) [±]
	Strona internetowa

Oxygene (znany również jako Chrome) – język programowania pod platformę .NET stworzony przez firmę RemObjects. Oxygene bazuje na języku programowania Object Pascal. Składnia Oxygene jest bardzo podobna do składni Delphi.NET. Kompilator Oxygene w pełni integruje się z Visual Studio 2003/2005/2008. Na chwilę obecną nie istnieją niezależne kompilatory Oxygene wraz z IDE.

Właściwości

Język platformy .NET
Bazuje na języku Object Pascal
Typy anonimowe
Anonimowe metody i delegaty
Metody asynchroniczne
Obsługa .NET 2.0
Obsługa LINQ
Obsługa Windows Presentation Foundation.
Obsługa Mono

Przykładowe programy

Hello World

namespace HelloWorld;

interface

type
  HelloClass = class
  public
    class method Main;
  end;

implementation

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

end.

Kontenery generyczne

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.

Metody generyczne

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.

Wyniki:

 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

Obsługa typu string w instrukcji case (odpowiednika switch w języku C)

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

Rozróżnianie typów klasy w instrukcji case

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

Quine (program generujący swój własny kod źródłowy)

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.

Zobacz też

(inne języki platformy .NET)

(platforma .NET)

Linki zewnętrzne