Question

我需要一些帮助。我有一个班级名称＆＃34;员工＆＃34;，我已经继承了两个基类，并说出了＃34;经理＆＃34;和＆＃34;职员＆＃34;，现在我需要另一个继承＆＃34;经理＆＃34;和＆＃34; Clerk＆＃34;，但在C＃或Unity / C＃中无法进行多重继承。但有人建议我使用＆＃34;接口＆＃34;。我是＆＃34;接口＆＃34;的新手。那么请有人帮帮我吗？请发送示例代码。

Answer 1

考虑一下：

public abstract class ManagerBase
{
    public void Execute()
    {
        Manage();
    }

    public virtual void Manage() {}
}

public abstract class ClerkBase
{
    public virtual void Expedite(){}

    public void Execute()
    {
        Expedite();
    }
}

public class ManagingClerk : ClerkBase, ManagerBase
{
    public override void Expedite()
    {
        Console.WriteLine("Expedited");
    }

    public override Manage()
    {
        Console.WriteLine("Managed");
    }
}

在这里尝试继承几个基类，问题是编译器无法知道派生继承的“执行”版本。这被称为“死亡钻石”

您可以做的不是提供实现并将基类标记为接口：

public interface IManager
{
    void Execute();

    void Manage();
}

public interface IClerk
{
    void Expedite();

    void Execute();
}

public class ManagingClerk : IClerk, IManager
{
    public void Expedite()
    {
        Console.WriteLine("Expedited");
    }

    void IClerk.Execute()
    {
        Expedite();
    }

    public void Manage()
    {
        Console.WriteLine("Managed");
    }
    void IManager.Execute()
    {
        Manage();
    }
}

这里编译器会知道哪些方法属于什么。您从基类中删除了继承的实现，但是您获得了多重继承。

Answer 2

您可以使用聚合：

public interface IEmployee
{
}

public interface IClerk : IEmployee
{
  void DoClerkThing();
}

public interface IManager : IEmployee
{
   void DoManagerThing();
}

public class Clerk : IClerk
{
  public void DoClerkThing()
  {
  }
}

public class Manager : IManager
{
   public void DoManagerThing()
   {
   }
}

public class ManagerAndClerk : IManager, IClerk
{
  private readonly Manager manager;
  private readonly Clerk clerk;

  public ManagerAndClerk(Manager manager, Clerk clerk)
  {
    this.manager = manager;
    this.clerk = clerk;
  }

  public void DoClerkThing()
  {
    this.clerk.DoClerkThing();
  }

  public void DoManagerThing()
  {
    this.manager.DoManagerThing();
  }
}

Answer 3

在Unity中，您可以将多个组件附加到单个游戏对象，这对于大多数组件类型可以是相同类型。这意味着您可以将两个脚本附加到单个游戏对象。

这与继承完全不同，但在很多情况下它非常有用，但使用界面可能更好。

您有Employee类，其派生类Clerk和Manager作为脚本组件。然后你将ManagingClerk作为另一个脚本：

[RequireComponent(typeof(Manager), typeof(Clerk))]
public class ManagingClerk : Employee {
}

现在，当您将此脚本附加到游戏对象时，它会自动附加经理和文员，您无法删除其中任何一个。

您可以使用GetComponent访问特定方法和成员：

Manager manager;
Clerk clerk;
void Awake(){
    //find components
    manager = GetComponent<Manager>();
    clerk = GetComponent<Clerk>();
    //initialize both
    manager.Init(this);
    clerk.Init(this);
}
public void DoManagerStuff() { manager.DoStuff(); }
public void DoClerkStuff() { clerk.DoStuff(); }

这种方法的缺点是你有三个员工连接到一个游戏对象，其中两个不是真实的。在更换经理和职员时，你需要格外小心，不要搞乱管理员。

为了初始化附属于managingClerk的职员和经理组件，你需要在经理和职员中实现一个方法（Init）。

具有统一性和C＃

3 个答案: