Restore removed API from Extensions

src/libraries/Microsoft.Extensions.Caching.Memory/ref/Microsoft.Extensions.Caching.Memory.cs

@@ -42,6 +42,9 @@ public partial class MemoryCacheOptions : Microsoft.Extensions.Options.IOptions<
  public MemoryCacheOptions() { }
  public Microsoft.Extensions.Internal.ISystemClock? Clock { get { throw null; } set { } }
  public double CompactionPercentage { get { throw null; } set { } }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.Obsolete("This property is retained only for compatibility. Remove use and instead call MemoryCache.Compact as needed.", error: true)]
+ public bool CompactOnMemoryPressure { get; set; }
  public System.TimeSpan ExpirationScanFrequency { get { throw null; } set { } }
  Microsoft.Extensions.Caching.Memory.MemoryCacheOptions Microsoft.Extensions.Options.IOptions<Microsoft.Extensions.Caching.Memory.MemoryCacheOptions>.Value { get { throw null; } }
  public long? SizeLimit { get { throw null; } set { } }

src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheOptions.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.ComponentModel;
 using Microsoft.Extensions.Internal;
 using Microsoft.Extensions.Options;
 
@@ -42,6 +43,10 @@ public long? SizeLimit
  }
  }
 
+ [EditorBrowsableAttribute(EditorBrowsableState.Never)]
+ [Obsolete("This property is retained only for compatibility. Remove use and instead call MemoryCache.Compact as needed.", error: true)]
+ public bool CompactOnMemoryPressure { get; set; }
+
  /// <summary>
  /// Gets or sets the amount to compact the cache by when the maximum size is exceeded.
  /// </summary>

src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.cs

@@ -9,6 +9,30 @@ namespace Microsoft.Extensions.Logging
  [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")]
  public static partial class ConsoleLoggerExtensions
  {
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory) { throw null; }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory, Microsoft.Extensions.Configuration.IConfiguration configuration) { throw null; }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory, Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings settings) { throw null; }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory, Microsoft.Extensions.Logging.LogLevel minLevel) { throw null; }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory, Microsoft.Extensions.Logging.LogLevel minLevel, bool includeScopes) { throw null; }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory, bool includeScopes) { throw null; }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory, System.Func<string, Microsoft.Extensions.Logging.LogLevel, bool> filter) { throw null; }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Microsoft.Extensions.Logging.ILoggerFactory AddConsole(this Microsoft.Extensions.Logging.ILoggerFactory factory, System.Func<string, Microsoft.Extensions.Logging.LogLevel, bool> filter, bool includeScopes) { throw null; }
  public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsole(this Microsoft.Extensions.Logging.ILoggingBuilder builder) { throw null; }
  public static Microsoft.Extensions.Logging.ILoggingBuilder AddConsole(this Microsoft.Extensions.Logging.ILoggingBuilder builder, System.Action<Microsoft.Extensions.Logging.Console.ConsoleLoggerOptions> configure) { throw null; }
  [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Binding TOptions to configuration values may require generating dynamic code at runtime.")]
@@ -27,6 +51,16 @@ public static partial class ConsoleLoggerExtensions
 }
 namespace Microsoft.Extensions.Logging.Console
 {
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This type is retained only for compatibility. The recommended alternative is ConsoleLoggerOptions.")]
+ public partial class ConfigurationConsoleLoggerSettings : Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings
+ {
+ public ConfigurationConsoleLoggerSettings(Microsoft.Extensions.Configuration.IConfiguration configuration) { }
+ public Microsoft.Extensions.Primitives.IChangeToken? ChangeToken { get { throw null; } }
+ public bool IncludeScopes { get { throw null; } }
+ public Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings Reload() { throw null; }
+ public bool TryGetSwitch(string name, out Microsoft.Extensions.Logging.LogLevel level) { throw null; }
+ }
  public abstract partial class ConsoleFormatter
  {
  protected ConsoleFormatter(string name) { }
@@ -86,6 +120,27 @@ public enum ConsoleLoggerQueueFullMode
  Wait = 0,
  DropWrite = 1,
  }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This type is retained only for compatibility. The recommended alternative is ConsoleLoggerOptions.", error: true)]
+ public partial class ConsoleLoggerSettings : Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings
+ {
+ public ConsoleLoggerSettings() { }
+ public Microsoft.Extensions.Primitives.IChangeToken? ChangeToken { get { throw null; } set { } }
+ public bool DisableColors { get { throw null; } set { } }
+ public bool IncludeScopes { get { throw null; } set { } }
+ public System.Collections.Generic.IDictionary<string, Microsoft.Extensions.Logging.LogLevel> Switches { get { throw null; } set { } }
+ public Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings Reload() { throw null; }
+ public bool TryGetSwitch(string name, out Microsoft.Extensions.Logging.LogLevel level) { throw null; }
+ }
+ [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+ [System.ObsoleteAttribute("This type is retained only for compatibility. The recommended alternative is ConsoleLoggerOptions.", error: true)]
+ public partial interface IConsoleLoggerSettings
+ {
+ Microsoft.Extensions.Primitives.IChangeToken? ChangeToken { get; }
+ bool IncludeScopes { get; }
+ Microsoft.Extensions.Logging.Console.IConsoleLoggerSettings Reload();
+ bool TryGetSwitch(string name, out Microsoft.Extensions.Logging.LogLevel level);
+ }
  public partial class JsonConsoleFormatterOptions : Microsoft.Extensions.Logging.Console.ConsoleFormatterOptions
  {
  public JsonConsoleFormatterOptions() { }

src/libraries/Microsoft.Extensions.Logging.Console/ref/Microsoft.Extensions.Logging.Console.csproj

@@ -21,6 +21,7 @@
 
  <ItemGroup>
  <ProjectReference Include="$(LibrariesProjectRoot)System.Text.Json\ref\System.Text.Json.csproj" />
+ <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
  <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Logging.Abstractions\ref\Microsoft.Extensions.Logging.Abstractions.csproj" />
  <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Logging\ref\Microsoft.Extensions.Logging.csproj" />
  <ProjectReference Include="$(LibrariesProjectRoot)Microsoft.Extensions.Options\ref\Microsoft.Extensions.Options.csproj" />

src/libraries/Microsoft.Extensions.Logging.Console/src/ConfigurationConsoleLoggerSettings.cs

@@ -0,0 +1,79 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.ComponentModel;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Extensions.Logging.Console
+{
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This type is retained only for compatibility. The recommended alternative is ConsoleLoggerOptions.")]
+ public class ConfigurationConsoleLoggerSettings : IConsoleLoggerSettings
+ {
+ internal readonly IConfiguration _configuration;
+
+ public ConfigurationConsoleLoggerSettings(IConfiguration configuration)
+ {
+ _configuration = configuration;
+ ChangeToken = configuration.GetReloadToken();
+ }
+
+ public IChangeToken? ChangeToken { get; private set; }
+
+ public bool IncludeScopes
+ {
+ get
+ {
+ bool includeScopes;
+ var value = _configuration["IncludeScopes"];
+ if (string.IsNullOrEmpty(value))
+ {
+ return false;
+ }
+ else if (bool.TryParse(value, out includeScopes))
+ {
+ return includeScopes;
+ }
+ else
+ {
+ var message = $"Configuration value '{value}' for setting '{nameof(IncludeScopes)}' is not supported.";
+ throw new InvalidOperationException(message);
+ }
+ }
+ }
+
+ public IConsoleLoggerSettings Reload()
+ {
+ ChangeToken = null!;
+ return new ConfigurationConsoleLoggerSettings(_configuration);
+ }
+
+ public bool TryGetSwitch(string name, out LogLevel level)
+ {
+ var switches = _configuration.GetSection("LogLevel");
+ if (switches == null)
+ {
+ level = LogLevel.None;
+ return false;
+ }
+
+ var value = switches[name];
+ if (string.IsNullOrEmpty(value))
+ {
+ level = LogLevel.None;
+ return false;
+ }
+ else if (Enum.TryParse<LogLevel>(value, true, out level))
+ {
+ return true;
+ }
+ else
+ {
+ var message = $"Configuration value '{value}' for category '{name}' is not supported.";
+ throw new InvalidOperationException(message);
+ }
+ }
+ }
+}

src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerExtensions.Obsolete.cs

@@ -0,0 +1,126 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.ComponentModel;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging.Configuration;
+using Microsoft.Extensions.Logging.Console;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Extensions.Logging
+{
+ public static partial class ConsoleLoggerExtensions
+ {
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory, Extensions.Configuration.IConfiguration configuration)
+ {
+ var settings = new ConfigurationConsoleLoggerSettings(configuration);
+ return factory.AddConsole(settings);
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory, Console.IConsoleLoggerSettings settings)
+ {
+ factory.AddProvider(new ConsoleLoggerProvider(ConsoleLoggerSettingsAdapter.GetOptionsMonitor(settings)));
+ return factory;
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory, Logging.LogLevel minLevel, bool includeScopes)
+ {
+ factory.AddConsole((n, l) => l >= LogLevel.Information, includeScopes);
+ return factory;
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory, Logging.LogLevel minLevel)
+ {
+ factory.AddConsole(minLevel, includeScopes: false);
+ return factory;
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory, bool includeScopes)
+ {
+ factory.AddConsole((n, l) => l >= LogLevel.Information, includeScopes);
+ return factory;
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory, System.Func<string, Logging.LogLevel, bool> filter, bool includeScopes)
+ {
+ factory.AddConsole(new ConsoleLoggerSettings() { IncludeScopes = includeScopes });
+ return factory;
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory, System.Func<string, Logging.LogLevel, bool> filter)
+ {
+ factory.AddConsole(filter, includeScopes: false);
+ return factory;
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ [Obsolete("This method is retained only for compatibility. The recommended alternative is AddConsole(this ILoggingBuilder builder).", error: true)]
+ public static Logging.ILoggerFactory AddConsole(this Logging.ILoggerFactory factory)
+ {
+ return factory.AddConsole(includeScopes: false);
+ }
+
+ [Obsolete]
+ private sealed class ConsoleLoggerSettingsAdapter : IConfigureOptions<ConsoleLoggerOptions>, IOptionsChangeTokenSource<ConsoleLoggerOptions>
+ {
+ private IConsoleLoggerSettings _settings;
+ private ConsoleLoggerSettingsAdapter(IConsoleLoggerSettings settings)
+ {
+ _settings = settings;
+ }
+
+ IChangeToken IOptionsChangeTokenSource<ConsoleLoggerOptions>.GetChangeToken() => _settings.ChangeToken ?? NullChangeToken.Instance;
+
+ string IOptionsChangeTokenSource<ConsoleLoggerOptions>.Name => Microsoft.Extensions.Options.Options.DefaultName;
+
+ void IConfigureOptions<ConsoleLoggerOptions>.Configure(ConsoleLoggerOptions options)
+ {
+ options.IncludeScopes = _settings.IncludeScopes;
+ if (_settings is ConfigurationConsoleLoggerSettings configSettings)
+ {
+ options.Configure(configSettings._configuration);
+ }
+ else if (_settings is ConsoleLoggerSettings consoleSettings)
+ {
+ options.DisableColors = consoleSettings.DisableColors;
+ }
+ }
+
+ internal static OptionsMonitor<ConsoleLoggerOptions> GetOptionsMonitor(IConsoleLoggerSettings settings)
+ {
+ ConsoleLoggerSettingsAdapter adapter = new(settings);
+ OptionsFactory<ConsoleLoggerOptions> factory = new( new IConfigureOptions<ConsoleLoggerOptions>[] { adapter }, Array.Empty<IPostConfigureOptions<ConsoleLoggerOptions>>());
+ IOptionsChangeTokenSource<ConsoleLoggerOptions>[] sources = new IOptionsChangeTokenSource<ConsoleLoggerOptions>[] { adapter };
+ OptionsCache<ConsoleLoggerOptions> cache = new();
+
+ return new OptionsMonitor<ConsoleLoggerOptions>(factory, sources, cache);
+ }
+ }
+
+ private sealed class NullChangeToken : IChangeToken, IDisposable
+ {
+ internal static NullChangeToken Instance { get; } = new NullChangeToken();
+ private NullChangeToken() { }
+ public bool HasChanged => false;
+ public bool ActiveChangeCallbacks => false;
+ public IDisposable RegisterChangeCallback(Action<object?> callback, object? state) => this;
+ public void Dispose() { }
+ }
+ }
+}

src/libraries/Microsoft.Extensions.Logging.Console/src/ConsoleLoggerExtensions.cs

@@ -15,7 +15,7 @@
 namespace Microsoft.Extensions.Logging
 {
  [UnsupportedOSPlatform("browser")]
- public static class ConsoleLoggerExtensions
+ public static partial class ConsoleLoggerExtensions
  {
  internal const string RequiresDynamicCodeMessage = "Binding TOptions to configuration values may require generating dynamic code at runtime.";
  internal const string TrimmingRequiresUnreferencedCodeMessage = "TOptions's dependent types may have their members trimmed. Ensure all required members are preserved.";