标签: code-design

正如您在下面的代码中看到的那样,在构造Child对象期间,在Init()之前调用DoStuff()方法.

我的情况是,我有很多子课.因此,在每个子节点的构造函数中的Init()之后直接重复调用DoStuff()方法将不是一个优雅的解决方案.

有没有办法在父类中创建某种post构造函数,它将在子构造函数之后执行？这样,我可以在那里调用DoStuff()方法.

如果您有任何其他设计理念可以解决我的问题,我也想听听它!

abstract class Parent
{
    public Parent()
    {
        DoStuff();
    }

    protected abstract void DoStuff();
}

class Child : Parent
{
    public Child()
    // DoStuff is called here before Init
    // because of the preconstruction
    {
        Init();
    }

    private void Init()
    {
        // needs to be called before doing stuff
    }

    protected override void DoStuff() 
    {
        // stuff
    }
}

静态类被认为是不好的做法？几天前我读了一篇关于这个的文章(找不到,对不起),基本上说有静态类(特别是那些'帮助'类)通常是坏代码的标志.这是正确的,如果是的话,原因是什么？

有没有办法将可执行块作为参数传递给静态方法？有可能吗？例如,我有这种方法

public static void someMethod(boolean flag, Block block1, BLock block2) {
    //some other code
    if(flag)
        block1.execute();
    else block2.execute();
    //some other code
}

或类似的东西.它实际上比这更复杂,我只是简化了问题.我正在尝试重构我的项目,我创建了一个包含我的类使用的静态方法的通用实用程序类.

什么时候功能太长了？我想是这个问题的一个子集.

确定课程太长的几个好指标是什么？

我正在为一个与外部承包商的项目重新制定一套代码验收指南,并意识到我过去没有涉及这个问题,但是应该在将来讨论这个问题.

在PHP中,是否可以退出PHP代码块(即PHP标记)？

<?php
    if (!A) phpexit();
    print("1");
?>

<?php
    print("2");
?>

所以,如果A是真的,那么结果是12,如果A是假,那么结果是2.

我知道你可以用if语句或其他东西来做这个,但我想知道是否还有一些特殊的PHP函数可以做到这一点.

这是原始代码:

public class FruitGrower {
    public void growAFruit(String type) {
        if ("wtrmln".equals(type)) {
            //do watermelon growing stuff
        } else if ("ppl".equals(type)) {
            //do apple growing stuff
        } else if ("pnppl".equals(type)) {
            //do pineapple growing stuff
        } else if ("rng".equals(type)) {
            //do orange growing stuff
        } else {
            // do other fruit growing stuff
        }
    }
}

这就是我改变它的方式:

public class FruitGrower {
    enum Fruits {
        WATERMELON {
            @Override
            void growAFruit() {
                //do watermelon growing stuff
            }
        },

        APPLE {
            @Override
            void …

我观察到静态和机器学习科学家在使用Python(或其他语言)时通常不会遵循ML /数据科学项目的OOPS.

主要是因为在开发用于生产的ML代码时,缺乏对oops中最佳软件工程实践的理解.因为他们大多来自数学和统计学教育背景而不是计算机科学.

ML科学家开发临时原型代码和另一个软件团队使其生产就绪的日子在业界已经结束.

问题

1. 我们如何使用OOP为ML项目构建代码？
2. 是否每个主要任务(如上图所示)如数据清理,特征转换,网格搜索,模型验证等都应该是一个单独的类？ML的推荐代码设计实践是什么？
3. 任何好的github链接都有很好的代码可供参考(可能是一个写得很好的kaggle解决方案)
4. 应每类像数据清洗有fit(),transform(),fit_transform()功能为每一个过程是怎样的remove_missing(),outlier_removal()？当这样做时,为什么scikit-learn BaseEstimator通常会被继承？
5. 生产中ML项目的典型配置文件的结构应该是什么？

我刚刚重构了一个同事的代码,粗略地看起来像这样......

public class Utility
  public void AddHistoryEntry(int userID, HistoryType Historytype, int companyID)
  {
    // Do something...
  }
  public void AddHistoryEntry(int userID, HistoryType historyType, int companyID, string notes)
  {
    // Do something...
  }
}

对此......

public class HistoryEntry
{
  public long UserID { get; private set; }
  public HistoryType HistoryType { get; private set; }
  public long CompanyID { get; set; }
  public string Notes { get; set; }

  public HistoryEntry(long userID, HistoryType historyType)
  {
    this.UserID = userID;
    this.HistoryType = historyType; …

我(现在比以往任何时候都更多)看到开发人员编写了大量的图层,例如:

implementation PresentationLayer ->
    interface IMyDTO ->
        implementation MyDTO ->
            interface IMyService -> 
                implementation MyService -> 
                    interface IMyDomainRepository ->
                        implementation MyDomainRepository ->
                            interface IMyDomainObject -> 
                                implementation MyDomainObject ->
                                    interface IMyIndependentStorageLayer ->
                                        implementation MyMSSQLStorageLayer

通过C#博客看,这似乎是自切片面包以来最好的事情.基本上,一切都松散耦合.不要直接使用域对象.通过服务层运行所有内容.通过存储库访问数据.所有图层都完全独立.

不要误解我的意思,我喜欢这个想法,但是不是时间上的权衡,特别是在一个更大的项目上？维护的投资回报率是否真的足以证明这一点？

我读到的解释有点尴尬,例如"如果需要,我可以附加不同的数据库".真？我不认为这是一个常见的问题,有人突然要求从MSSQL切换到Oracle,现在你坐在那里,希望你有一百万个层,彼此都不知道.

是否存在松散耦合过度的趋势,或者我只是在阅读错误的博客？你觉得这个怎么样,并且你有过这样的情况,你以后真的很高兴你在开始时做了额外的工作吗？

我在我的项目中使用Underscore.js.几乎所有文件都有这行代码:var _ = require('underscore').该require函数是同步的,因此每次使用时都会加载相同的文件.这是正确的做法吗？这不会影响性能吗？

而不是这样,可以在app.js文件中定义一个全局变量吗？

_ = require('underscore')

我已经读过你不应该使用全局变量,但这似乎是一个有效的用例.