由于多重继承是不好的(它使源代码更加复杂)，c#没有直接提供这样的模式。但有时候拥有这种能力是有帮助的。

c#和。net CLR还没有实现MI，因为他们还没有总结出它将如何在c#、VB.net和其他语言之间互操作，而不是因为“这会使源代码更复杂”。

MI是一个有用的概念，未回答的问题是:“当你在不同的超类中有多个公共基类时，你该怎么办?”

Perl是我使用过的唯一一种MI可以很好地工作的语言。. net可能有一天会引入它，但现在还没有，CLR已经支持MI，但正如我所说的，目前还没有针对它的语言结构。

在此之前，你会被代理对象和多个接口所困扰:(

考虑只使用组合而不是尝试模拟多重继承。你可以使用接口来定义组成组合的类，例如:isteable暗示了方向盘类型的属性，IBrakable暗示了BrakePedal类型的属性，等等。

一旦你完成了这些，你可以使用c# 3.0中添加的扩展方法功能来进一步简化对这些隐含属性的方法调用，例如:

public interface ISteerable { SteeringWheel wheel { get; set; } }

public interface IBrakable { BrakePedal brake { get; set; } }

public class Vehicle : ISteerable, IBrakable
{
    public SteeringWheel wheel { get; set; }

    public BrakePedal brake { get; set; }

    public Vehicle() { wheel = new SteeringWheel(); brake = new BrakePedal(); }
}

public static class SteeringExtensions
{
    public static void SteerLeft(this ISteerable vehicle)
    {
        vehicle.wheel.SteerLeft();
    }
}

public static class BrakeExtensions
{
    public static void Stop(this IBrakable vehicle)
    {
        vehicle.brake.ApplyUntilStop();
    }
}


public class Main
{
    Vehicle myCar = new Vehicle();

    public void main()
    {
        myCar.SteerLeft();
        myCar.Stop();
    }
}

由于多重继承是不好的(它使源代码更加复杂)，c#没有直接提供这样的模式。但有时候拥有这种能力是有帮助的。

c#和。net CLR还没有实现MI，因为他们还没有总结出它将如何在c#、VB.net和其他语言之间互操作，而不是因为“这会使源代码更复杂”。

MI是一个有用的概念，未回答的问题是:“当你在不同的超类中有多个公共基类时，你该怎么办?”

Perl是我使用过的唯一一种MI可以很好地工作的语言。. net可能有一天会引入它，但现在还没有，CLR已经支持MI，但正如我所说的，目前还没有针对它的语言结构。

在此之前，你会被代理对象和多个接口所困扰:(

是的，使用接口是一个麻烦，因为每当我们在类中添加方法时，我们都必须在接口中添加签名。此外，如果我们已经有一个类有一堆方法，但没有接口怎么办?我们必须手动为所有想要继承的类创建Interface。最糟糕的是，如果子类要从多个接口继承，我们必须在子类中实现接口中的所有方法。

通过遵循Facade设计模式，我们可以使用访问器模拟从多个类继承。在类内部使用{get;set;}将类声明为需要继承的属性，所有公共属性和方法都来自该类，并在子类的构造函数中实例化父类。

例如:

 namespace OOP
 {
     class Program
     {
         static void Main(string[] args)
         {
             Child somechild = new Child();
             somechild.DoHomeWork();
             somechild.CheckingAround();
             Console.ReadLine();
         }
     }

     public class Father 
     {
         public Father() { }
         public void Work()
         {
             Console.WriteLine("working...");
         }
         public void Moonlight()
         {
             Console.WriteLine("moonlighting...");
         }
     }


     public class Mother 
     {
         public Mother() { }
         public void Cook()
         {
             Console.WriteLine("cooking...");
         }
         public void Clean()
         {
             Console.WriteLine("cleaning...");
         }
     }


     public class Child 
     {
         public Father MyFather { get; set; }
         public Mother MyMother { get; set; }

         public Child()
         {
             MyFather = new Father();
             MyMother = new Mother();
         }

         public void GoToSchool()
         {
             Console.WriteLine("go to school...");
         }
         public void DoHomeWork()
         {
             Console.WriteLine("doing homework...");
         }
         public void CheckingAround()
         {
             MyFather.Work();
             MyMother.Cook();
         }
     }


 }

有了这个结构，类Child可以访问父类和母类的所有方法和属性，模拟多重继承，继承父类的实例。不完全一样，但很实用。

我创建了一个c#后编译器来实现这类事情:

using NRoles;

public interface IFirst { void FirstMethod(); }
public interface ISecond { void SecondMethod(); }

public class RFirst : IFirst, Role {
  public void FirstMethod() { Console.WriteLine("First"); }
}

public class RSecond : ISecond, Role {
  public void SecondMethod() { Console.WriteLine("Second"); }
}

public class FirstAndSecond : Does<RFirst>, Does<RSecond> { }

你可以将后编译器作为Visual Studio post-build-event运行:

C: \ some_path \ nroles-v0.1.0-bin \ nutate.exe " $(定位路径)"

在同一个程序集中，你可以这样使用它:

var fas = new FirstAndSecond();
fas.As<RFirst>().FirstMethod();
fas.As<RSecond>().SecondMethod();

在另一个程序集中，你像这样使用它:

var fas = new FirstAndSecond();
fas.FirstMethod();
fas.SecondMethod();

我知道我知道 尽管这是不允许的，但有时候你确实需要它，比如:

class a {}
class b : a {}
class c : b {}

就我而言，我想这样做 class b: Form(对，就是windows.forms) 类c: b {}

因为有一半的函数是相同的，你必须重写它们