Design Patterns

Facade Pattern

noreply@blogger.com (Sunny Tambi) — Mon, 22 Mar 2010 08:13:00 +0000

Facade is the front of a building. Technically, it is the simplified interface to a bigger and complex code. This complex code could be entire application or some library or bunch of disconnected classes. I would say, web services are also an example Facade as they provide simple to use and platform independent APIs against complex and dependent code.

Technorati Tags: facade,facade pattern

Factory Method Pattern

noreply@blogger.com (Sunny Tambi) — Fri, 20 Mar 2009 03:17:00 +0000

As the name says, it is a pattern for mass production of similar (nearly similar) products (don't be afraid of produts, it means classes/components/objects).

In this pattern, a Client asks for a Product (e.g. some component) from Factory. Factory creates a product on request and deliver it to client. This way products can be seperated from being viewed by clients. Lets take an example:

Let's create a "Share This" functionality. This functionality is an example of factory method pattern because all share sites' buttons in your application have a common connection among them; they are to share your site on some social network. To understand this, let's have the factory architecture for this.

It can be easily understood that Share Button Factory creates all the share buttons for client and also seperate clients from products (social network buttons).

Command Pattern

noreply@blogger.com (Sunny Tambi) — Wed, 06 Aug 2008 14:45:00 +0000

The Command Pattern allows a client to issue requests (commands) to an object without making any assumptions about the request or the receiving object (receiver). This is done by decoupling the client from the receiver by including an invoker.

Command Interface:

package
{
    public interface ICommand
    {
        function execute ():void;
    }
}

Concrete Command:

package
{
    public class ConcreteCommand implements ICommand
    {
        var receiver:Receiver;

        public function ConcreteCommand (rec:Receiver):void
        {
            receiver = rec;
        }

        public function execute ():void;
        {
            receiver.action ();
        }
    }
}

Receiver:

package
{
    public class Receiver
    {
        public function action ()
        {
            trace ("Receiver doing action.");
        }
    }
}

Invoker:

package
{
    public class Invoker
    {
        var currentCommand:ICommand;

        public function setCommand (c:ICommand):void
        {
            currentCommand = c;
        }

        public function executeCommand ():void
        {
            currentCommand.execute ();
        }
    }
}

Client:

package
{
    import flash.display.MovieClip;

    public class Main
    {
        public function Main ():void
        {
            var rec:Receiver = new Receiver ();
            var concCommand:ICommand = new ConcreteCommand (rec);
            var invoker:Invoker = new Invoker ();
            invoker.setCommand (concCommand);
            concCommand.execute ();
        }
    }
}

noreply@blogger.com (Sunny Tambi) — Wed, 23 Jul 2008 14:11:00 +0000

Design Patterns

Creational Patterns:

Factory Method Pattern
Singleton Pattern

Structural Patterns:

Decorator Pattern
Adapter Pattern
Composite Pattern

Behavioral Patterns:

Command Pattern
Observer Pattern
Template Method Pattern
State Pattern
Strategy Pattern

Multiple Patterns:

Model-View-Controller Pattern
Symmetric Proxy Pattern

Please visit again for more details...

[Courtsey AS3.0 Design Patterns: William B. Sanders and Chandima Cumaranatunge]