From 2bc1203a80d27a059b83b80b29d1d7449afcfa22 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <maryam.ariyan@microsoft.com>
Date: Tue, 27 Oct 2020 08:15:33 -0700
Subject: [PATCH 1/5] Enable nullable annotations for M.E.L.Abstractions

---
 .../TypeNameHelper/TypeNameHelper.cs          |  14 +-
 ...crosoft.Extensions.Logging.Abstractions.cs |  90 +++++------
 .../src/EventId.cs                            |   6 +-
 .../src/FormattedLogValues.cs                 |  20 +--
 .../src/ILogger.cs                            |   2 +-
 .../src/LogEntry.cs                           |   6 +-
 .../src/LogValuesFormatter.cs                 |  24 +--
 .../src/LoggerExtensions.cs                   |  62 ++++----
 .../src/LoggerExternalScopeProvider.cs        |  12 +-
 .../src/LoggerMessage.cs                      | 140 +++++++++---------
 .../src/LoggerT.cs                            |   2 +-
 ...oft.Extensions.Logging.Abstractions.csproj |   6 +-
 .../src/NullLogger.cs                         |   2 +-
 .../src/NullLoggerT.cs                        |   4 +-
 14 files changed, 197 insertions(+), 193 deletions(-)

diff --git a/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs b/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
index 66d767c3fdf88b..27f1f6380a4b18 100644
--- a/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
+++ b/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
@@ -31,7 +31,7 @@ internal static class TypeNameHelper
             { typeof(ushort), "ushort" }
         };
 
-        public static string GetTypeDisplayName(object item, bool fullName = true)
+        public static string? GetTypeDisplayName(object? item, bool fullName = true)
         {
             return item == null ? null : GetTypeDisplayName(item.GetType(), fullName);
         }
@@ -63,7 +63,7 @@ private static void ProcessType(StringBuilder builder, Type type, in DisplayName
             {
                 ProcessArrayType(builder, type, options);
             }
-            else if (_builtInTypeNames.TryGetValue(type, out string builtInName))
+            else if (_builtInTypeNames.TryGetValue(type, out string? builtInName))
             {
                 builder.Append(builtInName);
             }
@@ -76,7 +76,7 @@ private static void ProcessType(StringBuilder builder, Type type, in DisplayName
             }
             else
             {
-                string name = options.FullName ? type.FullName : type.Name;
+                string name = options.FullName ? type.FullName! : type.Name;
                 builder.Append(name);
 
                 if (options.NestedTypeDelimiter != DefaultNestedTypeDelimiter)
@@ -91,7 +91,7 @@ private static void ProcessArrayType(StringBuilder builder, Type type, in Displa
             Type innerType = type;
             while (innerType.IsArray)
             {
-                innerType = innerType.GetElementType();
+                innerType = innerType.GetElementType()!;
             }
 
             ProcessType(builder, innerType, options);
@@ -101,7 +101,7 @@ private static void ProcessArrayType(StringBuilder builder, Type type, in Displa
                 builder.Append('[');
                 builder.Append(',', type.GetArrayRank() - 1);
                 builder.Append(']');
-                type = type.GetElementType();
+                type = type.GetElementType()!;
             }
         }
 
@@ -110,14 +110,14 @@ private static void ProcessGenericType(StringBuilder builder, Type type, Type[]
             int offset = 0;
             if (type.IsNested)
             {
-                offset = type.DeclaringType.GetGenericArguments().Length;
+                offset = type.DeclaringType!.GetGenericArguments().Length;
             }
 
             if (options.FullName)
             {
                 if (type.IsNested)
                 {
-                    ProcessGenericType(builder, type.DeclaringType, genericArguments, offset, options);
+                    ProcessGenericType(builder, type.DeclaringType!, genericArguments, offset, options);
                     builder.Append(options.NestedTypeDelimiter);
                 }
                 else if (!string.IsNullOrEmpty(type.Namespace))
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
index 6c492ac9bd9cfc..bc657463dc24fd 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
@@ -10,11 +10,11 @@ public readonly partial struct EventId
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
-        public EventId(int id, string name = null) { throw null; }
+        public EventId(int id, string? name = null) { throw null; }
         public int Id { get { throw null; } }
-        public string Name { get { throw null; } }
+        public string? Name { get { throw null; } }
         public bool Equals(Microsoft.Extensions.Logging.EventId other) { throw null; }
-        public override bool Equals(object obj) { throw null; }
+        public override bool Equals(object? obj) { throw null; }
         public override int GetHashCode() { throw null; }
         public static bool operator ==(Microsoft.Extensions.Logging.EventId left, Microsoft.Extensions.Logging.EventId right) { throw null; }
         public static implicit operator Microsoft.Extensions.Logging.EventId (int i) { throw null; }
@@ -30,7 +30,7 @@ public partial interface ILogger
     {
         System.IDisposable BeginScope<TState>(TState state);
         bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel);
-        void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception exception, System.Func<TState, System.Exception, string> formatter);
+        void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter);
     }
     public partial interface ILoggerFactory : System.IDisposable
     {
@@ -50,35 +50,35 @@ public partial interface ISupportExternalScope
     }
     public static partial class LoggerExtensions
     {
-        public static System.IDisposable BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object[] args) { throw null; }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception exception, string message, params object[] args) { }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string message, params object[] args) { }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception exception, string message, params object[] args) { }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, string message, params object[] args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception exception, string message, params object[] args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string message, params object[] args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, System.Exception exception, string message, params object[] args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, string message, params object[] args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception exception, string message, params object[] args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string message, params object[] args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, System.Exception exception, string message, params object[] args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, string message, params object[] args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception exception, string message, params object[] args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string message, params object[] args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, System.Exception exception, string message, params object[] args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, string message, params object[] args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception exception, string message, params object[] args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string message, params object[] args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, System.Exception exception, string message, params object[] args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, string message, params object[] args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception exception, string message, params object[] args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string message, params object[] args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, System.Exception exception, string message, params object[] args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, string message, params object[] args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception exception, string message, params object[] args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string message, params object[] args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, System.Exception exception, string message, params object[] args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, string message, params object[] args) { }
+        public static System.IDisposable BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[]? args) { throw null; }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, string? message, params object?[]? args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
     }
     public partial class LoggerExternalScopeProvider : Microsoft.Extensions.Logging.IExternalScopeProvider
     {
@@ -93,7 +93,7 @@ public static partial class LoggerFactoryExtensions
     }
     public static partial class LoggerMessage
     {
-        public static System.Action<Microsoft.Extensions.Logging.ILogger, System.Exception> Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
+        public static System.Action<Microsoft.Extensions.Logging.ILogger, System.Exception?> Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
         public static System.Func<Microsoft.Extensions.Logging.ILogger, System.IDisposable> DefineScope(string formatString) { throw null; }
         public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, System.IDisposable> DefineScope<T1>(string formatString) { throw null; }
         public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, System.IDisposable> DefineScope<T1, T2>(string formatString) { throw null; }
@@ -101,12 +101,12 @@ public static partial class LoggerMessage
         public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, System.IDisposable> DefineScope<T1, T2, T3, T4>(string formatString) { throw null; }
         public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, System.IDisposable> DefineScope<T1, T2, T3, T4, T5>(string formatString) { throw null; }
         public static System.Func<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, T6, System.IDisposable> DefineScope<T1, T2, T3, T4, T5, T6>(string formatString) { throw null; }
-        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, System.Exception> Define<T1>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
-        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, System.Exception> Define<T1, T2>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
-        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, System.Exception> Define<T1, T2, T3>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
-        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, System.Exception> Define<T1, T2, T3, T4>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
-        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, System.Exception> Define<T1, T2, T3, T4, T5>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
-        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, T6, System.Exception> Define<T1, T2, T3, T4, T5, T6>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
+        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, System.Exception?> Define<T1>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
+        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, System.Exception?> Define<T1, T2>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
+        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, System.Exception?> Define<T1, T2, T3>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
+        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, System.Exception?> Define<T1, T2, T3, T4>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
+        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, System.Exception?> Define<T1, T2, T3, T4, T5>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
+        public static System.Action<Microsoft.Extensions.Logging.ILogger, T1, T2, T3, T4, T5, T6, System.Exception?> Define<T1, T2, T3, T4, T5, T6>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; }
     }
     public partial class Logger<T> : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger<T>
     {
@@ -133,11 +133,11 @@ public readonly partial struct LogEntry<TState>
         private readonly TState _State_k__BackingField;
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
-        public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception exception, System.Func<TState, System.Exception, string> formatter) { throw null; }
+        public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { throw null; }
         public string Category { get { throw null; } }
         public Microsoft.Extensions.Logging.EventId EventId { get { throw null; } }
-        public System.Exception Exception { get { throw null; } }
-        public System.Func<TState, System.Exception, string> Formatter { get { throw null; } }
+        public System.Exception? Exception { get { throw null; } }
+        public System.Func<TState, System.Exception?, string>? Formatter { get { throw null; } }
         public Microsoft.Extensions.Logging.LogLevel LogLevel { get { throw null; } }
         public TState State { get { throw null; } }
     }
@@ -147,7 +147,7 @@ internal NullLogger() { }
         public static Microsoft.Extensions.Logging.Abstractions.NullLogger Instance { get { throw null; } }
         public System.IDisposable BeginScope<TState>(TState state) { throw null; }
         public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
-        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception exception, System.Func<TState, System.Exception, string> formatter) { }
+        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter) { }
     }
     public partial class NullLoggerFactory : Microsoft.Extensions.Logging.ILoggerFactory, System.IDisposable
     {
@@ -170,6 +170,6 @@ public partial class NullLogger<T> : Microsoft.Extensions.Logging.ILogger, Micro
         public NullLogger() { }
         public System.IDisposable BeginScope<TState>(TState state) { throw null; }
         public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
-        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception exception, System.Func<TState, System.Exception, string> formatter) { }
+        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter) { }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs
index 5c7d7de2b9d367..7e031c5ec5f6b4 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs
@@ -44,7 +44,7 @@ public static implicit operator EventId(int i)
         /// </summary>
         /// <param name="id">The numeric identifier for this event.</param>
         /// <param name="name">The name of this event.</param>
-        public EventId(int id, string name = null)
+        public EventId(int id, string? name = null)
         {
             Id = id;
             Name = name;
@@ -58,7 +58,7 @@ public EventId(int id, string name = null)
         /// <summary>
         /// Gets the name of this event.
         /// </summary>
-        public string Name { get; }
+        public string? Name { get; }
 
         /// <inheritdoc />
         public override string ToString()
@@ -77,7 +77,7 @@ public bool Equals(EventId other)
         }
 
         /// <inheritdoc />
-        public override bool Equals(object obj)
+        public override bool Equals(object? obj)
         {
             if (obj is null)
             {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/FormattedLogValues.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/FormattedLogValues.cs
index ad0bde9b6fb958..4ee37937aa5148 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/FormattedLogValues.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/FormattedLogValues.cs
@@ -10,23 +10,23 @@
 namespace Microsoft.Extensions.Logging
 {
     /// <summary>
-    /// LogValues to enable formatting options supported by <see cref="string.Format(IFormatProvider, string, object)"/>.
+    /// LogValues to enable formatting options supported by <see cref="string.Format(IFormatProvider, string, object?)"/>.
     /// This also enables using {NamedformatItem} in the format string.
     /// </summary>
-    internal readonly struct FormattedLogValues : IReadOnlyList<KeyValuePair<string, object>>
+    internal readonly struct FormattedLogValues : IReadOnlyList<KeyValuePair<string, object?>>
     {
         internal const int MaxCachedFormatters = 1024;
         private const string NullFormat = "[null]";
         private static int _count;
         private static ConcurrentDictionary<string, LogValuesFormatter> _formatters = new ConcurrentDictionary<string, LogValuesFormatter>();
-        private readonly LogValuesFormatter _formatter;
-        private readonly object[] _values;
+        private readonly LogValuesFormatter? _formatter;
+        private readonly object?[]? _values;
         private readonly string _originalMessage;
 
         // for testing purposes
-        internal LogValuesFormatter Formatter => _formatter;
+        internal LogValuesFormatter? Formatter => _formatter;
 
-        public FormattedLogValues(string format, params object[] values)
+        public FormattedLogValues(string? format, params object?[]? values)
         {
             if (values != null && values.Length != 0 && format != null)
             {
@@ -55,7 +55,7 @@ public FormattedLogValues(string format, params object[] values)
             _values = values;
         }
 
-        public KeyValuePair<string, object> this[int index]
+        public KeyValuePair<string, object?> this[int index]
         {
             get
             {
@@ -66,10 +66,10 @@ public KeyValuePair<string, object> this[int index]
 
                 if (index == Count - 1)
                 {
-                    return new KeyValuePair<string, object> ("{OriginalFormat}", _originalMessage);
+                    return new KeyValuePair<string, object?> ("{OriginalFormat}", _originalMessage);
                 }
 
-                return _formatter.GetValue(_values, index);
+                return _formatter!.GetValue(_values!, index);
             }
         }
 
@@ -86,7 +86,7 @@ public int Count
             }
         }
 
-        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+        public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
         {
             for (int i = 0; i < Count; ++i)
             {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs
index d7164852b48375..b661d3fcb74db1 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs
@@ -20,7 +20,7 @@ public interface ILogger
         /// <param name="exception">The exception related to this entry.</param>
         /// <param name="formatter">Function to create a <see cref="string"/> message of the <paramref name="state"/> and <paramref name="exception"/>.</param>
         /// <typeparam name="TState">The type of the object to be written.</typeparam>
-        void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter);
+        void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter);
 
         /// <summary>
         /// Checks if the given <paramref name="logLevel"/> is enabled.
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
index e0cab847a156f5..cebd054da91b77 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
@@ -19,7 +19,7 @@ public readonly struct LogEntry<TState>
         /// <param name="state">The state for which log is being written.</param>
         /// <param name="exception">The log exception.</param>
         /// <param name="formatter">The formatter.</param>
-        public LogEntry(LogLevel logLevel, string category, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        public LogEntry(LogLevel logLevel, string category, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
         {
             LogLevel = logLevel;
             Category = category;
@@ -52,11 +52,11 @@ public LogEntry(LogLevel logLevel, string category, EventId eventId, TState stat
         /// <summary>
         /// Gets the log exception
         /// </summary>
-        public Exception Exception { get; }
+        public Exception? Exception { get; }
 
         /// <summary>
         /// Gets the formatter
         /// </summary>
-        public Func<TState, Exception, string> Formatter { get; }
+        public Func<TState, Exception?, string>? Formatter { get; }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs
index c6322199d6fdab..1df9e9da326724 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs
@@ -117,7 +117,7 @@ private static int FindIndexOfAny(string format, char[] chars, int startIndex, i
             return findIndex == -1 ? endIndex : findIndex;
         }
 
-        public string Format(object[] values)
+        public string Format(object?[]? values)
         {
             if (values != null)
             {
@@ -135,22 +135,22 @@ internal string Format()
             return _format;
         }
 
-        internal string Format(object arg0)
+        internal string Format(object? arg0)
         {
             return string.Format(CultureInfo.InvariantCulture, _format, FormatArgument(arg0));
         }
 
-        internal string Format(object arg0, object arg1)
+        internal string Format(object? arg0, object? arg1)
         {
             return string.Format(CultureInfo.InvariantCulture, _format, FormatArgument(arg0), FormatArgument(arg1));
         }
 
-        internal string Format(object arg0, object arg1, object arg2)
+        internal string Format(object? arg0, object? arg1, object? arg2)
         {
             return string.Format(CultureInfo.InvariantCulture, _format, FormatArgument(arg0), FormatArgument(arg1), FormatArgument(arg2));
         }
 
-        public KeyValuePair<string, object> GetValue(object[] values, int index)
+        public KeyValuePair<string, object?> GetValue(object?[] values, int index)
         {
             if (index < 0 || index > _valueNames.Count)
             {
@@ -159,25 +159,25 @@ public KeyValuePair<string, object> GetValue(object[] values, int index)
 
             if (_valueNames.Count > index)
             {
-                return new KeyValuePair<string, object>(_valueNames[index], values[index]);
+                return new KeyValuePair<string, object?>(_valueNames[index], values[index]);
             }
 
-            return new KeyValuePair<string, object>("{OriginalFormat}", OriginalFormat);
+            return new KeyValuePair<string, object?>("{OriginalFormat}", OriginalFormat);
         }
 
-        public IEnumerable<KeyValuePair<string, object>> GetValues(object[] values)
+        public IEnumerable<KeyValuePair<string, object?>> GetValues(object[] values)
         {
-            var valueArray = new KeyValuePair<string, object>[values.Length + 1];
+            var valueArray = new KeyValuePair<string, object?>[values.Length + 1];
             for (int index = 0; index != _valueNames.Count; ++index)
             {
-                valueArray[index] = new KeyValuePair<string, object>(_valueNames[index], values[index]);
+                valueArray[index] = new KeyValuePair<string, object?>(_valueNames[index], values[index]);
             }
 
-            valueArray[valueArray.Length - 1] = new KeyValuePair<string, object>("{OriginalFormat}", OriginalFormat);
+            valueArray[valueArray.Length - 1] = new KeyValuePair<string, object?>("{OriginalFormat}", OriginalFormat);
             return valueArray;
         }
 
-        private object FormatArgument(object value)
+        private object FormatArgument(object? value)
         {
             if (value == null)
             {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs
index 6f742843a5493b..03202d3e6c37a9 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs
@@ -10,7 +10,7 @@ namespace Microsoft.Extensions.Logging
     /// </summary>
     public static class LoggerExtensions
     {
-        private static readonly Func<FormattedLogValues, Exception, string> _messageFormatter = MessageFormatter;
+        private static readonly Func<FormattedLogValues, Exception?, string> _messageFormatter = MessageFormatter;
 
         //------------------------------------------DEBUG------------------------------------------//
 
@@ -23,7 +23,7 @@ public static class LoggerExtensions
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, EventId eventId, Exception exception, string message, params object[] args)
+        public static void LogDebug(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Debug, eventId, exception, message, args);
         }
@@ -36,7 +36,7 @@ public static void LogDebug(this ILogger logger, EventId eventId, Exception exce
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug(0, "Processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, EventId eventId, string message, params object[] args)
+        public static void LogDebug(this ILogger logger, EventId eventId, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Debug, eventId, message, args);
         }
@@ -49,7 +49,7 @@ public static void LogDebug(this ILogger logger, EventId eventId, string message
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, Exception exception, string message, params object[] args)
+        public static void LogDebug(this ILogger logger, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Debug, exception, message, args);
         }
@@ -61,7 +61,7 @@ public static void LogDebug(this ILogger logger, Exception exception, string mes
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug("Processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, string message, params object[] args)
+        public static void LogDebug(this ILogger logger, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Debug, message, args);
         }
@@ -77,7 +77,7 @@ public static void LogDebug(this ILogger logger, string message, params object[]
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, EventId eventId, Exception exception, string message, params object[] args)
+        public static void LogTrace(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Trace, eventId, exception, message, args);
         }
@@ -90,7 +90,7 @@ public static void LogTrace(this ILogger logger, EventId eventId, Exception exce
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace(0, "Processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, EventId eventId, string message, params object[] args)
+        public static void LogTrace(this ILogger logger, EventId eventId, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Trace, eventId, message, args);
         }
@@ -103,7 +103,7 @@ public static void LogTrace(this ILogger logger, EventId eventId, string message
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, Exception exception, string message, params object[] args)
+        public static void LogTrace(this ILogger logger, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Trace, exception, message, args);
         }
@@ -115,7 +115,7 @@ public static void LogTrace(this ILogger logger, Exception exception, string mes
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace("Processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, string message, params object[] args)
+        public static void LogTrace(this ILogger logger, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Trace, message, args);
         }
@@ -131,7 +131,7 @@ public static void LogTrace(this ILogger logger, string message, params object[]
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, EventId eventId, Exception exception, string message, params object[] args)
+        public static void LogInformation(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Information, eventId, exception, message, args);
         }
@@ -144,7 +144,7 @@ public static void LogInformation(this ILogger logger, EventId eventId, Exceptio
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation(0, "Processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, EventId eventId, string message, params object[] args)
+        public static void LogInformation(this ILogger logger, EventId eventId, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Information, eventId, message, args);
         }
@@ -157,7 +157,7 @@ public static void LogInformation(this ILogger logger, EventId eventId, string m
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, Exception exception, string message, params object[] args)
+        public static void LogInformation(this ILogger logger, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Information, exception, message, args);
         }
@@ -169,7 +169,7 @@ public static void LogInformation(this ILogger logger, Exception exception, stri
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation("Processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, string message, params object[] args)
+        public static void LogInformation(this ILogger logger, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Information, message, args);
         }
@@ -185,7 +185,7 @@ public static void LogInformation(this ILogger logger, string message, params ob
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, EventId eventId, Exception exception, string message, params object[] args)
+        public static void LogWarning(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Warning, eventId, exception, message, args);
         }
@@ -198,7 +198,7 @@ public static void LogWarning(this ILogger logger, EventId eventId, Exception ex
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning(0, "Processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, EventId eventId, string message, params object[] args)
+        public static void LogWarning(this ILogger logger, EventId eventId, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Warning, eventId, message, args);
         }
@@ -211,7 +211,7 @@ public static void LogWarning(this ILogger logger, EventId eventId, string messa
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, Exception exception, string message, params object[] args)
+        public static void LogWarning(this ILogger logger, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Warning, exception, message, args);
         }
@@ -223,7 +223,7 @@ public static void LogWarning(this ILogger logger, Exception exception, string m
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning("Processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, string message, params object[] args)
+        public static void LogWarning(this ILogger logger, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Warning, message, args);
         }
@@ -239,7 +239,7 @@ public static void LogWarning(this ILogger logger, string message, params object
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, EventId eventId, Exception exception, string message, params object[] args)
+        public static void LogError(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Error, eventId, exception, message, args);
         }
@@ -252,7 +252,7 @@ public static void LogError(this ILogger logger, EventId eventId, Exception exce
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError(0, "Processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, EventId eventId, string message, params object[] args)
+        public static void LogError(this ILogger logger, EventId eventId, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Error, eventId, message, args);
         }
@@ -265,7 +265,7 @@ public static void LogError(this ILogger logger, EventId eventId, string message
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, Exception exception, string message, params object[] args)
+        public static void LogError(this ILogger logger, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Error, exception, message, args);
         }
@@ -277,7 +277,7 @@ public static void LogError(this ILogger logger, Exception exception, string mes
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError("Processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, string message, params object[] args)
+        public static void LogError(this ILogger logger, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Error, message, args);
         }
@@ -293,7 +293,7 @@ public static void LogError(this ILogger logger, string message, params object[]
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, EventId eventId, Exception exception, string message, params object[] args)
+        public static void LogCritical(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Critical, eventId, exception, message, args);
         }
@@ -306,7 +306,7 @@ public static void LogCritical(this ILogger logger, EventId eventId, Exception e
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical(0, "Processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, EventId eventId, string message, params object[] args)
+        public static void LogCritical(this ILogger logger, EventId eventId, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Critical, eventId, message, args);
         }
@@ -319,7 +319,7 @@ public static void LogCritical(this ILogger logger, EventId eventId, string mess
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, Exception exception, string message, params object[] args)
+        public static void LogCritical(this ILogger logger, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Critical, exception, message, args);
         }
@@ -331,7 +331,7 @@ public static void LogCritical(this ILogger logger, Exception exception, string
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical("Processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, string message, params object[] args)
+        public static void LogCritical(this ILogger logger, string? message, params object?[]? args)
         {
             logger.Log(LogLevel.Critical, message, args);
         }
@@ -343,7 +343,7 @@ public static void LogCritical(this ILogger logger, string message, params objec
         /// <param name="logLevel">Entry will be written on this level.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, string message, params object[] args)
+        public static void Log(this ILogger logger, LogLevel logLevel, string? message, params object?[]? args)
         {
             logger.Log(logLevel, 0, null, message, args);
         }
@@ -356,7 +356,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, string message, p
         /// <param name="eventId">The event id associated with the log.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, string message, params object[] args)
+        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, string? message, params object?[]? args)
         {
             logger.Log(logLevel, eventId, null, message, args);
         }
@@ -369,7 +369,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId,
         /// <param name="exception">The exception to log.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, Exception exception, string message, params object[] args)
+        public static void Log(this ILogger logger, LogLevel logLevel, Exception? exception, string? message, params object?[]? args)
         {
             logger.Log(logLevel, 0, exception, message, args);
         }
@@ -383,7 +383,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, Exception excepti
         /// <param name="exception">The exception to log.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, Exception exception, string message, params object[] args)
+        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string? message, params object?[]? args)
         {
             if (logger == null)
             {
@@ -410,7 +410,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId,
         public static IDisposable BeginScope(
             this ILogger logger,
             string messageFormat,
-            params object[] args)
+            params object?[]? args)
         {
             if (logger == null)
             {
@@ -422,7 +422,7 @@ public static IDisposable BeginScope(
 
         //------------------------------------------HELPERS------------------------------------------//
 
-        private static string MessageFormatter(FormattedLogValues state, Exception error)
+        private static string MessageFormatter(FormattedLogValues state, Exception? error)
         {
             return state.ToString();
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs
index bd6980a963b1f4..203659948e62c2 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs
@@ -11,7 +11,7 @@ namespace Microsoft.Extensions.Logging
     /// </summary>
     public class LoggerExternalScopeProvider : IExternalScopeProvider
     {
-        private readonly AsyncLocal<Scope> _currentScope = new AsyncLocal<Scope>();
+        private readonly AsyncLocal<Scope?> _currentScope = new AsyncLocal<Scope?>();
 
         /// <summary>
         /// Creates a new <see cref="LoggerExternalScopeProvider"/>.
@@ -22,7 +22,7 @@ public LoggerExternalScopeProvider()
         /// <inheritdoc />
         public void ForEachScope<TState>(Action<object, TState> callback, TState state)
         {
-            void Report(Scope current)
+            void Report(Scope? current)
             {
                 if (current == null)
                 {
@@ -37,7 +37,7 @@ void Report(Scope current)
         /// <inheritdoc />
         public IDisposable Push(object state)
         {
-            Scope parent = _currentScope.Value;
+            Scope? parent = _currentScope.Value;
             var newScope = new Scope(this, state, parent);
             _currentScope.Value = newScope;
 
@@ -49,18 +49,18 @@ private class Scope : IDisposable
             private readonly LoggerExternalScopeProvider _provider;
             private bool _isDisposed;
 
-            internal Scope(LoggerExternalScopeProvider provider, object state, Scope parent)
+            internal Scope(LoggerExternalScopeProvider provider, object state, Scope? parent)
             {
                 _provider = provider;
                 State = state;
                 Parent = parent;
             }
 
-            public Scope Parent { get; }
+            public Scope? Parent { get; }
 
             public object State { get; }
 
-            public override string ToString()
+            public override string? ToString()
             {
                 return State?.ToString();
             }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessage.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessage.cs
index 27c7b5b75031c8..2d9fa977ee7255 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessage.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerMessage.cs
@@ -127,7 +127,7 @@ public static Func<ILogger, T1, T2, T3, T4, T5, T6, IDisposable> DefineScope<T1,
         /// <param name="eventId">The event id</param>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log message.</returns>
-        public static Action<ILogger, Exception> Define(LogLevel logLevel, EventId eventId, string formatString)
+        public static Action<ILogger, Exception?> Define(LogLevel logLevel, EventId eventId, string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 0);
 
@@ -148,11 +148,11 @@ public static Action<ILogger, Exception> Define(LogLevel logLevel, EventId event
         /// <param name="eventId">The event id</param>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log message.</returns>
-        public static Action<ILogger, T1, Exception> Define<T1>(LogLevel logLevel, EventId eventId, string formatString)
+        public static Action<ILogger, T1, Exception?> Define<T1>(LogLevel logLevel, EventId eventId, string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 1);
 
-            void Log(ILogger logger, T1 arg1, Exception exception)
+            void Log(ILogger logger, T1 arg1, Exception? exception)
             {
                 logger.Log(logLevel, eventId, new LogValues<T1>(formatter, arg1), exception, LogValues<T1>.Callback);
             }
@@ -175,11 +175,11 @@ void Log(ILogger logger, T1 arg1, Exception exception)
         /// <param name="eventId">The event id</param>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log message.</returns>
-        public static Action<ILogger, T1, T2, Exception> Define<T1, T2>(LogLevel logLevel, EventId eventId, string formatString)
+        public static Action<ILogger, T1, T2, Exception?> Define<T1, T2>(LogLevel logLevel, EventId eventId, string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 2);
 
-            void Log(ILogger logger, T1 arg1, T2 arg2, Exception exception)
+            void Log(ILogger logger, T1 arg1, T2 arg2, Exception? exception)
             {
                 logger.Log(logLevel, eventId, new LogValues<T1, T2>(formatter, arg1, arg2), exception, LogValues<T1, T2>.Callback);
             }
@@ -203,11 +203,11 @@ void Log(ILogger logger, T1 arg1, T2 arg2, Exception exception)
         /// <param name="eventId">The event id</param>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log message.</returns>
-        public static Action<ILogger, T1, T2, T3, Exception> Define<T1, T2, T3>(LogLevel logLevel, EventId eventId, string formatString)
+        public static Action<ILogger, T1, T2, T3, Exception?> Define<T1, T2, T3>(LogLevel logLevel, EventId eventId, string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 3);
 
-            void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, Exception exception)
+            void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, Exception? exception)
             {
                 logger.Log(logLevel, eventId, new LogValues<T1, T2, T3>(formatter, arg1, arg2, arg3), exception, LogValues<T1, T2, T3>.Callback);
             }
@@ -232,11 +232,11 @@ void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, Exception exception)
         /// <param name="eventId">The event id</param>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log message.</returns>
-        public static Action<ILogger, T1, T2, T3, T4, Exception> Define<T1, T2, T3, T4>(LogLevel logLevel, EventId eventId, string formatString)
+        public static Action<ILogger, T1, T2, T3, T4, Exception?> Define<T1, T2, T3, T4>(LogLevel logLevel, EventId eventId, string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 4);
 
-            void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, Exception exception)
+            void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, Exception? exception)
             {
                 logger.Log(logLevel, eventId, new LogValues<T1, T2, T3, T4>(formatter, arg1, arg2, arg3, arg4), exception, LogValues<T1, T2, T3, T4>.Callback);
             }
@@ -262,7 +262,7 @@ void Log(ILogger logger, T1 arg1, T2 arg2, T3 arg3, T4 arg4, Exception exception
         /// <param name="eventId">The event id</param>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log message.</returns>
-        public static Action<ILogger, T1, T2, T3, T4, T5, Exception> Define<T1, T2, T3, T4, T5>(LogLevel logLevel, EventId eventId, string formatString)
+        public static Action<ILogger, T1, T2, T3, T4, T5, Exception?> Define<T1, T2, T3, T4, T5>(LogLevel logLevel, EventId eventId, string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 5);
 
@@ -288,7 +288,7 @@ public static Action<ILogger, T1, T2, T3, T4, T5, Exception> Define<T1, T2, T3,
         /// <param name="eventId">The event id</param>
         /// <param name="formatString">The named format string</param>
         /// <returns>A delegate which when invoked creates a log message.</returns>
-        public static Action<ILogger, T1, T2, T3, T4, T5, T6, Exception> Define<T1, T2, T3, T4, T5, T6>(LogLevel logLevel, EventId eventId, string formatString)
+        public static Action<ILogger, T1, T2, T3, T4, T5, T6, Exception?> Define<T1, T2, T3, T4, T5, T6>(LogLevel logLevel, EventId eventId, string formatString)
         {
             LogValuesFormatter formatter = CreateLogValuesFormatter(formatString, expectedNamedParameterCount: 6);
 
@@ -315,9 +315,9 @@ private static LogValuesFormatter CreateLogValuesFormatter(string formatString,
             return logValuesFormatter;
         }
 
-        private readonly struct LogValues : IReadOnlyList<KeyValuePair<string, object>>
+        private readonly struct LogValues : IReadOnlyList<KeyValuePair<string, object?>>
         {
-            public static readonly Func<LogValues, Exception, string> Callback = (state, exception) => state.ToString();
+            public static readonly Func<LogValues, Exception?, string> Callback = (state, exception) => state.ToString();
 
             private readonly LogValuesFormatter _formatter;
 
@@ -326,13 +326,13 @@ public LogValues(LogValuesFormatter formatter)
                 _formatter = formatter;
             }
 
-            public KeyValuePair<string, object> this[int index]
+            public KeyValuePair<string, object?> this[int index]
             {
                 get
                 {
                     if (index == 0)
                     {
-                        return new KeyValuePair<string, object>("{OriginalFormat}", _formatter.OriginalFormat);
+                        return new KeyValuePair<string, object?>("{OriginalFormat}", _formatter.OriginalFormat);
                     }
                     throw new IndexOutOfRangeException(nameof(index));
                 }
@@ -340,7 +340,7 @@ public KeyValuePair<string, object> this[int index]
 
             public int Count => 1;
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 yield return this[0];
             }
@@ -353,9 +353,9 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
-        private readonly struct LogValues<T0> : IReadOnlyList<KeyValuePair<string, object>>
+        private readonly struct LogValues<T0> : IReadOnlyList<KeyValuePair<string, object?>>
         {
-            public static readonly Func<LogValues<T0>, Exception, string> Callback = (state, exception) => state.ToString();
+            public static readonly Func<LogValues<T0>, Exception?, string> Callback = (state, exception) => state.ToString();
 
             private readonly LogValuesFormatter _formatter;
             private readonly T0 _value0;
@@ -366,16 +366,16 @@ public LogValues(LogValuesFormatter formatter, T0 value0)
                 _value0 = value0;
             }
 
-            public KeyValuePair<string, object> this[int index]
+            public KeyValuePair<string, object?> this[int index]
             {
                 get
                 {
                     switch (index)
                     {
                         case 0:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[0], _value0);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[0], _value0);
                         case 1:
-                            return new KeyValuePair<string, object>("{OriginalFormat}", _formatter.OriginalFormat);
+                            return new KeyValuePair<string, object?>("{OriginalFormat}", _formatter.OriginalFormat);
                         default:
                             throw new IndexOutOfRangeException(nameof(index));
                     }
@@ -384,7 +384,7 @@ public KeyValuePair<string, object> this[int index]
 
             public int Count => 2;
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 for (int i = 0; i < Count; ++i)
                 {
@@ -401,9 +401,9 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
-        private readonly struct LogValues<T0, T1> : IReadOnlyList<KeyValuePair<string, object>>
+        private readonly struct LogValues<T0, T1> : IReadOnlyList<KeyValuePair<string, object?>>
         {
-            public static readonly Func<LogValues<T0, T1>, Exception, string> Callback = (state, exception) => state.ToString();
+            public static readonly Func<LogValues<T0, T1>, Exception?, string> Callback = (state, exception) => state.ToString();
 
             private readonly LogValuesFormatter _formatter;
             private readonly T0 _value0;
@@ -416,18 +416,18 @@ public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1)
                 _value1 = value1;
             }
 
-            public KeyValuePair<string, object> this[int index]
+            public KeyValuePair<string, object?> this[int index]
             {
                 get
                 {
                     switch (index)
                     {
                         case 0:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[0], _value0);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[0], _value0);
                         case 1:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[1], _value1);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[1], _value1);
                         case 2:
-                            return new KeyValuePair<string, object>("{OriginalFormat}", _formatter.OriginalFormat);
+                            return new KeyValuePair<string, object?>("{OriginalFormat}", _formatter.OriginalFormat);
                         default:
                             throw new IndexOutOfRangeException(nameof(index));
                     }
@@ -436,7 +436,7 @@ public KeyValuePair<string, object> this[int index]
 
             public int Count => 3;
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 for (int i = 0; i < Count; ++i)
                 {
@@ -452,9 +452,9 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
-        private readonly struct LogValues<T0, T1, T2> : IReadOnlyList<KeyValuePair<string, object>>
+        private readonly struct LogValues<T0, T1, T2> : IReadOnlyList<KeyValuePair<string, object?>>
         {
-            public static readonly Func<LogValues<T0, T1, T2>, Exception, string> Callback = (state, exception) => state.ToString();
+            public static readonly Func<LogValues<T0, T1, T2>, Exception?, string> Callback = (state, exception) => state.ToString();
 
             private readonly LogValuesFormatter _formatter;
             private readonly T0 _value0;
@@ -463,20 +463,20 @@ IEnumerator IEnumerable.GetEnumerator()
 
             public int Count => 4;
 
-            public KeyValuePair<string, object> this[int index]
+            public KeyValuePair<string, object?> this[int index]
             {
                 get
                 {
                     switch (index)
                     {
                         case 0:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[0], _value0);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[0], _value0);
                         case 1:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[1], _value1);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[1], _value1);
                         case 2:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[2], _value2);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[2], _value2);
                         case 3:
-                            return new KeyValuePair<string, object>("{OriginalFormat}", _formatter.OriginalFormat);
+                            return new KeyValuePair<string, object?>("{OriginalFormat}", _formatter.OriginalFormat);
                         default:
                             throw new IndexOutOfRangeException(nameof(index));
                     }
@@ -493,7 +493,7 @@ public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2)
 
             public override string ToString() => _formatter.Format(_value0, _value1, _value2);
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 for (int i = 0; i < Count; ++i)
                 {
@@ -507,9 +507,9 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
-        private readonly struct LogValues<T0, T1, T2, T3> : IReadOnlyList<KeyValuePair<string, object>>
+        private readonly struct LogValues<T0, T1, T2, T3> : IReadOnlyList<KeyValuePair<string, object?>>
         {
-            public static readonly Func<LogValues<T0, T1, T2, T3>, Exception, string> Callback = (state, exception) => state.ToString();
+            public static readonly Func<LogValues<T0, T1, T2, T3>, Exception?, string> Callback = (state, exception) => state.ToString();
 
             private readonly LogValuesFormatter _formatter;
             private readonly T0 _value0;
@@ -519,22 +519,22 @@ IEnumerator IEnumerable.GetEnumerator()
 
             public int Count => 5;
 
-            public KeyValuePair<string, object> this[int index]
+            public KeyValuePair<string, object?> this[int index]
             {
                 get
                 {
                     switch (index)
                     {
                         case 0:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[0], _value0);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[0], _value0);
                         case 1:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[1], _value1);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[1], _value1);
                         case 2:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[2], _value2);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[2], _value2);
                         case 3:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[3], _value3);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[3], _value3);
                         case 4:
-                            return new KeyValuePair<string, object>("{OriginalFormat}", _formatter.OriginalFormat);
+                            return new KeyValuePair<string, object?>("{OriginalFormat}", _formatter.OriginalFormat);
                         default:
                             throw new IndexOutOfRangeException(nameof(index));
                     }
@@ -550,11 +550,11 @@ public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2,
                 _value3 = value3;
             }
 
-            private object[] ToArray() => new object[] { _value0, _value1, _value2, _value3 };
+            private object?[] ToArray() => new object?[] { _value0, _value1, _value2, _value3 };
 
             public override string ToString() => _formatter.Format(ToArray());
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 for (int i = 0; i < Count; ++i)
                 {
@@ -568,9 +568,9 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
-        private readonly struct LogValues<T0, T1, T2, T3, T4> : IReadOnlyList<KeyValuePair<string, object>>
+        private readonly struct LogValues<T0, T1, T2, T3, T4> : IReadOnlyList<KeyValuePair<string, object?>>
         {
-            public static readonly Func<LogValues<T0, T1, T2, T3, T4>, Exception, string> Callback = (state, exception) => state.ToString();
+            public static readonly Func<LogValues<T0, T1, T2, T3, T4>, Exception?, string> Callback = (state, exception) => state.ToString();
 
             private readonly LogValuesFormatter _formatter;
             private readonly T0 _value0;
@@ -581,24 +581,24 @@ IEnumerator IEnumerable.GetEnumerator()
 
             public int Count => 6;
 
-            public KeyValuePair<string, object> this[int index]
+            public KeyValuePair<string, object?> this[int index]
             {
                 get
                 {
                     switch (index)
                     {
                         case 0:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[0], _value0);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[0], _value0);
                         case 1:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[1], _value1);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[1], _value1);
                         case 2:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[2], _value2);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[2], _value2);
                         case 3:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[3], _value3);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[3], _value3);
                         case 4:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[4], _value4);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[4], _value4);
                         case 5:
-                            return new KeyValuePair<string, object>("{OriginalFormat}", _formatter.OriginalFormat);
+                            return new KeyValuePair<string, object?>("{OriginalFormat}", _formatter.OriginalFormat);
                         default:
                             throw new IndexOutOfRangeException(nameof(index));
                     }
@@ -615,11 +615,11 @@ public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2,
                 _value4 = value4;
             }
 
-            private object[] ToArray() => new object[] { _value0, _value1, _value2, _value3, _value4 };
+            private object?[] ToArray() => new object?[] { _value0, _value1, _value2, _value3, _value4 };
 
             public override string ToString() => _formatter.Format(ToArray());
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 for (int i = 0; i < Count; ++i)
                 {
@@ -633,9 +633,9 @@ IEnumerator IEnumerable.GetEnumerator()
             }
         }
 
-        private readonly struct LogValues<T0, T1, T2, T3, T4, T5> : IReadOnlyList<KeyValuePair<string, object>>
+        private readonly struct LogValues<T0, T1, T2, T3, T4, T5> : IReadOnlyList<KeyValuePair<string, object?>>
         {
-            public static readonly Func<LogValues<T0, T1, T2, T3, T4, T5>, Exception, string> Callback = (state, exception) => state.ToString();
+            public static readonly Func<LogValues<T0, T1, T2, T3, T4, T5>, Exception?, string> Callback = (state, exception) => state.ToString();
 
             private readonly LogValuesFormatter _formatter;
             private readonly T0 _value0;
@@ -647,26 +647,26 @@ IEnumerator IEnumerable.GetEnumerator()
 
             public int Count => 7;
 
-            public KeyValuePair<string, object> this[int index]
+            public KeyValuePair<string, object?> this[int index]
             {
                 get
                 {
                     switch (index)
                     {
                         case 0:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[0], _value0);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[0], _value0);
                         case 1:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[1], _value1);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[1], _value1);
                         case 2:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[2], _value2);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[2], _value2);
                         case 3:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[3], _value3);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[3], _value3);
                         case 4:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[4], _value4);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[4], _value4);
                         case 5:
-                            return new KeyValuePair<string, object>(_formatter.ValueNames[5], _value5);
+                            return new KeyValuePair<string, object?>(_formatter.ValueNames[5], _value5);
                         case 6:
-                            return new KeyValuePair<string, object>("{OriginalFormat}", _formatter.OriginalFormat);
+                            return new KeyValuePair<string, object?>("{OriginalFormat}", _formatter.OriginalFormat);
                         default:
                             throw new IndexOutOfRangeException(nameof(index));
                     }
@@ -684,11 +684,11 @@ public LogValues(LogValuesFormatter formatter, T0 value0, T1 value1, T2 value2,
                 _value5 = value5;
             }
 
-            private object[] ToArray() => new object[] { _value0, _value1, _value2, _value3, _value4, _value5 };
+            private object?[] ToArray() => new object?[] { _value0, _value1, _value2, _value3, _value4, _value5 };
 
             public override string ToString() => _formatter.Format(ToArray());
 
-            public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+            public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
             {
                 for (int i = 0; i < Count; ++i)
                 {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs
index 59f2f043cd181c..a1731d0554bcfa 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs
@@ -42,7 +42,7 @@ bool ILogger.IsEnabled(LogLevel logLevel)
         }
 
         /// <inheritdoc />
-        void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
         {
             _logger.Log(logLevel, eventId, state, exception, formatter);
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj
index 26c5d1f3329de2..aaefacbbb1e1de 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj
@@ -1,8 +1,12 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
+    <TargetFrameworks>$(NetCoreAppCurrent);netstandard2.0;net461</TargetFrameworks>
+    <ExcludeCurrentNetCoreAppFromPackage>true</ExcludeCurrentNetCoreAppFromPackage>
     <EnableDefaultItems>true</EnableDefaultItems>
+    <!-- Use targeting pack references instead of granular ones in the project file. -->
+    <DisableImplicitAssemblyReferences>false</DisableImplicitAssemblyReferences>
+    <Nullable>enable</Nullable>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs
index f8bdacdc112d89..4fc72a30667d69 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs
@@ -32,7 +32,7 @@ public bool IsEnabled(LogLevel logLevel)
         }
 
         /// <inheritdoc />
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
         {
         }
     }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs
index 8e3a118575f359..ee977bf9ae03f8 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs
@@ -30,8 +30,8 @@ public void Log<TState>(
             LogLevel logLevel,
             EventId eventId,
             TState state,
-            Exception exception,
-            Func<TState, Exception, string> formatter)
+            Exception? exception,
+            Func<TState, Exception?, string>? formatter)
         {
         }
 

From fdca282a13a686862a925efaf7c1af47cb4c3f67 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <maryam.ariyan@microsoft.com>
Date: Tue, 27 Oct 2020 12:53:57 -0700
Subject: [PATCH 2/5] Corrections from review

---
 .../Extensions/Logging/NullExternalScopeProvider.cs    |  6 ++++--
 .../src/Extensions/TypeNameHelper/TypeNameHelper.cs    |  2 ++
 .../ref/Microsoft.Extensions.Logging.Abstractions.cs   | 10 +++++-----
 .../src/IExternalScopeProvider.cs                      |  4 ++--
 .../src/LogEntry.cs                                    |  2 +-
 .../src/LoggerExternalScopeProvider.cs                 |  8 ++++----
 6 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/libraries/Common/src/Extensions/Logging/NullExternalScopeProvider.cs b/src/libraries/Common/src/Extensions/Logging/NullExternalScopeProvider.cs
index 17936083a934dd..791ecc87152cd0 100644
--- a/src/libraries/Common/src/Extensions/Logging/NullExternalScopeProvider.cs
+++ b/src/libraries/Common/src/Extensions/Logging/NullExternalScopeProvider.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#nullable enable
+
 using System;
 
 namespace Microsoft.Extensions.Logging
@@ -20,12 +22,12 @@ private NullExternalScopeProvider()
         public static IExternalScopeProvider Instance { get; } = new NullExternalScopeProvider();
 
         /// <inheritdoc />
-        void IExternalScopeProvider.ForEachScope<TState>(Action<object, TState> callback, TState state)
+        void IExternalScopeProvider.ForEachScope<TState>(Action<object?, TState> callback, TState state)
         {
         }
 
         /// <inheritdoc />
-        IDisposable IExternalScopeProvider.Push(object state)
+        IDisposable IExternalScopeProvider.Push(object? state)
         {
             return NullScope.Instance;
         }
diff --git a/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs b/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
index 27f1f6380a4b18..72af1b65be5c38 100644
--- a/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
+++ b/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#nullable enable
+
 using System;
 using System.Text;
 using System.Collections.Generic;
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
index bc657463dc24fd..db50c9efb28735 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
@@ -23,8 +23,8 @@ public readonly partial struct EventId
     }
     public partial interface IExternalScopeProvider
     {
-        void ForEachScope<TState>(System.Action<object, TState> callback, TState state);
-        System.IDisposable Push(object state);
+        void ForEachScope<TState>(System.Action<object?, TState> callback, TState state);
+        System.IDisposable Push(object? state);
     }
     public partial interface ILogger
     {
@@ -83,8 +83,8 @@ public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger,
     public partial class LoggerExternalScopeProvider : Microsoft.Extensions.Logging.IExternalScopeProvider
     {
         public LoggerExternalScopeProvider() { }
-        public void ForEachScope<TState>(System.Action<object, TState> callback, TState state) { }
-        public System.IDisposable Push(object state) { throw null; }
+        public void ForEachScope<TState>(System.Action<object?, TState> callback, TState state) { }
+        public System.IDisposable Push(object? state) { throw null; }
     }
     public static partial class LoggerFactoryExtensions
     {
@@ -133,7 +133,7 @@ public readonly partial struct LogEntry<TState>
         private readonly TState _State_k__BackingField;
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
-        public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { throw null; }
+        public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter) { throw null; }
         public string Category { get { throw null; } }
         public Microsoft.Extensions.Logging.EventId EventId { get { throw null; } }
         public System.Exception? Exception { get { throw null; } }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/IExternalScopeProvider.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/IExternalScopeProvider.cs
index 85e8d9cf29a831..20855aa043c0aa 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/IExternalScopeProvider.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/IExternalScopeProvider.cs
@@ -17,13 +17,13 @@ public interface IExternalScopeProvider
         /// <param name="callback">The callback to be executed for every scope object</param>
         /// <param name="state">The state object to be passed into the callback</param>
         /// <typeparam name="TState">The type of state to accept.</typeparam>
-        void ForEachScope<TState>(Action<object, TState> callback, TState state);
+        void ForEachScope<TState>(Action<object?, TState> callback, TState state);
 
         /// <summary>
         /// Adds scope object to the list
         /// </summary>
         /// <param name="state">The scope object</param>
         /// <returns>The <see cref="IDisposable"/> token that removes scope on dispose.</returns>
-        IDisposable Push(object state);
+        IDisposable Push(object? state);
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
index cebd054da91b77..e935390abd20ac 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
@@ -19,7 +19,7 @@ public readonly struct LogEntry<TState>
         /// <param name="state">The state for which log is being written.</param>
         /// <param name="exception">The log exception.</param>
         /// <param name="formatter">The formatter.</param>
-        public LogEntry(LogLevel logLevel, string category, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        public LogEntry(LogLevel logLevel, string category, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
         {
             LogLevel = logLevel;
             Category = category;
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs
index 203659948e62c2..0afed527c11bc4 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExternalScopeProvider.cs
@@ -20,7 +20,7 @@ public LoggerExternalScopeProvider()
         { }
 
         /// <inheritdoc />
-        public void ForEachScope<TState>(Action<object, TState> callback, TState state)
+        public void ForEachScope<TState>(Action<object?, TState> callback, TState state)
         {
             void Report(Scope? current)
             {
@@ -35,7 +35,7 @@ void Report(Scope? current)
         }
 
         /// <inheritdoc />
-        public IDisposable Push(object state)
+        public IDisposable Push(object? state)
         {
             Scope? parent = _currentScope.Value;
             var newScope = new Scope(this, state, parent);
@@ -49,7 +49,7 @@ private class Scope : IDisposable
             private readonly LoggerExternalScopeProvider _provider;
             private bool _isDisposed;
 
-            internal Scope(LoggerExternalScopeProvider provider, object state, Scope? parent)
+            internal Scope(LoggerExternalScopeProvider provider, object? state, Scope? parent)
             {
                 _provider = provider;
                 State = state;
@@ -58,7 +58,7 @@ internal Scope(LoggerExternalScopeProvider provider, object state, Scope? parent
 
             public Scope? Parent { get; }
 
-            public object State { get; }
+            public object? State { get; }
 
             public override string? ToString()
             {

From dbe0de745eab41564fa739bf62d80dc796911402 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <maryam.ariyan@microsoft.com>
Date: Fri, 30 Oct 2020 09:43:22 -0700
Subject: [PATCH 3/5] LoggerExtensions.cs: params object?[] -> params object?[]

---
 ...crosoft.Extensions.Logging.Abstractions.cs | 58 +++++++++----------
 .../src/LoggerExtensions.cs                   | 58 +++++++++----------
 2 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
index db50c9efb28735..f469c46be86908 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
@@ -50,35 +50,35 @@ public partial interface ISupportExternalScope
     }
     public static partial class LoggerExtensions
     {
-        public static System.IDisposable BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[]? args) { throw null; }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, string? message, params object?[]? args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[]? args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[]? args) { }
-        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[]? args) { }
+        public static System.IDisposable BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[] args) { throw null; }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception? exception, string? message, params object?[] args) { }
+        public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, string? message, params object?[] args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { }
+        public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { }
     }
     public partial class LoggerExternalScopeProvider : Microsoft.Extensions.Logging.IExternalScopeProvider
     {
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs
index 03202d3e6c37a9..4ef6c371e2b918 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerExtensions.cs
@@ -23,7 +23,7 @@ public static class LoggerExtensions
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
+        public static void LogDebug(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Debug, eventId, exception, message, args);
         }
@@ -36,7 +36,7 @@ public static void LogDebug(this ILogger logger, EventId eventId, Exception? exc
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug(0, "Processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, EventId eventId, string? message, params object?[]? args)
+        public static void LogDebug(this ILogger logger, EventId eventId, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Debug, eventId, message, args);
         }
@@ -49,7 +49,7 @@ public static void LogDebug(this ILogger logger, EventId eventId, string? messag
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, Exception? exception, string? message, params object?[]? args)
+        public static void LogDebug(this ILogger logger, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Debug, exception, message, args);
         }
@@ -61,7 +61,7 @@ public static void LogDebug(this ILogger logger, Exception? exception, string? m
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogDebug("Processing request from {Address}", address)</example>
-        public static void LogDebug(this ILogger logger, string? message, params object?[]? args)
+        public static void LogDebug(this ILogger logger, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Debug, message, args);
         }
@@ -77,7 +77,7 @@ public static void LogDebug(this ILogger logger, string? message, params object?
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
+        public static void LogTrace(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Trace, eventId, exception, message, args);
         }
@@ -90,7 +90,7 @@ public static void LogTrace(this ILogger logger, EventId eventId, Exception? exc
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace(0, "Processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, EventId eventId, string? message, params object?[]? args)
+        public static void LogTrace(this ILogger logger, EventId eventId, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Trace, eventId, message, args);
         }
@@ -103,7 +103,7 @@ public static void LogTrace(this ILogger logger, EventId eventId, string? messag
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, Exception? exception, string? message, params object?[]? args)
+        public static void LogTrace(this ILogger logger, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Trace, exception, message, args);
         }
@@ -115,7 +115,7 @@ public static void LogTrace(this ILogger logger, Exception? exception, string? m
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogTrace("Processing request from {Address}", address)</example>
-        public static void LogTrace(this ILogger logger, string? message, params object?[]? args)
+        public static void LogTrace(this ILogger logger, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Trace, message, args);
         }
@@ -131,7 +131,7 @@ public static void LogTrace(this ILogger logger, string? message, params object?
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
+        public static void LogInformation(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Information, eventId, exception, message, args);
         }
@@ -144,7 +144,7 @@ public static void LogInformation(this ILogger logger, EventId eventId, Exceptio
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation(0, "Processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, EventId eventId, string? message, params object?[]? args)
+        public static void LogInformation(this ILogger logger, EventId eventId, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Information, eventId, message, args);
         }
@@ -157,7 +157,7 @@ public static void LogInformation(this ILogger logger, EventId eventId, string?
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, Exception? exception, string? message, params object?[]? args)
+        public static void LogInformation(this ILogger logger, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Information, exception, message, args);
         }
@@ -169,7 +169,7 @@ public static void LogInformation(this ILogger logger, Exception? exception, str
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogInformation("Processing request from {Address}", address)</example>
-        public static void LogInformation(this ILogger logger, string? message, params object?[]? args)
+        public static void LogInformation(this ILogger logger, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Information, message, args);
         }
@@ -185,7 +185,7 @@ public static void LogInformation(this ILogger logger, string? message, params o
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
+        public static void LogWarning(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Warning, eventId, exception, message, args);
         }
@@ -198,7 +198,7 @@ public static void LogWarning(this ILogger logger, EventId eventId, Exception? e
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning(0, "Processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, EventId eventId, string? message, params object?[]? args)
+        public static void LogWarning(this ILogger logger, EventId eventId, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Warning, eventId, message, args);
         }
@@ -211,7 +211,7 @@ public static void LogWarning(this ILogger logger, EventId eventId, string? mess
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, Exception? exception, string? message, params object?[]? args)
+        public static void LogWarning(this ILogger logger, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Warning, exception, message, args);
         }
@@ -223,7 +223,7 @@ public static void LogWarning(this ILogger logger, Exception? exception, string?
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogWarning("Processing request from {Address}", address)</example>
-        public static void LogWarning(this ILogger logger, string? message, params object?[]? args)
+        public static void LogWarning(this ILogger logger, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Warning, message, args);
         }
@@ -239,7 +239,7 @@ public static void LogWarning(this ILogger logger, string? message, params objec
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
+        public static void LogError(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Error, eventId, exception, message, args);
         }
@@ -252,7 +252,7 @@ public static void LogError(this ILogger logger, EventId eventId, Exception? exc
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError(0, "Processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, EventId eventId, string? message, params object?[]? args)
+        public static void LogError(this ILogger logger, EventId eventId, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Error, eventId, message, args);
         }
@@ -265,7 +265,7 @@ public static void LogError(this ILogger logger, EventId eventId, string? messag
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, Exception? exception, string? message, params object?[]? args)
+        public static void LogError(this ILogger logger, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Error, exception, message, args);
         }
@@ -277,7 +277,7 @@ public static void LogError(this ILogger logger, Exception? exception, string? m
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogError("Processing request from {Address}", address)</example>
-        public static void LogError(this ILogger logger, string? message, params object?[]? args)
+        public static void LogError(this ILogger logger, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Error, message, args);
         }
@@ -293,7 +293,7 @@ public static void LogError(this ILogger logger, string? message, params object?
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical(0, exception, "Error while processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[]? args)
+        public static void LogCritical(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Critical, eventId, exception, message, args);
         }
@@ -306,7 +306,7 @@ public static void LogCritical(this ILogger logger, EventId eventId, Exception?
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical(0, "Processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, EventId eventId, string? message, params object?[]? args)
+        public static void LogCritical(this ILogger logger, EventId eventId, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Critical, eventId, message, args);
         }
@@ -319,7 +319,7 @@ public static void LogCritical(this ILogger logger, EventId eventId, string? mes
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical(exception, "Error while processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, Exception? exception, string? message, params object?[]? args)
+        public static void LogCritical(this ILogger logger, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Critical, exception, message, args);
         }
@@ -331,7 +331,7 @@ public static void LogCritical(this ILogger logger, Exception? exception, string
         /// <param name="message">Format string of the log message in message template format. Example: <c>"User {User} logged in from {Address}"</c></param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
         /// <example>logger.LogCritical("Processing request from {Address}", address)</example>
-        public static void LogCritical(this ILogger logger, string? message, params object?[]? args)
+        public static void LogCritical(this ILogger logger, string? message, params object?[] args)
         {
             logger.Log(LogLevel.Critical, message, args);
         }
@@ -343,7 +343,7 @@ public static void LogCritical(this ILogger logger, string? message, params obje
         /// <param name="logLevel">Entry will be written on this level.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, string? message, params object?[]? args)
+        public static void Log(this ILogger logger, LogLevel logLevel, string? message, params object?[] args)
         {
             logger.Log(logLevel, 0, null, message, args);
         }
@@ -356,7 +356,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, string? message,
         /// <param name="eventId">The event id associated with the log.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, string? message, params object?[]? args)
+        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, string? message, params object?[] args)
         {
             logger.Log(logLevel, eventId, null, message, args);
         }
@@ -369,7 +369,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId,
         /// <param name="exception">The exception to log.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, Exception? exception, string? message, params object?[]? args)
+        public static void Log(this ILogger logger, LogLevel logLevel, Exception? exception, string? message, params object?[] args)
         {
             logger.Log(logLevel, 0, exception, message, args);
         }
@@ -383,7 +383,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, Exception? except
         /// <param name="exception">The exception to log.</param>
         /// <param name="message">Format string of the log message.</param>
         /// <param name="args">An object array that contains zero or more objects to format.</param>
-        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string? message, params object?[]? args)
+        public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string? message, params object?[] args)
         {
             if (logger == null)
             {
@@ -410,7 +410,7 @@ public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId,
         public static IDisposable BeginScope(
             this ILogger logger,
             string messageFormat,
-            params object?[]? args)
+            params object?[] args)
         {
             if (logger == null)
             {

From 5c4193e1e22c5d945ef9900aba8f99249b71595b Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <maryam.ariyan@microsoft.com>
Date: Wed, 4 Nov 2020 10:09:12 -0800
Subject: [PATCH 4/5] using Nullable Annotations, to allow annotations on
 relevant projects, not yet enabled

---
 .../Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs      | 2 ++
 .../src/Microsoft.Extensions.DependencyInjection.csproj         | 1 +
 .../src/Microsoft.Extensions.Http.csproj                        | 1 +
 3 files changed, 4 insertions(+)

diff --git a/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs b/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
index 72af1b65be5c38..1377491df5cfa7 100644
--- a/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
+++ b/src/libraries/Common/src/Extensions/TypeNameHelper/TypeNameHelper.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Text;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.Extensions.Internal
 {
@@ -33,6 +34,7 @@ internal static class TypeNameHelper
             { typeof(ushort), "ushort" }
         };
 
+        [return: NotNullIfNotNull("item")]
         public static string? GetTypeDisplayName(object? item, bool fullName = true)
         {
             return item == null ? null : GetTypeDisplayName(item.GetType(), fullName);
diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj b/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj
index 412c9bef97e48f..58552c053317fa 100644
--- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj
+++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj
@@ -4,6 +4,7 @@
     <TargetFrameworks>$(NetCoreAppCurrent);net461;netstandard2.0;netstandard2.1</TargetFrameworks>
     <!-- Debug IL generation -->
     <ILEmitBackendSaveAssemblies>False</ILEmitBackendSaveAssemblies>
+    <Nullable>Annotations</Nullable>
   </PropertyGroup>
   
   <!-- DesignTimeBuild requires all the TargetFramework Derived Properties to not be present in the first property group. -->
diff --git a/src/libraries/Microsoft.Extensions.Http/src/Microsoft.Extensions.Http.csproj b/src/libraries/Microsoft.Extensions.Http/src/Microsoft.Extensions.Http.csproj
index 6de909a45f7eaf..f8382783997e59 100644
--- a/src/libraries/Microsoft.Extensions.Http/src/Microsoft.Extensions.Http.csproj
+++ b/src/libraries/Microsoft.Extensions.Http/src/Microsoft.Extensions.Http.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
     <EnableDefaultItems>true</EnableDefaultItems>
+    <Nullable>Annotations</Nullable>
   </PropertyGroup>
 
   <ItemGroup>

From 0ad32e68e2c37a25fd513aecc8637ae4803998e3 Mon Sep 17 00:00:00 2001
From: Maryam Ariyan <maryam.ariyan@microsoft.com>
Date: Wed, 4 Nov 2020 18:34:39 -0800
Subject: [PATCH 5/5] formatter not null

---
 .../ref/Microsoft.Extensions.Logging.Abstractions.cs      | 8 ++++----
 .../src/ILogger.cs                                        | 2 +-
 .../src/LogEntry.cs                                       | 2 +-
 .../src/LoggerT.cs                                        | 2 +-
 .../src/NullLogger.cs                                     | 2 +-
 .../src/NullLoggerT.cs                                    | 2 +-
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
index f469c46be86908..e2d403bc7b38cf 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/ref/Microsoft.Extensions.Logging.Abstractions.cs
@@ -30,7 +30,7 @@ public partial interface ILogger
     {
         System.IDisposable BeginScope<TState>(TState state);
         bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel);
-        void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter);
+        void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter);
     }
     public partial interface ILoggerFactory : System.IDisposable
     {
@@ -133,7 +133,7 @@ public readonly partial struct LogEntry<TState>
         private readonly TState _State_k__BackingField;
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
-        public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter) { throw null; }
+        public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { throw null; }
         public string Category { get { throw null; } }
         public Microsoft.Extensions.Logging.EventId EventId { get { throw null; } }
         public System.Exception? Exception { get { throw null; } }
@@ -147,7 +147,7 @@ internal NullLogger() { }
         public static Microsoft.Extensions.Logging.Abstractions.NullLogger Instance { get { throw null; } }
         public System.IDisposable BeginScope<TState>(TState state) { throw null; }
         public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
-        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter) { }
+        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }
     }
     public partial class NullLoggerFactory : Microsoft.Extensions.Logging.ILoggerFactory, System.IDisposable
     {
@@ -170,6 +170,6 @@ public partial class NullLogger<T> : Microsoft.Extensions.Logging.ILogger, Micro
         public NullLogger() { }
         public System.IDisposable BeginScope<TState>(TState state) { throw null; }
         public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; }
-        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string>? formatter) { }
+        public void Log<TState>(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func<TState, System.Exception?, string> formatter) { }
     }
 }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs
index b661d3fcb74db1..15c70258276473 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/ILogger.cs
@@ -20,7 +20,7 @@ public interface ILogger
         /// <param name="exception">The exception related to this entry.</param>
         /// <param name="formatter">Function to create a <see cref="string"/> message of the <paramref name="state"/> and <paramref name="exception"/>.</param>
         /// <typeparam name="TState">The type of the object to be written.</typeparam>
-        void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter);
+        void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter);
 
         /// <summary>
         /// Checks if the given <paramref name="logLevel"/> is enabled.
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
index e935390abd20ac..cebd054da91b77 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogEntry.cs
@@ -19,7 +19,7 @@ public readonly struct LogEntry<TState>
         /// <param name="state">The state for which log is being written.</param>
         /// <param name="exception">The log exception.</param>
         /// <param name="formatter">The formatter.</param>
-        public LogEntry(LogLevel logLevel, string category, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
+        public LogEntry(LogLevel logLevel, string category, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
         {
             LogLevel = logLevel;
             Category = category;
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs
index a1731d0554bcfa..bea9a8bdeff700 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LoggerT.cs
@@ -42,7 +42,7 @@ bool ILogger.IsEnabled(LogLevel logLevel)
         }
 
         /// <inheritdoc />
-        void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
+        void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
         {
             _logger.Log(logLevel, eventId, state, exception, formatter);
         }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs
index 4fc72a30667d69..694ba8de9b1f6e 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLogger.cs
@@ -32,7 +32,7 @@ public bool IsEnabled(LogLevel logLevel)
         }
 
         /// <inheritdoc />
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string>? formatter)
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
         {
         }
     }
diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs
index ee977bf9ae03f8..1d228a33669f9b 100644
--- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs
+++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/NullLoggerT.cs
@@ -31,7 +31,7 @@ public void Log<TState>(
             EventId eventId,
             TState state,
             Exception? exception,
-            Func<TState, Exception?, string>? formatter)
+            Func<TState, Exception?, string> formatter)
         {
         }