← Modification précédente Modification suivante →

Version du 6 juin 2020 à 17:04

Description

It allows to add new functionalities to an object dynamically
The object does not know it is being « decorated »
Decorators both inherit the original class and contain an instantiation of it
It is an alternative to subclass to add new functionalities

Exemple

IUser.cs

public interface IUser
{
    string Name { get; set; }
}

User.cs

public class User : IUser
{
    public string Name { get; set; }

    public User(string name)
    {
        this.Name = name;
    }
}

UserTitle

public class UserTitle : IUser
{
    private IUser user;

    public string Name
    {
        get => $"{user.Name} ({Title})";
        set => user.Name = value;
    }

    public string Title { get; set; }

    public UserTitle(IUser user, string title)
    {
        this.user = user;
        this.Title = title;
    }
}

UserEmail.cs

public class UserEmail : IUser
{
    private IUser user;

    public string Name
    {
        get => $"{user.Name} - {Email}";
        set => user.Name = value;
    }

    public string Email { get; set; }

    public UserEmail(IUser user, string email)
    {
        this.user = user;
        this.Email = email;
    }
}

var user = new User("Nicolas");
Console.WriteLine(user.Name);  // Nicolas

var userWithTitle = new UserTitle(user, "Big Boss");
Console.WriteLine(userWithTitle.Name);  // Nicolas (Big Boss)

var userWithEmail = new UserEmail(user, "nicolas@world-company.net");
Console.WriteLine(userWithEmail.Name);  // Nicolas (Big Boss) - nicolas@world-company.net

@@ Ligne 2 : / Ligne 2 : @@
 [[Category:Design Patterns]]
 = Description =
-* It provides a way of attaching new state and behaviour to an object dynamically.
+* It allows to add new functionalities to an object dynamically
-* The object does not know it is being “decorated”.
+* The object does not know it is being « decorated »
-* Decorators both inherit the original class and contain an instantiation of it.
+* Decorators both inherit the original class and contain an instantiation of it
+* It is an alternative to subclass to add new functionalities
-= When to use it =
-When you have:
-* An existing component class that may be unavailable for subclassing.
-You want to:
-* Attach additional state or behavior to an object dynamically.
-* Make changes to some objects in a class without affecting others.
-* Avoid subclassing because too many classes could result.
-But consider using instead:
-* The Adapter pattern, which sets up an interface between different classes.
-* The Composite pattern, which aggregates an object without also inheriting its interface.
-* The Proxy pattern, which specifically controls access to objects.
-* The Strategy pattern, which changes the original object rather than wrapping it.
 = Exemple =