Static vs Singleton in C#

In C#, a static class is a class that cannot be instantiated and all its members must also be static. A static class is used to contain methods that are not associated with a particular object, but rather with the class itself.

A singleton is a design pattern that ensures that a class has only one instance and provides a global access point to it. Singletons are implemented by creating a class with a private constructor and a static method that returns a reference to the only instance of the class.

Here is an example of a static class in C#:

public static class MyMath
{
    public static int Add(int x, int y)
    {
        return x + y;
    }

    public static int Subtract(int x, int y)
    {
        return x - y;
    }
}

To use the methods in the MyMath class, you would simply call them using the class name:

int result = MyMath.Add(1, 2);

Here is an example of a singleton in C#:

public class MySingleton
{
    private static MySingleton instance;
    private MySingleton() {}

    public static MySingleton Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new MySingleton();
            }
            return instance;
        }
    }

    public void DoSomething()
    {
        // Implementation goes here
    }
}

To use the MySingleton class, you would call the Instance property to get a reference to the only instance of the class, and then call the method on that instance:

MySingleton.Instance.DoSomething();

It's important to note that a singleton can also be implemented using a static class and static methods, like this:

public static class MySingleton
{
    private static readonly MySingleton instance = new MySingleton();

    private MySingleton() {}

    public static MySingleton Instance
    {
        get
        {
            return instance;
        }
    }

    public void DoSomething()
    {
        // Implementation goes here
    }
}

In this case, the MySingleton class is a static class, but it has a private instance of itself and provides a static Instance property that returns a reference to that instance.