有用的迷你模式（不是设计模式）

Question

我最常用的迷你模式是：

VideoLookup = new ArrayList  { new ArrayList { buttonVideo1, "Video01.flv" },
                               new ArrayList { buttonVideo2, "Video02.flv" },
                               new ArrayList { buttonVideo3, "Video03.flv" }, 
                               new ArrayList { buttonVideo4, "Video04.flv" },
                               new ArrayList { buttonVideo4, "Video04.flv" }
                             };

这意味着我可以将单击的按钮与 ArrayList 中的每个项目进行比较，而不是使用每个按钮都有一个 case 的 switch 语句。 然后，当我找到匹配项时，我启动正确的文件（尽管第二部分的操作“查找”可以是委托或其他任何内容）。

主要好处是我不会遇到记住为每个 switch 语句情况添加所有正确代码的问题，我只需向查找 ArrayList 添加一个新项目。

（是的，我知道使用 ArrayList 不是最好的方法，但它是旧代码。而且我知道每次循环遍历数组并不像使用 switch 语句那么有效，但这段代码不是t 在一个紧密的循环中）

有其他人使用任何迷你模式来节省时间/精力或使代码更具可读性吗？ 它们不必只是与 GUI 相关。

更新：不要复制此代码，我知道它很糟糕，但我没有意识到有多糟糕。 使用类似这样的东西来代替。

Hashtable PlayerLookup = new Hashtable();
PlayerLookup.Add(buttonVideo1, "Video01.flv");
PlayerLookup.Add(buttonVideo2, "Video02.flv");
PlayerLookup.Add(buttonVideo3, "Video03.flv");
PlayerLookup.Add(buttonVideo4, "Video04.flv");

string fileName = PlayerLookup[currentButton].ToString();            

Answer 1

拜托拜托天哪请使用这个版本。

VideoLookup = new Dictionary<Button, string> {
    { buttonVideo1, "Video01.flv" },
    { buttonVideo2, "Video02.flv" },
    { buttonVideo3, "Video03.flv" }, 
    { buttonVideo4, "Video04.flv" },
    { buttonVideo4, "Video04.flv" }
};

Answer 2

您可以创建一个结构体或对象，其中包含按钮引用和表示文件名的字符串，然后是这些内容的列表。 或者，您可以使用字典，这样您自己就可以更轻松地进行操作。 有很多改进的方法。 :)

Answer 3

关于 switch 的主题，我写了很多这样的东西：

public Object createSomething(String param)
{
    return s == null                          ? new NullObject() :
           s.equals("foo")                    ? new Foo() :
           s.equals("bar")                    ? new Bar() :
           s.equals("baz") || s.equals("car") ? new BazCar() :
                                                new Object();
}

我认为与常规 switch 语句相比，它看起来更具可读性，并且能够进行更复杂的比较。 是的，它会更慢，因为你需要比较每个条件，但 99% 的时间这并不重要。

Answer 4

在Java中，我有时发现实现公共接口的私有内部类对于由紧密耦合元素组成的对象非常有帮助。 我已经在使用 Allen Holub 的 视觉代理架构，但除此之外就没有太多了。 据我所知，它没有名字。

例如，假设您有一个可以提供 Iterator 的 Collection 接口：

public interface Collection
{
  ...

  public Iterator iterate();
}

public interface Iterator
{
  public boolean hasNext();
  public Object next();
}

如果您有一个实现 Collection 的 Stack，那么您可以将其 Iterator 实现为私有内部类：

public class Stack implements Collection
{
  ...

  public Iterator iterate()
  {
    return new IteratorImpl();
  }

  private class IteratorImpl implements Iterator
  {
    public boolean hasNext() { ... }
    public Object next() { ... }
  }
}

Stack.IteratorImpl 可以完全访问 Stack 的所有私有方法，并且字段。 同时，Stack.IteratorImpl 对除 Stack 之外的所有人都是不可见的。

堆栈及其迭代器往往是紧密耦合的。 最坏的情况是，将 Stack 的迭代器实现为公共类可能会迫使您破坏 Stack 的封装。 私有内部类可以让你避免这种情况。 无论哪种方式，您都可以避免使用真正的实现细节来污染类层次结构。

Answer 5

在我的上一份工作中，我编写了 Andrei Alexandrescu 和 Petru Marginean 在 C++ 中引入的强制概念的 C# 版本（原始版本文章在这里）。

这真的很酷，因为它允许您将错误处理或条件检查与正常代码交织在一起，而不会破坏流程 - 例如：

string text = Enforce.NotNull( myObj.SomeMethodThatGetsAString(), "method returned NULL" );

这将检查第一个参数是否为空，如果为空，则抛出一个 EnforcementException 并将第二个参数作为消息，或者否则返回第一个参数。 有些重载也采用字符串格式化参数，以及允许您指定不同异常类型的重载。

您可能会争辩说，此类事情在 C# 中不太相关，因为运行时检查更好并且已经提供了相当丰富的信息 - 但这种习惯用法可以让您更接近源代码并提供更多信息，同时保持表达能力。

我使用相同的系统进行前后条件检查。

我可能会编写一个开源版本并从此处链接它。

Answer 6

因为当我快速编写代码时（截止日期！截止日期！为什么我在 stackoverflow.com？截止日期！），我最终会得到这样的代码：

Button1.Click += (o,e) => { DoSomething(foo); };

这会在某些时候导致我内存泄漏吗？ 我不知道！ 这可能值得一个问题。 确认！ 截止日期！

Answer 7

对于 Windows 表单，我经常使用 Tag 字段来放置伪命令字符串，以便我可以为一组共享按钮提供一个事件处理程序。 这对于执行几乎相同的操作但已参数化的按钮尤其有效。

在第一个示例中，我将按钮的标签设置为等于视频文件的名称——无需查找。

对于具有某种形式的基于文本的命令处理器来调度操作的应用程序，标签是一个刚刚输入命令处理器的字符串。 效果很好。

（顺便说一句：我见过术语“习语”用于迷你模式......）

Answer 8

我在 C# 中开始看到的一个新习惯是使用闭包参数来封装方法运行所需的一些配置或设置。 这样，您就可以控制代码在方法内必须运行的相对顺序。

Martin Fowler 将其称为嵌套闭包： http://www.martinfowler.com/dslwip/嵌套闭包.html

Answer 9

也许已经有更好的方法来做到这一点（vbEx2005/.Net2.0），但我发现有一类通用委托创建者很有用，它接受一个带有一些参数的方法，以及所有参数的值或这些参数中除一个之外的所有参数，并生成一个委托，该委托在调用时将使用指示的参数调用指定的函数。 与 ParameterizedThreadStart 这样基于 ParamArray 的东西不同，一切都是类型安全的。

例如，如果我说：

Sub Foo(param1 As Integer, param2 As String)
    ...
End Sub

...
  Dim theAct as Action(of Integer) = _
      ActionOf(of Integer).NewInv(AddressOf Foo,"Hello there")

  theAct(5)
...

结果将是在声明 Foo 的对象上调用 Foo(5, "Hello there") 。 不幸的是，我最终不得不为我想要支持的每个不同数量的参数提供单独的泛型类和方法，但是将所有剪切和粘贴都放在一个文件中比将额外的代码分散在各处来创建要好得多合适的代表。