标签: strategy-pattern

我在使用策略模式时遇到了一个问题.我正在实现创建任务的服务.此服务还解决了此任务的负责人员.解决职员是通过使用策略模式来完成的,因为有不同的方法可以做到这一点.关键是每个策略都需要不同的参数来解决职员.

例如:

interface ClerkResolver {
    String resolveClerk(String department);
}

class DefaultClerkResolver implements ClerkResolver {

    public String resolveClerk(String department) {
        // some stuff
    }
}

class CountryClerkResolver implements ClerkResolver {

    public String resolveClerk(String department) {
        // I do not need the department name here. What I need is the country.
    }

}

问题是每个解析器可能依赖于不同的参数来解决负责的职员.对我来说,这听起来像是我的代码中的设计问题.我还尝试将一个类作为参数来保留策略可能需要的所有值,例如:

class StrategyParameter {

   private String department;
   private String country;

   public String getDepartment() ...
}

interface ClerkResolver {
    String resolveClerk(StrategyParameter strategyParameter);
}

但说实话,我对这个解决方案并不满意,因为每当策略需要一个新的/不同的参数时我就必须更改参数类.其次,策略的调用者必须设置所有参数,因为他不知道哪个策略将解析职员,因此他必须提供所有参数(但这并不是那么糟糕).

同样,对我而言,这听起来像我的代码中的设计问题,但我找不到更好的解决方案.

---编辑

此解决方案的主要问题是创建任务时.任务服务如下所示:

class TaskService { …

关于这个话题的讨论很多,但每个人似乎都错过了一个明显的答案.我想帮助审查这个"明显的"IOC容器解决方案.各种对话假设运行时选择策略和使用IOC容器.我将继续这些假设.

我还想补充一个假设,即它不是必须选择的单一策略.相反,我可能需要检索一个对象图,该对象图在整个图的节点中找到了几个策略.

我将首先快速概述两个常用的解决方案,然后我将展示我希望看到IOC容器支持的"明显"替代方案.我将使用Unity作为示例语法,但我的问题不是Unity特有的.

命名绑定

这种方法要求每个新策略都手动添加绑定:

Container.RegisterType<IDataAccess, DefaultAccessor>();
Container.RegisterType<IDataAccess, AlphaAccessor>("Alpha");
Container.RegisterType<IDataAccess, BetaAccessor>("Beta");

......然后明确要求正确的策略:

var strategy = Container.Resolve<IDataAccess>("Alpha");

• 优点:简单,并得到所有IOC容器的支持
• 缺点:
  • 通常将调用者绑定到IOC容器,当然要求调用者知道有关策略的信息(例如名称"Alpha").
  • 必须手动将每个新策略添加到绑定列表中.
  • 此方法不适合处理对象图中的多个策略.简而言之,它不符合要求.

抽象工厂

为了说明这种方法,假设以下类:

public class DataAccessFactory{
    public IDataAccess Create(string strategy){
        return //insert appropriate creation logic here.
    }
    public IDataAccess Create(){
        return //Choose strategy through ambient context, such as thread-local-storage.
    }
}
public class Consumer
{
    public Consumer(DataAccessFactory datafactory)
    {
        //variation #1. Not sufficient to meet requirements.
        var myDataStrategy = datafactory.Create("Alpha");
        //variation #2.  This is sufficient for requirements.
        var myDataStrategy = …

我是一个熟练的程序员,使用JavaScript,但我不是大师.我知道你可以用它做一些非常强大的东西,除了相当基本的DOM操作之外我还没有看到太多东西.我想知道人们是否可以使用JavaScript提供一些传统设计模式概念的例子,例如Factory Method,Singleton等.在什么情况下这些模式将用于网络？

这是我到目前为止所拥有的:

namespace Strategy
{
    interface IWeaponBehavior
    {
        void UseWeapon();
    }
}

namespace Strategy
{
    class Knife : IWeaponBehavior
    {
        public void UseWeapon()
        {
            Console.WriteLine("You used the knife to slash the enemy! SLASH SLASH!");
        }
    }
}

namespace Strategy
{
    class Pan : IWeaponBehavior
    {
        public void UseWeapon()
        {
            Console.WriteLine("You use the pan! 100% Adamantium power! BONG!");
        }
    }
}

现在,如果我有一个Character.cs超类.该超类如何实现武器行为,以便子类可以更具体.

namespace Strategy
{
    class Character
    {
        public IWeaponBehavior weapon;

        public Character(IWeaponBehavior specificWeapon)
        {
            weapon = specificWeapon;
        }        
    }
}

namespace …

我目前正在开发一个解决方案,并以一种强有力地实现策略/提供者模式的方式进行设计.因此,该解决方案公开了许多接口并包含这些接口的默认实现,这些接口可以通过DI类型方法替换.

在主机应用程序使用许多这些接口的情况下,它期望处理可能发生的某些异常,例如IDataRetriever接口具有方法SomeDataType GetData(int timeout);并且主机可以处理一些自定义异常,例如DataRetrievalTimeoutException或NetworkConnectionException.

我的问题是,标记接口类的最佳方法是什么,当开发人员实现它时,他们会知道应该抛出某些异常并由主机处理？

目前我刚刚将xml标签添加到方法xml注释中 - 这是否足够？

我正在上课,我们刚刚了解了这些设计模式.但是我看不出它们之间有什么区别.它们听起来像是一样的,在抽象的类上创建具体的类.有人可以帮我解决这个疑问吗？谢谢 (:

以下代码示例是从Wikipedia复制的Strategy模式的实现.我的完整问题是......

Wiki的main方法:

//StrategyExample test application

class StrategyExample {

    public static void main(String[] args) {

        Context context;

        // Three contexts following different strategies
        context = new Context(new ConcreteStrategyAdd());
        int resultA = context.executeStrategy(3,4);

        context = new Context(new ConcreteStrategySubtract());
        int resultB = context.executeStrategy(3,4);

        context = new Context(new ConcreteStrategyMultiply());
        int resultC = context.executeStrategy(3,4);

    }

}

图案件:

// The classes that implement a concrete strategy should implement this

// The context class uses this to call the concrete strategy
interface Strategy …

当我第一次发现策略模式时,我惊讶于它为我和我的程序提供的看似无穷无尽的可能性.我可以更好地封装模型的行为,甚至可以即时交换这种行为.但该策略也可用于为包含对象提供特征和有效负载 - 在超类中声明的数据.生活很美好.

class MyMonsterAI   { float const see_radius_; virtual void attack () = 0; /* .. */ };
class ElveAI        { ElveAI() : see_radius_(150.0f) {} /* ... */ };
class CycloneAI     { CycloneAI() : see_radius_(50.0f) {} /* ... */ };
class Monster       { MyMonsterAI* ai_; };

随之而来的是策略模式,它将允许我更灵活地为一个包含类提供参数 - 整个类,但是我喜欢,虽然动态地交换了行为......但这并不太容易(除非部分策略是有策略!).

class MyMonsterTrait { typedef typename ElveAI AI; };

template< class MonsterTrait >
class Monster : public MonsterTrait::AI
{
    void idle (void) { attack(); }
};

这两种模式对我来说似乎都非常强大,我喜欢在不同情况下使用这两种模式.但我不确定在某些情况下是否存在特定/典型/更实用的应用程序.

我想知道:你在哪里使用战略和政策？哪个更适合？

策略模式与依赖注入有何不同？

即以下是您可以使用策略模式执行的操作:

class Foo{
   private readonly ISortAlgo _sortAlgo;

  public Foo(ISortAlgo sortAlgo)
  {
     _sortAlgo = sortAlgo;
  }

  public void Sort()
  {
    _sortAlgo.sort();
  }

}

使用DI你可以做同样的事情,基本上你可以有构造函数,setter,接口等注入.它会产生与战略模式相同的效果.我知道DI也有其他原则,例如松耦合,可测试性,布线等.

在实施方面,我没有看到太大的区别.

策略模式和DI有什么区别？

是否有任何标准的通用的"回调"或Java的"功能/法"类型,如System.Action<T>或System.Func<T,U>在.NET？

在我的具体情况中,我需要一个包装一个方法的类,该方法接受一个(泛型)参数类型T并且不返回任何内容(即void).

是的,为我自己创建这样的类/接口很容易,但如果有的话,我更喜欢标准库类.