Question

我理解命令模式属于行为模式，简单的工厂模式主要解决对象创建问题。但是当进入实现时，我觉得两者都遵循类似的步骤。

public interface ICommand
{
    string Name { get; }
    void Execute();
} 
public class StartCommand : ICommand
{
    public void Execute()
    {
        Console.WriteLine("I am executing StartCommand");
    } 
    public string Name
    {
        get { return "Start"; }
    }
} 
public class StopCommand : ICommand
{
    public void Execute()
    {
        Console.WriteLine("I am executing StopCommand");
    } 
    public string Name
    {
        get { return "Stop"; }
    }
}
public class Invoker
{
    ICommand cmd = null;
    public ICommand GetCommand(string action)
    {
        switch (action)
        {
            case "Start":
                cmd = new StartCommand();
                break;
            case "Stop":
                cmd = new StopCommand();
                break;
            default:
                break;
        }
        return cmd;
    }
}
class Program
{
    static void Main(string[] args)
    {
        Invoker invoker = new Invoker();
        // Execute Start Command
        ICommand command = invoker.GetCommand("Start");
        command.Execute();
        // Execute Stop Commad
        command = invoker.GetCommand("Stop");
        command.Execute();
        Console.WriteLine("Command Pattern demo");
        Console.Read();
    }
}

这是简单工厂模式的一个例子。

 interface IGet
    {
        string ConC(string s1, string s2);
    }

    class clsFirst : IGet
    {
        public string ConC(string s1, string s2)
        {
            string Final = "From First: " + s1 + " and " + s2;
            return Final;
        }
    }

    class clsSecond : IGet
    {
        public string ConC(string s1, string s2)
        {
            string Final = "From Second: " + s1 + " and " + s2;
            return Final;
        }
    } 
    class clsFactory
    {
        static public IGet CreateandReturnObj(int cChoice)
        {
            IGet ObjSelector = null;

            switch (cChoice)
            {
                case 1:
                    ObjSelector = new clsFirst();
                    break;
                case 2:
                    ObjSelector = new clsSecond();
                    break;
                default:
                    ObjSelector = new clsFirst();
                    break;
            }
            return ObjSelector;

        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            IGet ObjIntrface = null;
            int input = Convert.ToInt32(Console.ReadLine());
            ObjIntrface = clsFactory.CreateandReturnObj(input);
            string res = ObjIntrface.ConC("First", "Second");

        }
    }

我看不出实施方面的任何差异。有人可以帮助我理解这个吗？

Answer 1

Invoker是工厂模式，但不是命令：

public interface ICommandFactory
{
    ICommand CreateCommand(string action);
}

public class Invoker : ICommandFactory
{
    public ICommand CreateCommand(string action)
    {
        ...
    }
}

命令模式是一种行为设计模式，其中一个对象用于封装执行操作或稍后触发事件所需的所有信息

因此，您的StartCommand和StopCommand类只实现命令模式。

<强>更新

在第二个示例中，您实现了一个简单的工厂，clsFirst和clsSecond不是命令，因为它们的命名并不意味着捕获任何输入或上下文来执行操作 - 它们只是实现相同接口的类。您必须使用逻辑Invoke或Execute方法来暗示对某些内容采取操作（有时您可以撤消该操作）。但是如果你不是人类，而是某种人工智能，那么IGet和string ConC(string s1, string s2)可以完全是命令的定义和行动：）

再一次，工厂和命令之间没有任何共同之处。您可以使用工厂创建命令，但它是可选的。除了命令之外，您还可以使用工厂创建任何内容。

命令模式与C＃中的简单工厂模式

1 个答案: