使用 RC 嵌套结构的 Rust 依赖反转

Question

我正在尝试在 Rust 中做一些依赖反转。我的目标是创建一个结构，它接受任何其他符合特征的结构实例。

这不会编译，但基本上是我想要实现的：

// Trait for any kind of tool I may use in my work
trait ToolTrait {
  fn do_work(&self);
}

struct Saw {
  size: i32,
}

impl ToolTrait for Saw {
  fn do_work(&self) {
    println!("I'm a saw, size: {}cm", self.size);
  }
}

struct ScrewDriver {
  size: i32,
}

impl ToolTrait for ScrewDriver {
  fn do_work(&self) {
    println!("I'm a screwdriver, size: {}mm", self.size);
  }
}

// Work uses any struct that complies with ToolTrait
pub struct Work {
  tool: ToolTrait,
}

impl Work {
  // We can instantiate Work and set tool to it
  fn new(tool: ToolTrait) -> Work {
    Work { tool }
  }
}

let saw = Saw { size: 30 };
let work_1 = Work::new(saw);
work_1.tool.do_work(); // "I'm a saw, size: 30cm"

let screwdriver = ScrewDriver { size: 4 };
let work_2 = Work::new(screwdriver);
work_2.tool.do_work(); // "I'm a screwdriver, size: 4mm"

现在，关于 Rust 编译器，我们有几个错误警告：

pub struct Work {
  tool: ToolTrait,
}
// trait objects without an explicit `dyn` are deprecated

好的，让我们在Work 和impl Work 中都添加dyn：

pub struct Work {
  tool: dyn ToolTrait,
}
impl Work {
  fn new(tool: dyn ToolTrait) -> Work {
    Work {
      tool: Rc::new(tool),
    }
  }
}

完美，Work 没有错误。但是关注impl Work 我们有这个错误：

impl Work {
  fn new(tool: ToolTrait) -> Work {
    Work {
      tool: Rc::new(tool),
    }
  }
}
// the size for values of type `(dyn main::ToolTrait + 'static)` cannot be known at compilation time

有道理：Work 无法知道tool 的大小。但是我该如何解决呢？ 我将dyn ToolTrait 与std::rc::Rc 包装成Rc<dyn ToolTrait>：

pub struct Work {
  tool: Rc<dyn ToolTrait>,
}

impl Work {
  // We can instantiate Work and set tool to it
  fn new(tool: Rc<dyn ToolTrait>) -> Work {
    Work { tool }
  }
}

这是可行的，但这是实现依赖倒置的正确方法吗，就像我们在面向对象编程中通常所做的那样？

Answer 1

您可以通过工具使您的结构通用：

// Trait for any kind of tool I may use in my work
trait ToolTrait {
    fn do_work(&self);
}

struct Saw {
    size: i32,
}

impl ToolTrait for Saw {
    fn do_work(&self) {
        println!("I'm a saw, size: {}cm", self.size);
    }
}

struct ScrewDriver {
    size: i32,
}

impl ToolTrait for ScrewDriver {
    fn do_work(&self) {
        println!("I'm a screwdriver, size: {}mm", self.size);
    }
}

// Work uses any struct that complies with ToolTrait
pub struct Work<T> {
    tool: T,
}

impl<T: ToolTrait> Work<T> {
    // We can instantiate Work and set tool to it
    fn new(tool: T) -> Work<T> {
        Work { tool }
    }
}

fn main() {
    let saw = Saw { size: 30 };
    let work_1 = Work::new(saw);
    work_1.tool.do_work(); // "I'm a saw, size: 30cm"

    let screwdriver = ScrewDriver { size: 4 };
    let work_2 = Work::new(screwdriver);
    work_2.tool.do_work(); // "I'm a screwdriver, size: 4mm"
}