标签: solid-principles

我目前正在尝试学习使用IoC容器的好处并熟悉DI.我已经开始使用StructureMap,因为它看似相当简单但功能强大.

我想验证我对这些概念的理解是否正确.让我们假设一个应用程序中的以下基本类(为简洁起见,省略了详细信息):

public class OrderService : IOrderService
{
    private IOrderRepository _repository;
    private ITaxCalculator _taxCalculator;
    private IShippingCalculator _shippingCalculator;

    public OrderService(IOrderRepository repository, 
        ITaxCalculator taxCalculator, 
        IShippingCalculator shippingCalculator)
    {
        this._repository = repository;
        this._shippingCalculator = shippingCalculator;
        this._taxCalculator = taxCalculator;
    }

    public IOrder Find(int id) { return this._repository.Find(id); }
}

public class OrderRepository : IOrderRepository
{
    public IOrder Find(int id) { // ... }
}

public class StandardShippingCalculator : IShippingCalculator
{
    // ...
}

public class StandardTaxCalculator : ITaxCalculator
{
    private ITaxSpecification _specification;

    public StandardTaxCalculator(ITaxSpecification specification) …

我正在处理的一个应用程序处理工作项.根据工作项的状态,可以使用许多操作."完成""取消""重新分配"等...

为了提供动作的功能,我现在有一个看起来像这样的界面......

public interface IActionProvider{
    public void Complete(WorkItem workItem);
    public void Cancel (WorkItem workItem);
    public void Reassign(WorkItem workItem);
}

然后根据工作项的其他细节,我有接口的具体实现.仅举例......

public class NormalActionProvider :IActionProvider
{
    ...
}

和

public class UrgentActionProvider : IActionProvider
{
   ....
}

问题是,如果我想添加一个新动作,请说......"委托"我必须更新界面,当然这对所有实现都有影响.

这违反了开/关原则吗？你能推荐一个可以帮助我的设计模式或重构吗？

开放/封闭原则规定一个类应该开放以进行扩展,但是关闭以进行修改.

我认为修改部分严格指的是改变基类的源代码.但我与某人说过,这也涉及从基类中重写方法.

这个解释对吗？

我试图理解SOLID原则,特别是依赖性倒置原则.

在这是答案,它解释得非常好.

我想我已经理解我不能在课堂上创建任何类的实例.这样对吗？

但是如果我必须将一些内容保存到磁盘,我可以创建一个System.IO.File实例还是我必须注入它？

我不明白限制在哪里,如果我不能实例我自己的类,或者我不能实例.NET Framework类(或任何其他框架).

更新:
我认为这File是一个糟糕的例子,因为它被声明为静态.

顺便说一句,这个原则是否适用于静态类？

我想避免使用switch语句.我有30多种文档类型.还有可能我需要添加更多的文档类型.我宁愿传递IDocument并且具有在IDocument的实现中指定的类型.我忘了提到的其他东西是ProgressNoteViewModel,LabViewModel ...都继承自WorkspaceViewModel,所有具体实现构造函数都将类型IPatient作为参数.我也使用Castle作为我的IoC容器

我想将代码重构为类似的东西

viewModel = new TreeViewModel(repository.GetPatientDocumentListing(IDocumentType);
this.DocTreeViewModel = viewModel;
//How would I then be able to instantiate the right ViewModel
//based on IDocumentType and also pass a object into the
//constructor that is not know at compile time

我有以下代码:

switch (docType)
{
    case "ProgressNotes":
        viewModel = new TreeViewModel(repository.GetPatientProgressNotes());
        this.DocTreeViewModel = viewModel;
        ProgressNoteViewModel workspace = ProgressNoteViewModel.NewProgressNoteViewModel(_patient);
        break;
    case "Labs":
        viewModel = new TreeViewModel(repository.GetPatientLabs());
        this.DocTreeViewModel = viewModel;
        LabViewModel workspace = LabViewModel.NewLabViewModel(_patient);
        break;
}
this.Workspaces.Add(workspace);
this.SetActiveWorkspace(workspace);

我有YoutubeVideoService执行 CRUD（创建、读取、更新和删除）操作的类。在我看来，创建、读取、更新和删除是类更改的四个原因。这个类是否违反了单一职责原则？

如果违反，那么，我们应该有四个类，如CreateYoutubeVideoService，ReadYoutubeVideoService，UpdateYoutubeVideoService和DeleteYoutubeVideoService。有很多课程是不是有点矫枉过正？

我有为HR系统开发的系统.有会计员工和程序员员工.在加入公司的第一个月,员工没有任何角色.一名员工可以同时是会计师和程序员.我有一个由以下代码显示的设计.

现在,我需要通过实现新功能来增强系统:

终止所有会计师.(终止表示将员工的状态设置为IsActive = false).问题是我不能在没有检查的情况下将所有会计师直接设置为非活动状态.我需要检查一下他是否还有其他角色.

如何重新构造这些类以使终止函数更自然OO？

UPDATE

我正在寻找一个有@AlexDev答案的EF Database First解决方案模型和数据库架构的答案.

C#代码

List<Accountant> allAccountants =  Get All accountants from database

public class Employee
{
    public int EmpID { get; set; }
    public DateTime JoinedDate { get; set; }
    public int Salary { get; set; }
    public bool IsActive { get; set; }
}


public class Accountant : Employee
{
    public Employee EmployeeData { get; set; }
}

public class Programmer : Employee
{
    public Employee EmployeeData { get; set; }
} …

我有一个关于 Uncle Bob 的Clean Architecture 中的“用例输出端口”的问题 。

在图像中，鲍勃叔叔将端口描述为接口。我想知道是否有要这样或者如果调用的用例交互器还可以返回一个“简单”的价值。在任何一种情况下，应用程序和业务规则层都将定义接口适配器层必须使用的接口。所以我认为对于简单的调用，只返回一个值不会违反架构理念。

真的吗？

此外，我认为演示者实现的这个输出端口接口应该像观察者模式一样工作。演示者只是观察交互者的相关“事件”。在 .NET 事件是一等公民的情况下，我认为使用其中一个是相同的想法。

这些想法是否与 Clean Architecture 背后的想法兼容？

我有那个代码示例：

from time import sleep
import asyncio

class bird:

    def __init__(self, sleeptime=1):
        self.var = sleeptime

    def wait_meep(self):
        sleep(self.var)
        print("Meep")

    def do_sth(self):
        print("Dop Dop Do do ...")


class bird_async:

    def __init__(self, sleeptime=1):
        self.var = sleeptime

    async def wait_meep(self):
        await asyncio.sleep(self.var)
        print("Meep")

    def do_sth(self):
        print("Dop Dop Do do ...")

如您所见，两个客户端大多相同，并且应包含相同的名称（以便每个人都知道会发生什么）。现在我想干脆写bird_async(bird)。因为每个扩展 in 也bird应使用 in bird_async。这是可能的，但我的同事说，它不是 SOLID，因为我已经覆盖了wait_meep. 现在我正在寻找不同的灵魂并找到抽象类。我不知道的是，如果创建一个抽象类birdBase(ABC)也是 SOLID。我也会在那里覆盖，因为首先它是一个函数，然后是一个协程，或者我在这里错了？

什么是 SOLID 和 DRY 解决方案可以将这两个类组合在一起，而无需重命名方法？

我在 Laravel-Eloquent 的方法中找到了updateOrCreate(). 为什么在框架中我们可以找到破坏干净代码和 SOLID 规则的方法？