Variations: Static Class vs. Singleton Patterns

When growing apps with C# within the .NET framework, you may have a selection between two single, shared class cases. Whether or not you determine to make use of a static key phrase or a singleton design sample is dependent upon a number of components, that are outlined within the article under.          

Key Variations Between Static Lessons and Singleton Patterns

Put merely, a singleton is a sample whereas a static class is a key phrase. This implies you’ll be able to create one, persistent occasion throughout an software’s total lifespan with a singleton. The nifty factor about singletons is {that a} single occasion can be utilized as a parameter for different strategies. Alternatively, static courses solely allow static strategies and might’t be handed as parameters. 

Different key variations embody:

• Singletons can inherit from different courses, implement interfaces and allow inheritance, making them extra versatile than static courses.

• You possibly can implement singletons asynchronously or lazily, and the .NET framework CLR can mechanically load it. 

• Singletons comply with Object-Oriented Ideas, letting you deal with them polymorphically with out forcing customers to imagine there’s solely a single occasion.

• Singletons can dispose however static courses can’t.

• Static courses are saved within the stack whereas singletons are saved on the heap.

• Singletons can clone whereas static courses can’t. 

• Singletons can have a non-public constructor. 

The Singleton Sample

Most builders agree the singleton design sample is the perfect resolution. They allow you to design courses that require a single occasion, similar to supervisor courses, to be used in caching, thread swimming pools, and logging. They’re additionally nice for managing shared sources similar to printer spooling, the place you have to keep away from conflicting requests for a single useful resource. 

Under is an implementation of a singleton that I’ve used earlier than. As you understand, a singleton is a highly-efficient, sleek single-instance object. One in every of its essential options is that it has a static property that you need to entry to get the item reference.

/// <abstract>/// Pattern singleton object./// </abstract>public sealed class SiteStructure{    /// <abstract>    /// Doable an costly useful resource we have to solely retailer in a single place.    /// </abstract>    object[] _data = new object[10];    /// <abstract>    /// Allocate ourselves. We now have a non-public constructor, so nobody else can.    /// </abstract>    static readonly SiteStructure _instance = new SiteStructure();    /// <abstract>    /// Entry SiteStructure.Occasion to get the singleton object.    /// Then name strategies on that occasion.    /// </abstract>    public static SiteStructure Occasion    {        get { return _instance; }    }    /// <abstract>    /// It is a personal constructor, which means no outsides have entry.    /// </abstract>    personal SiteStructure()    {        // Initialize members, and so on. right here.    }}

What Is a Static Class?

A static class is a category that may’t be instantiated but in addition doesn’t require you to fiddle round creating cases for every new object. They eat fewer sources, and also you received’t have to duplicate the identical class in reminiscence. This makes it a useful container for units of strategies that completely function on output parameters and don’t need to set or get any inner occasion fields. If you happen to solely require a utility class with a number of utility strategies, a static class’s easy implementation can enhance app efficiency, making it a greater choice.

Its main drawback compared to singleton patterns is that you may’t change the way it behaves as soon as the category is embellished with the static key phrase. Nevertheless, the singleton sample’s prowess doesn’t finish there. Let’s check out the foremost variations between the 2 class cases.

Static Class Instance

Within the following instance, check out how I exploit a static key phrase on the category and constructor. Static courses could also be much less fiddly, however the singleton instance has many essential benefits, which we’ll check out after this code block.

/// <abstract>/// Static class instance. Pay heed to the static key phrases./// </abstract>static public class SiteStatic{    /// <abstract>    /// The information have to be a static member on this instance.    /// </abstract>    static object[] _data = new object[10];    /// <abstract>    /// C# does not outline when this constructor is run, however it would     /// be run proper earlier than it's used most certainly.    /// </abstract>    static SiteStatic()    {        // Initialize all of our static members.    }}

You should utilize static courses to retailer single-instance, international information. The category might be initialized at any time, however in my expertise, it’s initialized lazily — in different phrases, on the final attainable second. As such, you would possibly lose management over the precise habits of the category through the use of a static class.

Singleton Benefits in Motion

Singletons protect the standard class strategy and do not require that you just use the static key phrase in every single place. They might be extra demanding to implement at first, however they enormously simplify your program’s structure. In contrast to static courses, it’s attainable to use singletons as parameters or objects.

// We need to name a operate with this construction as an object.// Get a reference from the Occasion property on the singleton.{    SiteStructure web site = SiteStructure.Occasion;    OtherFunction(web site); // Use singleton as parameter.}

Interface Inheritance

In C#, an interface is a contract, and objects which have an interface should meet each requirement of that interface. Often, the necessities are a subset of the item in query. Right here’s how we will use a singleton with an interface, which is named ISiteInterface within the instance.

/// <abstract>/// Shops signatures of varied essential strategies associated to the positioning./// </abstract>public interface ISiteInterface{};/// <abstract>/// Skeleton of the singleton that inherits the interface./// </abstract>class SiteStructure : ISiteInterface{    // Implements all ISiteInterface strategies.    // [omitted]}/// <abstract>/// Right here is an instance class the place we use a singleton with the interface./// </abstract>class TestClass{    /// <abstract>    /// Pattern.    /// </abstract>    public TestClass()    {        // Ship singleton object to any operate that may take its interface.        SiteStructure web site = SiteStructure.Occasion;        CustomMethod((ISiteInterface)web site);    }    /// <abstract>    /// Receives a singleton that adheres to the ISiteInterface interface.    /// </abstract>    personal void CustomMethod(ISiteInterface interfaceObject)    {        // Use the singleton by its interface.    }}

Now we will reuse our singleton for any of the implementations of interface-conforming objects. There could also be 1, 2, or 10. We need not rewrite something again and again. We retailer state extra conventionally, use objects by their interfaces, and might use conventional object-oriented programming greatest practices. Reusing code can management the item state way more simply. This facilitates enormously improved code-sharing and an infinitely cleaner physique of code. 

Conclusion

With much less code, your applications are inclined to have fewer bugs and are simpler to keep up. Different benefits of singleton patterns over static courses are:

• Testability: Testing singleton patterns is far simpler than static courses 

• Reminiscence administration: Utilizing a singleton class helps you to benefit from rubbish assortment for managed objects

• Dependency injection: You possibly can’t use constructor injection with static courses, however you’ll be able to with singletons

• Extensibility: You possibly can have extension strategies with a singleton class however not a static class

If you wish to be taught extra about singleton vs. static, “C# Design Patterns” by Judith Bishop is a worthwhile learn.