C# 基于接口的设计问题

我的问题是相关的课堂设计。这里很难解释一切，所以我举了一个与我的问题类似的例子

要求：客户可以执行单个操作，也可以组合多个操作

根据上述要求，课程结构如下：

interface ICustAction
{
    void Execute();
}
class CustAction:ICustAction
{
    // this class contains a single action to be performed
    public void Execute()
    {
       //should execute customer action
    }
}

class CustActionCollction:ICustAction
{
   // list of actions to be performed
    private List<CustAction> _custActions;



    public void Execute()
    {
        //should execute all the customer action in the list
    }
}

class ExecutionEngine
{
    public void Execute(ICustAction action)
    {
        //executes customer action/ customer action collection based on reference
        action.Execute();
    }
}

接口ICustAction
{
void Execute（）；
}
集体诉讼：ICustAction
{
//此类包含要执行的单个操作
public void Execute（）
{
//应执行客户行动
}
}
类custactioncollection:iccustaction
{
//要执行的操作列表
私人名单(行动);；
public void Execute（）
{
//应执行列表中的所有客户操作
}
}
类执行引擎
{
公共作废执行（ICustAction操作）
{
//基于引用执行客户操作/客户操作集合
action.Execute（）；
}
}

新规定： 客户应该能够在CustActionCollection中添加CustActionCollection

例如： 客户行动收集： 客户行动1： 客户行动2： 客户操作集合1：（此操作集合可能有多个客户操作） 客户行动3：

基于这些需求，更新后的CustActionCollection类如下所示

 class CustActionCollction:ICustAction
{

   // list of actions to be performed
    private List<ICustAction> _custActions;



    public void Execute()
    {
        //should execute all the customer action in the list
    }
}

类custactioncollection:iccustaction
{
//要执行的操作列表
私人名单(行动);；
public void Execute（）
{
//应执行列表中的所有客户操作
}
}

现在这是我需要专家意见的新要求

我需要检查特定操作是否在客户操作集合中定义了多次

客户行动收集： 客户行动1： 客户行动2： 客户操作集合1：（此操作集合可能有多个客户操作） 客户行动3：

因此，检查应该是递归的，包括所有子集合

问题：

我应该在接口中添加此检查方法，还是应该专门用于customer action collection类

A） 如果该方法是在接口中定义的，那么该方法的签名是什么，然后两个类的实现是什么

B） 如果该方法不在接口中，那么该方法的实现是什么

---

很抱歉，如果我不能正确解释的话。

这完全取决于这个结构还需要什么样的更改（如果有）以及如何比较操作。 假设您已经可以将任何iCustomAction与任何其他iCustomAction进行比较： 我不建议将复制检查器方法放入接口中，因为如果您这样做，它在所有实现中的作用都完全相同。稍后，如果您想在复制检查的内部工作中做一些微小的更改，则需要编写大量代码（我们最有可能在oop中避免这些变化，不仅因为它更舒适，而且因为更舒适的东西也会有更少的错误）

如果我是你，我会在ICustAction中放入一些helper属性，该属性提供复制检查器方法相互比较所需的所有信息（如果你愿意，则为唯一标识符）。此时，你可以在custactioncollection中编写一次检查器

---

尊敬的Peter，我可以想出几种方法：

在集合中定义检查方法。在此方法中，迭代集合的各个元素，生成

CustAction

列表。当元素为

CustActionCollection

时，需要执行运行时类型检查以迭代包含的操作

在

ICustAction

CustAction

中创建方法

containsAction

通过将其与

this

---

如果我理解您的问题，似乎只有在

CustActionCollection

的情况下才需要检查重复项。因此，我认为您最好的实施方式是：

依靠Equals实现来检查

CustAction

相等性（不需要，但在我看来最有意义）

在

CustCollection.evaluate（）

方法中，生成所有

CustActions

的主列表，并检查是否存在重复项。它的外观如下所示（这在类

CustActionCollection

中）：

public void Execute（）
{
//应执行列表中的所有客户操作
if（性别歧视（））
{
//处理错误
}
}
二等兵
{
列表操作=ProcessCollection（此）；
for（int x=0；x

我会这样做： （我不知道您是只想检查重复项还是不执行重复项，所以两者都在这里）

两个接口

interface ICustAction
{
    void Execute();
}

interface ICustActionCollection : ICustAction
{
    List<ICustAction> Actions { get; }

    List<ICustAction> GetAllActions();

    void ExecuteDistinct();

    bool HasDuplicates();
}

然后你运行这个：

static void Main(string[] args)
{
    CustAction a = new CustAction(1);
    CustAction b = new CustAction(2);
    CustAction c = new CustAction(3);
    CustActionCollection coll = new CustActionCollection();
    CustActionCollection coll2 = new CustActionCollection();

    coll.Actions.Add(a);
    coll.Actions.Add(b);
    coll.Actions.Add(coll2);
    coll2.Actions.Add(a);
    coll2.Actions.Add(c);

    Console.WriteLine("Without distinct");
    coll.Execute();

    Console.WriteLine("With distinct");
    Console.WriteLine("Has duplicates: {0}", coll.HasDuplicates());
    coll.ExecuteDistinct();

    coll2.Actions.Remove(a);
    Console.WriteLine("Duplicate removed, simple Execute");
    Console.WriteLine("Has duplicates: {0}", coll.HasDuplicates());
    coll.Execute();
}

输出结果如下：

Without distinct
Execute: 1
Execute: 2
Execute: 1
Execute: 3
With distinct
Has duplicates: True
Execute: 3
Execute: 1
Execute: 2
Duplicate removed, simple Execute
Has duplicates: False
Execute: 1
Execute: 2
Execute: 3

编辑：我将ICustActionCollection界面更改为

ICustAction集合：ICustAction

因此，如果一个类实现了ICustActionCollection，您可以确定它也将实现ICustAction

class CustAction : ICustAction
{
    public int ID { get; private set; }

    public CustAction(int id)
    {
        ID = id;
    }

    public void Execute()
    {
        Console.WriteLine("Execute: {0}", ID);
    }
}

static void Main(string[] args)
{
    CustAction a = new CustAction(1);
    CustAction b = new CustAction(2);
    CustAction c = new CustAction(3);
    CustActionCollection coll = new CustActionCollection();
    CustActionCollection coll2 = new CustActionCollection();

    coll.Actions.Add(a);
    coll.Actions.Add(b);
    coll.Actions.Add(coll2);
    coll2.Actions.Add(a);
    coll2.Actions.Add(c);

    Console.WriteLine("Without distinct");
    coll.Execute();

    Console.WriteLine("With distinct");
    Console.WriteLine("Has duplicates: {0}", coll.HasDuplicates());
    coll.ExecuteDistinct();

    coll2.Actions.Remove(a);
    Console.WriteLine("Duplicate removed, simple Execute");
    Console.WriteLine("Has duplicates: {0}", coll.HasDuplicates());
    coll.Execute();
}

Without distinct
Execute: 1
Execute: 2
Execute: 1
Execute: 3
With distinct
Has duplicates: True
Execute: 3
Execute: 1
Execute: 2
Duplicate removed, simple Execute
Has duplicates: False
Execute: 1
Execute: 2
Execute: 3