如何告诉一个类它应该创建哪些对象？类型与对象混淆:(

Question

我有一个类 (SetOfRules) 想要（以某种方式）处理规则。 任务：创建这个类的一个新实例（这很简单），然后将规则（定义在类Rules和派生类中）添加到实例中。

问题 1：我不想实例化所有规则，然后将它们作为对象传递给 SetOfRules 的 Add-method，但我想将类名称（类型）列表传递给 Add-method。我怎么做？ 那么在 SetOfRules 内部实例化这样一个对象的语法是怎样的呢？

问题2：类规则和派生类不包含任何属性。它们只是转换方法的集合。 我是否必须将它们实例化为 SetOfRules 类中的一个对象，或者我可以将它们称为静态类的方法（我不能使用静态类，因为我在 Rule 类上使用继承来确保每个规则类都实现了需要）

这是我现在遇到的一些（伪）代码：

public class Rule
{
    virtual void transform( myObject ob)
    {
        ...
    }
}

public class SpecificRule1 : Rule
{
    ...
}

public class SpecificRule2 : Rule
{
    ...
}



public class SetOfRules
{
    public AddRules( ???? ListOfRuleTypes)
    {
    }
}

我想在其他地方做类似的事情：

SetOfRules easyRules = new SetOfRules();
easyRules.Add( new ??RuleTypes??[] { "SpecificRule2", "SpecificRule13", "SpecificRule22" });

感谢您的酷提示！

Answer 1

示例 - 计算订单商品折扣的规则：

public class OrderItem
{
    public int ItemId { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }

    public decimal Total => Quantity * Price;
}

折扣的合约（又名接口）可以这样定义：

public interface IDiscountRule
{
    decimal CalculateDiscount(OrderItem item);
}

现在让我们实现一些折扣规则

• 基本折扣 (2%)
• 白银折扣 (5%)
• 黄金折扣 (10%)

类定义：

/// <summary>
/// Abstract base class for the discount rules
/// </summary>
public abstract class DiscountRule : IDiscountRule
{
    private readonly int _percent;

    protected DiscountRule(int percent)
    {
        _percent = percent;
    }

    /// <inheritdoc />
    public decimal CalculateDiscount(OrderItem item)
    {
        if (item == null)
        {
            throw new ArgumentNullException(nameof(item));
        }

        decimal discount = item.Total * (decimal) (_percent/100.0);

        return discount;
    }
}


/// <summary>
/// 2% discount
/// </summary>
public class BasicDiscountRule : DiscountRule
{
    public BasicDiscountRule() : base(2)
    {

    }
}

/// <summary>
/// 5% discount
/// </summary>
public class SilverDiscountRule : DiscountRule
{
    public SilverDiscountRule() : base(5)
    {

    }
}

/// <summary>
/// 10% discount
/// </summary>
public class GoldDiscountRule : DiscountRule
{
    public GoldDiscountRule() : base(10)
    {

    }
}

使用规则计算订单商品的折扣：

var item = new OrderItem
{
    ItemId = 1,
    Price = 50,
    Quantity = 2
};

var rule = new SilverDiscountRule();
decimal discount = rule.CalculateDiscount(item);

现在让我们创建一个复合规则，以便将多个规则（折扣）应用于一个订单项：

/// <summary>
/// To apply multiple discount rules to an order item
/// </summary>
public class CompositeDiscountRule : IDiscountRule
{
    private readonly List<Type> _discountTypes;

    public CompositeDiscountRule()
    {
        _discountTypes = new List<Type>();
    }

    public CompositeDiscountRule(List<Type> discountTypes)
    {
        if (discountTypes == null)
        {
            throw new ArgumentNullException(nameof(discountTypes));
        }

        _discountTypes = discountTypes;
    }

    public void Register<T>() where T : IDiscountRule, new()
    {
        _discountTypes.Add(typeof(T));
    }

    /// <inheritdoc />
    public decimal CalculateDiscount(OrderItem item)
    {
        decimal totalDiscount = 0;

        foreach (var discountType in _discountTypes)
        {
            IDiscountRule rule = Activator.CreateInstance(discountType) as IDiscountRule;

            if (rule != null)
            {
                totalDiscount += rule.CalculateDiscount(item);
            }
        }

        return totalDiscount;
    }
}

您可以将复合规则与类型列表一起使用：

var item = new OrderItem
{
    ItemId = 1,
    Price = 50,
    Quantity = 2
};

// composite rule with types
var compositeRule = new CompositeDiscountRule(new List<Type>
{
    typeof(GoldDiscountRule),
    typeof(BasicDiscountRule)
});

decimal discount = compositeRule.CalculateDiscount(item); // discount = 12.0

或者，作为替代方案，使用泛型：

var item = new OrderItem
{
    ItemId = 1,
    Price = 50,
    Quantity = 2
};

// composite rule using generics
compositeRule = new CompositeDiscountRule();
compositeRule.Register<BasicDiscountRule>();
compositeRule.Register<SilverDiscountRule>();

decimal discount = compositeRule.CalculateDiscount(item); // discount = 7.0

Answer 2

看起来你想要一个带有契约的单例类：

public interface IRule
{
    void Transform(object o);
}
public abstract class SingletonBase<T> where T : SingletonBase<T>, new()
{
    public static T Instance { get; } = new T();
}
public class SpecificRule1 : SingletonBase<SpecificRule1>, IRule
{
    public void Transform(object o) => throw new NotImplementedException();
}
public class SpecificRule2 : SingletonBase<SpecificRule2>, IRule
{
    public void Transform(object o) => throw new NotImplementedException();
}
public class RuleSet : List<IRule>
{
    public void Add<TRule>() where TRule : SingletonBase<TRule>, IRule, new()
    {
        this.Add(SingletonBase<TRule>.Instance);
    }
}

您可以通过各种方式添加规则：

var rules = new RuleSet
{
    SpecificRule1.Instance,
    SpecificRule2.Instance,
};

rules = new RuleSet();
rules.Add(SpecificRule1.Instance);
rules.Add<SpecificRule2>();

Answer 3

请阅读pattern Decorator。它是一种结构化设计模式，可让您通过将新行为放置在包含这些行为的包装对象中来将新行为附加到对象。

我认为它会帮助你解决第一个问题

有用的链接：https://refactoring.guru/design-patterns/decorator