来自框架设计指南和FxCop规则。：

1.自定义异常的名称应以异常结尾

    class MyException : Exception

2.异常应为公共

    public class MyException : Exception

3.CA1032：异常应实现标准构造函数。

公共无参数构造函数。具有一个字符串参数的公共构造函数。具有一个字符串和异常的公共构造函数（因为它可以包装另一个异常）。如果类型未密封，则受保护的序列化构造函数；如果类型已密封，则为私有构造函数。基于MSDN：[可串行化（）]公共类MyException:异常{公共MyException（）{//添加任何类型特定的逻辑，并提供默认消息。}公共MyException（字符串消息）：基本（消息）{//添加任何类型特定的逻辑。}公共MyException（字符串消息，异常innerException）：基本（消息，内部异常）{//为内部异常添加任何特定于类型的逻辑。}受保护的MyException（SerializationInfo信息，StreamingContext上下文）：基本（信息，上下文）{//实现特定于类型的序列化构造函数逻辑。}}

or

    [Serializable()]
    public sealed class MyException : Exception
    {
      public MyException()
      {
         // Add any type-specific logic, and supply the default message.
      }

      public MyException(string message): base(message) 
      {
         // Add any type-specific logic.
      }
      public MyException(string message, Exception innerException): 
         base (message, innerException)
      {
         // Add any type-specific logic for inner exceptions.
      }
      private MyException(SerializationInfo info, 
         StreamingContext context) : base(info, context)
      {
         // Implement type-specific serialization constructor logic.
      }
    }  

将构造函数修改为以下值，以便正确调用基类构造函数：

public class MyExceptionClass : Exception
{
    public MyExceptionClass(string message, string extrainfo) : base(message)
    {
        //other stuff here
    }
}

请注意，构造函数不是可以在方法中随时调用的。这就是在构造函数主体中调用时出错的原因。

public class MyException : Exception
{
    public MyException() { }
    public MyException(string msg) : base(msg) { }
    public MyException(string msg, Exception inner) : base(msg, inner) { }
}

例如，使用要从中派生的基类：

public abstract class BaseClass
{
    protected BaseClass(int a, int b, int c)
    {
    }
}

要执行的非编译伪代码：

public class DerivedClass : BaseClass
{
    private readonly object fatData;
    
    public DerivedClass(int m)
    {
        var fd = new { A = 1 * m, B = 2 * m, C = 3 * m };
        base(fd.A, fd.B, fd.C); // base-constructor call
        this.fatData = fd;
    }
}

2020版本（见下文，了解更严格的解决方案）

使用更新的C#特性，即out-var，您可以摆脱公共静态工厂方法。

我刚刚（偶然）发现，在base内部调用的方法的out var参数-“call”流到构造函数主体。（可能是C#的怪癖，请参阅2023版本的C#1.0兼容解决方案）

使用一个静态私有帮助器方法，它可以向外部生成所有必需的基本参数（如果需要，还可以添加其他数据），这只是一个公共的普通构造函数：

public class DerivedClass : BaseClass
{
    private readonly object fatData;
    
    public DerivedClass(int m)
        : base(PrepareBaseParameters(m, out var b, out var c, out var fatData), b, c)
    {
        this.fatData = fatData;
        Console.WriteLine(new { b, c, fatData }.ToString());
    }

    private static int PrepareBaseParameters(int m, out int b, out int c, out object fatData)
    {
        var fd = new { A = 1 * m, B = 2 * m, C = 3 * m };
        (b, c, fatData) = (fd.B, fd.C, fd); // Tuples not required but nice to use
        return fd.A;
    }
}

2023更新

您只需要一个额外的私有构造函数和一个附带的私有静态工厂方法，该方法使用与公共构造函数相同的输入为新的私有构造函数准备数据：

public class DerivedClass : BaseClass
{
    private readonly FatData fatData;

    public DerivedClass(int m)
        : this(PrepareBaseParameters(m))
    {
        Console.WriteLine(this.fatData.ToString());
    }

    private DerivedClass(FatData fd)
        : base(fd.A, fd.B, fd.C)
    {
        this.fatData = fd;
    }

    private static FatData PrepareBaseParameters(int m)
    {
        // might be any (non-async) code which e.x. calls factory methods 
        var fd = new FatData(A: 1 * m, B: 2 * m, C: 3 * m);
        return fd;
    }

    private readonly record struct FatData(int A, int B, int C);
}

不需要特殊的C#版本，C#10记录结构只是为了简短，也可以与任何C#1.0类一起使用。

这个版本似乎稍长，但它更容易阅读和理解。

的确，使用base（something）调用基类构造函数，但在重载的情况下，使用this关键字

public ClassName() : this(par1,par2)
{
// do not call the constructor it is called in the this.
// the base key- word is used to call a inherited constructor   
} 

// Hint used overload as often as needed do not write the same code 2 or more times

public class MyExceptionClass : Exception
{
    public MyExceptionClass(string message,
      Exception innerException): base(message, innerException)
    {
        //other stuff here
    }
}

可以将内部异常传递给其中一个构造函数。