Eu tenho um código que está registrando Exception.Message . No entanto, li um artigo que afirma que é melhor usar Exception.ToString(). Com o último, você retém informações mais cruciais sobre o erro.

Isso é verdade e é seguro ir em frente e substituir todo o registro de código Exception.Message ?

Também estou usando um layout baseado em XML para log4net . É possível que Exception.ToString()possam conter caracteres XML inválidos, o que pode causar problemas?

Exception.Messagecontém apenas a mensagem (doh) associada à exceção. Exemplo:

Referência de objeto não definida para uma instância de um objeto

O Exception.ToString()método fornecerá uma saída muito mais detalhada, contendo o tipo de exceção, a mensagem (de antes), um rastreamento de pilha e todas essas coisas novamente para exceções aninhadas / internas. Mais precisamente, o método retorna o seguinte:

ToString retorna uma representação da exceção atual que deve ser entendida por humanos. Onde a exceção contém dados sensíveis à cultura, a representação de string retornada pelo ToString é necessária para levar em consideração a cultura atual do sistema. Embora não haja requisitos exatos para o formato da sequência retornada, ela deve tentar refletir o valor do objeto conforme percebido pelo usuário.

A implementação padrão do ToString obtém o nome da classe que lançou a exceção atual, a mensagem, o resultado da chamada do ToString na exceção interna e o resultado da chamada do Environment.StackTrace. Se algum desses membros for uma referência nula (Nada no Visual Basic), seu valor não será incluído na cadeia de caracteres retornada.

Se não houver mensagem de erro ou se for uma sequência vazia (""), nenhuma mensagem de erro será retornada. O nome da exceção interna e o rastreamento da pilha serão retornados apenas se não forem uma referência nula (Nada no Visual Basic).

Além do que já foi dito, não use ToString()no objeto de exceção para exibir ao usuário. Apenas a Messagepropriedade deve ser suficiente ou uma mensagem personalizada de nível superior.

Em termos de fins de registro, definitivamente use ToString()na Exceção, não apenas na Messagepropriedade, como na maioria dos cenários, você ficará coçando a cabeça onde especificamente essa exceção ocorreu e qual era a pilha de chamadas. O stacktrace teria lhe contado tudo isso.

Convertendo a exceção inteira em uma seqüência de caracteres

A chamada Exception.ToString()fornece mais informações do que apenas o uso da Exception.Messagepropriedade. No entanto, mesmo isso ainda deixa de fora muita informação, incluindo:

1. A Datapropriedade de coleção encontrada em todas as exceções.
2. Quaisquer outras propriedades customizadas adicionadas à exceção.

Há momentos em que você deseja capturar essas informações extras. O código abaixo lida com os cenários acima. Ele também grava as propriedades das exceções em uma boa ordem. Está usando o C # 7, mas deve ser muito fácil converter para versões mais antigas, se necessário. Veja também esta resposta relacionada.

public static class ExceptionExtensions
{
    public static string ToDetailedString(this Exception exception) =>
        ToDetailedString(exception, ExceptionOptions.Default);

    public static string ToDetailedString(this Exception exception, ExceptionOptions options)
    {
        if (exception == null)
        {
            throw new ArgumentNullException(nameof(exception));
        } 

        var stringBuilder = new StringBuilder();

        AppendValue(stringBuilder, "Type", exception.GetType().FullName, options);

        foreach (PropertyInfo property in exception
            .GetType()
            .GetProperties()
            .OrderByDescending(x => string.Equals(x.Name, nameof(exception.Message), StringComparison.Ordinal))
            .ThenByDescending(x => string.Equals(x.Name, nameof(exception.Source), StringComparison.Ordinal))
            .ThenBy(x => string.Equals(x.Name, nameof(exception.InnerException), StringComparison.Ordinal))
            .ThenBy(x => string.Equals(x.Name, nameof(AggregateException.InnerExceptions), StringComparison.Ordinal)))
        {
            var value = property.GetValue(exception, null);
            if (value == null && options.OmitNullProperties)
            {
                if (options.OmitNullProperties)
                {
                    continue;
                }
                else
                {
                    value = string.Empty;
                }
            }

            AppendValue(stringBuilder, property.Name, value, options);
        }

        return stringBuilder.ToString().TrimEnd('\r', '\n');
    }

    private static void AppendCollection(
        StringBuilder stringBuilder,
        string propertyName,
        IEnumerable collection,
        ExceptionOptions options)
        {
            stringBuilder.AppendLine($"{options.Indent}{propertyName} =");

            var innerOptions = new ExceptionOptions(options, options.CurrentIndentLevel + 1);

            var i = 0;
            foreach (var item in collection)
            {
                var innerPropertyName = $"[{i}]";

                if (item is Exception)
                {
                    var innerException = (Exception)item;
                    AppendException(
                        stringBuilder,
                        innerPropertyName,
                        innerException,
                        innerOptions);
                }
                else
                {
                    AppendValue(
                        stringBuilder,
                        innerPropertyName,
                        item,
                        innerOptions);
                }

                ++i;
            }
        }

    private static void AppendException(
        StringBuilder stringBuilder,
        string propertyName,
        Exception exception,
        ExceptionOptions options)
    {
        var innerExceptionString = ToDetailedString(
            exception, 
            new ExceptionOptions(options, options.CurrentIndentLevel + 1));

        stringBuilder.AppendLine($"{options.Indent}{propertyName} =");
        stringBuilder.AppendLine(innerExceptionString);
    }

    private static string IndentString(string value, ExceptionOptions options)
    {
        return value.Replace(Environment.NewLine, Environment.NewLine + options.Indent);
    }

    private static void AppendValue(
        StringBuilder stringBuilder,
        string propertyName,
        object value,
        ExceptionOptions options)
    {
        if (value is DictionaryEntry)
        {
            DictionaryEntry dictionaryEntry = (DictionaryEntry)value;
            stringBuilder.AppendLine($"{options.Indent}{propertyName} = {dictionaryEntry.Key} : {dictionaryEntry.Value}");
        }
        else if (value is Exception)
        {
            var innerException = (Exception)value;
            AppendException(
                stringBuilder,
                propertyName,
                innerException,
                options);
        }
        else if (value is IEnumerable && !(value is string))
        {
            var collection = (IEnumerable)value;
            if (collection.GetEnumerator().MoveNext())
            {
                AppendCollection(
                    stringBuilder,
                    propertyName,
                    collection,
                    options);
            }
        }
        else
        {
            stringBuilder.AppendLine($"{options.Indent}{propertyName} = {value}");
        }
    }
}

public struct ExceptionOptions
{
    public static readonly ExceptionOptions Default = new ExceptionOptions()
    {
        CurrentIndentLevel = 0,
        IndentSpaces = 4,
        OmitNullProperties = true
    };

    internal ExceptionOptions(ExceptionOptions options, int currentIndent)
    {
        this.CurrentIndentLevel = currentIndent;
        this.IndentSpaces = options.IndentSpaces;
        this.OmitNullProperties = options.OmitNullProperties;
    }

    internal string Indent { get { return new string(' ', this.IndentSpaces * this.CurrentIndentLevel); } }

    internal int CurrentIndentLevel { get; set; }

    public int IndentSpaces { get; set; }

    public bool OmitNullProperties { get; set; }
}

Dica superior - Exceções de log

A maioria das pessoas estará usando esse código para fazer logon. Considere usar o Serilog com meu pacote NuGet Serilog.Exceptions, que também registra todas as propriedades de uma exceção, mas o faz mais rápido e sem reflexo na maioria dos casos. O Serilog é uma estrutura de registro muito avançada, que é toda a raiva no momento da escrita.

Dica superior - Rastreamentos de pilha legíveis por humanos

Você pode usar o pacote Ben.Demystifier NuGet para obter rastreamentos de pilha legíveis por humanos para suas exceções ou o pacote NuGet serilog-richers- desmystify se você estiver usando o Serilog.

Eu diria que @Wim está certo. Você deve usar ToString()para arquivos de log - assumindo uma audiência técnica - e Message, se houver, para exibir ao usuário. Alguém poderia argumentar que mesmo isso não é adequado para um usuário, para todo tipo de exceção e ocorrência lá fora (pense em ArgumentExceptions, etc.).

Além disso, além do StackTrace, ToString()incluirá informações que você não obterá de outra forma. Por exemplo, a saída da fusão, se ativada para incluir mensagens de log na exceção "mensagens".

Alguns tipos de exceção ainda incluem informações adicionais (por exemplo, de propriedades customizadas) em ToString(), mas não na Mensagem.

Depende da informação que você precisa. Para depurar o rastreamento da pilha e a exceção interna são úteis:

    string message =
        "Exception type " + ex.GetType() + Environment.NewLine +
        "Exception message: " + ex.Message + Environment.NewLine +
        "Stack trace: " + ex.StackTrace + Environment.NewLine;
    if (ex.InnerException != null)
    {
        message += "---BEGIN InnerException--- " + Environment.NewLine +
                   "Exception type " + ex.InnerException.GetType() + Environment.NewLine +
                   "Exception message: " + ex.InnerException.Message + Environment.NewLine +
                   "Stack trace: " + ex.InnerException.StackTrace + Environment.NewLine +
                   "---END Inner Exception";
    }

Em termos do formato XML para log4net, você não precisa se preocupar com ex.ToString () para os logs. Simplesmente passe o objeto de exceção e o log4net fará o resto com todos os detalhes em seu formato XML pré-configurado. A única coisa que encontro ocasionalmente é a formatação de novas linhas, mas é quando estou lendo os arquivos em bruto. Caso contrário, a análise do XML funciona muito bem.

Bem, eu diria que depende do que você deseja ver nos logs, não é? Se você estiver satisfeito com o que o ex.Message fornece, use isso. Caso contrário, use ex.toString () ou até registre o rastreamento de pilha.