What is the difference between the Strategy and Template patterns?

  • The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. The Template pattern defines the skeleton of an algorithm in a method, deferring some steps to subclasses.
  • The Strategy pattern defines the skeleton of an algorithm in a method, deferring some steps to subclasses, while the Template pattern defines a family of algorithms and makes them interchangeable.
  • The Template pattern is used to allow for loose coupling between the sender of a request and its receivers, while the Strategy pattern provides a unified interface to a set of interfaces in a subsystem.
  • The Template pattern is used to convert the interface of a class into another interface clients expect, while the Strategy pattern allows sending requests to objects without knowing anything about the operation being requested or the receiver of the request.
The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable, while the Template pattern defines the skeleton of an algorithm in a method, deferring some steps to subclasses.

Explain what is Composition over Inheritance?

  • Composition over Inheritance is a design principle that eliminates the use of composition for code reuse.
  • Composition over Inheritance is a design principle that eliminates the use of inheritance for code reuse.
  • Composition over Inheritance is a design principle that favors class inheritance over object composition for code reuse.
  • Composition over Inheritance is a design principle that favors object composition over class inheritance for code reuse.
Composition over Inheritance is a design principle that favors object composition over class inheritance for code reuse. It allows for greater flexibility and maintainability in code design.

What is the difference between the Factory and Abstract Factory patterns?

  • None of the above
  • The Factory and Abstract Factory patterns are the same
  • The Factory pattern creates objects of a single class, while the Abstract Factory pattern creates objects of several classes
  • The Factory pattern creates objects of several classes, while the Abstract Factory pattern creates objects of a single class
The Factory pattern creates objects of a single class, while the Abstract Factory pattern creates objects of several classes

What is Data Access Object (DAO) pattern?

  • A design pattern to handle communication between objects
  • A design pattern to handle the database connections
  • A design pattern to manage complex state transitions
  • A design pattern to provide a unified interface to a set of interfaces
The DAO pattern provides a unified interface to a set of data sources. It separates the data persistence mechanism from the business logic, allowing the data to be accessed and modified easily and efficiently.

What is the difference between the Singleton and Prototype patterns?

  • The Singleton pattern allows multiple instances to be created from a single prototype object, while the Prototype pattern ensures that a class has only one instance and provides a global point of access to that instance.
  • The Singleton pattern ensures that a class has multiple instances, while the Prototype pattern allows only one instance to be created from a single prototype object.
  • The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance, while the Prototype pattern allows multiple instances to be created from a single prototype object.
  • The Singleton pattern ensures that a class has only one instance, while the Prototype pattern ensures that a class has multiple instances with unique characteristics.
The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance, while the Prototype pattern allows multiple instances to be created from a single prototype object.

What is the purpose of the Chain of Responsibility pattern?

  • To create complex objects step by step, using a builder object to abstract the process of creating the object
  • To provide a common interface for a group of related classes
  • To provide a simplified interface to a complex system, hiding the complexity of the system behind a single interface
  • To provide a way to pass requests along a dynamic chain of receivers until one of them handles the request
The Chain of Responsibility pattern provides a way to pass requests along a dynamic chain of receivers until one of them handles the request

What is Chain of Responsibility pattern?

  • A design pattern that allows objects to represent or act on behalf of other objects, providing a level of indirection between the client and the target object
  • A design pattern that creates objects by cloning existing objects, rather than creating new instances from scratch
  • A design pattern that passes a request through a chain of objects, allowing the objects in the chain to either handle the request or pass it on to the next object in the chain
  • A design pattern that provides a simplified interface to a complex system, allowing the client to interact with the system through a single, unified interface
Chain of Responsibility pattern is a design pattern that passes a request through a chain of objects, allowing the objects in the chain to either handle the request or pass it on to the next object in the chain. The pattern involves creating a chain of objects, where each object has a reference to the next object in the chain. This pattern can be useful in situations where you want to decouple the sender of a request from its receiver, allowing multiple objects to handle the request in a modular manner.

What is Mediator pattern?

  • A design pattern that allows the client to traverse a collection of objects, without exposing the underlying representation of the collection
  • A design pattern that converts a request into a standalone object, allowing the client to parametrize objects with different requests, queue a request, or log requests
  • A design pattern that provides a simplified interface to a complex system, allowing the client to interact with the system through a single, unified interface
  • A design pattern that uses a central authority to manage communication between components, reducing the coupling between components and allowing for more flexible and modular system design
Mediator pattern is a design pattern that uses a central authority to manage communication between components, reducing the coupling between components and allowing for more flexible and modular system design. In the Mediator pattern, the Mediator class acts as a centralized authority that manages communication between different components, and ensures that the components are decoupled from one another. This pattern can be useful in situations where you want to reduce the coupling between components, and promote a more flexible and modular system design.

What is the Observer design pattern used for?

  • To define a one-to-many dependency between objects so that changes to one object result in changes to many other objects.
  • To encapsulate operations in an object and pass them as messages.
  • To ensure that a class has only one instance and provide a global point of access to that instance.
  • To provide a way to dynamically instantiate objects of a specified class.
The Observer design pattern is used to define a one-to-many dependency between objects so that changes to one object result in changes to many other objects. This can be useful in situations where it is important to keep multiple objects in sync with each other.

How should I be grouping my Repositories when using Repository Pattern?

  • Repositories should be grouped based on the database tables they access, for example grouping all repositories that access a specific table in a single class or namespace.
  • Repositories should be grouped based on the domain entities they provide access to, for example grouping all repositories for a specific type of entity in a single class or namespace.
  • Repositories should be grouped based on the type of operations they support, for example grouping all repositories that support read operations in a single class or namespace.
  • Repositories should be grouped based on their implementation, for example grouping all repositories that use a specific data access technology in a single class or namespace.
Repositories should be grouped based on the domain entities they provide access to, as this provides a clear and organized way of grouping related repositories.