AYUDA EN LÍNEA
 WINDEVWEBDEV Y WINDEV MOBILE

Este contenido se ha traducido automáticamente.  Haga clic aquí  para ver la versión en inglés.
Ayuda / WLanguage / POO (Programación Orientada a Objetos)
  • Presentación
  • ¿Cómo proceder?
  • Operaciones realizadas mediante ExecuteProcess y mediante los operadores indirectos
  • Utilización de ExecuteProcess
  • Utilizando los operadores indirectos { ... }
  • Ejemplo
WINDEV
WindowsLinuxUniversal Windows 10 AppJavaReportes y ConsultasCódigo de Usuario (UMC)
WEBDEV
WindowsLinuxPHPWEBDEV - Código Navegador
WINDEV Mobile
AndroidWidget Android iPhone/iPadIOS WidgetApple WatchMac CatalystUniversal Windows 10 App
Otros
Procedimientos almacenados
Presentació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 { }.
¿Cómo proceder?
Los diferentes pasos para enumerar y manejar un objeto son los siguientes:
  1. 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
  2. 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.
  3. 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.
  4. 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
Ejemplo
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
Versión mínima requerida
  • Versión 16
Esta página también está disponible para…
Comentarios
Haga clic en [Agregar] para publicar un comentario

Última modificación: 27/05/2022

Señalar un error o enviar una sugerencia | Ayuda local