#124 fixed more nullable Warnings when targeting net8.0

Author: FreeAndNil

.editorconfig

@@ -132,4 +132,15 @@ csharp_style_prefer_not_pattern = true:suggestion
 csharp_style_prefer_extended_property_pattern = true:suggestion
 csharp_style_var_for_built_in_types = false:silent
 csharp_style_var_when_type_is_apparent = false:silent
-csharp_style_var_elsewhere = false:silent
+csharp_style_var_elsewhere = false:silent
+
+# SYSLIB0003: Type or member is obsolete
+dotnet_diagnostic.SYSLIB0003.severity = none
+# SYSLIB0005: Type or member is obsolete
+dotnet_diagnostic.SYSLIB0005.severity = none
+# SYSLIB0014: Type or member is obsolete
+dotnet_diagnostic.SYSLIB0014.severity = none
+# SYSLIB0050: Type or member is obsolete
+dotnet_diagnostic.SYSLIB0050.severity = none
+# SYSLIB0051: Type or member is obsolete
+dotnet_diagnostic.SYSLIB0051.severity = none

src/log4net/Appender/AdoNetAppender.cs

@@ -390,30 +390,28 @@ protected override void SendBuffer(LoggingEvent[] events)
         {
           // Create transaction
           // NJC - Do this on 2 lines because it can confuse the debugger
-          using (IDbTransaction dbTran = Connection.BeginTransaction())
+          using IDbTransaction dbTran = Connection.BeginTransaction();
+          try
+          {
+            SendBuffer(dbTran, events);
+
+            // commit transaction
+            dbTran.Commit();
+          }
+          catch (Exception ex)
           {
+            // rollback the transaction
             try
             {
-              SendBuffer(dbTran, events);
-
-              // commit transaction
-              dbTran.Commit();
+              dbTran.Rollback();
             }
-            catch (Exception ex)
+            catch (Exception)
             {
-              // rollback the transaction
-              try
-              {
-                dbTran.Rollback();
-              }
-              catch (Exception)
-              {
-                // Ignore exception
-              }
-
-              // Can't insert into the database. That's a bad thing
-              ErrorHandler.Error("Exception while writing to database", ex);
+              // Ignore exception
             }
+
+            // Can't insert into the database. That's a bad thing
+            ErrorHandler.Error("Exception while writing to database", ex);
           }
         }
         else
@@ -454,70 +452,66 @@ protected virtual void SendBuffer(IDbTransaction? dbTran, LoggingEvent[] events)
     {
       if (!string.IsNullOrWhiteSpace(CommandText))
       {
-        using (IDbCommand dbCmd = Connection!.CreateCommand())
+        using IDbCommand dbCmd = Connection!.CreateCommand();
+        // Set the command string
+        dbCmd.CommandText = CommandText;
+
+        // Set the command type
+        dbCmd.CommandType = CommandType;
+        // Send buffer using the prepared command object
+        if (dbTran is not null)
         {
-          // Set the command string
-          dbCmd.CommandText = CommandText;
+          dbCmd.Transaction = dbTran;
+        }
 
-          // Set the command type
-          dbCmd.CommandType = CommandType;
-          // Send buffer using the prepared command object
+        try
+        {
+          // prepare the command, which is significantly faster
+          Prepare(dbCmd);
+        }
+        catch (Exception)
+        {
           if (dbTran is not null)
           {
-            dbCmd.Transaction = dbTran;
-          }
-
-          try
-          {
-            // prepare the command, which is significantly faster
-            Prepare(dbCmd);
+            // rethrow exception in transaction mode, cuz now transaction is in failed state
+            throw;
           }
-          catch (Exception)
-          {
-            if (dbTran is not null)
-            {
-              // rethrow exception in transaction mode, cuz now transaction is in failed state
-              throw;
-            }
 
-            // ignore prepare exceptions as they can happen without affecting actual logging, eg on npgsql
-          }
+          // ignore prepare exceptions as they can happen without affecting actual logging, eg on npgsql
+        }
 
-          // run for all events
-          foreach (LoggingEvent e in events)
+        // run for all events
+        foreach (LoggingEvent e in events)
+        {
+          // No need to clear dbCmd.Parameters, just use existing.
+          // Set the parameter values
+          foreach (AdoNetAppenderParameter param in m_parameters)
           {
-            // No need to clear dbCmd.Parameters, just use existing.
-            // Set the parameter values
-            foreach (AdoNetAppenderParameter param in m_parameters)
-            {
-              param.FormatValue(dbCmd, e);
-            }
-
-            // Execute the query
-            dbCmd.ExecuteNonQuery();
+            param.FormatValue(dbCmd, e);
           }
+
+          // Execute the query
+          dbCmd.ExecuteNonQuery();
         }
       }
       else
       {
         // create a new command
-        using (IDbCommand dbCmd = Connection!.CreateCommand())
+        using IDbCommand dbCmd = Connection!.CreateCommand();
+        if (dbTran is not null)
         {
-          if (dbTran is not null)
-          {
-            dbCmd.Transaction = dbTran;
-          }
-          // run for all events
-          foreach (LoggingEvent e in events)
-          {
-            // Get the command text from the Layout
-            string logStatement = GetLogStatement(e);
+          dbCmd.Transaction = dbTran;
+        }
+        // run for all events
+        foreach (LoggingEvent e in events)
+        {
+          // Get the command text from the Layout
+          string logStatement = GetLogStatement(e);
 
-            LogLog.Debug(declaringType, $"LogStatement [{logStatement}]");
+          LogLog.Debug(declaringType, $"LogStatement [{logStatement}]");
 
-            dbCmd.CommandText = logStatement;
-            dbCmd.ExecuteNonQuery();
-          }
+          dbCmd.CommandText = logStatement;
+          dbCmd.ExecuteNonQuery();
         }
       }
     }
@@ -557,7 +551,7 @@ protected virtual string GetLogStatement(LoggingEvent logEvent)
       }
       else
       {
-        using StringWriter writer = new StringWriter(System.Globalization.CultureInfo.InvariantCulture);
+        using StringWriter writer = new(System.Globalization.CultureInfo.InvariantCulture);
         Layout.Format(writer, logEvent);
         return writer.ToString();
       }
@@ -574,7 +568,7 @@ protected virtual string GetLogStatement(LoggingEvent logEvent)
     /// <returns>An <see cref="IDbConnection"/> instance with a valid connection string.</returns>
     protected virtual IDbConnection CreateConnection(Type connectionType, string connectionString)
     {
-      IDbConnection connection = (IDbConnection)Activator.CreateInstance(connectionType);
+      IDbConnection connection = Activator.CreateInstance(connectionType).EnsureIs<IDbConnection>();
       connection.ConnectionString = connectionString;
       return connection;
     }
@@ -587,7 +581,7 @@ protected virtual IDbConnection CreateConnection(Type connectionType, string con
     /// <returns>A connection string used to connect to the database.</returns>
     protected virtual string ResolveConnectionString(out string connectionStringContext)
     {
-      if (ConnectionString is not null && ConnectionString.Length > 0)
+      if (ConnectionString is string { Length: > 0 })
       {
         connectionStringContext = "ConnectionString";
         return ConnectionString;
@@ -607,7 +601,7 @@ protected virtual string ResolveConnectionString(out string connectionStringCont
         }
       }
 
-      if (AppSettingsKey is not null && AppSettingsKey.Length > 0)
+      if (AppSettingsKey is string { Length: > 0 })
       {
         connectionStringContext = "AppSettingsKey";
         string? appSettingsConnectionString = SystemInfo.GetAppSetting(AppSettingsKey);
@@ -643,7 +637,7 @@ protected virtual Type ResolveConnectionType()
       {
         if (SystemInfo.GetTypeFromString(ConnectionType, true, false) is Type t)
         {
-            return t;
+          return t;
         }
         throw new InvalidOperationException($"Connection type {ConnectionType} was not found in any assembly");
       }
@@ -931,7 +925,7 @@ public virtual void Prepare(IDbCommand command)
     public virtual void FormatValue(IDbCommand command, LoggingEvent loggingEvent)
     {
       // Lookup the parameter
-      IDbDataParameter param = (IDbDataParameter)command.Parameters[ParameterName];
+      IDbDataParameter param = (IDbDataParameter)command.Parameters[ParameterName.EnsureNotNull()];
 
       // Format the value
       object? formattedValue = Layout?.Format(loggingEvent);

src/log4net/Appender/AppenderCollection.cs

@@ -51,14 +51,7 @@ public interface IAppenderCollectionEnumerator : IEnumerator<IAppender>
     /// An <c>AppenderCollection</c> wrapper that is read-only.
     /// </returns>
     public static AppenderCollection ReadOnly(AppenderCollection list)
-    {
-      if (list is null)
-      {
-        throw new ArgumentNullException(nameof(list));
-      }
-
-      return new ReadOnlyAppenderCollection(list);
-    }
+      => new ReadOnlyAppenderCollection(list.EnsureNotNull());
 
     /// <summary>
     /// An empty readonly static AppenderCollection
@@ -69,10 +62,7 @@ public static AppenderCollection ReadOnly(AppenderCollection list)
     /// Initializes a new instance of the <c>AppenderCollection</c> class
     /// that is empty and has the default initial capacity.
     /// </summary>
-    public AppenderCollection()
-    {
-      m_array = new IAppender[DEFAULT_CAPACITY];
-    }
+    public AppenderCollection() => m_array = new IAppender[DEFAULT_CAPACITY];
 
     /// <summary>
     /// Initializes a new instance of the <c>AppenderCollection</c> class
@@ -81,10 +71,7 @@ public AppenderCollection()
     /// <param name="capacity">
     /// The number of elements that the new <c>AppenderCollection</c> is initially capable of storing.
     /// </param>
-    public AppenderCollection(int capacity)
-    {
-      m_array = new IAppender[capacity];
-    }
+    public AppenderCollection(int capacity) => m_array = new IAppender[capacity];
 
     /// <summary>
     /// Initializes a new instance of the <c>AppenderCollection</c> class
@@ -530,10 +517,13 @@ void ICollection.CopyTo(Array array, int start)
       }
     }
 
-    object IList.this[int i]
+    object? IList.this[int i]
     {
       get => this[i];
-      set => this[i] = (IAppender)value;
+      set
+      {
+        this[i] = value.EnsureIs<IAppender>();
+      }
     }
 
     int IList.Add(object? x)
@@ -556,11 +546,11 @@ bool IList.Contains(object? x)
       return false;
     }
 
-    int IList.IndexOf(object x) => IndexOf((IAppender)x);
+    int IList.IndexOf(object? x) => IndexOf(x.EnsureIs<IAppender>());
 
-    void IList.Insert(int pos, object x) => Insert(pos, (IAppender)x);
+    void IList.Insert(int pos, object? x) => Insert(pos, x.EnsureIs<IAppender>());
 
-    void IList.Remove(object x) => Remove((IAppender)x);
+    void IList.Remove(object? x) => Remove(x.EnsureIs<IAppender>());
 
     void IList.RemoveAt(int pos) => RemoveAt(pos);
 

src/log4net/Appender/FileAppender.cs

@@ -62,11 +62,11 @@ namespace log4net.Appender
   /// <para>
   /// The <see cref="FileAppender"/> supports pluggable file locking models via
   /// the <see cref="LockingModel"/> property.
-  /// The default behavior, implemented by <see cref="FileAppender.ExclusiveLock"/> 
+  /// The default behavior, implemented by <see cref="ExclusiveLock"/> 
   /// is to obtain an exclusive write lock on the file until this appender is closed.
   /// The alternative models only hold a
-  /// write lock while the appender is writing a logging event (<see cref="FileAppender.MinimalLock"/>)
-  /// or synchronize by using a named system-wide Mutex (<see cref="FileAppender.InterProcessLock"/>).
+  /// write lock while the appender is writing a logging event (<see cref="MinimalLock"/>)
+  /// or synchronize by using a named system-wide Mutex (<see cref="InterProcessLock"/>).
   /// </para>
   /// <para>
   /// All locking strategies have issues and you should seriously consider using a different strategy that
@@ -111,15 +111,7 @@ private LockStateException(SerializationInfo info, StreamingContext context) : b
       private readonly LockingModelBase m_lockingModel;
       private int m_lockLevel;
 
-      public LockingStream(LockingModelBase locking)
-      {
-        if (locking is null)
-        {
-          throw new ArgumentNullException(nameof(locking));
-        }
-
-        m_lockingModel = locking;
-      }
+      public LockingStream(LockingModelBase locking) => m_lockingModel = locking.EnsureNotNull();
 
       protected override void Dispose(bool disposing)
       {
@@ -479,7 +471,7 @@ public override void CloseFile()
       /// </remarks>
       public override Stream? AcquireLock()
       {
-          return m_stream;
+        return m_stream;
       }
 
       /// <summary>
@@ -519,7 +511,7 @@ public override void OnClose()
     /// <para>
     /// Opens the file once for each <see cref="AcquireLock"/>/<see cref="ReleaseLock"/> cycle, 
     /// thus holding the lock for the minimal amount of time. This method of locking
-    /// is considerably slower than <see cref="FileAppender.ExclusiveLock"/> but allows 
+    /// is considerably slower than <see cref="ExclusiveLock"/> but allows 
     /// other processes to move/delete the log file whilst logging continues.
     /// </para>
     /// </remarks>
@@ -963,7 +955,7 @@ public virtual string? File
     /// </value>
     /// <remarks>
     /// <para>
-    /// The default encoding set is <see cref="System.Text.Encoding.Default"/>
+    /// The default encoding set is <see cref="Encoding.Default"/>
     /// which is the encoding for the system's current ANSI code page.
     /// </para>
     /// </remarks>
@@ -986,26 +978,27 @@ public virtual string? File
     public SecurityContext? SecurityContext { get; set; }
 
     /// <summary>
-    /// Gets or sets the <see cref="FileAppender.LockingModel"/> used to handle locking of the file.
+    /// Gets or sets the <see cref="LockingModel"/> used to handle locking of the file.
     /// </summary>
     /// <value>
-    /// The <see cref="FileAppender.LockingModel"/> used to lock the file.
+    /// The <see cref="LockingModel"/> used to lock the file.
     /// </value>
     /// <remarks>
     /// <para>
-    /// Gets or sets the <see cref="FileAppender.LockingModel"/> used to handle locking of the file.
+    /// Gets or sets the <see cref="LockingModel"/> used to handle locking of the file.
     /// </para>
     /// <para>
-    /// There are three built in locking models, <see cref="FileAppender.ExclusiveLock"/>, <see cref="FileAppender.MinimalLock"/> and <see cref="FileAppender.InterProcessLock"/> .
+    /// There are three built in locking models, <see cref="ExclusiveLock"/>, <see cref="MinimalLock"/> and <see cref="InterProcessLock"/> .
     /// The first locks the file from the start of logging to the end, the 
     /// second locks only for the minimal amount of time when logging each message
     /// and the last synchronizes processes using a named system-wide Mutex.
     /// </para>
     /// <para>
-    /// The default locking model is the <see cref="FileAppender.ExclusiveLock"/>.
+    /// The default locking model is the <see cref="ExclusiveLock"/>.
     /// </para>
     /// </remarks>
-    public LockingModelBase LockingModel { get; set; } = (LockingModelBase)Activator.CreateInstance(defaultLockingModelType);
+    public LockingModelBase LockingModel { get; set; }
+      = Activator.CreateInstance(defaultLockingModelType).EnsureIs<LockingModelBase>();
 
     /// <summary>
     /// Activate the options on the file appender.