好的，假设我有Ruby程序来读取版本控制日志文件并对数据进行某些处理。 （我没有，但是情况是类似的，我很喜欢这些类比）。 假设现在我想支持Bazaar和Git。 让我们假设该程序将以某种参数执行，该参数指示正在使用的版本控制软件。

鉴于此，我想制作一个LogFileReaderFactory，它给出一个版本控制程序的名称，它将返回一个适当的日志文件阅读器（从通用类继承），以读取日志文件并吐出规范的内部表示形式。 因此，当然，我可以制作BazaarLogFileReader和GitLogFileReader并将其硬编码到程序中，但是我希望将其设置为添加对新版本控制程序的支持就像放入一个新的类文件一样简单。 在Bazaar和Git阅读器的目录中。

因此，现在您可以称为“用日志执行某事-软件git”和“用日志进行某事-软件义卖市场”，因为这些工具都有日志读取器。 我想要的是可以简单地将SVNLogFileReader类和文件添加到同一目录中，并自动调用“ do-some-the-the-log --software svn”，而无需对其余部分进行任何更改 程序。 （当然，可以使用特定的模式来命名文件，并在require调用中使用它们。）

我知道这可以在Ruby中完成...我只是不怎么做...或者根本不应该这样做。

我正在编写一些重新连接逻辑，以定期尝试建立与发生故障的远程端点的连接。 本质上，代码如下所示：

public void establishConnection() {
    try {
        this.connection = newConnection();
    } catch (IOException e) {
        // connection failed, try again.
        try { Thread.sleep(1000); } catch (InterruptedException e) {};

        establishConnection();
    }
}

我已经在很多情况下使用类似于上面的代码解决了这个普遍的问题，但是我对结果不满意。 是否有设计用于解决此问题的设计模式？

我正在寻找访客模式的替代方法。 让我只关注模式的几个相关方面，同时跳过不重要的细节。 我将使用Shape的示例（对不起！）：

1. 您具有实现IShape接口的对象层次结构
2. 您要对层次结构中的所有对象执行许多全局操作，例如 绘图，WriteToXml等...
3. 诱人的是直接进入并将Draw（）和WriteToXml（）方法添加到IShape接口。 这不一定是一件好事-每当您希望添加要在所有形状上执行的新操作时，都必须更改每个IShape派生的类
4. 为每个操作实现一个访问者，即Draw访问者或WirteToXml访问者将用于该操作的所有代码封装在一个类中。 然后，添加新操作就是创建一个新的访问者类，该类对所有类型的IShape执行该操作
5. 当您需要添加新的IShape派生的类时，您基本上会遇到与3中相同的问题-必须更改所有访问者类以添加处理新的IShape派生的类型的方法

您在大多数关于访客模式的地方都指出，第5点几乎是该模式起作用的主要标准，我完全同意。 如果IShape派生的类的数量是固定的，那么这可能是一种非常优雅的方法。

因此，问题在于何时添加了新的IShape派生类-每个访问者实现都需要添加一个新方法来处理该类。 充其量，这是充其量是令人不愉快的，而在最坏的情况下是不可能的，这表明这种模式并不是为应对这种变化而设计的。

因此，问题是有人遇到过替代方法来处理这种情况吗？

假设我们有一个代码块，我们要执行70％的时间，又要执行30％的时间。

if(Math.random() < 0.7)
    70percentmethod();
else
    30percentmethod();

很简单。 但是，如果我们希望它可以轻松扩展为30％/ 60％/ 10％等呢？在这里，它将需要添加和更改所有if语句，这些if语句使用起来并不十分好，而且很慢并且容易引发错误。

到目前为止，我发现大型开关对于这种用例非常有用，例如：

switch(rand(0, 10)){
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:70percentmethod();break;
    case 8:
    case 9:
    case 10:30percentmethod();break;
}

可以很容易地将其更改为：

switch(rand(0, 10)){
    case 0:10percentmethod();break;
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:60percentmethod();break;
    case 8:
    case 9:
    case 10:30percentmethod();break;
}

但是这些也有它们的缺点，它们很麻烦并且被划分为预定数量的划分。

我认为某种理想的方法是基于“频率数”系统，例如：

(1,a),(1,b),(2,c) -> 25% a, 25% b, 50% c

然后，如果您添加了另一个：

(1,a),(1,b),(2,c),(6,d) -> 10% a, 10% b, 20% c, 60% d

因此，简单地将数字相加，使总和等于100％，然后将其分割即可。

我想用自定义的哈希图或类似的东西为它创建处理程序不会有太大的麻烦，但是我想知道在我将所有的意大利面做成这个之前是否有某种确定的方式/模式或lambda。

在.NET 4.5 / C＃5中，2727750404139484160声明为IReadOnlyDictionary<T>属性：

public interface IReadOnlyCollection<out T> : IEnumerable<T>, IEnumerable
{
    int Count { get; }
}

我想知道，对于IDictionary<T>同样实现IReadOnlyDictionary<T>接口是否有意义：

public interface ICollection<T> : IEnumerable<T>, IEnumerable, *IReadOnlyCollection<T>*

这意味着实现IDictionary<T>的类将自动实现IReadOnlyDictionary<T>。对我来说，这听起来很合理。

IDictionary<T>抽象可以看作是IReadOnlyDictionary<T>抽象的扩展。 请注意，例如ICollection<T>同时实现ICollection<T>和IReadOnlyCollection<T>。

但是，它并不是以这种方式设计的。

我在这里想念什么？ 为什么会选择当前的实现方式？

更新

我正在寻找一个使用面向对象设计推理来解释原因的答案：

• 实现IReadOnlyDictionary<T>和ICollection<T>的具体类，例如IDictionary<T>

是比以下更好的设计：

• IDictionary<T>直接实施IReadOnlyDictionary<T>

还请注意，这本质上与以下问题相同：

1. 为什么IDictionary<T>无法实现IReadOnlyDictionary<T>？
2. Why doesn't IDictionary<T> implement IReadOnlyDictionary<T>?

所以我正在学校里学习设计模式。 今天，有人告诉我“原型”设计模式。

我一定想念一些东西，因为我看不到它的好处。 我曾在网上看到有人说它比使用new快，但这没有任何意义。 在某个时候，无论如何创建新对象，都需要为其分配内存。

这种模式与“鸡还是蛋”问题难道不在同一圈吗？ 由于原型模式本质上只是克隆对象，因此在某些时候必须创建原始对象（即不克隆）。 这意味着我需要准备克隆的每个对象的现有副本已经准备好克隆了？

谁能解释这个模式的用途？

我可以通过添加子类来解决添加功能的问题，那么为什么我应该使用装饰器模式呢？装饰器模式的真正优势是什么？

在我的业务领域（金融机构的后台IT）中，软件组件通常具有全局配置，记录其进度，进行某种错误处理/计算短路，这很常见。 可以由Haskell中的Reader-，Writer-，Maybe-monads等进行很好的建模，并与monad变压器一起构成。

但是似乎存在一些缺点：monad转换器背后的概念非常棘手且难以理解，monad转换器导致非常复杂的类型签名，并且会造成性能损失。

所以我想知道：在处理上述常见任务时，monad变压器是最佳实践吗？

我对如何最好地将代码重构为更具可读性的方法感到困惑。

考虑这段代码：

var foo = getfoo();
if(foo!=null)
{
    var bar = getbar(foo);
    if(bar!=null)
    {
        var moo = getmoo(bar);
        if(moo!=null)
        {
            var cow = getcow(moo);
            ...
        }
    }
}
return;

如您所见，需要大量嵌套的if块，因为每个嵌套的if都取决于先前的值。

现在我想知道如何在这方面使代码更简洁。

我想到的一些选择是：

• 在每个if子句之后返回，这意味着我将在多个地方离开我的方法
• 抛出goto:s，之后我将它们捕获到最后，并将return语句放在我的finally子句中（或在try / catch块之外）
• 使用标签和goto:

这些选项中的大多数对我来说似乎有点“肮脏”，所以我想知道是否有一种很好的方法来清理我创建的这种混乱情况。

什么是上下文对象设计模式？

可能重复：
Singletons有什么不好？

可以理解，在某些情况下会滥用许多设计模式，就像妈妈总是说：“一件好事并不总是一件好事！”

我注意到这些天，我经常使用Singletons，我担心自己会滥用设计模式，并且越来越多地养成不良习惯。

我们正在开发一个Flex应用程序，该应用程序具有很大的层次结构数据结构，当用户对其进行操作时会保留在内存中。 用户可以按需加载，保存，更改和刷新数据。

该数据通过Singleton类进行集中，该类聚集了一些ArrayCollections，Arrays，value对象以及一些通过getter和setter公开的其他本机成员变量。

为了从应用程序中的任何地方获取对我们数据的引用，我们对整个Model.getInstance（）方法进行了处理，我确定每个人都熟悉。 这确保了我们始终能够获得相同的数据副本，因为在设计时，我们曾说过在应用程序生存期内仅允许存在一个实例。

通过该中央数据存储库，例如，我们可以轻松地调度属性更改的事件，并且可以具有多个引用中央数据的UI组件，更新它们的显示以反映发生的数据更改。

到目前为止，这种方法是有效的，并且已证明对我们的情况非常实用。

但是，我发现在创建新类时我有点过于渴望。 诸如某个类应该是Singleton还是应该以其他方式进行管理（例如使用工厂）之类的问题有时会变得有些困难，并带有一些不确定性。

我在哪里画单身人士？ 是否有确定何时使用Singleton以及何时远离它们的良好指南。

另外，有人可以推荐一本关于设计模式的好书吗？

当我阅读有关存储库的文档时，通常以“只读”方式使用实体和集合。

从来没有任何示例存储库使用类似persist()或flush()这样的方法。

但是，在使用SOA时，服务不应与实体管理器一起使用（是的，不是吗？），所以：

1. 我的服务应该知道全局EntityManager吗？
2. 我的服务应该只知道已使用的存储库（比如UserRepository和ArticleRepository）吗？

从这两个问题中又一个问题，我的服务是否应该明确地将我的实体persist()和flush()确定？

偏爱继承而不是继承

是非常流行的短语。 我读了几篇文章，最后每篇文章都说

当类之间存在纯IS-A关系时，请使用继承。

本文中的一个示例：

在Apple和Fruit之间存在明显的IS-A关系，即Apple IS-A Fruit，但作者也将其显示为Apple HAS-A Fruit（组成），以显示通过继承实现时的陷阱。

我在这里变得有些困惑，声明的含义是什么

当类之间存在纯IS-A关系时，请使用继承。

使用组合而不是继承是否意味着即使存在纯IS-A关系，也总是尝试应用组合，而仅在没有意义的情况下才保留继承？

我和我的团队一直在讨论使用CQRS（命令查询责任隔离）设计模式，但我们仍在尝试评估使用它的优缺点。 根据：[http://martinfowler.com/bliki/CQRS.html]

我们尚未在现场看到足够的CQRS用途，对此还没有信心   我们了解其优缺点

那么你们怎么想，何时需要使用CQRS的问题？

什么是交互器？ 它如何适合MVP设计？ 与使用交互器代码放入演示者相比，使用交互器的优缺点是什么？

我最近正在读《学习JavaScript设计模式》这本书。 我没有得到的是模块模式和显示模块模式之间的区别。 我觉得他们是同一回事。 有人可以举一个例子吗？

我在维基百科中已经读到Decorator模式用于.Net和Java IO类。

有人可以解释如何使用吗？ 举一个可能的例子，它的好处是什么？

维基百科上有一个Windows表单示例，但我想知道Java IO类如何发生这种情况。

我想知道使用.When()对象中的方法链接在流畅接口中实现.WithSkill()条件的最佳方法是什么？

例如，在以下示例中，我将如何实现.WithSkill()和.When()方法：

var level = 5;

var ninja = NinjaBuilder
    .CreateNinja()
    .Named("Ninja Boy")
    .AtLevel(level)
    .WithShurikens(10)
    .WithSkill(Skill.HideInShadows)
        .When(level > 3)
    .Build()

更新-此处提供示例解决方案。

有人会解释我何时要使用Groovy特性，Mixins（@Mixin）和Delegates（@Delegate）吗？ 也许需要权衡和设计方面的考虑会有所帮助。

它们似乎都允许重用行为的多个“类”。 谢谢。 :-)

这个SO线程也很有帮助：Groovy中@Delegate和@Mixin AST转换之间的区别

到目前为止，我使用了构建器模式的以下实现（与此处描述的实现相反）：

public class Widget {
    public static class Builder {
        public Builder(String name, double price) { ... }
        public Widget build() { ... }
        public Builder manufacturer(String value) { ... }
        public Builder serialNumber(String value) { ... }
        public Builder model(String value) { ... }
    }

    private Widget(Builder builder) { ... }
}

这在我遇到的大多数情况下都非常有效，在这种情况下，我需要使用各种必需/必需和可选参数来构建一个复杂的对象。 但是，最近我一直在努力了解当所有参数都是强制性参数（或至少绝大多数参数都是强制性参数）时，模式有什么好处。

解决此问题的一种方法是在逻辑上将传递给它们自己的类的参数分组，以减少传递给构建器构造函数的参数数量。

例如，代替：

Widget example = new Widget.Builder(req1, req2, req3,req4,req5,req6,req7,req8)
                           .addOptional(opt9)
                           .build();

分为以下几类：

Object1 group1 = new Object1(req1, req2, req3, req4);
Object2 group2 = new Object2(req5, req6);

Widget example2 = new Widget.Builder(group1, group2, req7, req8)
                            .addOptional(opt9)
                            .build();

尽管拥有单独的对象可以使事情大大简化，但是如果不熟悉代码，也会使事情变得有些困难。 我考虑的一件事是将所有参数移到他们自己的addParam(param)方法中，然后在build()方法中对所需参数进行验证。

什么是最佳实践？也许我没有考虑过更好的方法？