如何在 Rust 中建模策略模式？答案

【问题标题】：How to model the strategy pattern in Rust?如何在 Rust 中建模策略模式？
【发布时间】：2020-08-31 18:11:45
【问题描述】：

我正在寻找一种在 Rust 中实现策略模式的方法。我希望实现类似于这个伪代码的东西：

class StrategyBase {
    Data data;
    def abstract methodAWorkingOnData();
    def abstract methodBWorkingOnData();
}

class StrategyImplOne {
    def methodAWorkingOnData()
        ... method code ...

    def methodBWorkingOnData()
        ... method code ....
}

class StrategyImplTwo {
    def methodAWorkingOnData()
        ... method code ...

    def methodBWorkingOnData()
        ... method code ....
}

我希望我可以有一个绑定了两个特征的结构，但我找不到实现这种模式的方法。

【问题讨论】：

标签： rust strategy-pattern

【解决方案1】：

结合Generic Types, Traits, and Lifetimes 上的definition of the strategy pattern 和The Rust Programming Language 章节会产生一个简单的结果。

创建一个表示通用接口的特征并多次实现该特征。然后持有一个实现 trait 的泛型类型：

struct Context<S> {
    strategy: S,
}

impl<S> Context<S>
where
    S: Strategy,
{
    fn do_things(&self) {
        println!("Common preamble");
        self.strategy.execute();
        println!("Common postamble");
    }
}

trait Strategy {
    fn execute(&self);
}

struct ConcreteStrategyA;

impl Strategy for ConcreteStrategyA {
    fn execute(&self) {
        println!("ConcreteStrategyA")
    }
}

struct ConcreteStrategyB;

impl Strategy for ConcreteStrategyB {
    fn execute(&self) {
        println!("ConcreteStrategyB")
    }
}

fn main() {
    let a = Context {
        strategy: ConcreteStrategyA,
    };
    a.do_things();

    println!("\n---\n");

    let b = Context {
        strategy: ConcreteStrategyB,
    };
    b.do_things();
}

如果所有潜在的实现在编译时都是已知的，则可以使用枚举而不是特征。

您仍然必须应对任何正常的 Rust 设计决策，例如所有权、生命周期和可变性；这些都不是独一无二的。

另见：

【讨论】：