Multiton

 

Multiton
Design Patterns
Creational Design Patterns

In computer programming, the Multiton Pattern is a design pattern which generalizes the singleton pattern in two different ways:

1) On copy of the corresponding Singleton for each data type,

2) On copy of the corresponding Singleton for each value of a parameter.

Where the Singleton Pattern permits only one instance of a class to be instantiated, the Multiton Pattern allows multiple instances of a class to be instantiated.

List of Creational Design Patterns

List of Creational Design Patterns
Question & Answer

In the following, which five design patterns are the creational patterns?

 1) Abstract Factory
 2) Adapter
 3) Bridge
 4) Builder
 5) Chain of Responsibility
 6) Command
 7) Composite
 8) Decorator
 9) Facade
10) Factory Method
11) Flyweight
12) Interpreter
13) Iterator
14) Mediator
15) Memento
16) Observer
17) Prototype
18) Proxy
19) Singleton
20) State
21) Strategy
22) Template Method
23) Visitor
 
Creational Design Patterns

1. Abstract Factory
2. Builder
3. Factory Method
4. Prototype
5. Singleton

INTERVIEW :: DESIGN/DEVELOPMENT :: DESIGN PATTERNS :: BASIC CONCEPTS

INTERVIEW

  DESIGN/DEVELOPMENT

    DESIGN PATTERNS

      BASIC CONCEPTS

 

In the following, which five design patterns are the creational patterns?

 1) Abstract Factory
 2) Adapter
 3) Bridge
 4) Builder
 5) Chain of Responsibility
 6) Command
 7) Composite
 8) Decorator
 9) Facade
10) Factory Method
11) Flyweight
12) Interpreter
13) Iterator
14) Mediator
15) Memento
16) Observer
17) Prototype
18) Proxy
19) Singleton
20) State
21) Strategy
22) Template Method
23) Visitor
 

Design Patterns :: Singleton

Design Patterns :: Singleton

There are many common situations when singleton pattern is used:
 - Accesing resources in shared mode
 - Configuration Classes
 - Logger Classes
 - Serialization
 - Network Port Interface

Singleton Design Pattern

Check list
1.Define a private static attribute in the "single instance" class.
2.Define a public static accessor function in the class.
3.Do "lazy initialization" (creation on first use) in the accessor function.
4.Define all constructors to be protected or private.
5.Clients may only use the accessor function to manipulate the Singleton.

1. using System;
2. 
   
3. namespace DesignPatternsSingleton
4. {
5.   /// <summary>
6.   /// MainApp startup class for Design Patterns :: Singleton
7.   ///  http://gr1350.blogspot.com
8.   /// </summary>
9.   class MainApp
10.   {
11.   /// <summary>
12.   /// The Singleton class.
13.   /// </summary>
14.   public class Singleton
15.   {
16.     private static Singleton _instance;
17. 
    
18.     // Constructor is 'protected'
19.     protected Singleton()
20.     {
21.     }
22. 
    
23.     public static Singleton Instance()
24.     {
25.       // Uses lazy initialization.
26.       // Note: this is not thread safe.
27.       if (_instance == null)
28.       {
29.         _instance = new Singleton();
30.       }
31. 
    
32.       return _instance;
33.     }
34.   }
35. }

1. using System;
2. using System.Collections.Generic;
3. using System.Threading;
4. 
   
5. namespace DesignPatternsSingleton
6. {
7.   /// <summary>
8.   /// MainApp startup class for Real-World
9.   /// Singleton Design Pattern.
10.   /// </summary>
11.   class MainApp
12.   {
13.     /// <summary>
14.     /// Entry point into console application.
15.     /// </summary>
16.     static void Main()
17.     {
18.       LoadBalancer b1 = LoadBalancer.GetLoadBalancer();
19.       LoadBalancer b2 = LoadBalancer.GetLoadBalancer();
20.       LoadBalancer b3 = LoadBalancer.GetLoadBalancer();
21.       LoadBalancer b4 = LoadBalancer.GetLoadBalancer();
22. 
    
23.       // Same instance?
24.       if (b1 == b2 && b2 == b3 && b3 == b4)
25.       {
26.         Console.WriteLine("Same instance\n");
27.       }
28. 
    
29.       // Load balance 15 server requests
30.       LoadBalancer balancer = LoadBalancer.GetLoadBalancer();
31.       for (int i = 0; i < 15; i++)
32.       {
33.         string server = balancer.Server;
34.         Console.WriteLine("Dispatch Request to: " + server);
35.       }
36. 
    
37.       // Wait for user
38.       Console.ReadKey();
39.     }
40.   }
41. 
    
42.   /// <summary>
43.   /// The 'Singleton' class
44.   /// </summary>
45.   class LoadBalancer
46.   {
47.     private static LoadBalancer _instance;
48.     private List<string> _servers = new List<string>();
49.     private Random _random = new Random();
50. 
    
51.     // Lock synchronization object
52.     private static object syncLock = new object();
53. 
    
54.     // Constructor (protected)
55.     protected LoadBalancer()
56.     {
57.       // List of available servers
58.       _servers.Add("ServerI");
59.       _servers.Add("ServerII");
60.       _servers.Add("ServerIII");
61.       _servers.Add("ServerIV");
62.       _servers.Add("ServerV");
63.     }
64. 
    
65.     public static LoadBalancer GetLoadBalancer()
66.     {
67.       // Support multithreaded applications through
68.       // 'Double checked locking' pattern which (once
69.       // the instance exists) avoids locking each
70.       // time the method is invoked
71.       if (_instance == null)
72.       {
73.         lock (syncLock)
74.         {
75.           if (_instance == null)
76.           {
77.             _instance = new LoadBalancer();
78.           }
79.         }
80.       }
81. 
    
82.       return _instance;
83.     }
84. 
    
85.     // Simple, but effective random load balancer
86.     public string Server
87.     {
88.       get
89.       {
90.         int r = _random.Next(_servers.Count);
91.         return _servers[r].ToString();
92.       }
93.     }
94.   }
95. }