Trabajar con Interfaces e Inyeccion de Dependencias

Hola, creo que esta sería la última pregunta con respecto a este tema, como siempre agradeciendo a las personas que nos dan una mano.Y bueno al tema en cuestion, que resulta un poco mas enredado dado el nivel de abstraccion y cohesion que se esta tratanto de emplear... veamos con codigo:

Primera clase utiliza el objeto SoundTransform y lo Implementa

Código ActionScript :

package 
{
   import flash.media.SoundTransform;
   public class FNVSoundTransform implements IFNVSoundTransform
   {
      private var SetFNVSoundTransform:SoundTransform;
      private var SetFNVSoundTransformVolume:Number = 1;
      private var SetFNVSoundTransformPanning:Number = 0;

      public function FNVSoundTransform():void {}
      public function IGetFNVSoundTransform():SoundTransform { return SetFNVSoundTransform;    }
      public function ISetFNVSoundTransform(todo:SoundTransform):void { todo = SetFNVSoundTransform = new SoundTransform(SetFNVSoundTransformVolume,SetFNVSoundTransformPanning);
      }

Segunda clase La Implementacion de SoundTransform

Código ActionScript :

package
{
   import flash.media.SoundTransform;

   interface IFNVSoundTransform
   {
      function IGetFNVSoundTransform():SoundTransform;
      function ISetFNVSoundTransform(todo:SoundTransform):void;

Tercera clase: Es una clase no tan relativa, a exepcion de un metodo y por ende un objeto: que podria llamarse desde una funcion desde el momento que se ocupa

Código ActionScript :

package 
{
   import flash.media.Microphone;
   import flash.system.Security;
   import flash.system.SecurityPanel;

   public class FNVMicrophone
   {
      private var microphone:Microphone;
      private var SetMFNVSoundTransform:IFNVSoundTransform;//= new FNVSoundTransform();

      public function FNVMicrophone() {}
      public function setFNVmicrophone():void
      {
         microphone = new Microphone();
         microphone = Microphone.getMicrophone();
         Security.showSettings(SecurityPanel.PRIVACY);
      }
      public function GetFNVSoundTransformProperty():IFNVSoundTransform { return SetMFNVSoundTransform; }
      public function SetFNVSoundTransformProperty():void
      {   
         //microphone.soundtransform = new SoundTransform(); //como solucion temporal
         SetMFNVSoundTransform = new FNVSoundTransform();
         SetMFNVSoundTransform.ISetFNVSoundTransform( /*Objeto tipo SoundTransform*/); //Aca tengo problemas

//1. Basicamente me envia un error de cohesion... y no se cual seria la mejor forma de asignarle el objeto de la clase
//Microphone al objeto de la Interfaz.. dado que en un punto son diferentes (el 1er tipo de obj: el obj de la intefaz, que
//lo envia un tipo soundtransform.. 2do tipo: el que la propiedad requiere soundtransform) 
//2. Una forma de solucionarlo seria agragar un objeto tipo SoundTransforn que acepte la propiedad del metodo que
//se requiere, pero entoces tendria que repetir codidgo y objtos dentro de las classes o implementar un monton extends 
//3. A modo de pregunta: este seria un buen metodo, de implemtacion.. que se le puede hacer? 
//4. Si no, para que diablos estoy haciendo esta carambada  :lol:  :lol:  :lol:  Por favor, no quiero que el nivel de
//cohesion se combierta en el nivel de tonterias que trato de implementar  

Perdonen si los terminos no son los mas correctos, soy malicimo inventando nombres de varibles..

Saludos Cordiales,
Fred

Hola,
creo que estás liando demasiado las cosas para lo que pretendes.
El problema está en que SetMFNVSoundTransform es un objeto IFNVSoundTransform, no un SoundTransform y por eso no puedes asignarle una instancia de ese tipo (a no ser que hicieses que tu interfaz incluyese todos los métodos de la clase SoundTransform).
Si tu clase FNVSoundTransform va a tener todas las características de SoundTransform, y algunas más que vayas a añadir tú, mejor usa herencia en lugar de composición (con lo cual en FNVMicrophone, la variable SetMFNVSoundTransform pasará a ser un SoundTransform).
Pero si tu clase FNVSoundTransform no va a aportar nada nuevo a SoundTransform, lo mejor que puedes hacer es no crear esa clase, sino usar directamente una variable SoundTransform en la clase FNVMicrophone (var FNVSoundTransform:SoundTransform), y así no te haría falta crear ni la clase ni la interfaz.

Un consejo: Es mejor que sigas un estándar a la hora de poner nombre a tus variables, así te resultará más fácil seguir el código.
Sobre todo eso de llamar a las variables MFNVSoundTransform "SetMFNVSoundTransform" (piensa que son variables, no funciones); lo de llamar a las funciones de la interfaz IGetFNVSoundTransform, cuando realmente devuelven un objeto SoundTransform (además, eso de poner la "I" delante sólo se hace con el nombre de la interfaz, no con sus métodos (y no todo el mundo está de acuerdo con que deba ponerse)).

Holas, Gracias. Correcto basicamente el codigo que estoy utilizo es para el ejemplo en si..
Claro, como tu dices
"lo mejor que puedes hacer es no crear esa clase, sino usar directamente una variable SoundTransform en la clase FNVMicrophone (var FNVSoundTransform:SoundTransform), y así no te haría falta crear ni la clase ni la interfaz."
Sip lo mas utilizable para este ejemplo es crear una variable que seria del objeto SoundTransform, por ende un objeto de este mismo tipo, que se carga en el memoria. ok. Pero supongamos que esta varible Soundtranform la utilizan varias clases, y solo admite un tipo de objeto, seria correcto instanciarla cada vez que se necesite? Por otro lado heredarlas implicaria una dependencia fija, y la clase perderia abstracion, dado que en determinado caso, se quisiera o no utilizar esta propiedad. Esto es lo que no entiendo.
Perdonen las preguntas un poco salidas pero no le hayo, respuesta. he buscado en libros, en la web. pero los ejemplos son excasos, por cierto aca tienen un post referente algo similar, solo que no puedo utilizarlo a el problema que tengo en concreto..
[url=http://www.cristalab.com/tips/poo-dependencia-de-clases-y-polimorfismo-c71290l/][/url]

Ojala me puedan dar una mano,
Saludos Cordiales

Aquí te dejo un ejemplo simplificado de lo que pretendes. Hay una interfaz "ISoundTransformable", y 2 objetos que la implementan, llamados "FNVSoundTransform" y "FNVSoundTransform2".
En main creamos un objeto ISoundTransform, que podrá contener tanto una instancia de la clase FNVSoundTransform, como una instancia de la clase FNVSoundTransform2:
Interfaz:

Código ActionScript :

package 
{
    import flash.media.SoundTransform;

    public interface ISoundTransformable
    {
        //En el ejemplo yo uso getters y setters implicitos, pero podrían ser explicitos
        //como los que tu has puesto (getSoundTransform y setSoundTransform)
        function get soundTransform():SoundTransform;
        function set soundTransform(value:SoundTransform):void;
    }
}

Clase que implementa la interfaz:

Código ActionScript :

package 
{
    import flash.media.SoundTransform;
    import ISoundTransformable;
    
    public class FNVSoundTransform implements ISoundTransformable
    {
        private var _soundTransform:SoundTransform;

        public function FNVSoundTransform():void
        {
            //En el constructor es donde creamos la instancia SoundTransform
            //y donde la asignamos a la variable, no en la función set
            _soundTransform = new SoundTransform();
        }
        
        public function get soundTransform():SoundTransform
        {
            trace("Accedes a soundTransform de FNVSoundTransform");
            return _soundTransform;
        }
        
        public function set soundTransform(value:SoundTransform):void
        {
            trace("Cambias soundTransform de FNVSoundTransform");
            _soundTransform = value; 
        }
    }
}

Otra clase que implementa esa interfaz:

Código ActionScript :

package 
{
    import flash.media.SoundTransform;
    import ISoundTransformable;
    
    public class FNVSoundTransform2 implements ISoundTransformable
    {
        private var _soundTransform:SoundTransform;

        public function FNVSoundTransform2():void
        {
            _soundTransform = new SoundTransform();
        }
        
        public function get soundTransform():SoundTransform
        {
            trace("Accedes a soundTransform de FNVSoundTransform2");
            return _soundTransform;
        }
        
        public function set soundTransform(value:SoundTransform):void
        {
            trace("Cambias soundTransform de FNVSoundTransform2");
            _soundTransform = value; 
        }
    }
}

En main vemos el polimorfismo mediante el uso de la interfaz:

Código ActionScript :

import ISoundTransformable;
import FNVSoundTransform;
import FNVSoundTransform2;

var soundTransformable:ISoundTransformable;
var auxSoundTransform:SoundTransform;

//La variable soundTransformable puede ser tanto un FNVSoundTransform...
soundTransformable = new FNVSoundTransform();
auxSoundTransform = soundTransformable.soundTransform;
soundTransformable.soundTransform = new SoundTransform();

//... como puede ser un FNVSoundTransform2
soundTransformable = new FNVSoundTransform2();
auxSoundTransform = soundTransformable.soundTransform;
soundTransformable.soundTransform = new SoundTransform();

ohhhh Dios, Lo resolviste en la clase que llama a la interfaz, isidoro.. ese toque esta buenisimo... por alguna razon estupida solo me fijaba en clase que lo invocaba y tu lo implementaste excitosamente en la funcion set... Ya le puedo llamar Mcgiver o genio, que exito!!!!!!! Muchas Gracias de verdad, y cualquier cosa aqui estamos!!!

10000000 THKS!!!!!!!!

En Flex la inyección de dependencias son tomadas por distintos frameworks. RobotLegs (uno de mis favoritos) por ejemplo define un Context para la aplicación y un tag [Inject] en donde permite declarar que tipo de dependencia se pasa ... y nos evitamos todo el lío de instanciación, pro ejemplo cuando hay que hacer un "deferred registration" esperando que las vistas sean instanciadas: http://joelhooks.com/2009/07/17/robotlegs-as3-a-dependency-injection-driven-mvcs-framework-for-flashflex-%E2%80%93-inspired-by-puremvc/

Jorge

@solisarg: La verdad es que no conocía ese framework, y ... en serio, ¿hay algo que no sepas sobre ActionScript?

BuenAS:

+1 de otro adicto a Robotlegs + Signals.

Un saludo.

Holas, Jorge estube chekeando el link que publicaste y esta genial, parece que este framework promete bastante... voy a bajarlo...
Se Agradece el aporte!!

100's