标签: code-design

您对在项目中设计linq代码有什么建议？特别是,我对大而复杂的linq查询的代码设计感兴趣吗？

例如,你知道,你需要写很多巨大的linq东西,也许你的一些代码会有重复的部分,也许不会,你需要:

1. 使代码容易支持 - 意味着,如果您需要更改某些内容. - 你正在改变一件事,而不是很多

2. 使代码易于阅读 - 意味着,如果您需要找到某些东西 - 您可以轻松地执行此操作.

你可以使用你的例子,也许你的练习.也许是你在任何地方看到的一些模式 - 任何东西.

说linq我的意思是任何linq,linq到sql,linq到对象,linq到xml等.

TNX

假设我有一个看起来像这样的函数:

public void saveBooking(/* some inputs */) {
    //save into database
}

在保存到数据库之前,我必须进行各种验证.我在主程序中可以做的是这样的:

//do all the validations and do any necessary handling. Then...
saveBooking(/*inputs*/);

有了这个,我确信在保存到数据库之前,所有数据都必须通过所需的所有验证.但是,这意味着该功能saveBooking()非常依赖于验证方法.每次我想打电话saveBooking(),我都要确保不要忘记给他们打电话.

或者,我可以将所有验证放在函数本身中,这样我所要做的就是调用方法,一切都得到了解决.但是,为了独立处理所有错误,我必须使函数抛出异常并捕获主程序.它应该看起来像这样:

public void saveBooking(/* some inputs */) /* throws various exceptions */ {
    //various validations
    //save into database
}

//...and in the main program...
try{
    saveBooking(/*inputs*/);
}
catch(MyException1 e1){
    //do something
}
catch(MyException2 e2){
    //do something
}

这也意味着我必须自己创建多个例外.好消息是我不必担心我必须提前做出哪些验证.

有了这些,我不确定哪一个是最好的代码设计.我个人更喜欢第一种方法,它更具可读性,但它相互依赖太多而且当我需要在很多地方使用它时它会变得更糟.请指教!

我刚刚完成了一段复杂的代码.它适用于规范,它符合性能要求等,但我对此感到有点担心,并正在考虑重写和/或重构它.我应该这样做(花费时间,否则可能花在用户实际会注意到的功能上)？

我对代码感到焦虑的原因是:

1. 类层次结构复杂且不明显
2. 有些课程没有明确的目的(他们做了许多无关的事情)
3. 有些类使用其他内部(它们被声明为友元类)来绕​​过抽象层以获得性能,但我觉得它们通过这样做打破了封装
4. 有些类会泄漏实现细节(例如,我之前将地图更改为哈希映射,并发现自己必须修改其他源文件中的代码才能使更改生效)
5. 我的内存管理/池化系统有点笨拙而且不够透明

它们看起来是重构和清理代码,帮助未来维护和扩展的极好理由,但可能非常耗时.此外,我永远不会对我写的任何代码感到非常满意......

那么,stackoverflow会怎么想呢？清理代码或处理功能？

我希望您就以下主题发表意见:

想象一下,我们有一个方法负责实现一个特定的目的,但要做到这一点,它需要大量本地范围的对象的支持,其中许多实现IDisposable.

MS编码标准规定,当使用IDisposable不需要"生存"方法范围的本地对象(不会返回或不会被分配给某些更长寿的状态信息object)时,您应该使用该using构造.

问题是,在某些情况下,您可以获得嵌套的"地狱" using块:

using (var disposableA = new DisposableObjectA())
{
     using (var disposableB = new DisposableObjectB())
     {
          using (var disposableC = new DisposableObjectC())
          {
               //And so on, you get the idea.
          }
     }
}

如果您使用的某些对象派生自公共库或实现实现的公共interface,则可以以某种方式缓解此问题IDisposable.当然,这需要在需要对象的真实类型时必须投射所述对象.有时,只要铸件的数量不会失控,这是可行的:

using (var disposableA = new DisposableObjectA())
{
     using (DisposableBaseObject disposableB = new DisposableObjectB(),
            disposableC = new DisposableObjectC)
     {
          using (var disposableD = new DisposableObjectD())
          {
               //And so on, you get …

我喜欢这种方式,你可以在Scala中编写单行方法,例如List(1, 2, 3).foreach(..).map(..).

但是有一种情况,有时在编写Scala代码时会出现这种情况,事情变得有点难看.例:

def foo(a: A): Int = {
  // do something with 'a' which results in an integer
  // e.g. 'val result = a.calculateImportantThings

  // clean up object 'a'
  // e.g. 'a.cleanUp'

  // Return the result of the previous calculation
  return result
}

在这种情况下,我们必须返回一个结果,但是在计算完成后不能直接返回它,因为我们必须在返回之前做一些清理.

我总是要写一个三班轮.是否有可能编写一个单行代码来执行此操作(不更改类A,因为这可能是一个无法更改的外部库)？

我有一个包含几十个不同模块的大项目.我确实有很多常用的功能,我在项目的很多地方都使用过.例如:

• 检查字符串是否包含希伯来字符
• 生成随机的8个字母的字符串
• 猜测二进制数据的图像mime类型
• 转换HTML权利
• 等等...

我的问题是:

• 将所有这些函数放在将从每个代码文件加载的特定模块中是否常规？
• 这个模块应该有什么名字？common.py？
• 我的代码被分成不同的包.通常将文件放在根代码文件夹中,并加载一个超出包范围的文件？

是否有任何有效的理由可以解释为什么没有String.Split接受分隔符字符串和要分割的文本的重载？

string[] Split(string delimiter)

然后可以使用像

string input = "This - is - an - example";
string[] splitted = input.Split(" - ");
// results in:
//  { "This", "is", "an", "example" }

我真的知道,我可以轻松地创建一个扩展方法,但必须有正当理由说明为什么没有添加它.

请注意,我不是在寻找如何使用字符串分隔符拆分字符串的解决方案,我正在寻找解释,为什么这样的重载可能会导致问题.这是因为我认为它不会真正引起问题,我发现初学者很难理解为什么我们必须传递一个实际string[]而不是简单string的分隔符.

考虑以下访问者的简单语言解释器.

public interface Visitor{
    void visit( VarStat vs);
    void visit( Ident i);
    void visit( IntLiteral a);
    void visit( Sum s);
}

为了完整起见,我添加了一些代码,提供了必要的实现细节(您可以跳过并直接阅读问题).

public interface Visitable{
    void accept( Visitor v);
}

public class VarStat implements Visitable{
    Ident i;
    Exp   e;

    public VarStat(Ident id, Exp ex){
        i = id;
        e = ex;
    }

    public Ident getIdent() { return i; }
    public Exp getExp() { return e; }

    @Override
    public void accept( Visitor v){
        v.visit( this);
    }
}

public interface Exp extends Visitable{ …

这是一个问题陈述:我们有接口/超级班学生和教师

学生有两个实现/子分支,ScienceStudent和PhysicalEducationStudent

老师有ScienceTeacher和PhysicalEducationTeacher.

我们想要实现一个方法getMeetingPoint(Student,Teacher t),它根据学生和教师的类型返回他们见面的地方.

举例来说,如果其ScienceStudent和ScienceTeacher他们在满足实验室 如果PEStudent和体育教师,他们在满足地面,如果它的一个ScienceStudent和体育教师,反之亦然,他们在满足食堂

我们可以写一个天真的方法,检查使用instanceof.但问题是,当教师或学生扩展并且难以维护时,这变得复杂.这样的事情:

public class MeetingPointDecider {

    getMeetingPoint(Student s,Teacher t) {
        if(s instanceof ScienceStudent && t instanceof ScienceTeacher) {
            return "Lab";
        } else if (s instanceof PhysicalEducationStudent && t instanceof PhysicalEducationTeacher) {
            return "GRound";
        }
        .
        .
        .
    }
}

另一个选择是写一个工厂,它接受一个学生和一个教师,并返回类似MeetingPointDecision [Ground或Lab],但问题仍然存在.我们可以使用任何好的模式,在添加新类时我们不必修改现有的类(或最小的修改),Say instanceofScienceStudent我们有ChemistryStudent,PhysicsStudent和ChemistryLab,PhysicsLab.还有可能添加更多操作,这些操作根据学生和教师类型的不同而有所不同(其中访问者是一个选项,但不确定如何使用两个决定类来实现)

有人可以建议一个好方法来实现这个吗？

谢谢!

在编写类的构造函数时,我经常会问自己是否应该使用初始化成员变量或构造函数参数.这里有两个例子来说明我的意思:

构造函数参数

class Foo {
public:
    Foo(int speed) :
        mSpeed(speed),
        mEntity(speed)
    { }

private:
    int mSpeed;
    Entity mEntity;
}

成员变量

class Foo {
public:
    Foo(int speed) :
        mSpeed(speed),
        mEntity(mSpeed)
    { }

private:
    int mSpeed;
    Entity mEntity;
}

更进一步,在构造函数体中使用变量会产生同样的问题.

构造函数参数

class Foo {
public:
    Foo(int speed) :
        mSpeed(speed)
    {
        mMonster.setSpeed(speed);
    }

private:
    int mSpeed;
    Monster mMonster;
}

成员变量

class Foo {
public:
    Foo(int speed) :
        mSpeed(speed)
    {
        mMonster.setSpeed(mSpeed);
    }

private:
    int mSpeed;
    Monster mMonster;
}

我知道它并不重要(除了一些特殊情况),这就是为什么我宁愿在代码设计上征求意见,而不是让它起作用,什么不起作用.

如果您需要一个特定的问题可以使用:什么方式可以产生一个漂亮而一致的代码设计,并且一个人具有(dis)优势而不是另一个？

编辑:不要忘记问题的第二部分.构造函数体中的变量怎么样？