guard against null

src/Serilog/Capturing/PropertyValueConverter.cs

@@ -49,8 +49,8 @@ partial class PropertyValueConverter : ILogEventPropertyFactory, ILogEventProper
         IEnumerable<IDestructuringPolicy> additionalDestructuringPolicies,
         bool propagateExceptions)
     {
-        if (additionalScalarTypes == null) throw new ArgumentNullException(nameof(additionalScalarTypes));
-        if (additionalDestructuringPolicies == null) throw new ArgumentNullException(nameof(additionalDestructuringPolicies));
+        Guard.AgainstNull(additionalScalarTypes);
+        Guard.AgainstNull(additionalDestructuringPolicies);
         if (maximumDestructuringDepth < 0) throw new ArgumentOutOfRangeException(nameof(maximumDestructuringDepth));
         if (maximumStringLength < 2) throw new ArgumentOutOfRangeException(nameof(maximumStringLength));
         if (maximumCollectionCount < 1) throw new ArgumentOutOfRangeException(nameof(maximumCollectionCount));

src/Serilog/Configuration/LoggerDestructuringConfiguration.cs

@@ -34,12 +34,12 @@ public class LoggerDestructuringConfiguration
         Action<int> setMaximumStringLength,
         Action<int> setMaximumCollectionCount)
     {
-        _loggerConfiguration = loggerConfiguration ?? throw new ArgumentNullException(nameof(loggerConfiguration));
-        _addScalar = addScalar ?? throw new ArgumentNullException(nameof(addScalar));
-        _addPolicy = addPolicy ?? throw new ArgumentNullException(nameof(addPolicy));
-        _setMaximumDepth = setMaximumDepth ?? throw new ArgumentNullException(nameof(setMaximumDepth));
-        _setMaximumStringLength = setMaximumStringLength ?? throw new ArgumentNullException(nameof(setMaximumStringLength));
-        _setMaximumCollectionCount = setMaximumCollectionCount ?? throw new ArgumentNullException(nameof(setMaximumCollectionCount));
+        _loggerConfiguration = Guard.AgainstNull(loggerConfiguration);
+        _addScalar = Guard.AgainstNull(addScalar);
+        _addPolicy = Guard.AgainstNull(addPolicy);
+        _setMaximumDepth = Guard.AgainstNull(setMaximumDepth);
+        _setMaximumStringLength = Guard.AgainstNull(setMaximumStringLength);
+        _setMaximumCollectionCount = Guard.AgainstNull(setMaximumCollectionCount);
     }
 
     /// <summary>
@@ -51,7 +51,7 @@ public class LoggerDestructuringConfiguration
     /// <exception cref="ArgumentNullException">When <paramref name="scalarType"/> is <code>null</code></exception>
     public LoggerConfiguration AsScalar(Type scalarType)
     {
-        if (scalarType == null) throw new ArgumentNullException(nameof(scalarType));
+        Guard.AgainstNull(scalarType);
 
         _addScalar(scalarType);
         return _loggerConfiguration;
@@ -75,7 +75,7 @@ public LoggerConfiguration AsScalar(Type scalarType)
     // ReSharper disable once MemberCanBePrivate.Global
     public LoggerConfiguration With(params IDestructuringPolicy[] destructuringPolicies)
     {
-        if (destructuringPolicies == null) throw new ArgumentNullException(nameof(destructuringPolicies));
+        Guard.AgainstNull(destructuringPolicies);
 
         foreach (var destructuringPolicy in destructuringPolicies)
         {
@@ -108,7 +108,7 @@ public LoggerConfiguration With<TDestructuringPolicy>()
     /// <exception cref="ArgumentNullException">When <paramref name="transformation"/> is <code>null</code></exception>
     public LoggerConfiguration ByTransforming<TValue>(Func<TValue, object> transformation)
     {
-        if (transformation == null) throw new ArgumentNullException(nameof(transformation));
+        Guard.AgainstNull(transformation);
 
         var policy = new ProjectedDestructuringPolicy(t => t == typeof(TValue),
             o => transformation((TValue)o));
@@ -132,8 +132,8 @@ public LoggerConfiguration ByTransforming<TValue>(Func<TValue, object> transform
         Func<Type, bool> predicate,
         Func<TValue, object> transformation)
     {
-        if (predicate == null) throw new ArgumentNullException(nameof(predicate));
-        if (transformation == null) throw new ArgumentNullException(nameof(transformation));
+        Guard.AgainstNull(predicate);
+        Guard.AgainstNull(transformation);
 
         var policy = new ProjectedDestructuringPolicy(predicate,
             o => transformation((TValue)o));

src/Serilog/Configuration/LoggerEnrichmentConfiguration.cs

@@ -26,8 +26,8 @@ public class LoggerEnrichmentConfiguration
         LoggerConfiguration loggerConfiguration,
         Action<ILogEventEnricher> addEnricher)
     {
-        _loggerConfiguration = loggerConfiguration ?? throw new ArgumentNullException(nameof(loggerConfiguration));
-        _addEnricher = addEnricher ?? throw new ArgumentNullException(nameof(addEnricher));
+        _loggerConfiguration = Guard.AgainstNull(loggerConfiguration);
+        _addEnricher = Guard.AgainstNull(addEnricher);
     }
 
     /// <summary>
@@ -41,11 +41,11 @@ public class LoggerEnrichmentConfiguration
     /// <exception cref="ArgumentException">When any element of <paramref name="enrichers"/> is <code>null</code></exception>
     public LoggerConfiguration With(params ILogEventEnricher[] enrichers)
     {
-        if (enrichers == null) throw new ArgumentNullException(nameof(enrichers));
+        Guard.AgainstNull(enrichers);
 
         foreach (var logEventEnricher in enrichers)
         {
-            if (logEventEnricher == null)  throw new ArgumentException("Null enricher is not allowed.");
+            Guard.AgainstNull(logEventEnricher);
 
             _addEnricher(logEventEnricher);
         }
@@ -96,8 +96,8 @@ public LoggerConfiguration WithProperty(string name, object value, bool destruct
     /// <exception cref="ArgumentNullException">When <paramref name="configureEnricher"/> is <code>null</code></exception>
     public LoggerConfiguration When(Func<LogEvent, bool> condition, Action<LoggerEnrichmentConfiguration> configureEnricher)
     {
-        if (condition == null) throw new ArgumentNullException(nameof(condition));
-        if (configureEnricher == null) throw new ArgumentNullException(nameof(configureEnricher));
+        Guard.AgainstNull(condition);
+        Guard.AgainstNull(configureEnricher);
 
         return Wrap(this, e => new ConditionalEnricher(e, condition), configureEnricher);
     }
@@ -113,7 +113,7 @@ public LoggerConfiguration When(Func<LogEvent, bool> condition, Action<LoggerEnr
     /// <exception cref="ArgumentNullException">When <paramref name="configureEnricher"/> is <code>null</code></exception>
     public LoggerConfiguration AtLevel(LogEventLevel enrichFromLevel, Action<LoggerEnrichmentConfiguration> configureEnricher)
     {
-        if (configureEnricher == null) throw new ArgumentNullException(nameof(configureEnricher));
+        Guard.AgainstNull(configureEnricher);
 
         return Wrap(this, e => new ConditionalEnricher(e, le => le.Level >= enrichFromLevel), configureEnricher);
     }
@@ -129,7 +129,7 @@ public LoggerConfiguration AtLevel(LogEventLevel enrichFromLevel, Action<LoggerE
     /// <exception cref="ArgumentNullException">When <paramref name="configureEnricher"/> is <code>null</code></exception>
     public LoggerConfiguration AtLevel(LoggingLevelSwitch levelSwitch, Action<LoggerEnrichmentConfiguration> configureEnricher)
     {
-        if (configureEnricher == null) throw new ArgumentNullException(nameof(configureEnricher));
+        Guard.AgainstNull(configureEnricher);
 
         return Wrap(this, e => new ConditionalEnricher(e, le => le.Level >= levelSwitch.MinimumLevel), configureEnricher);
     }
@@ -150,9 +150,9 @@ public LoggerConfiguration AtLevel(LoggingLevelSwitch levelSwitch, Action<Logger
         Func<ILogEventEnricher, ILogEventEnricher> wrapEnricher,
         Action<LoggerEnrichmentConfiguration> configureWrappedEnricher)
     {
-        if (loggerEnrichmentConfiguration == null) throw new ArgumentNullException(nameof(loggerEnrichmentConfiguration));
-        if (wrapEnricher == null) throw new ArgumentNullException(nameof(wrapEnricher));
-        if (configureWrappedEnricher == null) throw new ArgumentNullException(nameof(configureWrappedEnricher));
+        Guard.AgainstNull(loggerEnrichmentConfiguration);
+        Guard.AgainstNull(wrapEnricher);
+        Guard.AgainstNull(configureWrappedEnricher);
 
         var enrichersToWrap = new List<ILogEventEnricher>();
 

src/Serilog/Configuration/LoggerFilterConfiguration.cs

@@ -26,8 +26,8 @@ public class LoggerFilterConfiguration
         LoggerConfiguration loggerConfiguration,
         Action<ILogEventFilter> addFilter)
     {
-        _loggerConfiguration = loggerConfiguration ?? throw new ArgumentNullException(nameof(loggerConfiguration));
-        _addFilter = addFilter ?? throw new ArgumentNullException(nameof(addFilter));
+        _loggerConfiguration = Guard.AgainstNull(loggerConfiguration);
+        _addFilter = Guard.AgainstNull(addFilter);
     }
 
     /// <summary>
@@ -39,7 +39,7 @@ public class LoggerFilterConfiguration
     /// <exception cref="ArgumentException">When any element of <paramref name="filters"/> is <code>null</code></exception>
     public LoggerConfiguration With(params ILogEventFilter[] filters)
     {
-        if (filters == null) throw new ArgumentNullException(nameof(filters));
+        Guard.AgainstNull(filters);
 
         foreach (var logEventFilter in filters)
         {

src/Serilog/Configuration/LoggerMinimumLevelConfiguration.cs

@@ -27,10 +27,10 @@ public class LoggerMinimumLevelConfiguration
     internal LoggerMinimumLevelConfiguration(LoggerConfiguration loggerConfiguration, Action<LogEventLevel> setMinimum,
         Action<LoggingLevelSwitch> setLevelSwitch, Action<string, LoggingLevelSwitch> addOverride)
     {
-        _loggerConfiguration = loggerConfiguration ?? throw new ArgumentNullException(nameof(loggerConfiguration));
-        _setMinimum = setMinimum ?? throw new ArgumentNullException(nameof(setMinimum));
+        _loggerConfiguration = Guard.AgainstNull(loggerConfiguration);
+        _setMinimum = Guard.AgainstNull(setMinimum);
         _setLevelSwitch = setLevelSwitch;
-        _addOverride = addOverride ?? throw new ArgumentNullException(nameof(addOverride));
+        _addOverride = Guard.AgainstNull(addOverride);
     }
 
     /// <summary>
@@ -53,7 +53,7 @@ public LoggerConfiguration Is(LogEventLevel minimumLevel)
     // ReSharper disable once UnusedMethodReturnValue.Global
     public LoggerConfiguration ControlledBy(LoggingLevelSwitch levelSwitch)
     {
-        if (levelSwitch == null) throw new ArgumentNullException(nameof(levelSwitch));
+        Guard.AgainstNull(levelSwitch);
 
         _setLevelSwitch(levelSwitch);
         return _loggerConfiguration;
@@ -113,8 +113,8 @@ public LoggerConfiguration ControlledBy(LoggingLevelSwitch levelSwitch)
     /// <exception cref="ArgumentNullException">When <paramref name="levelSwitch"/> is <code>null</code></exception>
     public LoggerConfiguration Override(string source, LoggingLevelSwitch levelSwitch)
     {
-        if (source == null) throw new ArgumentNullException(nameof(source));
-        if (levelSwitch == null) throw new ArgumentNullException(nameof(levelSwitch));
+        Guard.AgainstNull(source);
+        Guard.AgainstNull(levelSwitch);
 
         var trimmed = source.Trim();
         if (trimmed.Length == 0) throw new ArgumentException($"A source {nameof(source)} must be provided.", nameof(source));

src/Serilog/Configuration/LoggerSettingsConfiguration.cs

@@ -23,7 +23,7 @@ public class LoggerSettingsConfiguration
 
     internal LoggerSettingsConfiguration(LoggerConfiguration loggerConfiguration)
     {
-        _loggerConfiguration = loggerConfiguration ?? throw new ArgumentNullException(nameof(loggerConfiguration));
+        _loggerConfiguration = Guard.AgainstNull(loggerConfiguration);
     }
 
     /// <summary>
@@ -33,7 +33,7 @@ internal LoggerSettingsConfiguration(LoggerConfiguration loggerConfiguration)
     /// <exception cref="ArgumentNullException">When <paramref name="settings"/> is <code>null</code></exception>
     public LoggerConfiguration Settings(ILoggerSettings settings)
     {
-        if (settings == null) throw new ArgumentNullException(nameof(settings));
+        Guard.AgainstNull(settings);
 
         settings.Configure(_loggerConfiguration);
         return _loggerConfiguration;
@@ -48,7 +48,7 @@ public LoggerConfiguration Settings(ILoggerSettings settings)
     /// <exception cref="ArgumentNullException">When <paramref name="settings"/> is <code>null</code></exception>
     public LoggerConfiguration KeyValuePairs(IEnumerable<KeyValuePair<string, string>> settings)
     {
-        if (settings == null) throw new ArgumentNullException(nameof(settings));
+        Guard.AgainstNull(settings);
 
         var uniqueSettings = new Dictionary<string, string>();
         foreach (var kvp in settings)

src/Serilog/Configuration/LoggerSinkConfiguration.cs

@@ -24,8 +24,8 @@ public class LoggerSinkConfiguration
 
     internal LoggerSinkConfiguration(LoggerConfiguration loggerConfiguration, Action<ILogEventSink> addSink)
     {
-        _loggerConfiguration = loggerConfiguration ?? throw new ArgumentNullException(nameof(loggerConfiguration));
-        _addSink = addSink ?? throw new ArgumentNullException(nameof(addSink));
+        _loggerConfiguration = Guard.AgainstNull(loggerConfiguration);
+        _addSink = Guard.AgainstNull(addSink);
     }
 
     /// <summary>
@@ -113,7 +113,7 @@ internal LoggerSinkConfiguration(LoggerConfiguration loggerConfiguration, Action
         LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
         LoggingLevelSwitch? levelSwitch = null)
     {
-        if (configureLogger == null) throw new ArgumentNullException(nameof(configureLogger));
+        Guard.AgainstNull(configureLogger);
 
         var lc = new LoggerConfiguration().MinimumLevel.Is(LevelAlias.Minimum);
         configureLogger(lc);
@@ -145,7 +145,7 @@ internal LoggerSinkConfiguration(LoggerConfiguration loggerConfiguration, Action
         ILogger logger,
         LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum)
     {
-        if (logger == null) throw new ArgumentNullException(nameof(logger));
+        Guard.AgainstNull(logger);
 
         if (logger is Logger {HasOverrideMap: true})
         {
@@ -168,8 +168,8 @@ internal LoggerSinkConfiguration(LoggerConfiguration loggerConfiguration, Action
     /// <exception cref="ArgumentNullException">When <paramref name="configureSink"/> is <code>null</code></exception>
     public LoggerConfiguration Conditional(Func<LogEvent, bool> condition, Action<LoggerSinkConfiguration> configureSink)
     {
-        if (condition == null) throw new ArgumentNullException(nameof(condition));
-        if (configureSink == null) throw new ArgumentNullException(nameof(configureSink));
+        Guard.AgainstNull(condition);
+        Guard.AgainstNull(configureSink);
 
         // Level aliases and so on don't need to be accepted here; if the user wants both a condition and leveling, they
         // can specify `restrictedToMinimumLevel` etc in the wrapped sink configuration.
@@ -215,9 +215,9 @@ public LoggerConfiguration Conditional(Func<LogEvent, bool> condition, Action<Lo
         LogEventLevel restrictedToMinimumLevel,
         LoggingLevelSwitch? levelSwitch)
     {
-        if (loggerSinkConfiguration == null) throw new ArgumentNullException(nameof(loggerSinkConfiguration));
-        if (wrapSink == null) throw new ArgumentNullException(nameof(wrapSink));
-        if (configureWrappedSink == null) throw new ArgumentNullException(nameof(configureWrappedSink));
+        Guard.AgainstNull(loggerSinkConfiguration);
+        Guard.AgainstNull(wrapSink);
+        Guard.AgainstNull(configureWrappedSink);
 
         var sinksToWrap = new List<ILogEventSink>();
 

src/Serilog/Context/EnricherStack.cs

@@ -31,7 +31,7 @@ class EnricherStack: IEnumerable<ILogEventEnricher>
 
     EnricherStack(EnricherStack under, ILogEventEnricher top)
     {
-        _under = under ?? throw new ArgumentNullException(nameof(under));
+        _under = Guard.AgainstNull(under);
         Count = under.Count + 1;
         _top = top;
     }

src/Serilog/Context/LogContext.cs

@@ -75,7 +75,7 @@ public static IDisposable PushProperty(string name, object value, bool destructu
     /// <exception cref="ArgumentNullException">When <paramref name="enricher"/> is <code>null</code></exception>
     public static IDisposable Push(ILogEventEnricher enricher)
     {
-        if (enricher == null) throw new ArgumentNullException(nameof(enricher));
+        Guard.AgainstNull(enricher);
 
         var stack = GetOrCreateEnricherStack();
         var bookmark = new ContextStackBookmark(stack);
@@ -97,7 +97,7 @@ public static IDisposable Push(ILogEventEnricher enricher)
     /// <exception cref="ArgumentNullException">When <paramref name="enrichers"/> is <code>null</code></exception>
     public static IDisposable Push(params ILogEventEnricher[] enrichers)
     {
-        if (enrichers == null) throw new ArgumentNullException(nameof(enrichers));
+        Guard.AgainstNull(enrichers);
 
         var stack = GetOrCreateEnricherStack();
         var bookmark = new ContextStackBookmark(stack);

src/Serilog/Core/Enrichers/ConditionalEnricher.cs

@@ -21,8 +21,8 @@ class ConditionalEnricher : ILogEventEnricher, IDisposable
 
     public ConditionalEnricher(ILogEventEnricher wrapped, Func<LogEvent, bool> condition)
     {
-        _wrapped = wrapped ?? throw new ArgumentNullException(nameof(wrapped));
-        _condition = condition ?? throw new ArgumentNullException(nameof(condition));
+        _wrapped = Guard.AgainstNull(wrapped);
+        _condition = Guard.AgainstNull(condition);
     }
 
     public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)

src/Serilog/Core/Enrichers/FixedPropertyEnricher.cs

@@ -27,7 +27,7 @@ public FixedPropertyEnricher(in EventProperty eventProperty)
 
     public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
     {
-        if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
+        Guard.AgainstNull(logEvent);
 
         logEvent.AddPropertyIfAbsent(_eventProperty);
     }

src/Serilog/Core/Enrichers/PropertyEnricher.cs

@@ -51,8 +51,8 @@ public PropertyEnricher(string name, object? value, bool destructureObjects = fa
     /// <exception cref="ArgumentNullException">When <paramref name="propertyFactory"/> is <code>null</code></exception>
     public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
     {
-        if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
-        if (propertyFactory == null) throw new ArgumentNullException(nameof(propertyFactory));
+        Guard.AgainstNull(logEvent);
+        Guard.AgainstNull(propertyFactory);
 
         var property = propertyFactory.CreateProperty(_name, _value, _destructureObjects);
         logEvent.AddPropertyIfAbsent(property);

src/Serilog/Core/Enrichers/SafeAggregateEnricher.cs

@@ -20,7 +20,7 @@ class SafeAggregateEnricher : ILogEventEnricher
 
     public SafeAggregateEnricher(IEnumerable<ILogEventEnricher> enrichers)
     {
-        if (enrichers == null) throw new ArgumentNullException(nameof(enrichers));
+        Guard.AgainstNull(enrichers);
 
         _enrichers = enrichers.ToArray();
     }

src/Serilog/Core/Filters/DelegateFilter.cs

@@ -20,12 +20,12 @@ class DelegateFilter : ILogEventFilter
 
     public DelegateFilter(Func<LogEvent, bool> isEnabled)
     {
-        _isEnabled = isEnabled ?? throw new ArgumentNullException(nameof(isEnabled));
+        _isEnabled = Guard.AgainstNull(isEnabled);
     }
 
     public bool IsEnabled(LogEvent logEvent)
     {
-        if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
+        Guard.AgainstNull(logEvent);
         return _isEnabled(logEvent);
     }
 }

src/Serilog/Core/LevelOverrideMap.cs

@@ -45,7 +45,7 @@ public LevelOverride(string context, LoggingLevelSwitch levelSwitch)
         LogEventLevel defaultMinimumLevel,
         LoggingLevelSwitch? defaultLevelSwitch)
     {
-        if (overrides == null) throw new ArgumentNullException(nameof(overrides));
+        Guard.AgainstNull(overrides);
 
         _defaultLevelSwitch = defaultLevelSwitch;
         _defaultMinimumLevel = defaultLevelSwitch != null ? LevelAlias.Minimum : defaultMinimumLevel;

src/Serilog/Core/Logger.cs

@@ -379,7 +379,7 @@ public void Write(LogEvent logEvent)
 
     void ILogEventSink.Emit(LogEvent logEvent)
     {
-        if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
+        Guard.AgainstNull(logEvent);
 
         // Bypasses the level check so that child loggers
         // using this one as a sink can increase verbosity.