C# Multiple Inheritance

It's a good case, IMHO, to use interfaces here, something like that:

  // 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
  }

Short Answer

Consider using interfaces instead, which allow for multiple inheritance and can be declared using the interface keyword.

Long Answer

Inheritance from multiple base classes in C# is illegal. Classes may only have 1 base class while they can implement any number of interfaces. There are several reasons for this but it mostly comes down to that multiple inheritance introduces much more complexity into a class hierarchy.

Interfaces are used to declare a group of common functionality (methods and properties) that must be implemented by class.

To modify your existing code to use interfaces (instead of multiple inheritance), you can do the following:

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
}

This approach abstracts the implementation of an IApprove interface and, like multiple inheritance, allows the user to operate on objects that implement IApprove yet their concrete type is unknown (or irrelevant).

For more information on the usage of interfaces in C# refer to:

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

Consider the following example , it uses two interfaces :

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

}

You can use Composite pattern

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

Some basic example using the Decorator design pattern:

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

Demo:

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