Oxygene (język programowania)

Z Wikipedii, wolnej encyklopedii
Skocz do: nawigacji, wyszukiwania
Ujednoznacznienie Ten artykuł dotyczy języka programowania. Zobacz też: Oxygène – album muzyczny.

Oxygene (znany również jako Chrome) to 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.

Spis treści

Właściwości [edytuj]

Przykładowe programy [edytuj]

Hello World [edytuj]

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 [edytuj]

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 [edytuj]

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) [edytuj]

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 [edytuj]

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) [edytuj]

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 również [edytuj]

(inne języki platformy .NET)

(platforma .NET)

Linki zewnętrzne [edytuj]

Źródło „http://pl.wikipedia.org/w/index.php?title=Oxygene_(język_programowania)&oldid=35486897”