Add extension to have CreateLogger with Type object as well as generic

Author: adamhathcock

src/Microsoft.Extensions.Logging.Abstractions/LoggerFactoryExtensions.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.Extensions.Logging.Abstractions.Internal;
 
 namespace Microsoft.Extensions.Logging
 {
@@ -21,8 +22,26 @@ public static ILogger<T> CreateLogger<T>(this ILoggerFactory factory)
             {
                 throw new ArgumentNullException(nameof(factory));
             }
-
             return new Logger<T>(factory);
         }
+        /// <summary>
+        /// Creates a new ILogger instance using the full name of the given type.
+        /// </summary>
+        /// <param name="factory">The factory.</param>
+        /// <param name="type">The type.</param>
+        public static ILogger CreateLogger(this ILoggerFactory factory, Type type)
+        {
+            if (factory == null)
+            {
+                throw new ArgumentNullException(nameof(factory));
+            }
+
+            if (type == null)
+            {
+                throw new ArgumentNullException(nameof(type));
+            }
+
+            return factory.CreateLogger(TypeNameHelper.GetTypeDisplayName(type));
+        }
     }
 }

test/Microsoft.Extensions.Logging.Test/LoggerFactoryExtensionsTest.cs

@@ -110,6 +110,55 @@ public void CreatesLoggerName_OnMultipleTypeArgumentGenericType_CreatesWithoutGe
             Assert.Single(testSink.Writes);
             Assert.Equal(fullNameWithoutBacktick, testSink.Writes[0].LoggerName);
         }
+
+
+        [Fact]
+        public void LoggerFactoryCreate_CallsCreateWithCorrectName()
+        {
+            // Arrange
+            var expected = typeof(TestType).FullName;
+
+            var factory = new Mock<ILoggerFactory>();
+            factory.Setup(f => f.CreateLogger(
+                It.IsAny<string>()))
+            .Returns(new Mock<ILogger>().Object);
+
+            // Act
+            factory.Object.CreateLogger(typeof(TestType));
+
+            // Assert
+            factory.Verify(f => f.CreateLogger(expected));
+        }
+
+        [Fact]
+        public void LoggerFactoryCreate_SingleGeneric_CallsCreateWithCorrectName()
+        {
+            // Arrange
+            var factory = new Mock<ILoggerFactory>();
+            factory.Setup(f => f.CreateLogger(It.Is<string>(
+                x => x.Equals("Microsoft.Extensions.Logging.Test.GenericClass"))))
+            .Returns(new Mock<ILogger>().Object);
+
+            var logger = factory.Object.CreateLogger(typeof(GenericClass<TestType>));
+
+            // Assert
+            Assert.NotNull(logger);
+        }
+
+        [Fact]
+        public void LoggerFactoryCreate_TwoGenerics_CallsCreateWithCorrectName()
+        {
+            // Arrange
+            var factory = new Mock<ILoggerFactory>();
+            factory.Setup(f => f.CreateLogger(It.Is<string>(
+                x => x.Equals("Microsoft.Extensions.Logging.Test.GenericClass"))))
+            .Returns(new Mock<ILogger>().Object);
+
+            var logger = factory.Object.CreateLogger(typeof(GenericClass<TestType, SecondTestType>));
+
+            // Assert
+            Assert.NotNull(logger);
+        }
     }
 
     internal class TestType