Multiple SingleCores instead of MultiCore

[greenhorn]

Hi,

Imagine an pure AS3 (not Flex!) application like this:

- A main-application, which provides several UI-Elements, forms, menus etc.
AND
- a game-application which can be started from our main-app.

- We have no flex-modules, just 2 different MVC-Trees to seperate Game-code from MainApp-code.

Both apps have a MVC-like structure. So we decided to use the PMVC-Multicore-Version.

Some questions popped up:
- is it valid to interact from one core to the other like this??:
  (e.g.: GameCore wants to inform MainCore):
    -> ApplicationFacade.getInstance("main").sendNotification(SURPRISE);

AND

- maybe this is a stupid question, but:

Why can't we just setup 2 SingleCore-Facades instead of the multicore approach? Thus they are different singletons there should be no interference? Would that work? What's the advantage of multicore?

Please enlighten me! 

[Jason MacDonald]

You can't have 2 instances of the same class be singletons when they both are running under the same Virtual Machine. That is why multi-core exists. To communicate between cores have a look at either the PIpes Utility or Fabrication (which uses Pipes). Or you could use Interfaces. Either way you can't have two single-core PMVC apps running under the same Virtual Machine.

[puremvc]

Don't retrieve the other core's facade and manipulate it. This defeats the entire purpose of modularizing your app.

Although you may control the entire codebase, from a best practices perspective, always imagine that the other core was written by someone else, and therefore you don't know the internals of it, and specifically you don't know the notification mappings that have been set up inside the other core. This is just standard OOP encapsulation/data hiding.

For this reason you have two options for communicating between cores: interfaces and pipes.

With Interfaces, two communicating cores implement one or more known interfaces, have uni- or bi-directional references to each other and invoke interface methods on each other.

With Pipes, you use the MultiCore Pipes utility to connect the cores, and send IPipeMessages to each other via the pipelines. The Message class from the utility can be used out-of-box, or subclassed to give specific properties.

Examine the Flex Modularity and PipeWorks demos respectively to see these two approaches in action. Sure, they're Flex, but the concept is exactly the same. There is no difference in the PureMVC part, only the way your view hierarchy is built.

-=Cliff>