Try and set the log source if it's specified

serilog#566

src/Serilog/Log.cs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 using System;
+using System.Threading;
 using Serilog.Core;
 using Serilog.Core.Pipeline;
 using Serilog.Events;
@@ -54,6 +55,16 @@ public static ILogger Logger
             }
         }
 
+        /// <summary>
+        /// Resets <see cref="Logger"/> to the default and disposes the original if possible
+        /// </summary>
+        public static void CloseAndFlush()
+        {
+            ILogger logger = Interlocked.Exchange(ref _logger, new SilentLogger());
+
+            (logger as IDisposable)?.Dispose();
+        }
+
         /// <summary>
         /// Create a logger that enriches log events via the provided enrichers.
         /// </summary>

test/Serilog.Tests/LogTests.cs

@@ -1,5 +1,7 @@
-using Xunit;
+using System;
+using Xunit;
 using Serilog.Core.Pipeline;
+using Serilog.Tests.Support;
 
 namespace Serilog.Tests
 {
@@ -10,5 +12,36 @@ public void TheUninitializedLoggerIsSilent()
         {
             Assert.IsType<SilentLogger>(Log.Logger);
         }
+
+        [Fact]
+        public void DisposesTheLogger()
+        {
+            var disposableLogger = new DisposableLogger();
+            using (SwappedLogger(disposableLogger))
+            {
+                Log.CloseAndFlush();
+
+                Assert.True(disposableLogger.Disposed);
+            }
+        }
+
+        [Fact]
+        public void ResetsLoggerToSilentLogger()
+        {
+            using (SwappedLogger(new DisposableLogger()))
+            {
+                Log.CloseAndFlush();
+
+                Assert.IsType<SilentLogger>(Log.Logger);
+            }
+        }
+
+        private static IDisposable SwappedLogger(ILogger logger)
+        {
+            ILogger originalLogger = Log.Logger;
+            Log.Logger = logger;
+
+            return new DelegateDisposable(() => Log.Logger = originalLogger);
+        }
     }
 }

test/Serilog.Tests/Support/DelegateDisposable.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace Serilog.Tests.Support
+{
+    public class DelegateDisposable : IDisposable
+    {
+        private readonly Action _disposeAction;
+        private bool _disposed;
+
+        public DelegateDisposable(Action disposeAction)
+        {
+            _disposeAction = disposeAction;
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+                return;
+
+            _disposeAction();
+            _disposed = true;
+        }
+    }
+}

test/Serilog.Tests/Support/DisposableLogger.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using Serilog.Core;
+using Serilog.Events;
+
+namespace Serilog.Tests.Support
+{
+    public class DisposableLogger : ILogger, IDisposable
+    {
+        public bool Disposed { get; set; }
+
+        public void Dispose()
+        {
+            Disposed = true;
+        }
+
+        public ILogger ForContext(IEnumerable<ILogEventEnricher> enrichers)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ILogger ForContext(string propertyName, object value, bool destructureObjects = false)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ILogger ForContext<TSource>()
+        {
+            throw new NotImplementedException();
+        }
+
+        public ILogger ForContext(Type source)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Write(LogEvent logEvent)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Write(LogEventLevel level, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Write(LogEventLevel level, Exception exception, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsEnabled(LogEventLevel level)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Verbose(string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Verbose(Exception exception, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Debug(string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Debug(Exception exception, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Information(string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Information(Exception exception, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Warning(string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Warning(Exception exception, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Error(string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Error(Exception exception, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Fatal(string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Fatal(Exception exception, string messageTemplate, params object[] propertyValues)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}