// Gerardo Garcia Pineda

// Factory Method

// Objetivo: Command es un patrón de diseño de comportamiento que convierte solicitudes u operaciones simples en objetos.

​

using System;

​

namespace RefactoringGuru.DesignPatterns.Command.Conceptual

{

    // The Command interface declares a method for executing a command.

    public interface ICommand

    {

        void Execute();

    }

​

    // Some commands can implement simple operations on their own.

    class SimpleCommand : ICommand

    {

        private string _payload = string.Empty;

​

        public SimpleCommand(string payload)

        {

            this._payload = payload;

        }

​

        public void Execute()

        {

            Console.WriteLine($"SimpleCommand: See, I can do simple things like printing ({this._payload})");

        }

    }

​

    // However, some commands can delegate more complex operations to other

    // objects, called "receivers."

    class ComplexCommand : ICommand

    {

        private Receiver _receiver;

​

        // Context data, required for launching the receiver's methods.

        private string _a;

​

        private string _b;

​

        // Complex commands can accept one or several receiver objects along

        // with any context data via the constructor.

        public ComplexCommand(Receiver receiver, string a, string b)

        {

            this._receiver = receiver;

            this._a = a;

            this._b = b;

        }

​

        // Commands can delegate to any methods of a receiver.

        public void Execute()

        {

            Console.WriteLine("ComplexCommand: Complex stuff should be done by a receiver object.");

            this._receiver.DoSomething(this._a);

            this._receiver.DoSomethingElse(this._b);

        }

    }

​

    // The Receiver classes contain some important business logic. They know how

    // to perform all kinds of operations, associated with carrying out a

    // request. In fact, any class may serve as a Receiver.

    class Receiver

    {

        public void DoSomething(string a)

        {

            Console.WriteLine($"Receiver: Working on ({a}.)");

        }

​

        public void DoSomethingElse(string b)

        {

            Console.WriteLine($"Receiver: Also working on ({b}.)");

        }

    }

​

    // The Invoker is associated with one or several commands. It sends a

    // request to the command.

    class Invoker

    {

        private ICommand _onStart;

​

        private ICommand _onFinish;

​

        // Initialize commands.

        public void SetOnStart(ICommand command)

        {

            this._onStart = command;

        }

​

        public void SetOnFinish(ICommand command)

        {

            this._onFinish = command;

        }

​

        // The Invoker does not depend on concrete command or receiver classes.

        // The Invoker passes a request to a receiver indirectly, by executing a

        // command.

        public void DoSomethingImportant()

        {

            Console.WriteLine("Invoker: Does anybody want something done before I begin?");

            if (this._onStart is ICommand)

            {

                this._onStart.Execute();

            }

            Console.WriteLine("Invoker: ...doing something really important...");

            Console.WriteLine("Invoker: Does anybody want something done after I finish?");

            if (this._onFinish is ICommand)

            {

                this._onFinish.Execute();

            }

        }

    }

​

    class Program

    {

        static void Main(string[] args)

        {

            // The client code can parameterize an invoker with any commands.

            Invoker invoker = new Invoker();

            invoker.SetOnStart(new SimpleCommand("Say Hi!"));

            Receiver receiver = new Receiver();

            invoker.SetOnFinish(new ComplexCommand(receiver, "Send email", "Save report"));

​

            invoker.DoSomethingImportant();

        }

    }

}