Reduce logging allocs

Allow begin scope with pre-formatted message.
Only create logger array when loggers
Normal for loop condition in constructor
Log nop when no loggers
BeginScope to return null when no loggers
Logging is disabled when no loggers
Add provider to only create one resized array

Author: benaadams

src/Microsoft.Framework.Logging.Abstractions/LoggerExtensions.cs

@@ -559,6 +559,19 @@ public static IDisposable BeginScope(
             return logger.BeginScopeImpl(new FormattedLogValues(messageFormat, args));
         }
 
+        /// <summary>
+        /// Creates a scope with a pre-formatted message.
+        /// </summary>
+        /// <param name="logger">The <see cref="ILogger"/> to create the scope in.</param>
+        /// <param name="message">Pre-formatted string of the scope message.</param>
+        /// <returns>A disposable scope object. Can be null.</returns>
+        public static IDisposable BeginScope(
+            [NotNull] this ILogger logger,
+            [NotNull] string message)
+        {
+            return logger.BeginScopeImpl(message);
+        }
+
         //------------------------------------------HELPERS------------------------------------------//
 
         private static void Log(

src/Microsoft.Framework.Logging/Logger.cs

@@ -3,31 +3,38 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace Microsoft.Framework.Logging
 {
     internal class Logger : ILogger
     {
         private readonly LoggerFactory _loggerFactory;
         private readonly string _name;
-        private ILogger[] _loggers = new ILogger[0];
+        private ILogger[] _loggers;
 
         public Logger(LoggerFactory loggerFactory, string name)
         {
             _loggerFactory = loggerFactory;
             _name = name;
 
             var providers = loggerFactory.GetProviders();
-            _loggers = new ILogger[providers.Length];
-            for (var index = 0; index != providers.Length; index++)
+            if (providers.Length > 0)
             {
-                _loggers[index] = providers[index].CreateLogger(name);
+                _loggers = new ILogger[providers.Length];
+                for (var index = 0; index < providers.Length; index++)
+                {
+                    _loggers[index] = providers[index].CreateLogger(name);
+                }
             }
         }
 
         public void Log(LogLevel logLevel, int eventId, object state, Exception exception, Func<object, Exception, string> formatter)
         {
+            if (_loggers == null)
+            {
+                return;
+            }
+
             if (logLevel >= _loggerFactory.MinimumLevel)
             {
                 List<Exception> exceptions = null;
@@ -58,6 +65,11 @@ public void Log(LogLevel logLevel, int eventId, object state, Exception exceptio
 
         public bool IsEnabled(LogLevel logLevel)
         {
+            if (_loggers == null)
+            {
+                return false;
+            }
+
             if (logLevel < _loggerFactory.MinimumLevel)
             {
                 return false;
@@ -96,11 +108,13 @@ public bool IsEnabled(LogLevel logLevel)
 
         public IDisposable BeginScopeImpl(object state)
         {
-            var loggers = _loggers;
-            if (loggers.Length == 0)
+            if (_loggers == null)
             {
                 return null;
             }
+
+            var loggers = _loggers;
+
             var scope = new Scope(loggers.Length);
             List<Exception> exceptions = null;
             for (var index = 0; index != loggers.Length; index++)
@@ -133,7 +147,18 @@ public IDisposable BeginScopeImpl(object state)
         internal void AddProvider(ILoggerProvider provider)
         {
             var logger = provider.CreateLogger(_name);
-            _loggers = _loggers.Concat(new[] { logger }).ToArray();
+            int logIndex;
+            if (_loggers == null)
+            {
+                logIndex = 1;
+                _loggers = new ILogger[1];
+            }
+            else
+            {
+                logIndex = _loggers.Length;
+                Array.Resize(ref _loggers, logIndex + 1);
+            }
+            _loggers[logIndex] = logger;
         }
 
         private class Scope : IDisposable
@@ -202,4 +227,4 @@ internal void Add(IDisposable disposable)
             }
         }
     }
-}
+}