关于.net：从C＃中的两个类继承

inherit from two classes in C#

本问题已经有最佳答案，请猛点这里访问。

Possible Duplicate:
Multiple Inheritance in C#

号

我有两个类，A类和B类。这两个类不能互相继承。我正在创建名为ClassC的新类。现在，我想通过继承来实现类A和类B中的方法。我知道在C中多重继承是不可能的，但是有没有其他方法可以做到这一点？

谢谢

相关讨论

在C中不可能进行多步骤继承，但是可以使用接口来模拟，请参见C的模拟多继承模式。

基本思想是为希望访问的类B上的成员定义一个接口(称为IB，然后从A继承C，通过内部存储B的实例来实现IB，例如：

1
2
3
4
5
6
7
8
9
10

class C : A, IB
{
private B _b = new B();

// IB members
public void SomeMethod()
{
_b.SomeMethod();
}
}

在这一页上还解释了其他一些交替模式。

继承的一个常见的替代方法是委托(也称为组合)：x"有一个"y而不是x"是一个"y。因此，如果a有处理foos的功能，b有处理bars的功能，而您希望两者都在c中，那么如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class A() {
private FooManager fooManager = new FooManager(); // (or inject, if you have IoC)

public void handleFoo(Foo foo) {
fooManager.handleFoo(foo);
}
}

public class B() {
private BarManager barManager = new BarManager(); // (or inject, if you have IoC)

public void handleBar(Bar bar) {
barManager.handleBar(bar);
}
}

public class C() {
private FooManager fooManager = new FooManager(); // (or inject, if you have IoC)
private BarManager barManager = new BarManager(); // (or inject, if you have IoC)

... etc
}

号

如果您想从字面上使用A和B的方法代码，您可以使C类包含每个方法的实例。如果您针对A和B的接口进行编码，那么您的客户不需要知道您给他们的是C，而不是A或B。

1
2
3
4
5
6
7
8
9
10
11

interface IA { void SomeMethodOnA(); }
interface IB { void SomeMethodOnB(); }
class A : IA { void SomeMethodOnA() { /* do something */ } }
class B : IB { void SomeMethodOnB() { /* do something */ } }
class C : IA, IB
{
private IA a = new A();
private IB b = new B();
void SomeMethodOnA() { a.SomeMethodOnA(); }
void SomeMethodOnB() { b.SomeMethodOnB(); }
}

。

使用成分：

1
2
3
4
5
6
7
8
9
10
11

class ClassC
{
public ClassA A { get; set; }
public ClassB B { get; set; }

public C (ClassA a, ClassB b)
{
this.A = a;
this.B = b;
}
}

然后你可以打电话给C.A.DoA()。还可以将属性更改为接口或抽象类，如public InterfaceA A或public AbstractClassA A。

制作两个接口IA和IB：

1
2
3
4
5
6
7
8
9

public interface IA
{
public void methodA(int value);
}

public interface IB
{
public void methodB(int value);
}

接下来，让A执行IA和B执行IB。

1
2
3
4
5
6
7
8
9
10
11

public class A : IA
{
public int fooA { get; set; }
public void methodA(int value) { fooA = value; }
}

public class B : IB
{
public int fooB { get; set; }
public void methodB(int value) { fooB = value; }
}

。

然后实现C类，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class C : IA, IB
{
private A _a;
private B _b;

public C(A _a, B _b)
{
this._a = _a;
this._b = _b;
}

public void methodA(int value) { _a.methodA(value); }
public void methodB(int value) { _b.methodB(value); }
}

。

总体来说，这是一个糟糕的设计，因为您可以让A和B实现具有相同名称和变量类型的方法，如foo(int bar)，并且您需要决定如何实现它，或者如果您只是在_a和_b上调用foo(bar)。如其他地方所建议的，您应该考虑一个.A和.B属性，而不是组合这两个类。

您可以为A和B定义一个基类，您可以在其中保存这些方法/属性/字段的公共方法/属性/字段。

执行C:Base后。

或者为了模拟多重继承，定义一个通用的interface并在C中实现它们。

希望这有帮助。