Tato ukázková aplikace představuje dva programy klienta pro rychlé odesílání zpráv (jeden v rámci souboru SWF a druhý vytvořený pomocí formulářů OS Windows), které spolu navzájem komunikují. Uživatelské rozhraní zahrnuje rozhraní ovládání Shockwave Flash ActiveX v rámci kterého je načten soubor SWF obsahující klienta IM jazyka ActionScript. Rozhraní také zahrnuje několik textových polí, které vytvářejí klienta Windows Forms IM: pole pro zadávání zpráv (MessageText), další pole pro zobrazení zpráv odeslaných mezi klienty (Transcript) a třetí pole (Status), které zobrazí statut dostupnosti dle nastavení v klientovi IM souboru SWF IM.

Pro zahrnutí ovládání Shockwave Flash ActiveX do své aplikace Windows Forms jej musíte nejprve přidat do panelu nástrojů Microsoft Visual Studio.

Komunikace pomocí externího rozhraní API s aplikací kontejneru ActiveX funguje jako komunikace s webovým prohlížečem, s jedním důležitým rozdílem. Jak bylo popsáno dříve, když jazyk ActionScript komunikuje s webovým prohlížečem jsou, z pohledu vývojáře, funkce volány přímo; podrobnosti způsobu formátování volání a odpovědí funkcí pro jejich předání prohlížeči a přehrávači jsou skryty. Nicméně když je pro komunikaci s aplikací kontejneru ActiveX použito externí rozhraní API, odešle přehrávač Flash Player zprávy (volání funkce a návratové hodnoty) aplikaci ve specifickém formátu XML a očekává, že volání funkce a návratové hodnoty z aplikace kontejneru budou používat stejný formát XML. Vývojář aplikace kontejneru ActiveX musí napsat kód, který rozpozná a může vytvořit volání funkce a odpovědi v příslušném formátu.

Příklad Introvert IM C# zahrnuje sadu tříd, které vám umožňují vyhnout se hlášením o formátování; namísto toho můžete při volání funkcí jazyka ActionScript a při přijímání volání funkcí z jazyka ActionScript pracovat se standardními datovými typy. Třída ExternalInterfaceProxy společně s dalšími pomocnými třídami tyto funkce poskytuje a lze jí znovu použít v libovolném projektu .NET pro umožnění komunikace s externími rozhraními API.

Následující části kódu vyjmuté z formuláře hlavní aplikace (AppForm.cs) ukazují zjednodušenou interakci, které je dosaženo použitím třídy ExternalInterfaceProxy:

public class AppForm : System.Windows.Forms.Form 
{ 
    ... 
    private ExternalInterfaceProxy proxy; 
    ... 
    public AppForm() 
    { 
        ... 
        // Register this app to receive notification when the proxy receives 
        // a call from ActionScript. 
        proxy = new ExternalInterfaceProxy(IntrovertIMApp); 
        proxy.ExternalInterfaceCall += new ExternalInterfaceCallEventHandler(proxy_ExternalInterfaceCall); 
        ... 
    } 
    ...

Aplikace deklaruje a vytvoří instanci ExternalInterfaceProxy pojmenovanou proxy, předá ji v referenci ovládání Shockwave Flash ActiveX, které je v uživatelském rozhraní (IntrovertIMApp). Dále kód zaregistruje metodu proxy_ExternalInterfaceCall() pro přijmutí události proxy ExternalInterfaceCall. Tato událost je odeslána třídou ExternalInterfaceProxy, když je z přehrávače Flash Player obdrženo volání funkce. Přihlášení k této události je způsob, kterým kód C# přijme volání z jazyka ActionScript a odpoví na něj.

Když z jazyka ActionScript přijde volání funkce, instance ExternalInterfaceProxy (proxy) volání příjme, převede jej do formátu XML a uvědomí objekty, které jsou posluchači dané události proxy ExternalInterfaceCall. V případě třídy AppForm metoda proxy_ExternalInterfaceCall() zpracuje danou událost následovně:

    /// <summary> 
    /// Called by the proxy when an ActionScript ExternalInterface call 
    /// is made by the SWF 
    /// </summary> 
    private object proxy_ExternalInterfaceCall(object sender, ExternalInterfaceCallEventArgs e) 
    { 
        switch (e.FunctionCall.FunctionName) 
        { 
            case "isReady": 
                return isReady(); 
            case "setSWFIsReady": 
                setSWFIsReady(); 
                return null; 
            case "newMessage": 
                newMessage((string)e.FunctionCall.Arguments[0]); 
                return null; 
            case "statusChange": 
                statusChange(); 
                return null; 
            default: 
                return null; 
        } 
    } 
    ...

Metodě je předána instance ExternalInterfaceCallEventArgs, v tomto příkladě pojmenovaná e. Daný objekt má naopak vlastnost FunctionCall, která je instancí třídy ExternalInterfaceCall.

Instance ExternalInterfaceCall je jednoduchý objekt hodnoty se dvěma vlastnostmi. Vlastnost FunctionName obsahuje název funkce určený v příkazu jazyka ActionScript ExternalInterface.Call(). Jestliže jsou do jazyka ActionScript přidány jakékoliv parametry, jsou zahrnuty do vlastnosti objektu ExternalInterfaceCall Arguments. V tomto případě je metoda zpracovávající danou událost jednoduše příkazem switch, který se chová jako správce dopravy. Hodnota vlastnosti FunctionName (e.FunctionCall.FunctionName) určuje, která metoda třídy AppForm je volána.

Větve příkazu switch v předcházející ukázce kódu uvádějí běžné scénáře volání metody. Například libovolná metoda musí vrátit hodnotu do jazyka ActionScript (například volání metody isReady()) nebo by měla vrátit hodnotu null (jak můžete vidět v jiných voláních metody). Získání přístupu k parametrům předaných z jazyka ActionScript je ukázáno ve volání metody newMessage() (která předá parametr e.FunctionCall.Arguments[0], v prvním elementu pole Arguments).

Volání funkce jazyka ActionScript z C# pomocí třídy ExternalInterfaceProxy je ještě přímější než přijímání volání funkce z jazyka ActionScript. Pro volání funkce jazyka ActionScript použijte metodu instance ExternalInterfaceProxy Call(), a to následovně:

    /// <summary> 
    /// Called when the "Send" button is pressed; the value in the 
    /// MessageText text field is passed in as a parameter. 
    /// </summary> 
    /// <param name="message">The message to send.</param> 
    private void sendMessage(string message) 
    { 
        if (swfReady) 
        { 
            ... 
            // Call the newMessage function in ActionScript. 
            proxy.Call("newMessage", message); 
        } 
    } 
    ... 
    /// <summary> 
    /// Call the ActionScript function to get the current "availability" 
    /// status and write it into the text field. 
    /// </summary> 
    private void updateStatus() 
    { 
        Status.Text = (string)proxy.Call("getStatus"); 
    } 
    ... 
}

Jak ukazuje tento příklad, metoda třídy ExternalInterfaceProxy Call() je velice podobná svému protějšku v jazyce ActionScript ExternalInterface.Call(). První parametr je řetězec, název funkce, která bude volána. Jakékoliv dodatečné parametry (které zde nejsou uvedené) jsou předány společně s funkcí jazyka ActionScript. Jestliže funkce jazyka ActionScript vrátí hodnotu, je daná hodnota vrácena metodou Call() (viz následující příklad).

Použití objektu pro zabalení proxy okolo ovládání ActiveX nemusí být vždy praktické, nebo si můžete přát zapsat svou vlastní třídu proxy (například v jiném programovacím jazyce nebo cíleně na jinou platformu). Ačkoliv zde nebudou vysvětleny veškeré podrobnosti vytvoření proxy, naleznete v tomto příkladě dostatek informací pro pochopení vnitřních funkcí třídy proxy.

Metodu ovládání Shockwave Flash ActiveX CallFunction() můžete použít pro volání funkce jazyka ActionScript z kontejneru ActiveX pomocí externího rozhraní API. To je ukázáno v tomto výpise z metody třídy ExternalInterfaceProxy Call():

// Call an ActionScript function on the SWF in "_flashControl", 
// which is a Shockwave Flash ActiveX control. 
string response = _flashControl.CallFunction(request);

V tomto výpise kódu je _flashControl ovládání Shockwave Flash ActiveX. Volání funkce ActionScript jsou prováděna pomocí metody CallFunction(). Tato metoda přebírá jeden parametr (v příkladu request), což je řetězec obsahující pokyny ve formátu XML, včetně názvu funkce jazyka ActionScript, která má být volána, a libovolných parametrů. Libovolná hodnota vrácená z jazyka ActionScript je kódována jako řetězec ve formátu XML a je odeslána zpět jako vrácená hodnota volní CallFunction(). V tomto příkladě je řetězec XML uložen v proměnné response.

Přijímání volání funkce z jazyka ActionScript je proces zahrnující několik kroků. Volání funkce z jazyka ActionScript způsobí, že ovládání Shockwave Flash ActiveX odešle svou událost FlashCall, takže třída (například třída ExternalInterfaceProxy), která zamýšlí přijmout volání ze souboru SWF, potřebuje pro danou událost definovat objekt pro zpracování. Ve třídě ExternalInterfaceProxy je funkce zpracování události pojmenovaná _flashControl_FlashCall()a je zaregistrována pro poslouchání dané události v konstruktoru třídy, následovně:

private AxShockwaveFlash _flashControl; 
 
public ExternalInterfaceProxy(AxShockwaveFlash flashControl) 
{ 
    _flashControl = flashControl; 
    _flashControl.FlashCall += new _IShockwaveFlashEvents_FlashCallEventHandler(_flashControl_FlashCall); 
} 
... 
private void _flashControl_FlashCall(object sender, _IShockwaveFlashEvents_FlashCallEvent e) 
{ 
    // Use the event object's request property ("e.request") 
    // to execute some action. 
    ... 
    // Return a value to ActionScript; 
    // the returned value must first be encoded as an XML-formatted string. 
    _flashControl.SetReturnValue(encodedResponse); 
}

Objekt události (e) má vlastnost request(e.request), což je řetězec obsahující informaci o volání funkce, například název a parametry funkce ve formátu XML. Tuto informaci lze použít kontejnerem pro určení kódu, který bude spuštěn. Ve třídě ExternalInterfaceProxy je požadavek převeden z formátu XML na objekt ExternalInterfaceCall, který poskytuje stejné informace v přístupnější formě. Metoda ovládání ActiveX SetReturnValue() je použita pro vrácení výsledku funkce volajícímu jazyka ActionScript; výsledný parametr musí být opět kódován do formátu XML použitým externím rozhraním API.

Komunikace mezi jazykem ActionScript a aplikací hostující ovládání Shockwave Flash ActiveX používá specifický formát XML pro kódování volání a hodnot funkce. V příkladu Introvert IM C# umožňuje třída ExternalInterfaceProxy kódu ve formuláři aplikace pracovat přímo na hodnotách odeslaných nebo získaných z jazyka ActionScript a ignorovat podrobnosti formátu XML použitého přehrávačem Flash Player. Pro dosažení tohoto cíle používá třída ExternalInterfaceProxy metody třídy ExternalInterfaceSerializer pro převod zpráv XML na objekty .NET. Třída ExternalInterfaceSerializer má čtyři metody publikace:

• EncodeInvoke(): kóduje název funkce a C# ArrayList argumentů do příslušného formátu XML.

• EncodeResult(): kóduje výsledek do příslušného formátu XML.

• DecodeInvoke(): dekóduje volání funkce z jazyka ActionScript. Vlastnost objektu události FlashCall request je předána metodě DecodeInvoke() a převede volání do objektu ExternalInterfaceCall.

• DecodeResult(): Dekóduje XML získaný jako výsledek volání funkce jazyka ActionScript.

Tyto metody kódují hodnoty C# do formátu XML externího rozhraní a dekódují XML do objektů C#. Podrobnosti o formátu XML používaném přehrávačem Flash Player naleznete v části Formát XML externího rozhraní API.