创建一个新的Exception（或者更好的特定子类型），它包含新消息（并将原始异常作为InnerException传递）。
例如：

throw new MyExceptionType("Some interesting message", originalException);

注意：如果你真的想使用Activator.CreateInstance，你可以使用一个可以传递参数的重载，但是不同的Exception派生类型不能依赖于(message, innerException)的构造函数重载。

我在a blog post中找到了从a news site链接的解决方案：

catch (Exception e)
{
   Exception e2 = (Exception)Activator.CreateInstance(e.GetType(), message, e);
   throw e2;
}

它并不完美（您会丢失堆栈跟踪）;但这就是. NET的本质

我只是想在这里为Ian补充一下他的答案。如果你在blog post中使用这个技术，你不会丢失堆栈。是的，你会丢失最后一个异常的StackTrace成员中的堆栈，但是你不会因为内部异常而丢失整个堆栈。看这里：

class Program
{
    static void Main(string[] args)
    {
        try
        {
            Test1();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }

    public static void Test1()
    {
        try
        {
            Test2();
        }
        catch (Exception ex)
        {
            throw ExceptionUtil.Rethrow(ex, "caught in test1");
        }
    }

    public static void Test2()
    {
        throw new Exception("test2");
    }

    public static class ExceptionUtil
    {
        public static Exception Rethrow(Exception ex, string message)
        {
            if (ex == null)
            {
                ex = new Exception("Error rethrowing exception because original exception is <null>.");
            }

            Exception rethrow;

            try
            {
                rethrow = (Exception)Activator.CreateInstance(ex.GetType(), message, ex);
            }
            catch (Exception)
            {
                rethrow = new Exception(message, ex);
            }
            return rethrow;
        }

        public static Exception Rethrow(Exception ex, string message, params object[] args)
        {
            string formatted;

            try
            {
                formatted = String.Format(message, args);
            }
            catch (Exception ex2)
            {
                formatted = message + "\r\n\r\nAn error occurred filling in exception message details:\r\n\r\n" + ex2;
            }
            return Rethrow(ex, formatted);
        }
    }

}

如果您获取异常的完整字符串，则会得到：

System.Exception: caught in test1 ---> System.Exception: test2
at ScratchPad2.Program.Test2() in C:\Projects\Experiments\ScratchPad2\Program.cs:line 36
at ScratchPad2.Program.Test1() in C:\Projects\Experiments\ScratchPad2\Program.cs:line 26
--- End of inner exception stack trace ---
at ScratchPad2.Program.Test1() in C:\Projects\Experiments\ScratchPad2\Program.cs:line 30
at ScratchPad2.Program.Main(String[] args) in C:\Projects\Experiments\ScratchPad2\Program.cs:line 14

所以你得到了整个堆栈，加上额外的信息

您可以通过反射更改异常消息，如下所示...

Exception exception = new Exception("Some message.");
var type = typeof(Exception);
var flags = BindingFlags.Instance | BindingFlags.NonPublic;
var fieldInfo = type.GetField("_message", flags);
fieldInfo.SetValue(exception, message);

所以你可以创建一个扩展方法...

namespace ExceptionExample
{
    public static class ExceptionExtensions
    {
        public static void SetMessage(this Exception exception, string message)
        {
            if (exception == null)
                throw new ArgumentNullException(nameof(exception));

            var type = typeof(Exception);
            var flags = BindingFlags.Instance | BindingFlags.NonPublic;
            var fieldInfo = type.GetField("_message", flags);
            fieldInfo.SetValue(exception, message);
        }
    }
}

然后用它...

...
using static ExceptionExample.ExceptionExtensions;

public class SomeClass
{
    public void SomeMethod()
    {
        var reader = AnotherClass.GetReader();
        try
        {
            reader.Read();
        }
        catch (Exception ex)
        {
            var connection = reader?.Connection;
            ex.SetMessage($"The exception message was replaced.\n\nOriginal message: {ex.Message}\n\nDatabase: {connection?.Database}");
            throw; // you will not lose the stack trace
        }
    }
}

你必须记住如果你使用“throwex;“堆栈跟踪将丢失。
要避免这种情况，必须使用“throw;“无一例外**。

您可以将先前的异常 Package 在一个包含新消息的新异常中，并将内部异常用于堆栈跟踪等。

try
{
    throw new Exception("This error message sucks");
}
catch (Exception e)
{
    throw new Exception("There error message is prettier", e);
}

在我看来，最好的方法是从Exception（或其他框架提供的异常类）继承，然后将消息字符串放在对基构造函数的调用中，该构造函数将Message作为参数，如下所示：

public class InvalidGraphicTypeException : Exception
{

   public InvalidGraphicTypeException(Graphic badType) : 
      base("Invalid Graphic Type: " + badType.GetType().Name)
   {
   }
}

我知道这是一个很老的问题，但我不认为任何现有的答案是理想的（他们隐藏异常细节innerExceptions或掩码行号）。我使用的方法是使用静态工厂方法而不是构造函数示例化异常：

public class CustomException {
   public string SampleProperty { get; set; }

    public static CustomException FromAlert(Alert alert)
    {
        var ex = new CustomException(string.Format("{0}-{1}", alert.propertyA, alert.propertyB));
        ex.SampleProperty = "somethign else";
        return ex;
    }
}

因此，您现在可以抛出：
第一个月
把信息修改到你满意的程度。

处理这个问题的最好方法是编写适合这种特殊情况的自己的异常类。然后捕获异常，并抛出自己的异常。您可能希望看到以下内容：Exception Constructors -> Exception(String) | MS Docs了解更多信息。
如果您觉得自定义异常不是必需的，则应该能够在引发异常时将自定义字符串传递给Exception构造函数：设计Custom Exceptions | MS Docs

它是虚拟的（在Net4.6和Net6中），所以你可以在你的自定义异常类中覆盖它。
下面是一个如何在Net4.6中提取WebException响应消息并将其放入Message Property的示例。

public class ConnectionProblem : Exception
{
    private string CustomMessage { get; }
    public ConnectionProblem(Exception ex) : base(ex.Message, ex)
    {
        if (ex is System.Net.WebException)
        {//extract error
            var wex = (WebException)ex;
            var resStream = wex.Response.GetResponseStream();
            var resBytes = resStream.ReadToEnd();
            var resMsg = System.Text.Encoding.UTF8.GetString(resBytes);
            CustomMessage = $"{nameof(ConnectionProblem)} encounter with type {nameof(WebException)}, response got: '{resMsg}'";
        }
    }
    public override string Message => CustomMessage;
}