Usar los lenguajes Scripts desde Visual Basic

Ejemplos para usar el control msscript.ocx de Microsoft

Fecha: 5/Sep/98


Con este control, podemos usar cualquiera de los lenguajes Script, (JScript o VBScript), desde una aplicación de Visual Basic.
Entre una de las ventajas que se me ocurren es la de poder evaluar fórmulas e incluso crear un pequeño lenguaje de macros en nuestras aplicaciones de Visual Basic. Además de usar las propias intrucciones de los lenguajes Script, podemos usar dentro del lenguaje script propiedades y métodos de clases creadas en VB y usarlas internamente como si fuesen propias del lenguaje, aunque esto me imagino que sólo funcionará con el VBScript... de todas formas, las pruebas realizadas estarán hechas en ese lenguaje, ya que es el más parecido al VB de los dos que ofrece este control.

Para usarlo, lo único que necesitamos es tener el control MSScript.ocx insertado en nuestro formulario y desde ese momento, podemos usarlo, siguiendo las reglas de esos lenguajes, pero se pueden usar.
Vamos a ver un par de ejemplos y después crearemos un formulario que aceptará una serie de instrucciones y asignaciones para ejecutarlas al pulsar en un botón.

Para poder usar este control, tendrás que bajarte el control y las librerías necesarias, son de libre distribución (o al menos de libre uso) y te pongo la dirección de Microsoft desde la que puedes bajartela... yo ya lo tengo instalado y no recuerdo bien cómo llegó a mi equipo, puede ser que ya lo tengas en tu equipo, para comprobarlo, realiza una búsqueda en el disco C: y mira a ver si tienes el msscript.ocx, si es así, no tienes que realizar la descarga.

En caso de que no tengas el control, pasate por esta dirección:
http://msdn.microsoft.com/scripting/
y pincha en la sección Script Control y selecciona download.
Te harán más preguntas que para la declaración de hacienda, y al final puede que hasta te hartes de esperar, pero...
El fichero que me he bajado, aunque ya lo tenía, pero para comprobar, es: sct10en.exe de 247.960 bytes.
Comprobaré si se puede distribuir "gratuitamente" el control, aunque es posible que tengas las librerías correspondientes instaladas en tu equipo...

Una vez que lo tengas instalado y registrado, realmente no hace falta registrarlo para usarlo desde VB, ya que puedes usar el botón "Browse..." y añadir el control a la lista de controles (componentes) disponibles.
Inserta un control en el formulario que te habrá creado al seleccionar un nuevo proyecto y vamos a empezar a probar.

El clásico "Hola Mundo"

El lenguaje que usaremos en estas pruebas, será el VBScript, así será más fácil de entender.
Para hacer un programa que muestre "Hola Mundo", lo único que necesitamos es mostrar esa frase en un MsgBox, y eso es lo que haremos.
Pero para poder usar algo que esté escrito en VBScript, hay que usar algún procedimiento, da igual que sea un Sub o una Función, ya que se tiene que llamar a ese procedimiento, para que la cosa empiece a funcionar.
Veamos el ejemplo y cómo lo insertaríamos en el control:

'Prueba 1 de ScriptControl
Dim sCodigo As String

'El código a procesar
sCodigo = "Sub Hola() MsgBox ""Hola Mundo"" End Sub"
'Añadimos el código al control
ScriptControl1.AddCode sCodigo
'Ejecutamos el procedimiento
ScriptControl1.Run "Hola"

Fíjate que el código se ha escrito en una sóla línea, esto se puede hacer así o usar líneas diferentes, en caso que que tengas el código en un TextBox, puedes usar cambios de líneas e indentar el código para que quede más legible; pero si lo añades manualmente, acuerdate de usar dobles comillas dobles cada vez que quieras poner una cadena literal, sino te encontrarás con un error. Por supuesto que todo el código debe ir en una misma variable.
Una vez que tenemos el código que queremos ejecutar, lo añadimos usando el método AddCode, de esta forma, se añade el código y está listo para ser ejecutado.
Y para ejecutar el código se usa el método Run, después de Run se indicará lo que queremos ejecutar, normalmente el nombre de un procedimiento o función, aunque también se pueden especificar más cosas, por ejemplo los parámetros que espera una función, etc.
Por defecto, el lenguaje usado es el VBScript, pero si queremos usar otro lenguaje, hay que indicarselo mediante la propiedad Language, y los valores aceptados son: JScript y VBScript:
ScriptControl1.Language = "JSCript"

Este control también se puede usar para evaluar expresiones, usando las funciones que incorporan estos lenguajes scripts, al realizar operaciones con el JScript, me he encontrado con algunos errores, ya que algunas veces no distingue una cadena de un número, así que he optado por hacer las pruebas con el VBScript.
Si quieres saber las funciones y demás cosillas que te permiten hacer estos lenguajes Scripts, pincha en los links de la página principal que te llevarán a las páginas correspondientes.

Puedes fabricarte una utilidad que permita al usuario escribir algunas asignaciones a variables y después añadir un método que te de el resultado de la operación, incluso crear una función que devuelva el resultado de las operaciones realizadas y usar ese valor para tus propios cálculos... en fin, cada vez que necesites evaluar expresiones, puedes servirte de este control.

Para hacer las cosas simples, aunque normalmente estos ejemplos simples no suelen servir para nada, vamos a ver cómo evaluar una expresión y obtener el valor devuelto. Para conseguir este valor, se puede usar tanto Run, como Eval, pero esta última es más versátil que la primera, ya que en Run se pueden usar parámetros, pero estos deben especificarse "implícitamente", sin embargo con Eval, se puede usar una cadena que contenga la función que queremos usar y los parámetros correspondientes.
Veremos los dos ejemplos.

'Prueba 2 de ScriptControl
Dim sCodigo As String
Dim vValor As Variant

sCodigo = "Function Multiplica(a, b)" & vbCrLf & _
          "    Multiplica = a * b" & vbCrLf & _
          "End Function"

'Por supuesto que también se podría asignar así:
'sCodigo = "Function Multiplica(a, b) Multiplica = a * b End Function"

'Añadimos el código, especificamos el lenguaje y ejecutamos
With ScriptControl1
    .Language = "VBScript"
    .AddCode sCodigo
    
    'Usamos Run para obtener el resultado
    'vValor = .Run("Multiplica", "2", "5")
    
    'Usando Eval, nos permite que la expresión esté en
    'una variable... además de hacerlo directamente,
    'pero se usa de la misma forma que lo haríamos desde VB
    vValor = .Eval("Multiplica(2,5)")
    
    'Mostramos el valor devuelto
    MsgBox "El valor devuelto es: " & vValor
End With

En el caso de Run, además de tener que indicar el nombre de la función a ejecutar, que se puede indicar mediante una variable, hay que especificar los parámetros que necesita esa función, por tanto, es preferible usar este método cuando sepamos los valores que se necesitan.

Por otro lado, usando Eval, tenemos mayor libertad, ya que se puede usar el contenido de una variable, en la que se ha asignado lo que queremos evaluar. Por ejemplo, podríamos tener en un formulario un TextBox para incluir todo el código, en otro TextBox se podría introducir lo que queremos evaluar, de esta forma sería fácil de hacer, ya que el usuario tendría que escribir lo que quiere evaluar y nosotros simplemente tendríamos que pasar como parámetro el contenido de ese otro TextBox.

Pero como siempre, vamos a verlo con un ejemplo:
Crea un nuevo proyecto, inserta el control msscript.ocx, un TextBox (Text1) con la propiedad Multiline=True y que tenga las dos barras de scroll, añade otro TextBox (Text2), para insertar lo que queremos evaluar y CommandButon (cmdEval) para que al pulsarlo se ejecute el código.
En este botón vamos a usar una rutina de detección de errores, ya que los errores se detectan en tiempo de ejecución, ya que todo lo que se ejecuta con los Scripts no es "compilado", sino interpretado... como en los viejos tiempos del Basic de MS-DOS.

Una nota importante, todo lo que se inserte en la caja de texto a evaluar, debe ser una función, o alguna operación que devuelva un valor. Por ejemplo: 25 * 2 dará el resultado esperado.

Vamos a ver una imagen del formulario en tiempo de ejecución:

Y este es el código:

'------------------------------------------------------------------
'Pruebas de uso del control ScriptControl               (28/Jun/98)
'
'Revisado:                                              (27/Ago/98)
'Para el ejemplo en mis páginas:                        (04/Sep/98)
'
'©Guillermo 'guille' Som, 1998
'------------------------------------------------------------------
Option Explicit


Private Sub Form_Load()
    'Un poco de texto de ejemplo:
    Text1 = "Function Multiplica(a, b)" & vbCrLf & _
            "    Multiplica = a * b" & vbCrLf & _
            "End Function"
    
    Text2 = "Multiplica(2,5)"
End Sub


Private Sub cmdEval_Click()
    'Ejecutar el contenido del Text2
    Dim retValue As Variant
    
    'Interceptamos los posibles errores
    On Local Error GoTo Error_Ejecutar
    
    'Añadimos el código y evaluamos
    With ScriptControl1
        .AddCode Text1
        'Esta asignación no es necesaria, ya que VBScript
        'es el lenguaje por defecto
        .Language = "VBScript"
        'Asignamos el valor devuelto
        retValue = .Eval(Text2)
        ' y lo mostramos
        MsgBox "El valor devuelto por: " & Text2 & vbCrLf & " es: " & retValue
    End With
    
    Exit Sub
Error_Ejecutar:
    MsgBox "Se ha producido el siguiente error:" & vbCrLf & _
            ScriptControl1.Error.Number & ", " & _
            ScriptControl1.Error.Description
    Err = 0
End Sub

Pero este control tiene un montón de posibilidades más, por ejemplo, podemos crear nuestros propios módulos e insertarlo en el control y después añadir funciones y otros procedimientos a ese módulo.
También podemos crear una clase y usar esa clase desde el código insertado en el propio control, es decir que podemos extender el "vocabulario" del lenguaje script, de la misma forma que ampliamos el de Visual Basic.

Veamos un ejemplo de esto que acabo de decir:

Crea un nuevo proyecto, añade al formulario el control msscript.ocx.
Añade un módulo de clase normal, cambiale el nombre a cMiClase, añade este código al módulo de clase:

'------------------------------------------------------------------
'Módulo de ejemplo para usar con el control msscript    (04/Sep/98)
'cMiClase.cls
'
'©Guillermo 'guille' Som, 1998
'------------------------------------------------------------------
Option Explicit


Public Function Multiplica(x, y)
    Multiplica = x * y
End Function

Escribe esto en el evento Form_Load:

'Prueba 4 de ScriptControl
Dim miObjeto As cMiClase
Dim sCodigo As String

Set miObjeto = New cMiClase

sCodigo = _
    "Sub PruebaObjeto(a,b)" & vbCrLf & _
    "    Dim Valor" & vbCrLf & _
    "    Valor = MiObjetoScript.Multiplica(a,b)" & vbCrLf & _
    "    Msgbox ""El valor es: "" & Valor" & vbCrLf & _
    "End Sub"
    
With ScriptControl1
    .AddObject "MiObjetoScript", miObjeto
    .AddCode sCodigo
    .Run "PruebaObjeto", 3, 4
End With

Por supuesto que si la clase acepta propiedades, podemos asignar esas propiedades desde el código del script, de la misma forma que asignaríamos en cualquier programa VB.
En este ejemplo, en AddObject, se especifica el nombre del objeto, (para usar en el código script), en este caso es: MiObjetoScript y a continuación se inserta el objeto que acabamos de crear.
Después desde el propio código a usar, llamamos a la función "Multiplica" de igual forma a como lo haríamos en un programa normal y corriente.

Si quieres seguir experimentando, en la ayuda que se incluye con el control vienen unos cuantos ejemplos, de los cuales he tomado los que aquí te he puesto... je, je.

Así que vamos a dejarlo por hoy y más adelante veremos si pongo algo más. Es que aún no he experimentado mucho con este control y no me he "visto" todos los ejemplos...

 

Nos vemos.
Guillermo


la Luna del Guille o... el Guille que está en la Luna... tanto monta...