Clases
Generalidades
El lenguaje 4D soporta el concepto de clases. En un lenguaje de programación, el uso de una clase permite definir el comportamiento de un objeto con propiedades y funciones asociadas.
Cada objeto es una instancia de su clase. Una vez definida una clase usuario, puede instanciar los objetos de esta clase en cualquier parte de su código. A class can extend
another class, and then inherits from its functions and properties (declared and computed).
El modelo de clases en 4D es similar al de las clases en JavaScript, y se basa en una cadena de prototipos.
Por ejemplo, puede crear una clase Person
con la siguiente definición:
//Class: Person.4dm
Class constructor($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname
Function get fullName() -> $fullName : Text
$fullName:=This.firstName+" "+This.lastName
Function sayHello() -> $welcome : Text
$welcome:="Hello "+This.fullName
En un método, creando una "Persona":
var $person : cs.Person //object of Person class
var $hello : Text
$person:=cs.Person.new("John";"Doe")
// $person:{firstName: "John"; lastName: "Doe"; fullName: "John Doe"}
$hello:=$person.sayHello() //"Hello John Doe"
Gestión de clases
Definición de una clase
Una clase usuario en 4D está definida por un archivo método específico (.4dm), almacenado en la carpeta /Project/Sources/Classes/
. El nombre del archivo es el nombre de la clase.
Al nombrar las clases, debe tener en cuenta las siguientes reglas:
- Un nombre de clase debe cumplir con reglas de denominación de las propiedades.
- .
- No se recomienda dar el mismo nombre a una clase y a una tabla de la base, para evitar conflictos.
Por ejemplo, si quiere definir una clase llamada "Polygon", tiene que crear el siguiente archivo:
Project folder Project Sources Classes Polygon.4dm
Borrar una clase
Para eliminar una clase existente, puede:
- en su disco, elimine el archivo de clase .4dm de la carpeta "Classes",
- in the 4D Explorer, select the class and click or choose Move to Trash from the contextual menu.
Utilizar la interfaz 4D
Los archivos de clase se almacenan automáticamente en la ubicación adecuada cuando se crean a través de la interfaz de 4D, ya sea a través del menú Archivo o del Explorador.
Menú Archivo y barra de herramientas
Puede crear un nuevo archivo de clase para el proyecto seleccionando Nueva > Clase... en el menú Archivo de 4D Developer o en la barra de herramientas.
También puede utilizar el atajo Ctrl+Mayús+Alt+k.
Explorador
En la página Métodos del Explorador, las clases se agrupan en la categoría Clases.
Para crear una nueva clase, puede:
- select the Classes category and click on the button.
- seleccione Nueva clase... en el menú de acciones de la parte inferior de la ventana del Explorador, o en el menú contextual del grupo Clases.
- seleccione Nueva > Clase... en el menú contextual de la página de inicio del Explorador.
Soporte del código de clase
En las diferentes ventanas 4D (editor de código, compilador, depurador, explorador de ejecución), el código de la clase se maneja básicamente como un método proyecto con algunas especificidades:
- En el editor de código:
- una clase no puede ser ejecutada
- una función de clase es un bloque de código
- Ir a la definición en un objeto miembro busca las declaraciones de función de clase; por ejemplo, "$o.f()" encontrará "Function f".
- Buscar referencias en la declaración de función de clase busca la función utilizada como miembro de objeto; por ejemplo, "Function f" encontrará "$o.f()".
- En el explorador de Ejecución y Depurador, las funciones clase se muestran con el formato
<ClassName>
constructor o<ClassName>.<FunctionName>
.
Class stores
Las clases disponibles son accesibles desde sus class stores. Hay dos class stores disponibles:
cs
para el almacén de clases de usuario4D
para el class store integrado
cs
cs : Object
Parámetros | Tipo | Descripción | ||
---|---|---|---|---|
classStore | Object | <- | Class store usuario para el proyecto o componente |
The cs
command returns the user class store for the current project or component. Devuelve todas las clases de usuario definidas en el proyecto o componente abierto. Por defecto, sólo las clases ORDA están disponibles.
Ejemplo
Quiere crear una nueva instancia de un objeto de myClass
:
$instance:=cs.myClass.new()
4D
4D : Object
Parámetros | Tipo | Descripción | ||
---|---|---|---|---|
classStore | Object | <- | Class store 4D |
The 4D
command returns the class store for available built-in 4D classes. Ofrece acceso a las APIs específicas como CryptoKey.
Ejemplo
Quiere crear una nueva llave en la clase CryptoKey
:
$key:=4D.CryptoKey.new(New object("type";"ECDSA";"curve";"prime256v1"))
El objeto clase
Cuando una clase es definida en el proyecto, se carga en el entorno del lenguaje 4D. Una clase es un objeto de la clase "Class". Un objeto clase tiene las siguientes propiedades y funciones:
name
stringsuperclass
object (null if none)new()
function, allowing to instantiate class objectsisShared
property, true if the class is sharedisSingleton
property, true if the class defines a singleton.me
property, allowing to instantiate and access singletons.
In addition, a class object can reference a constructor
object (optional).
Un objeto de clase en sí mismo es un objeto compartido y, por tanto, se puede acceder a él desde diferentes procesos de 4D simultáneamente.
Herencia
If a class inherits from another class (i.e. the Class extends keyword is used in its definition), the parent class is its superclass
.
When 4D does not find a function or a property in a class, it searches it in its superclass
; if not found, 4D continues searching in the superclass of the superclass, and so on until there is no more superclass (all objects inherit from the "Object" superclass).
Palabras clave de clase
En las definiciones de clase se pueden utilizar palabras claves específicas de 4D:
Function <Name>
para definir las funciones de clase de los objetos.Class constructor
para inicializar nuevos objetos de la clase.property
para definir propiedades estáticas de los objetos con un tipo.Function get <Name>
yFunction set <Name>
para definir las propiedades calculadas de los objetos.Class extends <ClassName>
para definir la herencia.
Function
Sintaxis
{shared} Function <name>({$parameterName : type; ...}){->$parameterName : type}
// code
Las funciones de clase son propiedades específicas de la clase. Son objetos de la clase 4D.Function. En el archivo de definición de clase, las declaraciones de función utilizan la palabra clave Function
seguida del nombre de la función.
If the function is declared in a shared class, you can use the shared
keyword so that the function could be called without Use...End use
structure. Para obtener más información, consulte el párrafo Funciones compartidas a continuación.
El nombre de la función debe ser compatible con las reglas de nomenclatura de objetos.
Dado que las propiedades y las funciones comparten el mismo espacio de nombres, no está permitido utilizar el mismo nombre para una propiedad y una función de la misma clase (en este caso se produce un error).
Comenzar el nombre de la función con un caracter guión bajo ("_") excluirá la función de las funcionalidades de autocompletado en el editor de código 4D. Por ejemplo, si declara Function _myPrivateFunction
en MyClass
, no se propondrá en el editor de código cuando digite en "cs.MyClass. "
.
Inmediatamente después del nombre de la función, los parámetros de la función se pueden declarar con un nombre y un tipo de datos asignados, incluido el parámetro de retorno (opcional). Por ejemplo:
Function computeArea($width : Integer; $height : Integer)->$area : Integer
En una función de clase, el comando This
se utiliza como instancia del objeto. Por ejemplo:
Function setFullname($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname
Function getFullname()->$fullname : Text
$fullname:=This.firstName+" "+Uppercase(This.lastName)
Para una función clase, el comando Current method name
devuelve: <ClassName>.<FunctionName>
, por ejemplo "MyClass.myFunction".
En el código de la aplicación, las funciones de clases se llaman como los métodos miembros de las instancias de objetos y pueden recibir parámetros si los hay. Se soportan las siguientes sintaxis:
- uso del operador
()
. Por ejemplo,myObject.methodName("hello")
- utilización de un método miembro de la clase "4D.Function":
Si una función de clase no es hilo seguro y es llamada por un método con el atributo "Puede ejecutarse en proceso apropiativo":
- el compilador no genera ningún error (lo que es diferente en comparación con los métodos regulares),
- un error es lanzado por 4D sólo en tiempo de ejecución.
Parámetros
Los parámetros de las funciones se declaran utilizando el nombre del parámetro y su tipo, separados por dos puntos. El nombre del parámetro debe cumplir con las reglas de nomenclatura de las propiedades. Múltiples parámetros (y tipos) están separados por punto y coma (;).
Function add($x; $y : Variant; $z : Integer; $xy : Object)
Si no se declaró el tipo, el parámetro se definirá como Variant
.
Valor devuelto
Se declara el parámetro de retorno (opcional) añadiendo una flecha (->
) y la definición del parámetro de retorno después de la lista de parámetros de entrada, o dos puntos (:
) y el tipo de parámetro de retorno únicamente. Por ejemplo:
Function add($x : Variant; $y : Integer)->$result : Integer
$result:=$x+$y
You can also declare the return parameter by adding only : type
and use the return expression
(it will also end the function execution). Por ejemplo:
Function add($x : Variant; $y : Integer): Integer
// algo de código
return $x+$y
Ejemplo 1
property name : Text
property height; width : Integer
// Class: Rectangle
Class constructor($width : Integer; $height : Integer)
This.name:="Rectangle"
This.height:=$height
This.width:=$width
// Function definition
Function getArea()->$result : Integer
$result:=(This.height)*(This.width)
// En un método proyecto
var $rect : cs.Rectangle
var $area : Real
$rect:=cs.Rectangle.new(50;100)
$area:=$rect.getArea() //5000
Ejemplo 2
This example uses the return expression
:
Function getRectArea($width : Integer; $height : Integer) : Integer
If ($width > 0 && $height > 0)
return $width * $height
Else
return 0
End if
Class Constructor
Sintaxis
// Class: MyClass
{shared} {singleton} Class Constructor({$parameterName : type; ...})
// code
Una función constructora de clase acepta parámetros opcionales y puede ser utilizada para crear e inicializar objetos de la clase del usuario.
When you call the new()
function, the class constructor is called with the parameters optionally passed to the new()
function.
Sólo puede haber una función constructora en una clase (de lo contrario se devuelve un error). A constructor can use the Super
keyword to call the constructor of the super class.
Puede crear y escribir propiedades de instancia dentro del constructor (ver ejemplo). Alternatively, if your instance properties' values do not depend on parameters passed to the constructor, you can define them using the property
keyword.
Utilizando la palabra clave shared
se crea una clase compartida, utilizada para instanciar únicamente objetos compartidos. Para obtener más información, consulte el párrafo Clases compartidas.
Utilizando la palabra clave singleton
se crea un singleton, utilizado para crear una única instancia. Para obtener más información, consulte el párrafo Clases singleton.
Ejemplo
// Class: MyClass
// Class constructor of MyClass
Class Constructor ($name : Text ; $age : Integer)
This.name:=$name
This.age:=$age
// En un método proyecto
// Se puede instanciar un objeto
var $o : cs.MyClass
$o:=cs.MyClass.new("John";42)
// $o = {"name":"HelloWorld";"age":42}
propiedad
Sintaxis
property <propertyName>{; <propertyName2>;...}{ : <propertyType>}
La palabra claveproperty
se puede utilizar para declarar una propiedad dentro de una clase usuario. Una propiedad de clase tiene un nombre y un tipo.
La declaración de propiedades de clase mejora las sugerencias del editor de código, las funciones de tecleo predictivo y la detección de errores.
Properties are declared for new objects when you call the new()
function, however they are not automatically added to objects (they are only added when they are assigned a value).
Una propiedad se añade automáticamente al objeto cuando se inicializa en la línea de declaración.
Los nombres de las propiedades deben cumplir las normas de denominación de propiedades.
Dado que las propiedades y las funciones comparten el mismo espacio de nombres, no está permitido utilizar el mismo nombre para una propiedad y una función de la misma clase (en este caso se produce un error).
El tipo de propiedad puede ser uno de los siguientes tipos soportados:
propertyType | Contenido |
---|---|
Text | Valor texto |
Date | Valor fecha |
Time | Valor Hora |
Boolean | Valor booleano |
Integer | Valor entero largo |
Real | Valor real |
Pointer | Valor puntero |
Picture | Valor imagen |
Blob | Valeor Blob escalar |
Collection | Valor colección |
Variant | Valor variant |
Object | Objeto con clase por defecto (4D.object) |
4D.<className> | Objeto del nombre de la clase 4D |
cs.<className> | Objeto del nombre de la clase usuario |
cs.<namespace>.<className> | Objeto del componente <namespace> nombre de la clase |
Si omite el tipo en la línea de declaración, la propiedad se crea como una variante.
La palabra clave property
sólo puede utilizarse en métodos clase y fuera de cualquier bloque Function
o Class Constructor
.
Inicialización de la propiedad en la línea de declaración
Al declarar una propiedad, tiene la flexibilidad de especificar su tipo de datos y proporcionar su valor en una sola declaración. La sintaxis soportada es:
property <propertyName> { : <propertyType>} := <Propertyvalue>
Cuando se utiliza esta sintaxis, no se pueden declarar varias propiedades en la línea de declaración.
Puede omitir el tipo en la línea de declaración, en cuyo caso el tipo se deducirá cuando sea posible. Por ejemplo:
// Class: MyClass
property name : Text := "Smith"
property age : Integer := 42
property birthDate := !1988-09-29! //date is inferred
property fuzzy //variant
When you initialize a property in its declaration line, it is added to the class object after its instantiation with the new()
function but before the constructor is called.
Si una clase extiende a otra, las propiedades de la clase padre se instancian antes que las propiedades de la clase hija.
Ejemplo
// Clase: MyClass
property name : Text
property age : Integer
property color : Text := "Blue"
En un método:
var $o : cs.MyClass
$o:=cs.MyClass.new() //$o:{"color" : "Blue"}
$o.name:="Juan" //$o:{"color" : "Azul"; "name" : "John"}
$o.age:="Smith" //error con la sintaxis de verificación
Function get
y Function set
Sintaxis
{shared} Function get <name>()->$result : type
// código
{shared} Function set <name>($parameterName : type)
// código
Function get
y Function set
son accesos que definen las propiedades calculadas en la clase. Una propiedad calculada es una propiedad nombradas con un tipo de datos que enmascara un cálculo. Cuando se accede a un valor de propiedad calculado, 4D sustituye el código del accesor correspondiente:
- cuando se lee la propiedad,
Function get
se ejecuta, - cuando se escribe la propiedad,
Function get
se ejecuta.
Si no se accede a la propiedad, el código nunca se ejecuta.
Las propiedades calculadas están diseñadas para manejar datos que no necesitan ser guardados en memoria. Generalmente se basan en propiedades persistentes. For example, if a class object contains as persistent property the gross price and the VAT rate, the net price could be handled by a computed property.
In the class definition file, computed property
En el archivo de definición de la clase, las declaraciones de propiedades calculadas utilizan las palabras claves Function get
(getter) y Function set
(setter) seguido por el nombre de la propiedad. El nombre debe cumplir con las reglas de nomenclatura de las propiedades.
Función get
devuelve un valor del tipo de la propiedad y Function set
toma un parámetro del tipo de la propiedad. Ambos argumentos deben cumplir con los parámetros de función estándar.
Cuando ambas funciones están definidas, la propiedad calculada es read-write. Si solo se define una Function get
, la propiedad calculada es de solo lectura. En este caso, se devuelve un error si el código intenta modificar la propiedad. If only a Function set
is defined, 4D returns undefined when the property is read.
If the functions are declared in a shared class, you can use the shared
keyword with them so that they could be called without Use...End use
structure. Para obtener más información, consulte el párrafo Funciones compartidas a continuación.
El tipo de la propiedad calculada es definido por la declaración de tipo $return
del *getter *. Puede ser de cualquier tipo de propiedad válido.
Asignar undefined a una propiedad de objeto limpia su valor mientras se preserva su tipo. Para ello, la
Function get
es llamada primero para recuperar el tipo de valor, luegoFunction set
es llamado con un valor vacío de ese tipo.
Ejemplo 1
//Class: Person.4dm
property firstName; lastName : Text
Class constructor($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname
Function get fullName() -> $fullName : Text
$fullName:=This.firstName+" "+This.lastName
Function set fullName( $fullName : Text )
$p:=Position(" "; $fullName)
This.firstName:=Substring($fullName; 1; $p-1)
This.lastName:=Substring($fullName; $p+1)
//en un método proyecto
$fullName:=$person.fullName // Function get fullName() is called
$person.fullName:="John Smith" // Function set fullName() is called
Ejemplo 2
Function get fullAddress()->$result : Object
$result:=New object
$result.fullName:=This.fullName
$result.address:=This.address
$result.zipCode:=This.zipCode
$result.city:=This.city
$result.state:=This.state
$result.country:=This.country
Class extends <ClassName>
Sintaxis
// Class hijo
Class extends <ParentClass>
La palabra clave Class extends
se utiliza en la declaración de clase para crear una clase usuario que es hijo de otra clase usuario. La clase hijo hereda todas las funciones de la clase padre.
La extensión de clase debe respetar las siguientes reglas:
- Una clase de usuario no puede extender una clase integrada (excepto las 4D.Object y clases ORDA que se extienden por defecto para las clases de usuario).
- Una clase usuario no puede extender una clase usuario de otro proyecto o componente.
- Una clase usuario no puede extenderse a sí misma.
- No es posible extender las clases de una manera circular (es decir, "a" extiende "b" que extiende "a").
- No es posible definir una clase usuario compartida extendida a partir de una clase usuario no compartida.
La ruptura de tal regla no es detectada por el editor de código o el intérprete, solo el compilador y comprobar sintaxis
arrojará un error en este caso.
An extended class can call the constructor of its parent class using the Super
command.
Ejemplo
Este ejemplo crea una clase llamada Square
de una clase llamada Polygon
.
//Class: Square
//path: Classes/Square.4dm
Class extends Polygon
Class constructor ($side : Integer)
// It calls the parent class's constructor with lengths
// provided for the Polygon's width and height
Super($side;$side)
// In derived classes, Super must be called before you
// can use 'This'
This.name:="Square"
Function getArea() -> $area : Integer
$area:=This.height*This.width
Super
Super( ...param : any )
Super : Object
Parámetros | Tipo | Descripción | |
---|---|---|---|
param | any | -> | Parámetro(s) a pasar al constructor de la clase padre |
Result | Object | <- | Padre del objeto |
The Super
keyword allows calls to the superclass
, i.e. the parent class.
Super
tiene dos propósitos diferentes:
- Dentro de un código constructor,
Super
es un comando que permite llamar al constructor de la superclase. Cuando se utiliza en un constructor, el comandoSuper
aparece solo y debe ser usado antes de usar la palabra claveThis
.
- Si todos los class constructors en el árbol de herencia no son llamados correctamente, se genera el error -10748. Es responsabilidad del desarrollador 4D asegurarse de que las llamadas sean válidas.
- Si el comando
This
es llamado en un objeto cuyas superclases no han sido construidas, se genera el error -10743. - Si se llama a
Super
fuera de un contexto de objeto, o en un objeto cuyo constructor de superclase ya ha sido llamado, se genera el error -10746.
// dentro del constructor myClass
var $text1; $text2 : Texto
Super($text1) //llamada del constructor de la superclase con un parámetro texto
Este. aram:=$text2 // usar un segundo parámetro
- Dentro de una función de clase,
Super
designa el prototipo de la superclase y permite llamar a una función de la jerarquía de superclases.
Super.doSomething(42) //llama a la función "doSomething"
//declarada en superclases
Ejemplo 1
Este ejemplo ilustra el uso de Super
en un class constructor. El comando es llamado para evitar duplicar las partes del constructor que son comunes entre las clases Rectangle
y Square
.
// Class: Rectangle
Class constructor($width : Integer; $height : Integer)
This.name:="Rectangle"
This.height:=$height
This.width:=$width
Function sayName()
ALERT("Hi, I am a "+This.name+".")
// Function definition
Function getArea()
var $0 : Integer
$0:=(This.height)*(This.width)
//Class: Square
Class extends Rectangle
Class constructor ($side : Integer)
// Llama al class constructor de la clase padre con longitudes
// proporcionadas para el ancho y alto del rectángulo
Super($side;$side)
// En las clases derivadas, Super debe ser llamado antes de que
// pueda utilizar 'This'
This. ame:="Square"
Function getArea()
C_LONGINT($0)
$0:=This.height*This.width
Ejemplo 2
Este ejemplo ilustra el uso de Super
en un método miembro clase. Ha creado la clase Rectangle
con una función:
//Class: Rectangle
Function nbSides()
var $0 : Text
$0:="I have 4 sides"
También creó la clase Square
con una función que llama a la función superclase:
//Class: Square
Class extends Rectangle
Function description()
var $0 : Text
$0:=Super.nbSides()+" which are all equal"
Entonces puede escribir en un método proyecto:
var $square : Objeto
var $message : Texto
$square:=cs.Square.new()
$message:=$square.description() //tengo 4 lados iguales
This
This : Object
Parámetros | Tipo | Descripción | |
---|---|---|---|
Result | Object | <- | Objeto actual |
The This
keyword returns a reference to the currently processed object.
En la mayoría de los casos, el valor de This
está determinado por cómo se llama una función. No se puede definir por asignación durante la ejecución, y puede ser diferente cada vez que se llame a la función.
Cuando se llama a una fórmula como método miembro de un objeto, su This
se define en el objeto sobre el que se llama al método. Por ejemplo:
$o:=New object("prop";42;"f";Formula(This.prop))
$val:=$o.f() //42
When a class constructor function is used (with the new()
function), its This
is bound to the new object being constructed.
//Class: ob
Class Constructor
// Crear las propiedades en This
// asignándolas
This.a:=42
// en un método 4D
$o:=cs.ob.new()
$val:=$o.a //42
Al llamar a la superclase del constructor en un constructor utilizando la palabra clave Super, tenga en cuenta que
This
no debe ser llamado antes del constructor de la superclase, de lo contrario se genera un error. Ver este ejemplo.
En todos los casos, This
se refiere al objeto sobre el que se ha llamado el método, como si el método fuera una función del objeto.
//Class: ob
Function f()
$0:=This.a+This.b
Entonces puede escribir en un método proyecto:
$o:=cs.ob.new()
$o.a:=5
$o.b:=3
$val:=$o.f() //8
En este ejemplo, el objeto asignado a la variable $o no tiene su propia propiedad f, la hereda de su clase. Como f es llamado como un método de $o, su This
se refiere a $o.
Comandos de clases
Varios comandos del lenguaje 4D permiten manejar las funcionalidades de las clases.
OB Class
OB Class ( object ) -> Object | Null
OB Class
devuelve la clase del objeto pasado como parámetro.
OB Instance of
OB Instance of ( object ; class ) -> Boolean
OB Instance of
devuelve true
si object
pertenece a la class
o a una de las clases heredadas y false
de lo contrario.
Clases compartidas
Puede crear clases compartidas. A shared class is a user class that instantiates a shared object when the new()
function is called on the class. Una clase compartida sólo puede crear objetos compartidos.
Shared classes also support shared functions that can be called without Use...End use
structures.
The .isShared
property of Class objects allows to know if the class is shared.
- Una clase que hereda de una clase no compartida no puede definirse como compartida.
- Las clases compartidas no están soportadas por las clases basadas en ORDA.
Creación de una clase compartida
Para crear una clase compartida, añada la palabra clave shared
antes del Class Constructor. Por ejemplo:
//shared class: Person
shared Class Constructor($firstname : Text; $lastname : Text)
This.firstName:=$firstname
This.lastName:=$lastname
//myMethod
var $person := cs.Person.new("John"; "Smith")
OB Is shared($person) // true
cs.Person.isShared //true
Funciones compartidas
If a function defined inside a shared class modifies objects of the class, it should call Use...End use
structure to protect access to the shared objects. Sin embargo, para simplificar el código, puede definir la función como compartida, de modo que active automáticamente un Use...End use
interno cuando se ejecute.
Para crear una función compartida, añada la palabra clave shared
antes de la palabra clave Function en una clase compartida. Por ejemplo:
//shared class Foo
shared Class Constructor()
This.variable:=1
shared Function Bar($value : Integer)
This.variable:=$value //no need to call use/end use
Si se utiliza la palabra clave shared
en una clase usuario no compartida, se ignora.
Clases Singleton
Una clase singleton es una clase usuario que sólo produce una única instancia. Para más información sobre los singletons, por favor consulte la página Wikipedia sobre los singletons.
The class singleton is instantiated at the first call of the cs.<class>.me
property. The instantiated class singleton is then always returned when the me
property is used.
If you need to instantiate a singleton with parameters, you can also call the new()
function. En este caso, se recomienda instanciar el singleton en algún código ejecutado al inicio de la aplicación.
El alcance de una instancia singleton puede ser el proceso actual o todos los procesos. Un singleton process tiene un valor único para el proceso en el que se instancia, mientras que un singleton interprocess tiene un valor único para todos los procesos de la aplicación. Los singletons son útiles para definir los valores que necesitan estar disponibles desde cualquier parte de una aplicación o proceso.
The .isSingleton
property of Class objects allows to know if the class is a singleton.
Las clases Singleton no están soportadas por las clases ORDA.
Creación de un singleton process
To create a process singleton class, add the singleton
keyword before Class Constructor
. Por ejemplo:
//class: ProcessTag
singleton Class Constructor()
This.tag:=Random
Para utilizar el singleton process:
//in a process
var $mySingleton := cs.ProcessTag.me //First instantiation
//$mySingleton.tag = 5425 for example
...
var $myOtherSingleton := cs.ProcessTag.me
//$myOtherSingleton.tag = 5425
//in another process
var $mySingleton := cs.ProcessTag.me //First instantiation
//$mySingleton.tag = 14856 for example
...
var $myOtherSingleton := cs.ProcessTag.me
//$myOtherSingleton.tag = 14856
Creación de un singleton interprocess
Para crear un singleton interprocess, añada las palabras claves shared singleton
antes del Class Constructor. Por ejemplo:
//Class VehicleFactory
property vehicleBuilt : Integer
shared singleton Class constructor()
This.vehicleBuilt := 0 //Number of vehicles built by the factory
shared Function buildVehicle ($type : Text) -> $vehicle : cs.Vehicle
Case of
: $type="car"
$vehicle:=cs.Car.new()
: $type="truck"
$vehicle:=cs.Truck.new()
: $type="sport car"
$vehicle:=cs.SportCar.new()
: $type="motorbike"
$vehicle:=cs.Motorbike.new()
Else
$vehicle:=cs.Car.new()
End case
This.vehicleBuilt+=1
Luego puede llamar al singleton cs.VehicleFactory para obtener un nuevo vehículo desde cualquier lugar de su aplicación con una sola línea:
$vehicle:=cs.VehicleFactory.me.buildVehicle("truck")
Dado que la función buildVehicle() modifica el singleton cs.VehicleFactory (incrementando This.vehicleBuilt
), debe agregar la palabra clave shared
.
Ver también
Ver también esta entrada de blog para más detalles.