je définis 3 interfaces dans mon projet de flex, "B", "C" et "D". L'interface "D" étend l'interface "B", et l'interface "C" est un consommateur de l'instance de type "B". Après cela, j'ai défini 2 modules, M1 et M2. M1 implémente l'interface "D" et M2 implémente l'interface "C". M2 a une fonction publique comme suit.communication entre les modules de flexion par des interfaces
/* in the "M2" module */
// the stub is declared in the "C" interface.
public function consume(b:B):void{
if(b is D){ // line 1: type determination
// do something on the D interface
}
}
Et puis je définis 2 chargeurs module (MLD1 & MLD2) pour charger M1 et M2 (en définissant l'URL) dans l'application principale. Et après avoir chargé M1 et M2, j'ai essayé de fournir M1 pour M2 via la fonction "C.consume (B): void" implémentée dans le module M2. Les codes sont comme suit.
/* in the "main" application */
var m1:B = mld1.child as B; // line 2: cast type to B
var m2:C = mld2.child as C;
m2.consume(m1); // line 3: provide m1 instance for m2
Cependant, lorsqu'il appelle la M2.consume (B): fonction vide dans la ligne 3, le « si » la détermination de la consommation fonction (ligne 1) toujours échouer et le corps du « si » la structure sera toujours ignorée. Mais si j'ajoute la ligne de détermination de type comme indiqué dans la ligne 1 dans le module "M2" à l'application principale avant la ligne 3, alors la détermination de type dans la ligne 1 sera réussie. C'est-à-dire les codes que ce qui suit dans l'application principale permettra de transmettre la détermination du type dans la ligne 1.
/* in the "main" application: make type determination be line 3 */
var m1:B = mld1.child as B; // line 2: cast type to B
if(m1 is D) // just make a plain determination. nothing else.
;
var m2:C = mld2.child as C;
m2.consume(m1); // line 3: provide m1 instance for m2
ou si je fais un type jeté directement au type D, il sera également atteindre la même résultat.
/* in the "main" application: make type cast before line 3 */
var m1:B = mld1.child as D; // line 2: after modified, cast type to D.
var m2:C = mld2.child as C;
m2.consume(m1); // line 3: provide m1 instance for m2
Je me demande pourquoi la détermination de la ligne 1 sera couronnée de succès que si je l'ai mentionné le type « D » dans l'application principale. La détermination du type ou le type cast dans l'application principale fera-t-elle une différence sur l'objet cible? Et que dois-je faire, si je souhaite l'application principale d'être conscients de l'interface « B » et son interface à la consommation (l'interface « C »), de sorte que l'application peut prendre en charge toutes les interfaces sous et classes de la « B » et "C" interface.
Merci!
Rien de personnel, mais mon esprit simple est dérouté par cette soupe à l'alphabet :) Je pense que votre explication serait plus claire si vous montriez les noms de variables qui avaient un sens. Va lui donner une autre lecture ... –
@Sunil D. Merci pour vos conseils. J'apprécie beaucoup. En fait, j'ai essayé de les nommer d'une manière méchante, "B" pour l'interface de base, "C" pour l'interface du consommateur et "D" pour l'interface dérivée. Ils prennent juste la première lettre comme identification. Eh bien, peut-être que je n'ai pas précisé cela clairement. – xnslong