Factory creates objects. The clients who use the factory can focus on other behavior. So the object creation delegated to another object.

Factory Object

Benefits: if there are multiple clients that want to instantiate the same set of classes, then by using a Factory object, you have cut out redundant code and made software easier to modify. Means if need a change of object creation, then have to modify just a factory instead of every client and it’s calling coding to an interface, not an implementation.

Factory:

public class CarFactory(){
    public Car createCar(string carType) {
        Car car;
        
        if(carType.Equals("sport")){
            car = new SportCar();
        }
        else if(carType.Equals("city")){
            car = new CityCar();
        }        

        return car;
    }
}

The singleton pattern refers to having only one object of a class. Again, enforces one and only one object of a Singleton class which globally accessible within a program.

Code example:

public sealed class Singleton
{
   private static volatile Singleton instance;
   private static object syncRoot = new Object();

   private Singleton() {}

   public static Singleton Instance
   {
      get 
      {
         if (instance == null) 
         {
            lock (syncRoot) 
            {
               if (instance == null) 
                  instance = new Singleton();
            }
         }

         return instance;
      }
   }
}

The design patterns will help you to make flexible, reusable, and maintainable software.

Creational

• Abstract Factory
• Builder
• Factory Method
• Prototype
• Singleton

Structural

• Adapter
• Bridge
• Composite
• Decorator
• Facade
• Flyweight
• Proxy

Behavioral

• Chain of Responsibility
• Command
• Interpreter
• Iterator
• Mediator
• Memento
• Observer
• State
• Strategy
• Template Method
• Visitor

How to make sure the system that you’ve created is correct?

For example, you can run tests and see if the actual behavior matches what you expect. But there is another technique called model checking.

Model Checking is a systematic check of your systems state model in all its possible states, can help to find laws. Its done after code has been written and before deployment.

How to model check software? Model checkers generate a State Model from your code.

State Model is an abstract state machine that can be in one of various states. The model checker then checks that the state model conforms to certain behavioral properties.

There are 3 different phases to performing model checking:

1. The Modeling phase – this is where you enter the model description and describe the desired properties.
2. The Running phase – can see how your model conforms to the desired properties that has been wrote in the modeling phase.
3. The Analysis phase – checks if all the desired properties are satisfied and if any are violated. Violations are called Counterexamples. Also you can analyze how you got this state using the information from the model checker with advice where to fix. And then run the phases again until eliminate the issues.