C#多重继承

//I have the Following Person Class which Hold Common Properties 
//and a Type of Person e.g : Student, Faculty, Administrative
public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Type { get; set; }
}

//This is my Student Class, which is Derived from Person
public class Student : Person
{
    public DateTime DateOfBirth { get; set; }
    public DateTime EnrollmentDate { get; set; }
    public string Remarks { get; set; }
    public bool Approved { get; set; }
    public DateTime ApprovedDate { get; set; }
    public int ApprovedUserId { get; set; }
}

//This is my Faculty Class, which is also Derived from Person
public class Faculty : Person
{
    public DateTime HiredDate { get; set; }
    public bool Approved { get; set; }
    public DateTime ApprovedDate { get; set; }
    public int ApprovedUserId { get; set; }
}

 public class Approve {
    public bool Approved { get; set; }
    public DateTime ApprovedDate { get; set; }
    public int ApprovedUserId { get; set; }
}

public class Student : Person, Approve
{
    public DateTime DateOfBirth { get; set; }
    public DateTime EnrollmentDate { get; set; }
    public string Remarks { get; set; }
}

一个可能的解决方案是修改层次结构：

public class PersonWithApprove : Person { // TODO: replace with non disgusting name
    public bool Approved { get; set; }
    // etc...
}
public class Student : PersonWithApprove {
}
public class Faculty : PersonWithApprove {
}

或者你可以创建一个接口：

public interface IApprove {
    bool Approved { get; set; }
    // etc
}
public class Student : Person, IApprove {
}

您也可以将类Approve保留为这样，并使类具有该类型的属性：

public class Student : Person {
    Approve _approve = new Approve();
    public Approve Approve {
        get { return _approve; }
    }
}

IMHO，在这里使用接口是一个很好的例子，类似于

  // Interfaces:
  // General person
  public interface IPerson {
    int Id { get; set; }
    string FirstName { get; set; }
    string LastName { get; set; }
    string Type { get; set; }
  }
  // Approvable person
  public interface IApprovable {
    bool Approved { get; set; }
    DateTime ApprovedDate { get; set; }
    int ApprovedUserId { get; set; }
  } 
  // Student is a IPerson + IApprovable
  public interface IStudent: IPerson, IApprovable {
    DateTime DateOfBirth { get; set; }
    DateTime EnrollmentDate { get; set; }
  }
  // So classes will be
  public class Approve: IApprovable {
    ... //TODO: Implement IApprovable interface here
  } 
  public class Faculty: IPerson, IApprovable {
    public DateTime HiredDate { get; set; }
    ... //TODO: Implement IPerson interface here
    ... //TODO: Implement IApprovable interface here
  }
  public class Student: IStudent {
    public string Remarks { get; set; }
    ... //TODO: Implement IStudent interface here
  }

简短回答

请考虑使用接口，它允许多重继承，并且可以使用interface关键字声明。

长答案

从C#中的多个基类继承是非法的。类可能只有一个基类，而它们可以实现任意数量的接口。这有几个原因，但主要是因为多重继承给类层次结构引入了更多的复杂性。

接口用于声明一组必须由类实现的通用功能（方法和属性）。

要修改现有代码以使用接口（而不是多重继承），可以执行以下操作：

public interface IApprove // Defines a set of functionality that a class must implement.
{
    // All these properties must be inherited as public when implemented.
    bool Approved { get; set; } // Property declaration.
    DateTime ApprovedDate { get; set; }
    int ApprovedUserId { get; set; }
}
public class Student : Person, IApprove
{
    public DateTime DateOfBirth { get; set; }
    public DateTime EnrollmentDate { get; set; }
    public string Remarks { get; set; }
    #region IApprove Implementation
    private bool _approved; // Private variable that is accessed through the 'Approved' property of the 'IApprove' interface.
    public bool Approved // Defines 'Approved' inherited from IApprove
    {
        get { return _approved; }
        set { _approved = value; }
    }
    private DateTime _approvedDate;
    public DateTime ApprovedDate // Defines 'ApprovedDate' inherited from IApprove.
    {
        get { return _approvedDate; }
        set { _approvedDate = value; }
    }
    private int _approvedUserId;
    public int IApprove.ApprovedUserId // Alternative syntax to define an interfaces property.
    {
        get { return _approvedUserId; }
        set { _approvedUserId = value; }
    }
    #endregion
}

这种方法抽象了IApprove接口的实现，并且与多重继承一样，允许用户对实现IApprove但其具体类型未知（或不相关）的对象进行操作。

有关C#中接口使用的更多信息，请参阅：

http://msdn.microsoft.com/en-us/library/87d83y5b.aspx

考虑以下示例，它使用两个接口：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

////////
////////
/// Multiple Inheritance With Interfaces
public interface Interface1
{
    void func1();
    void fun();
}
public interface Interface2
{
    void func2();
    void fun();
}
public class MyTestBaseClass : Interface1, Interface2
{
    void Interface1.func1()
    {
        Console.WriteLine("From MyInterface1 Function()");
        return;
    }

    void Interface2.func2()
    {
        Console.WriteLine("From MyInterface2 Function()");
        return;
    }
    void Interface1.fun()
    {
        Console.WriteLine("fun1()");
    }
    void Interface2.fun()
    {
        Console.WriteLine("fun2()");
    }

    public static void Main()
    {
        MyTestBaseClass myclass = new MyTestBaseClass();
        ((Interface1)myclass).func1();
        ((Interface2)myclass).func2();
    }
}

您可以使用复合模式

    public class Student:Person
    {
        public Approve App { get; set; }
        public DateTime DateOfBirth { get; set; }
        public DateTime EnrollmentDate { get; set; }
        public string Remarks { get; set; }
    }

使用Decorator设计模式的一些基本示例：

public class Class1
{
    public void Method1()
    {
        Console.write($"Class1: Method1, MyInt: {MyInt}");
    }
    public int MyInt { get; set; }
}
public class Class2
{
    public void Method2()
    {   
        Console.write($"Class2: Method2, MyInt: {MyInt}");      
    }
    public int MyInt { get; set; }
 }
public class MultipleClass
{
    private Class1 class1 = new Class1();
    private Class2 class2 = new Class2();
    public void Method1()
    {
        class1.Method1();
    }
    public void Method2()
    {
        class2.Method2();
    }
    private int _myInt;
    public int MyInt
    {
        get { return this._myInt; }
        set
        {
            this._myInt = value;
            class1.MyInt = value;
            class2.MyInt = value;
        }
    }
}

演示：

 MultipleClass multipleClass = new MultipleClass();
 multipleClass.Method1(); //OUTPUT: Class1: Method1, MyInt: 1 
 multipleClass.Method2(); //OUTPUT: Class2: Method2, MyInt: 1
 multipleClass.MyInt = 1;