C# 使用unity和C的类和接口#_C#_Class_Unity3d_Interface

C# 使用unity和C的类和接口#

c# class unity3d interface

C# 使用unity和C的类和接口#,c#,class,unity3d,interface,C#,Class,Unity3d,Interface,我需要一些帮助。我有一个类名“Employee”，我从中继承了两个基类，分别是“Manager”和“Clerk”，现在我需要另一个同时继承“Manager”和“Clerk”的类，但是在C#或Unity/C#中，多重继承是不可能的。但有人建议我使用“接口”。我对“接口”有点陌生。有人能帮我吗？发送示例代码。您可以使用聚合： public interface IEmployee { } public interface IClerk : IEmployee { void DoClerkT

我需要一些帮助。我有一个类名“Employee”，我从中继承了两个基类，分别是“Manager”和“Clerk”，现在我需要另一个同时继承“Manager”和“Clerk”的类，但是在C#或Unity/C#中，多重继承是不可能的。但有人建议我使用“接口”。我对“接口”有点陌生。有人能帮我吗？

发送示例代码。

您可以使用聚合：

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();
  }
}

您可以使用聚合：

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();
  }
}

考虑这一点：

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");
    }
}

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

相反，您可以不提供实现并将基类标记为接口：

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();
    }
}

在这里，编译器将知道什么方法属于什么。您失去了基类的继承实现，但获得了多重继承。

考虑一下：

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");
    }
}

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

相反，您可以不提供实现并将基类标记为接口：

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();
    }
}

在这里，编译器将知道什么方法属于什么。您可以从基类中释放继承的实现，但您可以获得多重继承。

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

这与继承有很大不同，但在许多情况下非常有用，但使用接口可能是一个更好的主意。

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

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

现在，当您将此脚本附加到游戏对象时，它会自动附加Manager和Clerk，并且您无法删除它们中的任何一个

您可以使用

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(); }

经理；
秘书；
无效唤醒（）{
//查找组件
manager=GetComponent（）；
clerk=GetComponent（）；
//初始化两者
manager.Init（this）；
秘书：初始（本）；
}
public void domagerstuff（）{manager.DoStuff（）；}
public void DoClerkStuff（）{clerk.DoStuff（）；}

这种方法的缺点是，一个游戏对象上有三名员工，其中两人不是真实的。在更换经理和职员时，你需要格外小心，不要把管理职员搞得一团糟

为了初始化附加到managingClerk的clerk和manager组件，您需要在manager和clerk中实现一个方法（Init）。