Object Creational Patterns and Instantiation
page 6 of 10
by Brian Mains
Feedback
Average Rating: This article has not yet been rated.
Views (Total / Last 10 Days): 42555/ 84

Singleton

Sometimes you need global access to an object, because this object may contain static properties, events, or methods you may access throughout your application.  Through this static object, the application can be more easily decoupled from other related classes because more classes can interact through the singleton and not as much by referencing the other objects directly.

This is the singleton pattern; it has the benefits that it maintains its own instance and provides this central access throughout the application. The key benefit is the ability to expose events, which the other classes in a project can subscribe to by attaching their own event handlers to it.  When the event fires, all registered objects are subscribed to that event; this is similar to the Observer pattern.

How can you create a global instance?  Let us use a class called ServicesCentral, which provides access to key objects/collections throughout an application. The class definition and the singleton reference would appear as such:

Listing 11

public class ServicesCentral 
 { 
 private static readonly ServicesCentral _instance = new ServicesCentral(); 
 
 public static ServicesCentral Instance 
 { 
 get { return _instance; } 
 } 
 
 private ServicesCentral() 
 { 
 //Instantiate any collection objects here 
 } 
 } 

A static instance variable represents the ServicesCentral class, which is exposed through the Instance property. This instance is used internally to give access to the properties and methods, as we will see next. The constructor of the singleton is also marked private or protected so only the singleton can instantiate itself. Within that constructor, any of the objects are instantiated so they are available to the user of the singleton.  Let us look at a few objects that can be exposed through the singleton.

Listing 12

private MenuCollection _menus = nullprivate ToolbarCollection _toolbars = nullprivate MarkedListRepository _currentList = nullpublic static MenuCollection Menus 
 { 
 get { return Instance._menus; } 
 } 
 
 public static ToolbarCollection Toolbars 
 { 
 get { return Instance._toolbars; } 
 } 
 
 public static MarkedListRepository CurrentList 
 { 
 get { return Instance._currentList; } 
 } 
 
 private ServicesCentral() 
 { 
 _menus = new MenuCollection(); 
 _toolbars = new ToolbarCollection(); 
 _currentList = new MarkedListRepository(); 
 } 

The singleton exposes a collection of menus, toolbars, and other objects that are important to an application. The scenario above is similar to exposing an API for an application, such as Word or Excel. All of the necessary objects are instantiated in the private constructor. Because the instance is instantiated internally, all objects are referenced through the Instance property because this Instance property is the true object that holds the singleton reference.

Notice how the private variables that hold references to these objects are not static; instead, because they are exposed through the Instance property and because Instance contains a reference to the singleton object, it can access the appropriate internal variables.  In addition to existing properties, you can add helper properties/methods that are generally helpful in your application. For instance, you can add the following.

Listing 13

public static CultureInfo CurrentCulture 
 { 
 get { return Thread.CurrentThread.CurrentCulture; } 
 } 
 
 public static CultureInfo CurrentUICulture 
 { 
 get { return Thread.CurrentThread.CurrentUICulture; } 
 } 
 
 public static string CurrentDirectory 
 { 
 get { return AppDomain.CurrentDomain.BaseDirectory; } 
 } 
 
 public static string GetFilePath(string fileName) 
 { 
 return CurrentDirectory + @"\" + fileName; 
 } 

The list could go on, containing whatever centralized objects, properties, or methods that are needed.


View Entire Article

User Comments

No comments posted yet.






Community Advice: ASP | SQL | XML | Regular Expressions | Windows


©Copyright 1998-2021 ASPAlliance.com  |  Page Processed at 2021-12-04 8:52:02 PM  AspAlliance Recent Articles RSS Feed
About ASPAlliance | Newsgroups | Advertise | Authors | Email Lists | Feedback | Link To Us | Privacy | Search