标签: anti-patterns

我刚刚为我编写的方法添加了一个out bool参数,以便在我的UI中收到警告.我已经使用了out而不是让方法本身返回false/true,因为这意味着DoSomething失败/成功.我的想法是warnUser会指出警告实际上是什么,而不必查看方法的实现.

原始代码

public void DoSomething(int id, string input);

新规范

public void DoSomething(int id, string input, out bool warnUser);

我正在使用Moq来测试此代码,但它不支持out/ref参数,因为Lambda表达式不支持它们

测试代码

mockService.Verify(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<bool>());

因此,采用了参数不好的做法,如果是的话我该怎么办呢？

正如我读到的那样 Effective java

膨胀的类层次结构可能导致包含许多方法的膨胀类,这些方法仅在其参数类型上有所不同,因为类层次结构中没有类型可捕获常见行为.

在链接中

膨胀的类通常有许多特殊情况:属性或行为对某些实例有效,但对其他实例无效.程序员通常会通过引入类型标记来处理特殊情况.

Tagged类和膨胀类之间存在相似性,因为Effective java它被提到:

一个类,其实例有两种或多种风格,并包含一个标记字段,指示实例的风格.实例背负着属于其他风格的无关字段.

所以总结这两个类可能有标记类型/字段,并且这两个类都有很多实现(在一个类中模拟了很多特性).

我对这些术语感到困惑,我想知道,这两个Bloated类和Tagged类有什么区别？

我刚刚重构了一些代码,这些代码位于我正在处理的类的不同部分,因为它是一系列嵌套的条件运算符(？:),它通过一个相当简单的switch语句(C#)变得更加清晰.

您何时会触摸不直接与您正在处理的代码以使其更清晰？

最近我看了一些我在工作中致力于我们的版本控制系统的代码,我发现它已被替换了一堆(没关系),但旧版本仍在那里,注释掉了.

我猜这个家伙对于删除它感觉有点"不安全",因此将其留在那里注释掉了.但是,这并不是必需的,因为我们正在使用版本控制.(旧版本错了,所以它不会像以后那样需要.)

这些stackoverflow问题处理的问题是,是否留下这样的旧代码是一个好主意:

• /sf/ask/8639641/
• 评论中的旧代码

但是,我的问题是:这个问题是否有一个术语,或者在与同事谈论它时可以引用一个"反模式名称"？

我有一个C背景,并且是C++的新手.我有一个基本的设计问题.我有一个班级(我称之为"厨师"b/c我的问题似乎与此类似,无论是在复杂性还是问题方面)基本上都是这样的

    class chef
    {
    public:
          void prep();
          void cook();
          void plate();

    private: 
          char name;
          char dish_responsible_for;
          int shift_working;
          etc...
    }

在伪代码中,这可以通过以下方式实现:

   int main{
    chef my_chef;
    kitchen_class kitchen;
    for (day=0; day < 365; day++)
         {
         kitchen.opens();
         ....

         my_chef.prep();
         my_chef.cook();
         my_chef.plate();

         ....

         kitchen.closes();
         }
   }

这里的厨师班似乎是一个怪物类,并有可能成为一个.厨师似乎也违反了单一的责任原则,所以我们应该有这样的事情:

  class employee
  {
  protected: 
        char name;
        int shift_working;
  }

  class kitchen_worker : employee
  {
  protected: 
        dish_responsible_for;
  }

  class cook_food : kitchen_worker
  {
  public:
        void cook();
        etc...
  }
  class prep_food : kitchen_worker
  {
  public:
        void prep();
        etc... …

维基百科将"呼叫超级"归类为反模式,我真的不明白为什么.该模式经常用于Objective-C/cocoa; 例如init/dealloc,drawrect,awakefromnib都需要你调用super.我在这里误解了这个概念吗？

链接到文章:http://en.wikipedia.org/wiki/Call_super

是否可能和/或一个好主意使用Ninject(或任何其他IoC容器)为不存在适当实现的情况创建默认绑定,并使用此默认绑定而不是必须处理ActivationException当存在多个绑定,或者特定请求没有绑定时？

我一直在使用Ninject的工厂和公约扩展项目,但我想知道他们是否正在掩盖我在更基础的层面上犯的错误,所以我创建了一个测试来说明我想要做的事情,因为我尽我所能:

鉴于以下内容:

public interface IWidget { }
public class DefaultWidget : IWidget { }
public class BlueWidget : IWidget { }

以下使用FluentAssertions进行xUnit测试:

[Fact]
public void Unknown_Type_Names_Resolve_To_A_Default_Type()
{
    StandardKernel kernel = new StandardKernel();

    // intention: resolve a `DefaultWidget` implementation whenever the 
    // 'name' parameter does not match the name of any other bound implementation
    kernel.Bind<IWidget>().To<DefaultWidget>();
    kernel.Bind<IWidget>().To<BlueWidget>().Named(typeof(BlueWidget).Name);
    kernel.Get<IWidget>("RedWidget").Should().BeOfType<DefaultWidget>();

    //      ACTIVATION EXCEPTION (**NO matching bindings available** for `IWidget`)
} …

出于方便和安全的原因,我想使用该using语句来分配和释放来自/到池的对象

public class Resource : IDisposable
{
    public void Dispose()
    {
        ResourcePool.ReleaseResource(this);
    }
}

public class ResourcePool
{
    static Stack<Resource> pool = new Stack<Resource>();

    public static Resource GetResource()
    {
        return pool.Pop();
    }

    public static void ReleaseResource(Resource r)
    {
        pool.Push(r);
    }
}

和访问池一样

using (Resource r = ResourcePool.GetResource())
{
     r.DoSomething();
}

我找到了一些关于滥用using和Dispose()范围处理的主题,但所有这些主题都包含在内using (Blah b = _NEW_ Blah()).
在离开使用范围但保留在池中之后,不会释放对象.
如果using语句只是简单地扩展到一个简单,try finally Dispose()这应该工作正常但是在幕后会发生更多的事情,或者在未来的.Net版本中这种情况不会发生吗？

我正在制作一个swing应用程序,并意识到我有一些需要访问同一组常量的类.我不能让自己宣布一个人是他们的主要持有人并将他们全部放在那里并让其他人参考它; 我想,嘿,我只是让它们都从一些常见的地方继承,但是Java不会做多重继承,但我可以把无限接口放在东西上.所以我想把它们全部转移到一个界面中(这是真的,我自然而然地没有进行任何研究).

我后来才知道这是异端邪说."事实上,它有一个名称,它有一个名称:恒定接口反模式" - 如此处所讨论的(以及替代解决方案(我选择使用)).

我一直很好,直到我查看的源代码JDialog和JFrame,因此阅读:

public class JDialog extends Dialog implements WindowConstants,
                                               Accessible,
                                               RootPaneContainer,
                               TransferHandler.HasGetTransferHandler
{
...

和

public class JFrame extends Frame implements WindowConstants,
                                             Accessible,
                                             RootPaneContainer,
                             TransferHandler.HasGetTransferHandler
{
...

也许这只是我,但我确实在那里看到一个恒定的界面.更有趣的是JDialog中的作者声明之一,即James Gosling.语言的父亲在他的手表上允许这个所谓的错误？

(另一个值得注意的例子 - SwingConstans)

如果常量接口反模式是一个坏主意,那么为什么它在语言最着名的一个包(即swing)中被大量使用？

year年错误是一种代码缺陷，当在a 年的环境中（通常是在公历阳历系统中）执行时，会产生有问题的意外结果。

上一个leap年是2016年。下一个leap年是2020年和2024年。

leap年有两个独特的属性：

• years年有2月29日，而普通年没有。
• 年总共有366天，而普通年只有365天。

这篇文章旨在帮助其他人了解of年错误的性质，它们在各种语言中的外观以及如何纠正它们。

年错误通常分为两种影响类别：

• 类别1：导致错误条件的变量，例如异常，错误返回代码，未初始化的变量或无限循环
• 类别2：导致错误数据的那些，例如范围查询或聚合中的一对一问题

对于每个答案，请指出编程语言和/或平台，以及上面定义的影响类别。（请遵循现有答案使用的模板。）

请针对每种语言和缺陷类型创建一个单独的答案，并投票给您最喜欢的，尤其是您亲身遇到的那些投票（在可能的情况下留下带有轶事的评论）。

我将提供一些答案以开始使用，并随着时间的推移以其他示例进行更新。