using System;

// The base Component interface defines operations that can be altered by

    // decorators.

    public interface Shape

    {

       string Draw();

    }

​

    // Concrete Components provide default implementations of the operations.

    // There might be several variations of these classes.

    public class Circle : Shape

    {

        public string Draw()

        {

            return "Drawing a circle";

        }

    }

​

    // The base Decorator class follows the same interface as the other

    // components. The primary purpose of this class is to define the wrapping

    // interface for all concrete decorators. The default implementation of the

    // wrapping code might include a field for storing a wrapped component and

    // the means to initialize it.

    public abstract class ShapeDecorator : Shape

    {

        protected Shape _shape;

​

        public ShapeDecorator(Shape shape)

        {

            this._shape = shape;

        }

​

        public void SetShape(Shape shape)

        {

            this._shape = shape;

        }

​

        // The Decorator delegates all work to the wrapped component.

        public virtual string Draw()

        {

            if (this._shape == null)

              return string.Empty;

​

​

          return this._shape.Draw();

        }

    }

​

    // Concrete Decorators call the wrapped object and alter its result in some

    // way.

    public class RedCircleDecorator: ShapeDecorator

    {

        public RedCircleDecorator(Shape shape) : base(shape)

        {

        }

​

        // Decorators may call parent implementation of the operation, instead

        // of calling the wrapped object directly. This approach simplifies

        // extension of decorator classes.

        public override string Draw()

        {

            var baseResult = base.Draw();

            return baseResult +  " And making it red";

        }

    }

     public class Client

    {

        // The client code works with all objects using the Component interface.

        // This way it can stay independent of the concrete classes of

        // components it works with.

        public void ClientCode(Shape shape)

        {

            Console.WriteLine("RESULT: " + shape.Draw());

        }

    }

    public class Program

    {

        public static void Main(string[] args)

        {

            Client client = new Client();

​

            var circle = new Circle();

            Console.WriteLine("Client: I get a simple Circle :");

            client.ClientCode(circle);

            Console.WriteLine();

​

            // ...as well as decorated ones.

            //

            // Note how decorators can wrap not only simple components but the

            // other decorators as well.

            RedCircleDecorator decorator1 = new RedCircleDecorator(circle);

            Console.WriteLine("Client: Now I've got a red  Circle :");

            client.ClientCode(decorator1);

        }

    }