ARTICLE
Creational Patterns - Singleton using VB.NET
Tags: .NET, Behavioral Pattern, Creational Patterns, Design, Design Patterns, GetCommandLineArgs, Singleton, Singleton Class, Singleton in VB.NET., Singleton Pattern, Structural Patterns, System.Environment, VB.NET
This article discusses the implementation of the Singleton Design Pattern.Most programming involves usage of Design Patterns in one form or other .There are around 23 Design Patterns that are available.
Introduction.
Most programming involves usage of Design Patterns in one form or other .There are around 23 Design Patterns that are available. They are categorized as given below:
I] Creational Patterns.
1. Singleton
2. Factory
3. Abstract Factory
4. Builder
5. Prototype
II] Structural Patterns.
1. Adapter
2. Bridge
3. Composite
4. Decorator
5. Facade
6. Flyweight
7. Proxy
III] Behavioral Pattern.
1. Chain Of Responsibility
2. Command
3. Interpreter
4. Iterator
5. Mediator
6. Memento
7. Observer
8. State
9. Strategy
10. Template Method
11. Visitor
This paper discusses the implementation of the Singleton Design Pattern.
The Concept
Design patterns are commonly defined as time-tested solutions to recurring design problems.
The most striking benefits of Design Patterns are as follows:
- They provide you with a way to solve issues related to software development using a proven solution. The solution facilitates the development of highly cohesive modules with minimal coupling. They isolate the variability that may exist in the system requirements, making the overall system easier to understand and maintain.
- Design patterns make communication between designers more efficient. Software professionals can immediately picture the high-level design in their thoughts immediately the name of the pattern used to solve a particular issue when discussing system design.
Singleton Pattern: In the Singleton Pattern we have at any given instance a single instance of the Singleton Class active. All instantiation of the Singleton Class references the same instance of the Class. The pattern also provides a global point of access to the sole instance of the class.
Class Diagram
Sequence Diagram
Implementation.
Steps for implementing the Singleton Pattern:
Step1:
Create a project of type Console Application. Name it SingletonTest.
Step2:
Add a Class File named Singleton and add the following code.
'/ <summary>
'/ Summary description for Singleton.
'/ </summary>
Public Class Singleton 'Fields
Private Shared instance As Singleton
'/ <summary>
'/ Standard default Constructor
'/ </summary> Protected Sub New()
End Sub 'New
'/ <summary>
'/ Static method for creating the single instance
'/ of the Constructor
'/ </summary>
'/ <returns></returns>
Public Shared Function Instance() As Singleton
' initialize if not already done
If Instance Is Nothing Then
Instance = New Singleton
End If
' return the initialized instance of the Singleton Class
Return Instance
End Function 'Instance
End Class 'Singleton Step 3:
Create a Client class that would access the Singleton Class as follows :
'/ <summary>
'/ Summary description for Client.
'/ </summary>
Class Client 'Entry point which delegates to C-style main Private Function Public Overloads Shared Sub Main()
Main(System.Environment.GetCommandLineArgs())
End Sub '/ <summary>
'/ The main entry point for the application.
'/ </summary>
Overloads Shared<STAThread()> _
Sub Main(args() As String)
' Constructor is protected -- cannot use new
Dim s1 As Singleton = Singleton.Instance()
Dim s2 As Singleton = Singleton.Instance()
If s1 = s2 Then
Console.WriteLine("The same instance")
End If
Console.ReadLine()
End Sub 'Main
End Class 'Client Step 4:
Run the Application it would display the following output: 
Conclusion.
Thus we have implemented the Singleton Design Pattern using the .Net framework.Like any Concepts/Theory Singleton Pattern also has its pros and cons.
Benefits of Singleton Pattern:
- Instance control: Singleton prevents other objects from instantiating their own copies of the Singleton object, ensuring that all objects access the single instance.
- Flexibility: Because the class controls the instantiation process, the class has the flexibility to change the instantiation process.
Drawbacks of Singleton Pattern:
- Overhead: Although the amount is minuscule, there is some overhead involved in checking whether an instance of the class already exists every time an object requests a reference. This problem can be overcome by using static initialization.
- Possible development confusion: When using a singleton object (especially one defined in a class library), developers must remember that they cannot use the new keyword to instantiate the object. Because application developers may not have access to the library source code, they may be surprised to find that they cannot instantiate this class directly.
- Object lifetime: Singleton does not address the issue of deleting the single object. In languages that provide memory management (for example, languages based on the .NET Framework), only the Singleton class could cause the instance to be deallocated because it holds a private reference to the instance. In languages, such as C++, other classes could delete the object instance, but doing so would lead to a dangling reference inside the Singleton class.
NOTE: THIS ARTICLE IS CONVERTED FROM C# TO VB.NET USING A CONVERSION TOOL. ORIGINAL ARTICLE CAN BE FOUND ON C# CORNER (WWW.C-SHARPCORNER.COM).