c#中的多重继承

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

例如，我能够使用接口和三个类实现缺少的多重继承模式:

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

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

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

public class FirstAndSecond: IFirst, ISecond
{
    First first = new First();
    Second second = new Second();
    public void FirstMethod() { first.FirstMethod(); }
    public void SecondMethod() { second.SecondMethod(); }
}

每当我向其中一个接口添加方法时，我也需要更改类FirstAndSecond。

是否有一种方法可以像在c++中那样将多个现有类注入到一个新类中?

也许有一种使用某种代码生成的解决方案?

或者它看起来像这样(虚构的c#语法):

public class FirstAndSecond: IFirst from First, ISecond from Second
{ }

这样，当我修改其中一个接口时，就不需要更新类FirstAndSecond。

EDIT

也许考虑一个实际的例子会更好:

您有一个现有的类(例如，基于ITextTcpClient的基于文本的TCP客户端)，您已经在项目中的不同位置使用它。现在，您觉得有必要创建一个类的组件，以便windows窗体开发人员可以轻松访问。

据我所知，你目前有两种方法来做到这一点:

编写一个从组件继承的新类，并使用类本身的实例实现TextTcpClient类的接口，如FirstAndSecond所示。编写一个继承TextTcpClient的新类，并以某种方式实现IComponent(实际上还没有尝试过这个)。

在这两种情况下，您都需要为每个方法而不是每个类做工作。因为你知道我们将需要TextTcpClient和Component的所有方法，所以将这两个方法合并到一个类中是最简单的解决方案。

为了避免冲突，这可以通过代码生成来完成，结果可以在之后修改，但手动输入这是一个纯粹的痛苦。

当前回答

考虑只使用组合而不是尝试模拟多重继承。你可以使用接口来定义组成组合的类，例如: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();
    }
}

2008-10-07 13:13:31

其他回答

您可以有一个实现IFirst和ISecond的抽象基类，然后从该基类继承。

2008-10-07 13:09:28

我创建了一个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();

2011-05-14 14:48:48

一旦你完成了这些，你可以使用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();
    }
}

2008-10-07 13:13:31

这与Lawrence Wenham的回答相似，但取决于您的用例，这可能是一种改进，也可能不是——您不需要setter。

public interface IPerson {
  int GetAge();
  string GetName();
}

public interface IGetPerson {
  IPerson GetPerson();
}

public static class IGetPersonAdditions {
  public static int GetAgeViaPerson(this IGetPerson getPerson) { // I prefer to have the "ViaPerson" in the name in case the object has another Age property.
    IPerson person = getPerson.GetPersion();
    return person.GetAge();
  }
  public static string GetNameViaPerson(this IGetPerson getPerson) {
    return getPerson.GetPerson().GetName();
  }
}

public class Person: IPerson, IGetPerson {
  private int Age {get;set;}
  private string Name {get;set;}
  public IPerson GetPerson() {
    return this;
  }
  public int GetAge() {  return Age; }
  public string GetName() { return Name; }
}

现在，任何知道如何获取一个人的对象都可以实现IGetPerson，并且它将自动拥有GetAgeViaPerson()和GetNameViaPerson()方法。从这一点开始，基本上所有的Person代码都进入IGetPerson，而不是IPerson，除了新的ivars，它必须同时进入IGetPerson和IPerson。在使用这样的代码时，你不需要关心你的IGetPerson对象本身是不是一个IPerson。

2017-02-20 10:20:59

如果你可以接受IFirst和ISecond的方法只能与IFirst和ISecond的契约交互的限制(就像你的例子一样)……你可以用扩展方法做你想做的事情。在实践中，这种情况很少发生。

public interface IFirst {}
public interface ISecond {}

public class FirstAndSecond : IFirst, ISecond
{
}

public static MultipleInheritenceExtensions
{
  public static void First(this IFirst theFirst)
  {
    Console.WriteLine("First");
  }

  public static void Second(this ISecond theSecond)
  {
    Console.WriteLine("Second");
  }
}

///

public void Test()
{
  FirstAndSecond fas = new FirstAndSecond();
  fas.First();
  fas.Second();
}

因此，基本思想是在接口中定义所需的实现……这个需要的东西应该支持扩展方法中的灵活实现。当你需要“向接口添加方法”时，你可以添加一个扩展方法。

2008-10-07 13:23:19

c#中的多重继承

推荐文章

最新文章

标签