多重继承在C#中是不可能的，但是可以使用接口模拟，参见Simulated Multiple Inheritance Pattern for C#。
基本思想是为类B上你想要访问的成员定义一个接口（称之为IB），然后让C继承A，并通过在内部存储B的示例来实现IB，例如：

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中同时使用这两种功能，那么您可以这样做：

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。

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

使用composition：

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：

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

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

接下来让A实现IA，B实现IB。

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类：

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定义一个基类，在这个基类中你可以保存它们的一个 common 方法/属性/字段。
实现C:Base后。
或者为了模拟多重继承，定义一个公共的interface（s）并在C中实现它们
希望这能帮上忙。

你的意思是你想让C类成为A & B的基类吗？

public abstract class C
{
    public abstract void Method1();

    public abstract void Method2();
}

public class A : C
{
    public override void Method1()
    {
        throw new NotImplementedException();
    }

    public override void Method2()
    {
        throw new NotImplementedException();
    }
}

public class B : C
{
    public override void Method1()
    {
        throw new NotImplementedException();
    }

    public override void Method2()
    {
        throw new NotImplementedException();
    }
}