Serilog: Ajout de la prise en charge de la chaîne interpolée

Je ne sais pas comment le support de FormattableString aiderait beaucoup ici. Du moins pas jusqu'à ce que https://github.com/dotnet/roslyn/issues/142 soit résolu.

Que feriez-vous pour des scénarios comme log.Information($"Processed {Path.Combine(folderPath, fileName)} in {elapsedMs:000} ms."); ?

Aussi, pour référence; Interpolation de chaînes C# 6 et Serilog

@Pvlerick - article de blog soigné ! J'y avais aussi pensé dans le passé et, même avec le billet de blog de

@khellang a raison sur le scénario donné. Une partie de moi pense que "le parfait est l'ennemi du bien" et le problème référencé de Roslyn finira par apporter une solution. En attendant, se connecter avec des espaces réservés factices ne serait pas la fin du monde. L'autre partie de moi s'inquiète que quelque chose soit construit puis se brise à l'avenir. Matière à réflexion :fork_and_knife:

@IanYates merci. Je suis d'accord que c'est une sorte de boîte de vers et comme vous l'avez souligné à juste titre, cela pourrait conduire à quelque chose de fragile qui pourrait se briser à l'avenir.

Je vais continuer à enquêter et voir s'il existe un moyen de faire en sorte que cela fonctionne bien en ce qui concerne les points de @nblumhardt et nous verrons.

facile:
log.Information_($"Processed {new {Position = position}} in {new {Elapsed = elapsed}:000} ms.")

J'ai dû l'implémenter en tant qu'extension avec le suffixe "_", car sinon roslyn invoque ILogger.Information(string) place :

    public static class LoggerExtensions
    {
        public class FormattableLogPropValue : IFormattable
        {
            public FormattableLogPropValue(string name, object value)
            {
                this.Name = name;
                this.Value = value;
            }

            public string Name { get; }
            public object Value { get; }

            public bool IsObject() {
                var type = Value?.GetType();
                var res = Type.GetTypeCode(type)==TypeCode.Object;
                return res;
            }

            public string ToString(string format, IFormatProvider formatProvider)
            {
                var prefix = IsObject() ? "@" : string.Empty;
                if (format?.Length > 0) format = ":" + format;
                return $"{{{prefix}{Name}{format}}}";
            }

            public override string ToString()
            {
                return this.ToString(null, null);
            }
        }

        public static void Information_(this ILogger logger, FormattableString str)
        {
            var loggables = str.GetArguments().Select(arg=>GetPropValueFromArgument(logger, arg)??arg).ToArray();

            var messageTemplate = string.Format(str.Format, args: loggables.Select(arg => GetPropValueFromArgument(logger,arg)??arg).ToArray());

            var propertyValues = loggables.OfType<FormattableLogPropValue>().Select(pv=>pv.Value).ToArray();
            logger.Information(messageTemplate, propertyValues: propertyValues);
        }


        static FormattableLogPropValue GetPropValueFromArgument(ILogger logger, object arg)
        {
            var argType = arg.GetType();
            if (!argType.Name.StartsWith("<>f__AnonymousType")) return null;
            var props = argType.GetProperties();
            if (props.Length != 1) throw new ArgumentException("Parameter should only have single property");
            var prop = props.First();
            return new FormattableLogPropValue(prop.Name, prop.GetValue(arg));
        }
    }

Quelqu'un veut-il soumettre un PR?

Je viens de publier une bibliothèque (avec des extensions à Serilog, NLog et Microsoft ILogger) qui permet d'écrire des messages de journal à l'aide de chaînes interpolées tout en définissant les noms de propriété via différentes syntaxes.
J'aimerais entendre des commentaires.
https://github.com/Drizin/InterpolatedLogging