Различие между принципом единой ответственности и разделением интересов

разделение интересов и принцип единой ответственности (SoC vs SRP )

из связанной статьи:

разделение проблем (SoC) – это процесс разбиения компьютерной программы на отдельные функции, которые пересекаются как можно меньше функциональности. Беспокойство-это любая часть интереса или фокуса в программе. Как правило, проблемы являются синонимами функций или поведения. http://en.wikipedia.org/wiki/Separation_of_concerns

принцип единой ответственности (SRP) – каждый объект должен иметь единую ответственность, и что все его услуги должны быть тесно связаны с этой ответственностью. На каком-то уровне сплоченность рассматривается как синоним СРП. http://en.wikipedia.org/wiki/Single_responsibility_principle

единая ответственность гласит, что объект несет ответственность за одну единицу работы.

разделение проблем гласит, что приложения должны быть разделены на модули, функциональные возможности которых перекрываются как можно меньше.

подобные конечные результаты...немного разные приложения.

на мой взгляд, принцип единой ответственности является одним из инструментов/идиом для достижения разделения проблем.

принцип единой ответственности и разделение интересов-это действительно одно и то же.

конечно, вы можете увязнуть в академической дискуссии, пытаясь дразнить какую-то разницу между ними, но почему? Во всех смыслах и целях они описывают одно и то же. Самая большая проблема заключается в том, что люди настолько увлекаются желанием точно знать, что такое" забота "и" ответственность", что они, возможно, упускают важную идею SRP и соц.

эта идея состоит в том, чтобы просто разделить вашу кодовую базу на слабо связанные изолированные части. Это позволяет нескольким разработчикам работать над различными частями, не влияя друг на друга, а также позволяет одному разработчику изменять одну изолированную часть, не нарушая другую.

Это применяется на уровне модуля, например MVC является архитектурным шаблоном, способствующим SRP и SoC. Кодовая база разделена на изолированные модели, представления и контроллеры. Таким образом, изменение вида можно сделать независимо от модели. Два не страшно переплетено.

на более низком уровне это должно быть применено и к классам. Вместо того чтобы помещать десятки методов в один класс, разделите код на несколько. По тем же причинам.

также даже на уровне метода, разделите большие методы на меньшие методы.

в принципе. SRP-это принцип, а не правило, поэтому вам не нужно (читать: не может/не должен) следовать ему религиозно крайность. Это не значит заходить слишком далеко и иметь только один семистрочный метод в каждом классе, например. Это просто означает общий принцип разделения кода на изолированные части. Дело в том, что это приведет к лучшей кодовой базе и более стабильному программному обеспечению.

разделение проблем (SoC). разделите приложение на отдельные функции с минимальным перекрытием функциональности, насколько это возможно. (Microsoft.)

"концерн" = "отличительной чертой" = "отдельного раздела"

"концерн" работает как на высоком, так и на низком уровнях

принцип единой ответственности гласит, что каждый модуль или класс должен иметь ответственность за одну часть функциональности, предоставляемой программным обеспечением, и эта ответственность должна быть полностью инкапсулирована классом. Все его услуги должны быть тесно увязаны с этой ответственностью. (Определение Википедии)

"ответственность" = "причина изменения" изменить? "одна часть функциональности, предоставляемой программным обеспечением"= Базовый Блок

вывод

• принцип единой ответственности работает на базовых единицах - > работает на низком уровне

• разделение проблем работает как на высоком, так и на низком уровнях

• SRP и SoC работают вместе для разделения проблем. Они
  точно так же на низком уровне уровень

разделение проблем-это процесс; принцип единой ответственности-это философия дизайна / архитектуры. Они не совсем несвязны, но служат разным целям.

подобное но: SoC связано с проблемами: чтобы разбить сложную проблему на несколько проблем, SRP должен иметь только одну ответственность.

SRP и SOC работают на разных уровнях абстракции. Цель в обоих случаях уменьшить сцепление и усилить сцепление. В то время как SRP работает больше на уровне объекта, SOC может также работать над реализацией функционального уровня. Функция может быть реализована одним объектом, но также и несколькими объектами. Поэтому сцепление и сцепление обоих принципов могут отличаться.

Я попытался провести сравнение между разделением проблем(SoC) и принципом единой ответственности (SRP).

различия

• SRP находится на уровне класса, но SoC находится в каждой компьютерной программе, абстракции ... или иногда архитектурный уровень.

• SRP - это качество (как не что), разделяющее ваш домен на сплоченные классы, у которых есть только одна ответственность (одна причина для изменения). В другую сторону, SoC-это принцип проектирования для разделения контекста на отдельные разделы, так что каждый раздел обращается к отдельной проблеме(что не как), Поскольку существует множество инструментов (например, классы, функции, модули, пакеты,...) для достижения этой цели разные уровни.

• концепция SRP основана на когезии (высокой когезии), тогда как SoC близка к Молекулярности, разделению и завоеванию (D&C), ... на каждом уровне абстракции.

• SoC - это a хороший принцип проектирования, чтобы справиться со сложностью, такой как абстракция, тогда как для достижения отдельных ответственных классов вы можете использовать принцип SoC в качестве отличного решения. Как, способ узнать, что класс имеет более чем одну ответственность, если вы можете извлечь другую ответственность(озабоченность) из этого класса.

сходство

• после применения каждого из этих принципов, ваш контекст становится более многоразовым, ремонтопригодным, надежным, читаемым,... .