Oxygene (lenguaje de programación)

Oxygene no utiliza "Unidades" como Delphi, sino que emplea espacios de nombres .NET para organizar y agrupar tipos. Un espacio de nombres puede abarcar varios archivos (y ensamblados), pero un archivo solo puede contener tipos de un único espacio de nombres. Este espacio de nombres se define en la parte superior del archivo:

espacio de nombres AplicaciónConsola1;

Los archivos de Oxygene se dividen en una sección de interfaz y una sección de implementación, que es la estructura conocida de Delphi. La sección de interfaz sigue a la declaración del espacio de nombres. Contiene la usescláusula que, en Oxygene, importa tipos de otros espacios de nombres:

utiliza System.Linq ;​​

Los espacios de nombres importados deben estar en el propio proyecto o en los ensamblados a los que se hace referencia. A diferencia de C#, en Oxygene no se pueden definir alias para los espacios de nombres, solo para nombres de tipos individuales (véase más abajo).

Tras la usescláusula, un archivo contiene declaraciones de tipo, como las que se conocen en Delphi:

interfaztipo ConsoleApp = clase pública método de clase Main ; fin ;

Al igual que en C#, el método Main es el punto de entrada de cualquier programa. Puede tener un parámetro para pasar argumentos de línea de comandos al programa.args : Array of String

Se pueden declarar más tipos sin repetir la typepalabra clave.

La implementación de los métodos declarados se encuentra en la sección de implementación:

implementaciónMétodo de clase ConsoleApp.Main ; begin // agrega tu propio código aquí Console.WriteLine ( 'Hola Mundo .' ) ; end ;fin .

Los archivos siempre terminan conend.

Como lenguaje .NET, Oxygene utiliza el sistema de tipos de .NET : existen tipos de valor (como las estructuras) y tipos de referencia (como las matrices o las clases).

Aunque no introduce tipos "predefinidos" propios, Oxygene ofrece nombres genéricos más "pascalistas" para algunos de ellos, ^{[ 5 ]} de modo que, por ejemplo, se System.Int32puede usar como Integery Boolean( System.Boolean), Char( System.Char), Real( System.Double) también se unen a la familia de nombres de tipos pascalistas. El carácter de estructura de estos tipos, que es parte de .NET, se conserva completamente.

Como en todos los lenguajes .NET, los tipos en Oxygene tienen visibilidad. En Oxygene, la visibilidad predeterminada es assembly, que es equivalente a la internalvisibilidad en C#. La otra visibilidad de tipo posible es public.

tipo MyClass = clase pública fin ;

La visibilidad se puede configurar para cada tipo definido (clases, interfaces, registros, ...).

Se puede definir un alias para los tipos, que se puede usar localmente o en otros ensamblados de Oxygene.

type IntList = public List < Integer >; //visible en otros ensamblados de Oxygene SecretEnumerable = IEnumerable < String >; //no visible en otros ensamblados

Los alias de tipo público no serán visibles para otros idiomas.

tipo MyRecord = método de registro Foo ; fin ;

Las interfaces son un concepto fundamental en el mundo .NET; el propio framework las utiliza ampliamente. Una interfaz especifica un pequeño conjunto de métodos, propiedades y eventos que una clase debe implementar al implementar dicha interfaz. Por ejemplo, la interfaz IEnumerable<T>especifica el GetEnumeratormétodo que se utiliza para iterar sobre secuencias.

Las interfaces se declaran igual que las clases:

tipo MyInterface = interfaz pública método MakeItSo : IEnumerable ; propiedad Bar : String lectura escritura ; fin ;

Tenga en cuenta que, para las propiedades, los métodos getter y setter no se especifican explícitamente.

Los delegados definen firmas para los métodos, de modo que estos puedan recibir parámetros (por ejemplo, funciones de devolución de llamada) o almacenarse en variables, etc. Son el equivalente en .NET, con seguridad de tipos, a los punteros a funciones. También se utilizan en eventos. Al asignar un método a un delegado, es necesario usar el @operador `asignar`, para que el compilador sepa que no se desea llamar al método, sino simplemente asignarlo.

Oxygene puede crear delegados anónimos; por ejemplo, se pueden pasar métodos al Invokemétodo de un control sin declarar el delegado:

método MainForm.MainForm_Load ( sender : System.Object ; e : System.EventArgs ) ; begin Invoke ( @DoSomething ) ; end ;​​​​​​​

DoSomethingEl compilador creará un delegado anónimo con la firma del método .

Oxygene admite delegados polimórficos, lo que significa que los delegados que tienen parámetros de tipos descendentes son compatibles con la asignación. Supongamos dos clases MyClassy MyClassEx = class(MyClass), entonces en el siguiente código BlubbExes compatible con la asignación a Blubb.

tipo delegate Blubb ( remitente : Object ; m : MyClass ) ; delegate BlubbEx ( remitente : Object ; mx : MyClassEx ) ;

Los campos se pueden usar para delegar la implementación de una interfaz, si el tipo al que pertenecen implementa dicha interfaz:

Implementador = clase pública ( IMyInterface ) // ... implementar interfaz ... fin ;MyClass = public class ( IMyInterface ) fSomeImplementor : Implementor ; public implements IMyInterface ; //se encarga de implementar la interfaz end ;

En este ejemplo, el compilador creará métodos y propiedades públicas en MyClass, que llaman a los métodos/propiedades de fSomeImplementor, para implementar los miembros de IMyInterface. Esto se puede usar para proporcionar una funcionalidad similar a la de un mixin. ^{[ 6 ]}

Los métodos anónimos se implementan dentro de otros métodos. No son accesibles fuera del método a menos que se almacenen en un campo delegado. Los métodos anónimos pueden usar las variables locales del método en el que se implementan y los campos de la clase a la que pertenecen.

Los métodos anónimos son especialmente útiles cuando se trabaja con código que se supone que se ejecuta en un hilo de GUI, lo cual se hace en .NET pasando un método al Invokemétodo ( Control.Invokeen WinForms, Dispatcher.Invokeen WPF):

método Window1.PredictNearFuture ; // declarado como asíncrono en la interfaz begin // ... Calcular el resultado aquí , almacenar en la variable "theFuture " Dispatcher.Invoke ( DispatcherPriority.ApplicationIdle , method ; begin theFutureTextBox.Text : = theFuture ; end ) ; end ;

Los métodos anónimos también pueden tener parámetros:

método Window1.PredictNearFuture ; // declarado como asíncrono en la interfaz begin // ... Calcular el resultado aquí, almacenar en la variable " theFuture " Dispatcher.Invoke ( DispatcherPriority.ApplicationIdle , method ( aFuture : String ) ; begin theFutureTextBox.Text : = aFuture ; end , theFuture ) ; end ;

Ambos códigos fuente utilizan delegados anónimos .

La notificación de propiedades se utiliza principalmente para el enlace de datos , cuando la interfaz gráfica de usuario (GUI) necesita saber cuándo cambia el valor de una propiedad. El framework .NET proporciona las interfaces INotifyPropertyChangedy INotifyPropertyChanging(en .NET 3.5) para este propósito. Estas interfaces definen eventos que deben activarse cuando una propiedad cambia o ha cambiado.

Oxygene proporciona un notifymodificador que se puede usar en las propiedades. Si se usa este modificador, el compilador agregará las interfaces a la clase, las implementará y creará código para generar los eventos cuando la propiedad cambie o haya cambiado.

propiedad Foo : String leer fFoo escribir SetFoo ; notificar ; propiedad Bar : String ; notificar 'Blubb' ; //notificará que la propiedad "Blubb" fue modificada en lugar de "Bar"

El modificador se puede usar en propiedades que tengan un método setter. El código para generar los eventos se agregará a este método durante la compilación.

espacio de nombres GenericMethodTest ; interfaztype GenericMethodTest = static class public class method Main ; private class method Swap < T > ( var left , right : T ) ; class method DoSwap < T > ( left , right : T ) ; end ;implementaciónclass 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 ;método de clase GenericMethodTest . Main ; begin var a := 23 ; // inferencia de tipo var b := 15 ; DoSwap < Integer > ( a , b ) ; // no hay conversión descendente a Object en este método.var aa := 'abc' ; // inferencia de tipo var bb := 'def' ; DoSwap < String > ( aa , bb ) ; // no hay conversión descendente a Object en este método.DoSwap ( 1.1 , 1.2 ) ; // inferencia de tipo para parámetros genéricos Console . ReadLine () ; end ;método de clase GenericMethodTest . Swap < T > ( var left , right : T ) ; begin var temp := left ; left := right ; right := temp ; end ;fin .

Salida del programa:

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