Leer registros de una base de datos mysql en as3 y asp

Leemos los registros de una db mysql mediante un script asp al que le pasamos una cadeena con la orden sql, y nos devuelve un xml con el resultado.
En este ejemplo añadí un datagrid al escenario, que llamé dg y que se encarga de recibir los datos.Se llama por ejemplo así:
var datosdb:leeDb = new leeDb();
datosdb.carga_datos ("select * from usuarios");
Archivos: leeDb.as, leeDb.asp

leeDb.as

package codigo{
 import flash.display.*;
 import flash.events.*;
 import flash.net.*;
 import fl.controls.DataGrid;
 import fl.controls.dataGridClasses.DataGridColumn;
 import fl.data.DataProvider;
 // clase
 public class leeDb extends Sprite {
  public var dg:DataGrid;
  //  constructor
  public function leeDb ():void {
   trace ("constructor");
  }
  public function carga_datos (sql:String):void {
   // sql a URLVariables
   var urlVariables:URLVariables=new URLVariables;
   urlVariables.sql=sql;

   // definimos valores de llamada
   var urlRequest:URLRequest=new URLRequest;
   urlRequest.method=URLRequestMethod.POST;
   urlRequest.url="http://localhost/webprueba/codigo/leeDb.asp";
   urlRequest.data=urlVariables;

   // creo loader y evento
   var urlLoader:URLLoader=new URLLoader;
   urlLoader.addEventListener (Event.COMPLETE,cargaCompleta);

   // leemos
   urlLoader.load (urlRequest);

  }
  // _______________funciones___________________________________
  private function cargaCompleta (evento:Event):void {
   var myxml:XML = new XML(evento.target.data);
   var totalRegistros:int = myxml.child("*").length();
   var totalCampos:int = myxml.child(0).child("*").length();
   var dp:DataProvider = new DataProvider(myxml);
   // ponemos columnas
   var columna:DataGridColumn = new DataGridColumn ();
   for each (var item:XML in myxml.child(0).elements()) {
    columna = dg.addColumn(new DataGridColumn(item.name().toString()));
    columna.width = 300 / totalCampos ;
   }
   dg.move (0,200);
   dg.width = 300;
   dg.rowCount = totalRegistros;
   dg.dataProvider = dp;
  }
 }
}

leeDb.asp

<% 'declaramos las variables
dim dbConexion,sql, rs, x, y, tabla
'cadena conexión a db
dbConexion = "Driver={mySQL ODBC 3.51 Driver};Server=localhost;Port=;Option=4;Database=prueba;Uid=;Pwd=;"
'cargamos variable sql
sql = Request.Form("sql")
'leemos datos a tabla
Set rs = Server.CreateObject ("ADODB.RecordSet")
rs.Open sql, dbConexion
tabla = rs.GetRows 
'Cabecera del archivo xml
response.ContentType="text/xml"
Response.Write "<?xml version='1.0' encoding='UTF-8'?>"
Response.Write "<regs>" 
for x = 0 to UBound(tabla,2)    
   Response.Write "<reg>"    
   for y = 0 to UBound(tabla,1)         
       Response.Write "<" & rs.Fields(y).Name & ">"
       Response.Write tabla (y,x)
       Response.Write "</" & rs.Fields(y).Name & ">"
    next
   Response.Write("</reg>")
next
Response.Write("</regs>")
rs.Close
Set rs = Nothing
%>

Comunicación entre clases

Estas dos clases permiten comunicar eventos entre clases.
Su uso es sencillo.En la clase que lanza el evento:

import EventCentral
import ProjectEvent
EventCentral.getInstance().dispatchEvent (new ProjectEvent(ProjectEvent.LANG, {name:"nombreEvento"}));

Y en la clase que escucha el evento:

import EventCentral
import ProjectEvent
EventCentral.getInstance().addEventListener (ProjectEvent.LANG, TuFuncion);

ProjectEvent.as

package
{
 import flash.events.Event;
 // class
 public class ProjectEvent extends Event
 {
     // variables
     public static const LANG:String = "LANG"
 
     public var params:Object;

     /*
        ProjectEvent constructor
        @param $type : the event string
        @param $params : an object containing any number of values to be sent to listeneers
        @return : a reference ot the event
   
      */    
     public function ProjectEvent($type:String, $params:Object = null)
     {
         super($type, true, true);
         this.params = $params
     }
 
     /*
        Overrides the flash.events.Event's clone method
        @return Event
      */    
     public override function clone():Event
     {
         return new ProjectEvent(this.type, this.params);
     }
 
     /*
        Overrides the flash.events.Event's toString method
        @return String - Class name
   
      */    
     override public function toString():String
     {
         return ("[Event ProjectEvent]");
     }
 }

}

EventCentral.as

package
{
 import flash.events.EventDispatcher;
 import flash.events.Event;
 //
 public class EventCentral extends EventDispatcher
 {
     // variables
     private static  var instance:EventCentral=new EventCentral  ;

     // constructor
     public function EventCentral ():void
     {
         super ();
         if (instance)
         {
             throw new Error("EventCentral is a Singleton and can only be accessed through EventCentral.getInstance()");
         }
         //trace ("[EventCentral] : constructed");
     }
     public static  function getInstance():EventCentral
     {
         return instance;
     }
     /*
        Overrides the dispatchEvent method in flash.events.EventDispatcher
        @param $event : any qualified event
        @return Boolean
   
      */
     public override  function dispatchEvent ($event:Event):Boolean
     {
         return super.dispatchEvent($event);
     }
 }
}

Clase para cargar hoja de estilo

Esta clase carga un archivo css y lo asocia a la propiedad estilo para aplicarla al texto.

css.as

package {
  import flash.display.Sprite;
  import flash.events.Event;
  import flash.events.IOErrorEvent;
  import flash.net.*;
  import flash.text.*;

  public class css extends Sprite {

      public var estilo:StyleSheet = new StyleSheet();

      public function css ():void {

          var loader:URLLoader;
          var req:URLRequest=new URLRequest("datos/css/css1.css");
          loader=new URLLoader  ;
          loader.dataFormat = URLLoaderDataFormat.TEXT;

          // loaders
          loader.addEventListener (Event.COMPLETE,onCSSFileLoaded);
          loader.addEventListener (IOErrorEvent.IO_ERROR, catchIOError);

          // llamada
          loader.load (req);
          //_________________________________________________
          function catchIOError (event:IOErrorEvent) {
              trace ("Error encontrado: "+event);
          }
      }
      function onCSSFileLoaded (event:Event):void {
          estilo.parseCSS (event.target.data);
          trace (event.target.data);
      }
  }
}

Clase para mantener varios idiomas en nuestros proyectos

Esta clase mantiene las traducciones a los idiomas que desees.
Las traducciones se guardan en archivos XML (uno por idioma). Las clases EventCentral y ProjectEvent se utilizan para pasar el evento de cambio de idioma al resto de clases para que actualicen sus textos (Las publicaré en breve).Ejemplo de uno de los archivos xml para frances


fr.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xliff PUBLIC "-//XLIFF//DTD XLIFF//EN"
"http://www.oasis-open.org/committees/xliff/documents/xliff.dtd" >
<xliff version="1.0" lang="es">
 <file datatype="plaintext">
  <header></header>
   <body>
   <trans-unit  resname="nombre">
    <source>Nom d'utilisateur</source>
   </trans-unit>

   <trans-unit  resname="clave">
    <source>Mot de passe</source>
   </trans-unit>

   <trans-unit  resname="logeado">
    <source>Utilisateur:</source>
   </trans-unit>

   <trans-unit  resname="no_logeado">
    <source>Mauvais l'utilisateur ou mot de passe.</source>
   </trans-unit>

   <trans-unit  resname="enviar">
    <source>Envoyer</source>
   </trans-unit>

   <trans-unit  resname="usr_vacio">
    <source>L'utilisateur n'existe.</source>
   </trans-unit>

   <trans-unit  resname="cla_vacia">
    <source>Mot de passe n'existe.</source>
   </trans-unit>
  </body>
 </file>
</xliff>

idioma.as

package codigo{
 import EventCentral;
 import ProjectEvent;
 import fl.lang.Locale;
 import flash.display.*;
 import fl.data.DataProvider;
 import fl.controls.*;
 import flash.events.*;

 public class idioma extends Sprite {
  var datos:DataProvider=new DataProvider;
  var combo:ComboBox=new ComboBox;
  // ____________________constructor________________________

  public function idioma ():void {
   //cargo los xml de idiomas y los iniciamos
   Locale.addXMLPath ("es","datos/lang/es.xml");
   Locale.addXMLPath ("en","datos/lang/en.xml");
   Locale.addXMLPath ("fr","datos/lang/fr.xml");
   Locale.setDefaultLang ("es");
   Locale.setLoadCallback (init);
   Locale.loadLanguageXML (Locale.getDefaultLang());
   trace (Locale.stringIDArray);
   // datos combo
   datos.addItem ({data:"es",label:"Español"});
   datos.addItem ({data:"en",label:"English"});
   datos.addItem ({data:"fr",label:"Française"});
   combo.dataProvider=datos;
   combo.addEventListener (Event.CHANGE,accion);
   addChild (combo);
  }
  // _______________funciones___________________________________

  private function init (event:Boolean):void {
   if (event) {
    // mandamos evento inicial para que las demas clases inicien el idioma
    EventCentral.getInstance().dispatchEvent (new ProjectEvent(ProjectEvent.LANG, {name:"Reynaldo"}));
   } else {
    trace ("no se ha podido cargar el archivo de idioma XML.");
   }
  }
  // funciones

  // se ha cambiado el idioma, cambiamos y mandamos evento
  private function accion (evento:Event):void {
   //trace ("idioma: "+evento.target.selectedItem.data);
   Locale.loadLanguageXML (evento.target.selectedItem.data );
   EventCentral.getInstance().dispatchEvent (new ProjectEvent(ProjectEvent.LANG, {name:"Reynaldo"}));
  }
 }
}

Clase para cargar archivos (swf, jpg, gif , png)

Con esta clase cargamos contenido (imagen o swf). También ilustra sobre la utilización de los listeners.

package {

  //Importamos clases
  import flash.display.*;
  import flash.events.*;
  import flash.net.URLRequest;

  public class cargaImagen extends Sprite {

      //_________ Constructor
      public function cargaImagen ():void {
      //
      }
      //____________ Método para iniciar la carga
      public function init (imagen:String):void {

      //Se crea objeto cargador
      var loader:Loader=new Loader  ;
      //Se añaden los listeners
      ponListeners (loader.contentLoaderInfo);
      //Creo el objeto que contiene la petición
      var peticion:URLRequest=new URLRequest(imagen);
      //Cargo la petición
      loader.load (peticion);
      }

      //Añade los listeners al cargador
      function ponListeners (dispatcher:IEventDispatcher):void {
      dispatcher.addEventListener (Event.COMPLETE,completeHandler);
      dispatcher.addEventListener (HTTPStatusEvent.HTTP_STATUS,httpStatusHandler);
      dispatcher.addEventListener (Event.INIT,initHandler);
      dispatcher.addEventListener (IOErrorEvent.IO_ERROR,ioErrorHandler);
      dispatcher.addEventListener (Event.OPEN,openHandler);
      dispatcher.addEventListener (ProgressEvent.PROGRESS,progressHandler);
      }

      //Funcion que se ejecuta cuando termina la descarga.
      function completeHandler (event:Event):void {
      trace ("completeHandler: " + event);
      addChild (event.target.content);
      }

      //Se ejecuta al recibir un código de estado HTTP
      function httpStatusHandler (event:HTTPStatusEvent):void {
      trace ("httpStatusHandler: " + event);
      }

      //Se distribuye cuando las propiedades del objeto cargado están disponibles
      //A partir de su distribucion podriamos modificar el objeto (ancho, escala, etc)
      function initHandler (event:Event):void {
      trace ("initHandler: " + event);
      }

      //Se ejecuta cuando hay un error de entrada/salida, por ejemplo, al intentar cargar un
      //archivo inexistente
      function ioErrorHandler (event:IOErrorEvent):void {
      trace ("ioErrorHandler: " + event);
      }

      //Se ejecuta cuando comienza la operación de carga
      function openHandler (event:Event):void {
      trace ("openHandler: " + event);
      }

      //Se ejecuta durante el progreso de la carga
      function progressHandler (event:ProgressEvent):void {
      trace ("progressHandler: bytesLoaded=" + event.bytesLoaded + " bytesTotal=" +                 event.bytesTotal);
      }
  }
}

Saludos

Empiezo este blog con el ánimo de profundizar en el código y programación en as3