标签: solid-principles

"子类型必须可替代其基类型"

假设我已经有了Bird类,并且:

class Parrot extends Bird {
   public function Talk() {
     echo 'Talk';
   }
}

鸟不能说话,所以我无法用鸟取代鹦鹉.

这只是一个基本的例子,但通常扩展类可以比基类做得更多.我错过了什么？

我刚刚回答了一个与SRP有关的问题让我想到:SRP如何站在实用工具类上？

根据定义,实用程序类往往会做很多事情.我可以看到单个接入点上的gatering相关实用程序是如何有用的.按照SRP标准,您无法在一个类中实现实用程序.这是否意味着实用程序类是禁止的,或者SRP是否允许它,如果它只是多个类的外观,每个类都遵循SRP？

我已经看过战略模式和开放封闭原则对我来说都是一样的.如果它们相同,为什么我们有不同的名称模式\原则.

请分享您对此的想法.

嗨我的任务是重构一部分代码,以便它与开放/封闭原则相对应.我设法在两种方法中应用策略模式但在一种方法中我不知道应该如何进行.

public ProductPriceCalculator(Product product)
{
    this.product = product;
    buyerStrategy = new BuyerStrategy();
    discountStrategy = new DiscountStrategy();
}

public Price CalculatePrice()
{
    price = new Price();

    decimal productPrice = product.BasePrice + 
                           (product.BasePrice * product.Addition);
    decimal TVA = CalculateTVA();
    price.ProductPrice = productPrice*TVA;
    decimal discount = CalculateDiscount(price.ProductPrice);
    price.Discount = price.ProductPrice * discount;
    price.ProductPriceWithDiscount = price.ProductPrice - price.Discount;
    price.TransportPrice = product.Transport.GetTransportPrice();
    price.TotalPrice = price.ProductPriceWithDiscount + price.TransportPrice;

    return price;
} 

在这种情况下,这个方法通过使用类中的方法来初始化对象.现在这个方法没有关闭进行修改,因为如果在某些时候我必须向Price添加另一个属性,我将不得不回到这里初始化它.

我该如何正确构建此代码？

它说Derived类不应抛出Base类不知道的任何异常,我试图找到它的工作原理,在基类中我抛出System.Exception并在Derived中抛出ArgNullException().有人可以解释这是好的

 class b
        {
           virtual public void foo()
           {
               try
               {
                   if (true)
                       throw  new System.Exception();
               }
               catch (Exception ex)
               {
                   Console.WriteLine("in base");

               }
           }


        }
        class a : b
        {   
            override public void foo() 
            {
                try
                {
                    if (true)
                        throw new ArgumentNullException();
                }
                catch (Exception ex)
                {
                    Console.WriteLine("in dervied");
                }
            }           

        }

我目前正在学习依赖注入,以便使用MVC创建更易于维护的代码.我已经向我的控制器注入模型和计算器服务,而不是具有新的依赖性.

我在构造函数中有一些Convert.ToDecimal调用,并且不知道是否需要担心使用依赖注入来移除静态方法调用,这是一种DI设计气味.删除太远了吗？

private readonly ICalculationService _calculation;
private readonly ICalculatorModelService _calculatormodel;

public CalculatorController(ICalculationService calculation,
    ICalculatorModelService calculatormodel) {
    _calculation = calculation;
    _calculatormodel = calculatormodel;
}

public ActionResult Index() {
    var model = _calculatormodel;
    return View(model);
}

public PartialViewResult Calculate(string submit, string txtValue, 
    string value1) {
    var model = _calculatormodel;
    if (submit == "+")
    {
        if (Session["value1"] == null)
            Session.Add("value1",Convert.ToDecimal(txtValue));
        else
            Session["value1"] = value1;
    }
    else if (submit == "=")
    {
        if (Session["value1"] == null)
        Session.Add("value1", 0);

        model.Result = _calculation.Calculate(Convert
            .ToDecimal(Session["value1"]), Convert.ToDecimal(txtValue));
    } …

我为不同的输入创建了一个单元测试,以确保输出正确.

[TestMethod]
    public void CountInversionTest()
    {
        #region Arrange
        int[] sourceArray = {4, 3, 2, 1};
        int correctInversionCount = 6;
        int[] sourceArray2 = { 1, 3, 5, 2, 4, 6};
        int correctInversionCount2 = 3;
        int[] sourceArray3 = { 5, 6, 2, 3, 1, 4, 7 };
        int correctInversionCount3 = 10;
        #endregion

        #region Act
        Sorter sorter = new Sorter();
        int inversionCount = sorter.CountInversion(sourceArray);
        int inversionCount2 = sorter.CountInversion(sourceArray2);
        int inversionCount3 = sorter.CountInversion(sourceArray3);
        #endregion

        #region Assert
        Assert.AreEqual(correctInversionCount, inversionCount);
        Assert.AreEqual(correctInversionCount2, inversionCount2);
        Assert.AreEqual(correctInversionCount3, inversionCount3);
        #endregion
    } …

我有以下代码

public class A 
{
      public double foo(double y) 
      {
             return real_value;
      }
}

其中foo方法的输入-1 < y < 1和函数的结果是大于零的实数。

然后我有class B继承class A并覆盖方法的继承foo。

public class B extends A 
{
      public override double foo(double y)
      {
         return real_value;
      }
}

其中foo方法的输入0 < y < 1和函数的结果是任何实数。

这里是否违反了 Liskov 替换原则？

提前致谢。

在 C#8 中，微软为接口方法引入了默认实现。这仍然是一个相当新的功能，似乎有很多关注的博主在写这个。

我想知道的是，默认实现是否有可能成为依赖倒置和 DI 的有用工具，或者它是否会促进不良的编程风格？它是否违反了任何众所周知的原则，如 SOLID？

我对这个建筑难题一无所知，我很想听到一些批评或建议。

情况：

一个实体和关系都已经共享（i节点）和独特的方法（IEntity或IRelation）

类需要知道使用接口 IEntity 或 IRelation 的共享方法和唯一方法。

题：

在尝试使用 SOLID & DRY 原则进行编程时，以下架构是好还是坏？

附加信息：这个问题的主要原因是因为在第一个图中（当前实现） Entity 和 Relation 都实现了 INode 接口两次。

情况一：

情况二：