|
|
|
|
|
|
|
|
|
|
- Presentación
- ¿Cómo proceder?
- Operaciones realizadas mediante ExecuteProcess y mediante los operadores indirectos
- Utilización de ExecuteProcess
- Utilizando los operadores indirectos { ... }
- Ejemplo
Elementos de una clase: Enumeración y manejo a través de la programación
Varios tipos de variables de WLanguage se utilizan para enumerar y manipular dinámicamente los elementos de una clase. Un desarrollador que esté familiarizado con la Programación Orientada a Objetos (POO) puede crear métodos personalizados que se adapten a los elementos que se encuentran en un sistema class. Tienes la habilidad de enumerar: Durante esta enumeración, usted tendrá la habilidad de recuperar: - el nombre del elemento.
- el tipo de elemento.
Por ejemplo: - capacidad de recuperar el nombre de un método para llamarlo utilizando ExecuteProcess.
- capacidad de recuperar el nombre y el tipo de una variable para averiguar o asignar su valor mediante el uso de la operadores indirectos { }.
Los diferentes pasos para enumerar y manejar un objeto son los siguientes: - Recuperación de la Definition del objeto a manipular a través de GetDefinition.
Ejemplo:
O is cWord // Instantiation of the CWord class
Def is Definition // Declaration of a Definition variable
Def = GetDefinition(O) // Retrieve the definition of the O object in the Def variable
Trace(Def..Name) // Display the name of the object
Trace(Def.DefinitionFamily)
Trace(Def.Type) // Display the type of the object
- Recuperación de la lista de métodos. Se utiliza un bucle "FOR EACH" para leer la propiedad Procedimiento del Definition Variable. Esta Property corresponde a una array que contiene todos los procedimientos encontrados en el objeto descrito.
Ejemplo:
// Declaration of the variable that will contain the description of a procedure
Proc is procedure Description
// List of procedures (or methods) of the Def object
FOR EACH Proc OF Def.Procedure
Trace (Proc.Name) // Displays the name of the procedure found
END
Puede acceder a otras propiedades utilizando el nombre Property Property en el objeto. Para obtener más información, consulte Procedure Description. - Recuperación de la lista de propiedades. Se utiliza un bucle FOR EACH para leer el Property Property. Esta Property corresponde a una array que contiene todas las propiedades encontradas en el objeto descrito.
Ejemplo:
// Declaration of a variable that will contain the description of a property
Prop is Property Description
// List of properties of the Def object
FOR EACH Prop OF Def.Property
Trace (Prop.Name) // Displays the name of the property found
END
Puede acceder a otras propiedades utilizando el nombre Property Property en el objeto. Para obtener más información, consulte Property Description.
También puede utilizar PropertyExist para determinar si existe un Property específico en una clase. - Recuperación de la lista de variables. Un bucle FOR EACH lee la propiedad Variable. Esta Property corresponde a una array que contiene todas las variables encontradas en el objeto descrito.
Ejemplo:
// Declaration of the variable that will contain the description of a variable
Prop is Variable Description
// List of variables of the Def object
FOR EACH Var OF Def.Variable
// Displays the name and type of Variable found
Trace (Var.Name, Var.Declaration.Type, Var.Definition.Name)
END
Puede acceder a otras propiedades utilizando el nombre Property Property en el objeto. Para obtener más información, consulte Variable Description.
Operaciones realizadas mediante ExecuteProcess y mediante los operadores indirectos Utilización de ExecuteProcess ExecuteProcess se utiliza para llamar al código de un event associated con un objeto. Por ejemplo, el siguiente código provoca la llamada del código de clic del botón Validar: ExecuteProcess(ValidateButton, trtClick)
Para ejecutar un método de clase, basta con utilizar una variable de tipo "Procedimiento description" con ExecuteProcess. Por ejemplo: c is BalloonTip
p is procedure Description
Def is Definition
Def = GetDefinition(c)
// Retrieves the first procedure of the BalloonTip object
p = Def.Procedure[1]
// Runs the procedure represented by p of the c object
ExecuteProcess(c, p)
Utilizando los operadores indirectos { ... } Los operadores indirectos { } se utilizan para manipular el contenido de un Variable por direccionamiento indirecto: el nombre del objeto a tratar se encuentra en un Variable. La sintaxis es la siguiente: {Variable_containing_Object_name, VariableType} donde VariableType es una constante del lenguaje que comienza con indXXX. Ejemplo:
// Fills the "EDT_CITY" control with "Montpellier"
ControlName is string
ControlName = "EDT_CITY"
{ControlName, indControl} = "Montpellier"
Para que manipular sea miembro de un método de clase, todo lo que tienes que hacer es pasar { }: - la instancia de la clase
- una variable description Variable o el nombre del miembro.
Por ejemplo:
c is cWord
var is Variable Description
Def is Definition
Def = GetDefinition(c)
// Retrieves the 2nd variable of the class: version of Word
var = Def.Variable[2]
Trace(var.Name) // Displays the variable name
Trace("Version of Word: ",{c, var}) // Displays the version of Word
El siguiente ejemplo de código se utiliza para enumerar todos los procedimientos, propiedades y variables que se encuentran en una clase. En este ejemplo, el cPalabra proviene del ejemplo "WD Controlling Word" (suministrado con WINDEV). o is cWord
def is Definition
def = GetDefinition(o)
Trace(def.Nom)
Trace(def.DefinitionFamily)
Trace(def.Type)
Proc is procedure Description
Prop is Property Description
Var is Variable Description
Trace("--------------- Procedures --------------------")
FOR EACH Proc OF def.Procedure
Trace(Proc.Global, Proc.Inherited, Proc.Name, Proc.Virtual)
END
Trace("--------------- Properties --------------------")
FOR EACH Prop OF def.Property
Trace(Prop.Declaration, Prop.Definition, Prop.Write, ...
Prop.Global, Prop.Inherited, Prop.Read, Prop.Name, Prop.Virtual)
END
Trace("--------------- Variables --------------------")
FOR EACH Var OF def.Variable
Trace(Var.Name, Var.Definition.Type, Var.Definition.Name)
SWITCH Var.Definition.Type
CASE 1, 4, 8, 19
// Display the value of the variable via indirection
Trace({o,Var})
CASE 34 // array
Trace("Dimension: ", {o,Var.Nom}..Count)
CASE 36 // structure
v is Variable Description
Trace("Structure " + Var.Definition.Name)
Trace("........................................................")
FOR EACH v OF Var.Definition.Variable
Trace(v.Name, v.Definition.Type, v.Definition.Name)
END
Trace("........................................................")
OTHER CASE
END
Trace("======================================================================")
END
Esta página también está disponible para…
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|