10.3.3 Inheritance
A class inherits the members of its direct base class type. Inheritance means that a class implicitly contains all members of its direct base class type, except for the instance constructors, destructors and static constructors of the base class.

    [Serializable]
    public class MyException : Exception
    {
      public MyException() { }
      public MyException(string message) : base(message) { }
      public MyException(string message, Exception inner) : base(message, inner) { }
      protected MyException(SerializationInfo info, StreamingContext context) : base(info, context) { }
    }

_M_>>кто вам такое сказал?

L>А неушто наследуются?

using System;

public class A
{
    public A()
    {
        Console.WriteLine("A()");
    }
    public A(string str)
    {
        Console.WriteLine("A(string): {0}", str);
    }
}

public class B : A
{
    public B()
    {
        Console.WriteLine("B()");
    }
}

public class C : A
{
    public C() : base()
    {
        Console.WriteLine("C()");
    }
}

public class D : A
{
    public D(string str)
    {
        Console.WriteLine("D(string): {0}", str);
    }
}

public class E : A
{
    public E(string str) : base(str)
    {
        Console.WriteLine("E(string): {0}", str);
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("==implicit no params==");
        B b = new B();
        Console.WriteLine("==explicit no params==");
        C c = new C();
        Console.WriteLine("==implicit with params==");
        D d = new D("paramStr");
        Console.WriteLine("==explicit with params==");
        E e = new E("paramStr");
    }
}

==implicit no params==
A()
B()
==explicit no params==
A()
C()
==implicit with params==
A()
D(string): paramStr
==explicit with params==
A(string): paramStr
E(string): paramStr

10.11.1 Constructor initializers
.......
If an instance constructor has no constructor initializer, a constructor initializer of the form base() is implicitly provided. Thus, an instance constructor declaration of the form

C(...) {...}

is exactly equivalent to

C(...): base() {...}

_M_>ну так просвяти неграмотных

class A {
  public A() {}
  public A(string text) {}
  public A(int number) {}

  public void Method() {}
}

class B : A {
}

static class Program
{
  static void Main() {
    var b = new B(); // Это вызов не унаследованного, а созданного в B компилятором конструктора класса B
    b.Method(); // Это вызов унаследованного метода из класса A. 
                // Сигнатура этого метода, его наличие вообще, тип возвращаемого параметра и т.п. могут быть
                // изменены в классе A без переделки класса B, так как метод "принадлежит" A, а B его никак не использует.
                // Для сравнения: скрытие конструктора по-умолчанию у А потребует передки класса B.

    // Так как конструкторы не наследуются, то следующие вызовы не корректны
    var b2 = new B("test");
    var b3 = new B(4);
  }
}

    var b2 = new B("test");
    var b3 = new B(4);

public A(string text, int number) {}

var b4 = new B("test", 8);

public class B : A
{
    public B(string str)
    {
        base(str);
    }
}

public B(string str) : base(str)

_M_>public class B : A
_M_>{
_M_>    public B(string str)
_M_>    {
_M_>        base(str);
_M_>    }
_M_>}

_M_>

_M_>>public B(string str) : base(str)
_M_>>

public class A
{
    public A()
    {
    }
    
    public A(string str)
    {
    }

    protected void Method(string str)
    {
    }
}

public class B : A
{
    public B() : base.Method(str)
    {
    }
}