Post
Ask Question

Wrapper Class vs. Object Composition with UseCase

Today, we will explore two important concepts in object-oriented programming: Wrapper Classes and Object Composition. These concepts play crucial roles in designing modular and maintainable software solutions by leveraging the principles of encapsulation, abstraction, inheritance, and polymorphism. In software design, choosing between using a wrapper class or object composition is crucial for creating flexible, maintainable, and reusable code. Each approach has its specific use cases, advantages, and trade-offs. Understanding when and where to use them can help in designing better systems. Lets start.

Wrapper Class
 

Definition

A wrapper class, often associated with the Adapter design pattern, wraps an existing class to provide a different interface or add functionality. It enables compatibility between different systems or adapts a class to meet specific requirements without modifying the original class.

When to Use?

  1. Adapting Interfaces
    • When you need to adapt an existing class to work with a different interface expected by the client code.
    • Useful in scenarios where integrating with legacy systems or third-party libraries that have incompatible interfaces.
  2. Enhancing Functionality
    • When you need to add new functionalities to an existing class without altering its source code.
    • Wrappers can extend the capabilities of a class in a non-intrusive manner.
  3. Interfacing with External Systems
  4. When working with external systems or APIs that you do not control, and you need to create a local interface that integrates smoothly with your application.

Wrapper Class real-life example

We'll consider a scenario where we have a legacy logging system that we want to integrate into a new application with a different logging interface.

Legacy Logging System

public class LegacyLogger
{
    public void LogMessage(string message)
    {
        Console.WriteLine($"Legacy Logger: {message}");
    }
}

New Logging Interface

public interface ILogger
{
    void Log(string message);
}

Wrapper Class

The wrapper class will adapt the LegacyLogger to the new ILogger interface.

public class LoggerAdapter : ILogger
{
    private readonly LegacyLogger _legacyLogger;
    public LoggerAdapter(LegacyLogger legacyLogger)
    {
        _legacyLogger = legacyLogger;
    }
    public void Log(string message)
    {
        // Adapting the method call to the legacy logger
        _legacyLogger.LogMessage(message);
    }
}

Client Code

The client code will use the ILogger interface, unaware that it is actually using the LegacyLogger through the LoggerAdapter.

class Program
{
    static void Main()
    {
        // Create an instance of the legacy logger
        LegacyLogger legacyLogger = new LegacyLogger();
        // Wrap the legacy logger with the adapter
        ILogger logger = new LoggerAdapter(legacyLogger);
        // Use the logger as if it were the new interface
        logger.Log("This is a log message.");
        // Output: Legacy Logger: This is a log message.
    }
}

Code Explanation

  1. LegacyLogger: The existing class with its own logging method (LogMessage).
  2. ILogger: The new logging interface that the application uses.
  3. LoggerAdapter: The wrapper class that adapts the LegacyLogger to the ILogger interface. It holds an instance of LegacyLogger and implements ILogger. The Log method of ILogger is implemented to call the LogMessage method of LegacyLogger.
  4. Program: The client code that uses ILogger to log messages. It uses LoggerAdapter to wrap the LegacyLogger instance, thus enabling the use of the legacy logger through the new interface.

Object Composition
 

Definition

Object composition is a design principle where a class is composed of one or more objects of other classes, allowing it to leverage their functionality. This promotes flexibility and reuse, as behavior can be built by combining simpler components.

When to Use?

  1. Modular Design
    • When you want to create a class by combining the functionalities of several other classes.
    • Ideal for building modular and reusable components.
  2. Avoiding Inheritance Limitations
    • When inheritance is not suitable, such as when a class needs to combine behaviors from multiple sources.
    • Composition allows combining behaviors dynamically without the rigidity of inheritance hierarchies.
  3. Dynamic Behavior
    • When the behavior of a class needs to change at runtime by changing the composed objects.
    • Composition enables dynamic modification and reconfiguration of object behavior.

Object Composition real-life example

// Component class
public class Engine
{
    public void Start()
    {
        Console.WriteLine("Engine started.");
    }
}
// Another component class
public class Transmission
{
    public void Shift()
    {
        Console.WriteLine("Transmission shifted.");
    }
}
// Class that composes other classes
public class Car
{
    private readonly Engine _engine;
    private readonly Transmission _transmission;

    public Car(Engine engine, Transmission transmission)
    {
        _engine = engine;
        _transmission = transmission;
    }

    public void Drive()
    {
        _engine.Start();
        _transmission.Shift();
        Console.WriteLine("Car is driving.");
    }
}
// Client code
class Program
{
    static void Main()
    {
        Engine engine = new Engine();
        Transmission transmission = new Transmission();
        Car car = new Car(engine, transmission);
        car.Drive();
        // Output:
        // Engine started.
        // Transmission shifted.
        // Car is driving.
    }
}

Code Explanation

  • Engine Class: Provides a Start() method that prints "Engine started."
  • Transmission Class: Provides a Shift() method that prints "Transmission shifted."
  • Car Class: Composes Engine and Transmission objects. The Drive() method calls their methods and prints "Car is driving."
  • Client Code: Instantiates Engine and Transmission, then creates a Car object and calls Drive(), demonstrating composition.

Benefits

  • Reusability: Components can be reused in different contexts.
  • Flexibility: Behavior can be modified by changing components.
  • Encapsulation: The car simplifies the interface while hiding internal details.

Key Differences

  1. Purpose
    • Wrapper Class: Adapts an existing interface to match the client's expectations.
    • Object Composition: Builds complex functionality by combining simpler objects.
  2. Implementation
    • Wrapper Class: Implements a new interface that delegates calls to an existing class.
    • Object Composition: Contains instances of other classes to leverage their behavior.
  3. Flexibility
    • Wrapper Class: Typically more rigid, designed to fit a specific mismatch scenario.
    • Object Composition: More flexible, allowing dynamic changes to the composed objects and their interactions.
  4. Use Case
    • Wrapper Class: Suitable for integrating with legacy systems or third-party libraries.
    • Object Composition: Ideal for building new systems with modular and reusable components.

Conclusion

Choosing between a wrapper class and object composition depends on the specific requirements of your application. Wrappers are ideal for adapting interfaces and enhancing functionality without altering existing code, making them suitable for integration with legacy systems or third-party libraries. On the other hand, object composition promotes flexibility, reuse, and dynamic behavior, making it a powerful tool for building modular and maintainable systems. Understanding the strengths and use cases of each approach will help you design more robust and adaptable applications in C#.


Similar Articles