Don't split global state for logging.

Fixes #1478

Author: ngbrown

src/NHibernate/Logging.cs

@@ -52,6 +52,10 @@ public static class NHibernateLogger
 		private const string nhibernateLoggerConfKey = "nhibernate-logger";
 		private static INHibernateLoggerFactory _loggerFactory;
 
+#pragma warning disable 618
+		internal static ILoggerFactory LegacyLoggerFactory { get; private set; }
+#pragma warning restore 618
+
 		static NHibernateLogger()
 		{
 			var nhibernateLoggerClass = GetNhibernateLoggerClass();
@@ -68,9 +72,21 @@ public static void SetLoggersFactory(INHibernateLoggerFactory loggerFactory)
 			_loggerFactory = loggerFactory ?? new NoLoggingNHibernateLoggerFactory();
 
 #pragma warning disable 618
-			if (!(loggerFactory is LoggerProvider.LegacyLoggerFactoryAdaptor))
+			// Also keep global state for obsolete logger
+			if (loggerFactory == null)
+			{
+				LegacyLoggerFactory = new NoLoggingLoggerFactory();
+			}
+			else
 			{
-				LoggerProvider.SetLoggersFactory(new LoggerProvider.ReverseLegacyLoggerFactoryAdaptor(loggerFactory));
+				if (loggerFactory is LoggerProvider.LegacyLoggerFactoryAdaptor legacyAdaptor)
+				{
+					LegacyLoggerFactory = legacyAdaptor.Factory;
+				}
+				else
+				{
+					LegacyLoggerFactory = new LoggerProvider.ReverseLegacyLoggerFactoryAdaptor(loggerFactory);
+				}
 			}
 #pragma warning restore 618
 		}

src/NHibernate/Logging.obsolete.cs

@@ -82,54 +82,47 @@ public interface ILoggerFactory
 	[Obsolete("Use NHibernateLogger instead.")]
 	public class LoggerProvider
 	{
-		private static ILoggerFactory _legacyLoggerFactory;
-
 		[Obsolete("Implement INHibernateLoggerFactory and use NHibernateLogger.SetLoggersFactory() instead")]
 		public static void SetLoggersFactory(ILoggerFactory loggerFactory)
 		{
-			_legacyLoggerFactory = loggerFactory ?? new NoLoggingLoggerFactory();
-
-			if (!(loggerFactory is ReverseLegacyLoggerFactoryAdaptor))
-			{
-				var factory = loggerFactory == null || loggerFactory is NoLoggingLoggerFactory
-					? null
-					: (INHibernateLoggerFactory) new LegacyLoggerFactoryAdaptor(loggerFactory);
+			var factory = (loggerFactory == null || loggerFactory is NoLoggingLoggerFactory)
+				? null
+				: (INHibernateLoggerFactory) new LegacyLoggerFactoryAdaptor(loggerFactory);
 
-				NHibernateLogger.SetLoggersFactory(factory);
-			}
+			NHibernateLogger.SetLoggersFactory(factory);
 		}
 
 		[Obsolete("Use NHibernateLogger.For() instead.")]
 		public static IInternalLogger LoggerFor(string keyName)
 		{
-			return _legacyLoggerFactory.LoggerFor(keyName);
+			return NHibernateLogger.LegacyLoggerFactory.LoggerFor(keyName);
 		}
 
 		[Obsolete("Use NHibernateLogger.For() instead.")]
 		public static IInternalLogger LoggerFor(System.Type type)
 		{
-			return _legacyLoggerFactory.LoggerFor(type);
+			return NHibernateLogger.LegacyLoggerFactory.LoggerFor(type);
 		}
 
 		// Since 5.1
 		[Obsolete("Used only in Obsolete functions to thunk to INHibernateLoggerFactory")]
 		internal class LegacyLoggerFactoryAdaptor : INHibernateLoggerFactory
 		{
-			private readonly ILoggerFactory _factory;
+			internal ILoggerFactory Factory { get; }
 
 			public LegacyLoggerFactoryAdaptor(ILoggerFactory factory)
 			{
-				_factory = factory;
+				Factory = factory;
 			}
 
 			public INHibernateLogger LoggerFor(string keyName)
 			{
-				return new NHibernateLoggerThunk(_factory.LoggerFor(keyName));
+				return new NHibernateLoggerThunk(Factory.LoggerFor(keyName));
 			}
 
 			public INHibernateLogger LoggerFor(System.Type type)
 			{
-				return new NHibernateLoggerThunk(_factory.LoggerFor(type));
+				return new NHibernateLoggerThunk(Factory.LoggerFor(type));
 			}
 		}