标签: single-responsibility-principle

SRP(PDF版本; HTML版本)表明了这一点

一个班级改变的理由绝不应该是一个原因

当您查看Outlook,日历事件窗口时,它具有"保存并关闭"按钮.

因此,当Save或Close中的任何一个或两个的功能发生变化时,该按钮应该会发生变化.它显然违反了SRP.

此功能既节省时间又方便,因为大多数用户在日历上保存约会时都希望这样做.

但是现在,我的问题是,除了功能需要在Outlook中使用之外,你还有什么时候违反SRP？

单一责任原则是否意味着您的验证规则应该在实体外部？

如果是,那么每个验证规则使用一个类吗？

鉴于Mixins 通常会在类中引入新行为,这通常意味着类会有多个行为.

如果一个类只有一个责任,则将其定义为只有一个改变原因的类.

所以,我可以从两个不同的角度看待这一点

1. 这个班只有一个改变的理由.混合的模块也只有一个变化的原因.如果更改了类,则只需要重新测试类.如果更改模块,则只需要重新测试模块.因此,SRP是完整的.

2. 该班现在有两个改变的原因.如果更改了类,则类和模块都需要重新测试.如果更改了模块,则类和模块都需要重新测试.Henge,SRP受到侵犯.

mixin的使用是否违反了单一责任原则,最终导致系统难以维护？

我见过的大多数ASP.NET MVC示例都描述了用户正在查看对象(或对象集合)然后从该页面移动到显示用户完成的表单的情况.在提交具有良好输入的表单后,用户被重定向回显示对象(或列表)的页面,并且用户可以看到他们的更改成功.

我遇到了每个业务规则都没有视图或列表页面的情况.

在ASP.NET MVC中,这种场景有哪些好的方法？

在使用Classic ASP和ASP.NET的过去,我会处理输入,然后向用户显示成功消息或带有错误的表单 - 所有这些都来自同一页面.这似乎违背了最佳实践(SRP,视图中没有逻辑等).

一种简单的方法是重定向到一个新页面,告诉用户他们的更改是成功的,但随后用户可以随时访问该页面.如果我开始使用逻辑来防止这种情况(即tempdata),那么解决方案就会变得很脏.

我可以重定向到目标网页,但没有确认.也许我可以依赖一个消息系统,当他们返回登录页面时向最终用户显示确认信息？

我已经用Python编程了一段时间,并且已经介绍了Python风格的一些知识,但是仍然存在如何正确使用类的问题.在阅读面向对象的讲座时,我经常会发现像单一责任原则这样的规则

"单一责任原则说一个班级应该有一个,而且只有一个,有理由改变"

读到这篇文章,我可能会想到将一个类分成两个,比如:

class ComplicatedOperations(object):
    def __init__(self, item):
        pass

    def do(self):
        ...

    ## lots of other functions

class CreateOption(object):
    def __init__(self, simple_list):
        self.simple_list = simple_list

    def to_options(self):
        operated_data = self.transform_data(self.simple_list)
        return self.default_option() + operated_data

    def default_option(self):
        return [('', '')]

    def transform_data(self, simple_list):
        return [self.make_complicated_operations_that_requires_losts_of_manipulation(item)
                        for item in simple_list]

    def make_complicated_operations_that_requires_losts_of_manipulation(self, item):
            return ComplicatedOperations(item).do()

对我来说,这提出了许多不同的问题; 喜欢:

• 我什么时候应该使用类变量或在类函数中传递参数？
• 如若ComplicatedOperations类是类或只是一堆的功能是什么？
• 该__init__方法应该用于计算最终结果.这是否会使该类难以测试.
• 蟒蛇的规则是什么？

回答后编辑:

所以,阅读奥古斯托理论,我最终会得到这样的结论:

class ComplicatedOperations(object):
    def __init__(self):
        pass

    def do(self, item):
        ...

    ## lots of other functions

def …

根据Robert C. Martin的说法,SRP表示:

一个班级改变的理由绝不应该是一个原因.

但是,在他的书" 清洁代码"第3章:函数中,他展示了以下代码块:

    public Money calculatePay(Employee e) throws InvalidEmployeeType {
        switch (e.type) {
            case COMMISSIONED:
                return calculateCommissionedPay(e);
            case HOURLY:
                return calculateHourlyPay(e);
            case SALARIED:
                return calculateSalariedPay(e);
            default:
                throw new InvalidEmployeeType(e.type);
        }
    }

然后陈述:

这个功能有几个问题.首先,它很大,当添加新的员工类型时,它会增长.其次,它显然不止一件事.第三,它违反了单一责任原则(SRP),因为改变的原因不止一个.[强调我的]

首先,我认为SRP是为类定义的,但事实证明它也适用于函数.其次,这个功能有多个原因需要改变？我只能看到它因员工的变化而发生变化.

出于我的目的，我需要在 xml 文件中搜索特定节点，如果找到，则将其删除。我应该将搜索功能提取到其自己的方法中，并将删除功能提取到其自己的方法中吗？这样做似乎更昂贵，因为我将搜索 xml 文件一次以查看它是否存在，然后再次搜索以将其删除。如果我将这两个功能合并到一个方法中，我可以在找到它时立即将其删除。我在这里理解的SRP正确吗？

我目前正在学习Java并学习封装,我不确定以下哪项是更好的做法:

1. 使用getter将字段值从一个类返回到另一个类,然后通过另一个类中的方法打印它.
2. 从另一个类调用类中的方法以打印字段的值.

该值不会被操纵,只能通过System.out.println()显示;

任何意见,将不胜感激 :)

编辑:一个类(人)持有关于人的信息,例如姓名,年龄,体重等,另一个类(目录)具有用于搜索人的LinkedList以找到具有匹配年龄的对象的方法.如果找到某人,则该方法打印出该人的姓名.

我有一个很大的类（1500 行，但很快会是它的几倍），我想将其拆分，以便更好地与SRP配合使用（并且每个文件都更小且更易于管理。）

该类包含 50-100 个属性，并针对它执行几种不同类型的操作 - 其中之一是执行update多个步骤，例如更新数据库和发送电子邮件。

所以我想我想要4节课。

我应该如何构建类？

这是我现在拥有的简化版本：

class Foo {
    public function __construct ($params) {}

    public function update () {
        $this->updateDatabase();
        $this->sendEmails();
    }

    private function updateDatabase () {}
    private function sendEmails () {}
}

$foo = new Foo($params);
$foo->update();

updateDatabase()并且sendEmails ()每个都调用许多其他方法——每个都有数百行代码，并且它们有几个兄弟方法执行其他任务。

使用静态方法的基本重写

class Foo {
    public function __construct ($params) {}
}

class FooUpdate {
    public static function update ($fooParam) {
        FooUpdateDatabase::main($fooParam);
        FooSendEmails::main($fooParam);
    }
}

class FooUpdateDatabase {
    public static function …

我试图了解 SRP 原理，但大多数软线程没有回答我遇到的这个特定查询，

用例

每当用户尝试在网站中注册/创建用户帐户时，我都会尝试向用户的电子邮件地址发送一封电子邮件来验证自己。

没有建议零售价

class UserRegistrationRequest {
    String name;
    String emailId;
}
class UserService {
    Email email;

    boolean registerUser(UserRegistrationRequest req) {
        //store req data in database
        sendVerificationEmail(req);
        return true;
    }

    //Assume UserService class also has other CRUD operation methods()    

    void sendVerificationEmail(UserRegistrationRequest req) {
        email.setToAddress(req.getEmailId());
        email.setContent("Hey User, this is your OTP + Random.newRandom(100000));
        email.send();
    }
}

上述类“UserService”违反了 SRP 规则，因为我们将“UserService”CRUD 操作和触发验证电子邮件代码合并到 1 个类中。

因此我这样做，

含建议零售价

class UserService {
    EmailService emailService;

    boolean registerUser(UserRegistrationRequest req) {
        //store req data in database
        sendVerificationEmail(req); …