标签: strategy-pattern

这实际上更多的是一个方法问题，但我用 php 来呈现它。

假设我们有一个包含给定事件在迭代中发生的四个百分比的列表。

array=('walk the dog'=>.25,'read the paper'=>.25,'drink coffee'=>.0,'listen to music'=>.50)

（键只是测试 - 实际上，这将在策略模式中使用，该策略模式将不同的方法应用于偶然使用的对象call_user_func()）

在一个循环中，通过随机调整的选择来选择这些事件之一的最佳方式是什么，考虑到它们各自的权重（IE，对于这个特定的配置，将会听到很多音乐而不是很多咖啡喝了）

目前我有类似的东西：

for($i=1;$i<=3;$i++){
  $rand = 1/rand(1,10);
  //choose from the list
}

但这需要将百分比映射到值范围（50-100% 为听音乐，0-25% 为遛狗，25-50 为阅读论文），因为该迭代的“值”是作为浮点数计算的0 到 1 之间。这改变了需要记录百分比的方式。

是否有任何一种方法可以将值的身份保留为应选择的真实概率而不是范围？这肯定会使代码更加可配置，因为我必须使这些值可调。如果我说得太含糊，请告诉我。

当我进入策略进入仓位时，当我查看显示条件颜色变化的图表时，实际买入订单直到该颜色的第三根蜡烛才会执行，反之亦然，而卖出时则为第三根蜡烛执行卖出策略之前的红色蜡烛。

如果我可以更改一根蜡烛图中的指标颜色，那么我似乎应该能够在同一根蜡烛中执行策略。

关于为什么策略执行延迟有什么想法吗？

谁能告诉我如何在AOP中实施战略模式？

使用Spring-AOP或AspectJ的示例将非常有用.

使用默认策略是否正常,如下面的代码所示:

public abstract class ClContext
{
    protected sealed class InitialAlgorithm : IClAlgorithm
    {
        public void Initialize()
        {
            return;
        }
        public void Execute()
        {
            return;
        }
        public Byte[] Result
        {
            get { return new Byte[1]{0}; }
        }
    }
    protected IClAlgorithm algorithm;

    protected ClContext(IClAlgorithm algorithm = null)
    {
        this.algorithm = algorithm ?? new ClContext.InitialAlgorithm();
    }

    public void Execute()
    {
        this.algorithm.Execute();
    }
}

提供自动实现的属性也是正常的,例如:

public IClAlgorithm Algorithm 
{
    get;
    set;
}

从设计的角度来看,我只是好奇,这是可以接受的.

谢谢!

这是定义Strategy Pattern:

策略 - 定义一系列算法,封装每个算法,并使它们可互换.策略允许算法独立于使用它的客户端.

因此,策略将功能分为两部分:一部分不改变,另一部分可以在未来某个时间改变.

而且,在MVC中,他们说:

控制器是视图的策略

这意味着控制器是变化的,View将来可能不会改变.

我还不太了解.我想他们两个都可以在未来改变.

请解释一下为什么人们这么说.

这是C++中Strategy Pattern的示例实现:

ConcreteStrategy.h

class ConcreteStrategy {
public:
    ConcreteStrategy();
    ~ConcreteStrategy();
    const OtherObject* doSomething(const OtherObject &obj);
};

ConcreteStrategy.cpp

#include "ConcreteStrategy.h"

ConcreteStrategy::ConcreteStrategy() { // etc. }
ConcreteStrategy::~ConcreteStrategy() { // etc. }
const OtherObject* ConcreteStrategy::doSomething(const OtherObject &obj) { // etc. }

MyContext.h

template <class Strategy> class MyContext {
    public:
        MyContext();
        ~MyContext();
        const OtherObject* doAlgorithm(const OtherObject &obj);
    private:
        Strategy* _the_strategy;
};

MyContext.cpp

#include "MyContext.h"

template <typename Strategy>
MyContext<Strategy>::MyContext() {
    _the_strategy = new Strategy;
}

template <typename Strategy>
MyContext<Strategy>::~MyContext() {
    delete _the_strategy;
}

template <typename Strategy> …

我想将不同的算法封装为策略.所有策略都将提供可能在参数的数量和类型上有所不同的单一方法.

template <typename... Arguments>
double price(Arguments... parameters)

策略不应该使用它们直接在类中编码.有没有一种使用可变参数模板实现策略设计模式的简单方法？我也知道"基于策略的设计",我试图使用可变参数模板实现类似的功能

我想在我的应用程序中加入策略模式.

我在lib下面存储了以下类.

class Network
  def search
    raise "NO"
  end

  def w_read
    raise "NO"
  end
  #...
end

和

class FacebookClass < Network
  def search
    # FacebookClass specific...
  end

  def w_read
    raise OneError.new("...")
  end
end

和

class TwitterClass < Network
  def search
    # TwitterClass specific...
  end

  def w_read
    # TwitterClass specific...
  end

  def write
    # TwitterClass specific...
  end
end

现在我想调用的方法搜索的TwitterClass从应用程序/模型/ network_searcher.rb.我怎样才能做到这一点？我是否成功实施了策略模式？

为什么在策略模式中需要 Context 类？

例如，我想使用 zip 或 rar 压缩来压缩文件。我们可以使用带有以下文件的策略模式来解决这个问题。

1.ICompressionStrategy...Its interface
2.ZipCompressionStrategy ..implements IcompressionStrategy
3.RarCompressionStrategy ..implements IcompressionStrategy
4.CompressionContext..Inject IcompressionStrategy
5.Client..Inject CompressionContext

在上面的场景中，为什么我们需要 CompressionContext 类？为什么我不能将 IcompressionStrategy 注入 Client 类？

在上述场景中使用 CompressionContext 类有什么好处？我可以避免吗？

这是我正在谈论的示例

http://java.dzone.com/articles/design-patterns-strategy

我需要在求职面试中创建客户端 - 服务器程序,其中客户端发送命令并且服务器处理它们.

服务器需要能够轻松更改,这意味着以后可能会有更多的命令类型.

所以我使用Strategy实现它,这意味着类处理命令看起来类似于:

public class ServerProcessor
{
    Dictionary<string, Action<string>> commandsType;

    public ServerProcessor()
    {
        commandsType = new Dictionary<string, Action<string>>();
    }

    public void RegisterCommand(string commandName, Action<string> command)
    {
        commandsType.Add(commandName, command);
    }

    public void Process(string commandName, string vars)
    {
        if (commandsType.ContainsKey(commandName))
        {
            commandsType[commandName].Invoke(vars);
        }
    }
}

在我这样做之后,面试官说我需要使用Command模式实现它,但没有说明原因.

Command模式将是这样的:

public interface ICommand
{
    void Execute(string vars);
    string GetName();
}

public class ServerProcessor2
{
    List<ICommand> commandsType;

    public ServerProcessor2()
    {
        commandsType = new List<ICommand>();
    }

    public void RegisterCommand(ICommand commandName)
    {
        commandsType.Add(commandName);
    }

    public void …