标签: code-design

我有很多代码片段必须在初始化期间运行一次.

我必须以这种方式使用布尔标志,因为它在一个事件中

bool _fuse;

void PerformLayout()
{
    Size size;

    if (!_fuse)
    {
        size = _InitialContainerSize;
        _fuse = true;
    }
    else
        size = parent.Size;

    // ...
}

因为它经常发生,我做了一些事情来使这个布尔变量看起来像一个保险丝:

所以我这样做了:

bool _fuse;

void PerformLayout()
{
    Size size;

    if (!Burnt(ref _fuse))
        size = _InitialContainerSize;
    else
        size = parent.Size;

    // ...
}

如果它初始化为false,则查询结果返回false一次,将切换为true,并且后续调用返回true.

public static bool Burnt(ref bool value)
{
    if (!value)
    {
        value = true;
        return false;
    }
    else
        return true;
}

当然,它有效,但我只是中等满意,我相信有更优雅的解决方案.你的是什么？

请考虑以下代码:

class Base
{
public:
    virtual void Foo() {}
};

class Derived : public Base
{
private:
    void Foo() {}
};

void func()
{
    Base* a = new Derived;
    a->Foo(); //fine, calls Derived::Foo()

    Derived* b = new Derived;
//  b->Foo(); //error
    static_cast<Base*>(b)->Foo(); //fine, calls Derived::Foo()
}

关于此事,我听过两种不同的思想流派:

1)保持可访问性与基类相同,因为用户无论如何都可以使用static_cast来获取访问权限.

2)使功能尽可能私密.如果用户需要a-> Foo()而不是b-> Foo(),那么Derived :: Foo应该是私有的.如果需要,它总是可以公开.

是否有理由偏好其中一个？

我正在创造一个我有小"粒子"的游戏.它们的数量经常变化(每隔几秒钟),我想知道存储它们的最佳方法是什么.是std::vector或std::deque为了这个美好的？

是否可以保留永远不会被使用的空间(在那个容器中)(我有上限)？

我正在开发简单的模拟库并遇到问题,我有模拟Time变量,在任何情况下都不能由API用户(程序员)修改(只提供有关模拟时间的信息),但应该可以通过模拟库进行修改,所以它不能是恒定的.

这是我想出来的,但对我来说似乎有点棘手

double simTime;                // Internal time, modified by library
const double& Time = simTime;  // Time info provided for programmer in API

有没有更好的方法呢？

这个问题来自于这个问题:

def fringe8((px, py), (x1, y1, x2, y2)):

就个人而言,看到一个带有固定数量的迭代(如元组)或两个或更多字典(如Shotgun API中)的两个参数的函数是我的烦恼之一.它很难使用,因为所有的冗长和双括号外壳.

这不会更好:

>>> class Point(object):
...     def __init__(self, x, y):
...         self.x = x
...         self.y = y
...     
>>> class Rect(object):
...     def __init__(self, x1, y1, x2, y2):
...         self.x1 = x1
...         self.y1 = y1
...         self.x2 = x2
...         self.y2 = y2
...     
>>> def fringe8(point, rect):
...     # ...
...
>>>
>>> point = Point(2, 2)
>>> …

我注意到UnderScoreJS具有许多围绕本机Javascript函数的包装函数。

举个例子：

_.isArray, _.isBoolean, _.isNaN?

有什么理由吗？还是在使用underscoreJS库时仅仅是为了确保代码一致性而已，还是无论如何都只是增强了这些功能？

例如，_。isArray函数可以简化为：

_.isArray = nativeIsArray || function(obj) {
    return toString.call(obj) === '[object Array]';
  };

任何的想法？

if preset.exists('//*[@id="i0116"]', '10', '1'):
    if (log.enter_username()):
        if preset.exists('//*[@id="i0116"]', '10', '1'):
            if (log.enter_password()):
                locked = unlock(details[0], details[1], browser, ' ', ' ', ' ')
                if not (locked.checkBlocked()):
                    # unlock account
                else:
                    searches = search(details[0], details[1], browser)
            else:
                browser.quit()
                continue
        else:
            browser.quit()
            continue
    else:
        browser.quit()
        continue
else:
    browser.quit()
    continue

我正在使用Python制作一个机器人,我有很多异常处理要做到这一点,我可能最终会有至少5个以上的这些,如果是的话,其他的......

我在这里做错了吗？我应该在方法本身内部硬编码这些异常,而不是使用控制文件来执行此操作吗？

我一再被告知在编程时不要重复自己.我遇到过一个场景,我想知道是编写两个函数,每个函数用于特定目的,还是一个函数来处理这两个目的.我不确定什么是"最佳实践"方法:

所讨论的所有函数都涉及允许一个人将列表项的等级改变一个位置,加上或减去一个.所有项目及其等级都保存在MySQL数据库表中.)

两个函数一个用于将项目的等级向上移动一个,另一个用于将等级向下移动一个.

一个函数我可以通过添加"方向"的附加参数并使用if语句来决定是向上还是向下移动项目,将相同的函数写入一个函数.

在性能方面,编写两个函数并让它们共享负载会更好吗？如果相同的功能接收大量请求,是否存在"功能过载"这样的事情？

我不认为它是相关的,但我正在使用ColdFusion,而我的附加"方向"参数将是一个包含在语句中的字符串,该语句检查它的值以确定要采取的操作.

我正在研究使用独立存储在Windows Phone中进行持久性建模的不同选项.我提出的一个想法是每个对象处理它自己的概念(当然是理所当然的)持久性,而不是为了保存对象而创建一个存储库或其他这样的实体.

我似乎无法找到关于这种持久性方法的任何好信息,这让我相信我可能偶然发现了一种反模式.

有没有人以这种方式接近坚持？如果是这样的话,你对这种方法的看法是什么？

在我的WPF应用程序中,我有几个基于记录的给定ID的地方,我调用一个新表单作为模态显示以查看详细信息.然后它会关闭并返回到预期的调用源.这一切都没有问题.

为了简化编码,我在显示的表单的构造函数的末尾添加了一个"ShowDialog()"调用.这可以防止每个地方需要这种形式被称为需要...

var myModalForm = new MyModalForm(someIdToDisplay);
myModalForm.ShowDialog();

简化,我只需要用Id创建模态表单,例如

new MyModalForm(someIdToDisplay);

但是通过ReSharper检查器,它返回"由'new'表达式创建的可能未分配的对象".

我知道垃圾收集器会在它完成后得到它,但作为一个模态形式,一旦完成,我不需要用它做任何其他事情.所以,这是不好的,还是好的,只是忽略这种警告的考虑.其他一切在应用程序中工作正常.

与枚举相比,使用字符串进行比较是否常见？

我有这个警报:

没有互联网连接,请再试一次

我必须有许多代码块可以产生这个消息,我想把它放在UIAlertView一个我不会每次都创建它的类中,这可能吗？

我们需要在我们的应用程序中代表大量数字.我们使用整数数组来做这个.最终的生产应该是性能最大化.我们考虑将数组封装在一个类中,这样我们就可以添加与数组相关的属性,如isNegative,numberBase等.

但是,我们担心使用课程会使我们的表现明智.我们做了一个测试,我们创建了一个固定数量的数组,并通过纯数组使用设置它的值,并创建一个类,并通过类访问数组:

for (int i = 0; i < 10000; i++)
{
    if (createClass)
    {
        BigNumber b = new BigNumber(new int[5000], 10);
        for (int j = 0; j < b.Number.Length; j++)
        {
            b[j] = 5;
        }
    }
    else
    {
        int[] test = new int[5000];
        for (int j = 0; j < test.Length; j++)
        {
            test[j] = 5;
        }
    }
}

并且似乎使用类几乎将上述代码的运行时间减慢了6倍.我们通过将数组封装在结构中来尝试上述操作,这导致运行时间几乎等于纯数组使用.

与结构相比,使用类时导致这种巨大开销的原因是什么？当你使用堆栈而不是堆时,它真的只是你获得的性能提升吗？

编辑: BigNumber只将数组存储在属性公开的私有变量中.简化:

public class BigNumber{
  private int[] number;

  public BigNumber(int[] number) { this.number = …