Changing BuildScopeImpl to BuildScope<TState>

Closes #366
aspnet · Mar 31, 2016 · 654a863 · 654a863
1 parent 6be93eb
commit 654a863
Show file tree

Hide file tree

Showing 19 changed files with 37 additions and 47 deletions.
diff --git a/samples/SampleApp/Program.cs b/samples/SampleApp/Program.cs
@@ -124,7 +124,7 @@ public void Execute(string[] args)
                     _logger.LogWarning("Unexpected warning", ex);
                 }
 
-                using (_logger.BeginScopeImpl("Main"))
+                using (_logger.BeginScope("Main"))
                 {
 
                     _logger.LogInformation("Waiting for user input");

diff --git a/src/Microsoft.Extensions.Logging.Abstractions/ILogger.cs b/src/Microsoft.Extensions.Logging.Abstractions/ILogger.cs
@@ -33,6 +33,6 @@ public interface ILogger
         /// </summary>
         /// <param name="state">The identifier for the scope.</param>
         /// <returns>An IDisposable that ends the logical operation scope on dispose.</returns>
-        IDisposable BeginScopeImpl(object state);
+        IDisposable BeginScope<TState>(TState state);
     }
 }
diff --git a/src/Microsoft.Extensions.Logging.Abstractions/LoggerExtensions.cs b/src/Microsoft.Extensions.Logging.Abstractions/LoggerExtensions.cs
@@ -357,7 +357,7 @@ public static IDisposable BeginScope(
                 throw new ArgumentNullException(nameof(messageFormat));
             }
 
-            return logger.BeginScopeImpl(new FormattedLogValues(messageFormat, args));
+            return logger.BeginScope(new FormattedLogValues(messageFormat, args));
         }
 
         //------------------------------------------HELPERS------------------------------------------//

diff --git a/src/Microsoft.Extensions.Logging.Abstractions/LoggerMessage.cs b/src/Microsoft.Extensions.Logging.Abstractions/LoggerMessage.cs
@@ -22,7 +22,7 @@ public static Func<ILogger, IDisposable> DefineScope(string formatString)
         {
             var logValues = new LogValues(new LogValuesFormatter(formatString));
 
-            return logger => logger.BeginScopeImpl(logValues);
+            return logger => logger.BeginScope(logValues);
         }
 
         /// <summary>
@@ -35,7 +35,7 @@ public static Func<ILogger, T1, IDisposable> DefineScope<T1>(string formatString
         {
             var formatter = new LogValuesFormatter(formatString);
 
-            return (logger, arg1) => logger.BeginScopeImpl(new LogValues<T1>(formatter, arg1));
+            return (logger, arg1) => logger.BeginScope(new LogValues<T1>(formatter, arg1));
         }
 
         /// <summary>
@@ -49,7 +49,7 @@ public static Func<ILogger, T1, T2, IDisposable> DefineScope<T1, T2>(string form
         {
             var formatter = new LogValuesFormatter(formatString);
 
-            return (logger, arg1, arg2) => logger.BeginScopeImpl(new LogValues<T1, T2>(formatter, arg1, arg2));
+            return (logger, arg1, arg2) => logger.BeginScope(new LogValues<T1, T2>(formatter, arg1, arg2));
         }
 
         /// <summary>
@@ -64,7 +64,7 @@ public static Func<ILogger, T1, T2, T3, IDisposable> DefineScope<T1, T2, T3>(str
         {
             var formatter = new LogValuesFormatter(formatString);
 
-            return (logger, arg1, arg2, arg3) => logger.BeginScopeImpl(new LogValues<T1, T2, T3>(formatter, arg1, arg2, arg3));
+            return (logger, arg1, arg2, arg3) => logger.BeginScope(new LogValues<T1, T2, T3>(formatter, arg1, arg2, arg3));
         }
 
         /// <summary>

diff --git a/src/Microsoft.Extensions.Logging.Abstractions/LoggerOfT.cs b/src/Microsoft.Extensions.Logging.Abstractions/LoggerOfT.cs
@@ -29,9 +29,9 @@ public Logger(ILoggerFactory factory)
             _logger = factory.CreateLogger(TypeNameHelper.GetTypeDisplayName(typeof(T)));
         }
 
-        IDisposable ILogger.BeginScopeImpl(object state)
+        IDisposable ILogger.BeginScope<TState>(TState state)
         {
-            return _logger.BeginScopeImpl(state);
+            return _logger.BeginScope(state);
         }
 
         bool ILogger.IsEnabled(LogLevel logLevel)

diff --git a/src/Microsoft.Extensions.Logging.Console/ConsoleLogger.cs b/src/Microsoft.Extensions.Logging.Console/ConsoleLogger.cs
@@ -197,7 +197,7 @@ public bool IsEnabled(LogLevel logLevel)
             return Filter(Name, logLevel);
         }
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
             if (state == null)
             {

diff --git a/src/Microsoft.Extensions.Logging.Debug/DebugLogger.cs b/src/Microsoft.Extensions.Logging.Debug/DebugLogger.cs
@@ -36,9 +36,9 @@ public DebugLogger(string name, Func<string, LogLevel, bool> filter)
 
 
         /// <inheritdoc />
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
-            return new NoopDisposable();
+            return NoopDisposable.Instance;
         }
 
         /// <inheritdoc />
@@ -82,6 +82,8 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
 
         private class NoopDisposable : IDisposable
         {
+            public static NoopDisposable Instance = new NoopDisposable();
+
             public void Dispose()
             {
             }

diff --git a/src/Microsoft.Extensions.Logging.EventLog/EventLogLogger.cs b/src/Microsoft.Extensions.Logging.EventLog/EventLogLogger.cs
@@ -61,9 +61,9 @@ public EventLogLogger(string name, EventLogSettings settings)
         public IEventLog EventLog { get; }
 
         /// <inheritdoc />
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
-            return new NoopDisposable();
+            return NoopDisposable.Instance;
         }
 
         /// <inheritdoc />
@@ -172,6 +172,8 @@ private EventLogEntryType GetEventLogEntryType(LogLevel level)
 
         private class NoopDisposable : IDisposable
         {
+            public static NoopDisposable Instance = new NoopDisposable();
+
             public void Dispose()
             {
             }

diff --git a/src/Microsoft.Extensions.Logging.Testing/NullLogger.cs b/src/Microsoft.Extensions.Logging.Testing/NullLogger.cs
@@ -9,7 +9,7 @@ public class NullLogger : ILogger
     {
         public static readonly NullLogger Instance = new NullLogger();
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
             return NullDisposable.Instance;
         }

diff --git a/src/Microsoft.Extensions.Logging.Testing/NullLoggerOfT.cs b/src/Microsoft.Extensions.Logging.Testing/NullLoggerOfT.cs
@@ -9,7 +9,7 @@ public class NullLogger<T> : ILogger<T>
     {
         public static readonly NullLogger<T> Instance = new NullLogger<T>();
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
             return NullDisposable.Instance;
         }

diff --git a/src/Microsoft.Extensions.Logging.Testing/TestLogger.cs b/src/Microsoft.Extensions.Logging.Testing/TestLogger.cs
@@ -21,7 +21,7 @@ public TestLogger(string name, TestSink sink, bool enabled)
 
         public string Name { get; set; }
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
             _scope = state;
 

diff --git a/src/Microsoft.Extensions.Logging.Testing/TestLoggerOfT.cs b/src/Microsoft.Extensions.Logging.Testing/TestLoggerOfT.cs
@@ -14,9 +14,9 @@ public TestLogger(TestLoggerFactory factory)
             _logger = factory.CreateLogger<T>();
         }
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
-            return _logger.BeginScopeImpl(state);
+            return _logger.BeginScope(state);
         }
 
         public bool IsEnabled(LogLevel logLevel)

diff --git a/src/Microsoft.Extensions.Logging.TraceSource/TraceSourceLogger.cs b/src/Microsoft.Extensions.Logging.TraceSource/TraceSourceLogger.cs
@@ -63,7 +63,7 @@ private static TraceEventType GetEventType(LogLevel logLevel)
             }
         }
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
             return new TraceSourceScope(state);
         }

diff --git a/src/Microsoft.Extensions.Logging/Logger.cs b/src/Microsoft.Extensions.Logging/Logger.cs
@@ -100,7 +100,7 @@ public bool IsEnabled(LogLevel logLevel)
             return false;
         }
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
             if (_loggers == null)
             {
@@ -109,7 +109,7 @@ public IDisposable BeginScopeImpl(object state)
 
             if (_loggers.Length == 1)
             {
-                return _loggers[0].BeginScopeImpl(state);
+                return _loggers[0].BeginScope(state);
             }
 
             var loggers = _loggers;
@@ -120,7 +120,7 @@ public IDisposable BeginScopeImpl(object state)
             {
                 try
                 {
-                    var disposable = loggers[index].BeginScopeImpl(state);
+                    var disposable = loggers[index].BeginScope(state);
                     scope.SetDisposable(index, disposable);
                 }
                 catch (Exception ex)

diff --git a/test/Microsoft.Extensions.Logging.Test/ConsoleLoggerTest.cs b/test/Microsoft.Extensions.Logging.Test/ConsoleLoggerTest.cs
@@ -615,8 +615,8 @@ public void CallingBeginScopeOnLogger_AlwaysReturnsNewDisposableInstance()
             var sink = t.Item2;
 
             // Act
-            var disposable1 = logger.BeginScopeImpl("Scope1");
-            var disposable2 = logger.BeginScopeImpl("Scope2");
+            var disposable1 = logger.BeginScope("Scope1");
+            var disposable2 = logger.BeginScope("Scope2");
 
             // Assert
             Assert.NotNull(disposable1);
@@ -633,7 +633,7 @@ public void CallingBeginScopeOnLogger_ReturnsNonNullableInstance()
             var sink = t.Item2;
 
             // Act
-            var disposable = logger.BeginScopeImpl("Scope1");
+            var disposable = logger.BeginScope("Scope1");
 
             // Assert
             Assert.NotNull(disposable);

diff --git a/test/Microsoft.Extensions.Logging.Test/DebugLoggerTest.cs b/test/Microsoft.Extensions.Logging.Test/DebugLoggerTest.cs
@@ -9,30 +9,14 @@ namespace Microsoft.Extensions.Logging
 {
     public class DebugLoggerTest
     {
-        [Fact]
-        public void CallingBeginScopeOnLogger_AlwaysReturnsNewDisposableInstance()
-        {
-            // Arrange
-            var logger = new DebugLogger("Test");
-
-            // Act
-            var disposable1 = logger.BeginScopeImpl("Scope1");
-            var disposable2 = logger.BeginScopeImpl("Scope2");
-
-            // Assert
-            Assert.NotNull(disposable1);
-            Assert.NotNull(disposable2);
-            Assert.NotSame(disposable1, disposable2);
-        }
-
         [Fact]
         public void CallingBeginScopeOnLogger_ReturnsNonNullableInstance()
         {
             // Arrange
             var logger = new DebugLogger("Test");
 
             // Act
-            var disposable = logger.BeginScopeImpl("Scope1");
+            var disposable = logger.BeginScope("Scope1");
 
             // Assert
             Assert.NotNull(disposable);

diff --git a/test/Microsoft.Extensions.Logging.Test/LoggerTest.cs b/test/Microsoft.Extensions.Logging.Test/LoggerTest.cs
@@ -137,7 +137,7 @@ public CustomLogger(string name, ThrowExceptionAt throwExceptionAt, List<string>
                 _store = store;
             }
 
-            public IDisposable BeginScopeImpl(object state)
+            public IDisposable BeginScope<TState>(TState state)
             {
                 if (_throwExceptionAt == ThrowExceptionAt.BeginScope)
                 {

diff --git a/test/Microsoft.Extensions.Logging.Test/TestLogger.cs b/test/Microsoft.Extensions.Logging.Test/TestLogger.cs
@@ -26,7 +26,7 @@ public TestLogger(string name, TestSink sink, Func<LogLevel, bool> filter)
 
         public string Name { get; set; }
 
-        public IDisposable BeginScopeImpl(object state)
+        public IDisposable BeginScope<TState>(TState state)
         {
             _scope = state;
 
@@ -36,7 +36,7 @@ public IDisposable BeginScopeImpl(object state)
                 Scope = state,
             });
 
-            return new NoopDisposable();
+            return NoopDisposable.Instance;
         }
 
         public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
@@ -65,6 +65,8 @@ public bool IsEnabled(LogLevel logLevel)
 
         private class NoopDisposable : IDisposable
         {
+            public static NoopDisposable Instance = new NoopDisposable();
+
             public void Dispose()
             {
             }

diff --git a/test/Microsoft.Extensions.Logging.Testing.Tests/NullLoggerTest.cs b/test/Microsoft.Extensions.Logging.Testing.Tests/NullLoggerTest.cs
@@ -14,7 +14,7 @@ public void BeginScope_CanDispose()
             var logger = NullLogger.Instance;
 
             // Act & Assert
-            using (logger.BeginScopeImpl(null))
+            using (logger.BeginScope("48656c6c6f20576f726c64"))
             {
             }
         }