<Import Project="..\..\Directory.Build.props" />
<ItemGroup>
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Caching.Abstractions\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Configuration\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Configuration.Abstractions\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Configuration.Binder\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Configuration.CommandLine\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Configuration.EnvironmentVariables\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.DependencyInjection.Abstractions\**\*csproj" />
<PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.FileProviders.*\**\*csproj" />
<PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.FileSystemGlobbing\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Hosting.Abstractions\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Logging.Abstractions\**\*csproj" />
+ <PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Options.*\**\*csproj" />
<PortedExtensionsProject Include="$(MSBuildThisFileDirectory)Microsoft.Extensions.Primitives\**\*csproj" />
- <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\**\Microsoft.AspNetCore.Testing\**\*.csproj" Exclude="@(PortedExtensionsProject)" />
<ProjectExclusions Include="$(MSBuildThisFileDirectory)*\ref\**\Microsoft.Extensions.*proj" Exclude="@(PortedExtensionsProject)" />
<ProjectExclusions Include="$(MSBuildThisFileDirectory)*\src\**\Microsoft.Extensions.*proj" Exclude="@(PortedExtensionsProject)" />
- <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\**\Microsoft.Extensions.*.Tests.csproj" Exclude="@(PortedExtensionsProject)" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\Microsoft.Extensions.*.Tests.csproj" Exclude="@(PortedExtensionsProject)" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\FunctionalTests\Microsoft.Extensions.Configuration.Functional.Tests.csproj" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\Common\test\Microsoft.Extensions.Logging.Testing.Tests.csproj" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\FunctionalTests\Microsoft.Extensions.Hosting.Functional.Tests.csproj" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\TestApp\Microsoft.Extensions.Hosting.TestApp.csproj" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\UnitTests\Microsoft.Extensions.Hosting.Unit.Tests.csproj" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)*\tests\Common\Microsoft.Extensions.Logging.Tests.csproj" />
+ <ProjectExclusions Include="$(MSBuildThisFileDirectory)Common\tests\Extensions\**\*.csproj" />
</ItemGroup>
<PropertyGroup Condition="$(MSBuildProjectName.StartsWith('Microsoft.Extensions.'))">
<StrongNameKeyId>MicrosoftAspNetCore</StrongNameKeyId>
<IsAspNetCoreApp>true</IsAspNetCoreApp>
<!-- Temporarily ignore nit warning/errors (e.g. extra whitespace) from Extensions projects -->
- <NoWarn Condition="!$(MSBuildProjectName.EndsWith('.Tests'))">$(NoWarn);SA1129;SA1028;SA1027;SA1121;CA1200;SA1000;CA1507;CA1802;CA1825</NoWarn>
- </PropertyGroup>
+ <NoWarn Condition="!$(MSBuildProjectName.EndsWith('.Tests'))">$(NoWarn);SA1129;SA1028;SA1027;SA1121;CA1200;SA1000;CA1507;CA1802;CA1825;CA1018;SA1648;CA2007;SA1001;SA1026</NoWarn>
+ <NoWarn Condition="!$(MSBuildProjectName.Contains('ref'))">$(NoWarn);CS0618</NoWarn>
+ </PropertyGroup>
<PropertyGroup>
<ToolSetCommonDirectory>$(RepoRoot)artifacts\toolset\Common\</ToolSetCommonDirectory>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Caching.Abstractions.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.Caching.Distributed
{
public static partial class DistributedCacheExtensions
{
public static string GetString(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key) { throw null; }
- [System.Diagnostics.DebuggerStepThroughAttribute]
public static System.Threading.Tasks.Task<string> GetStringAsync(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
public static void Set(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, byte[] value) { }
public static System.Threading.Tasks.Task SetAsync(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, byte[] value, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
public static partial class CacheExtensions
{
public static object Get(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key) { throw null; }
- [System.Diagnostics.DebuggerStepThroughAttribute]
public static System.Threading.Tasks.Task<TItem> GetOrCreateAsync<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, System.Func<Microsoft.Extensions.Caching.Memory.ICacheEntry, System.Threading.Tasks.Task<TItem>> factory) { throw null; }
public static TItem GetOrCreate<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, System.Func<Microsoft.Extensions.Caching.Memory.ICacheEntry, TItem> factory) { throw null; }
public static TItem Get<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key) { throw null; }
public MemoryCacheEntryOptions() { }
public System.DateTimeOffset? AbsoluteExpiration { get { throw null; } set { } }
public System.TimeSpan? AbsoluteExpirationRelativeToNow { get { throw null; } set { } }
- public System.Collections.Generic.IList<Microsoft.Extensions.Primitives.IChangeToken> ExpirationTokens { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Collections.Generic.IList<Microsoft.Extensions.Caching.Memory.PostEvictionCallbackRegistration> PostEvictionCallbacks { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public Microsoft.Extensions.Caching.Memory.CacheItemPriority Priority { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public System.Collections.Generic.IList<Microsoft.Extensions.Primitives.IChangeToken> ExpirationTokens { get { throw null; } }
+ public System.Collections.Generic.IList<Microsoft.Extensions.Caching.Memory.PostEvictionCallbackRegistration> PostEvictionCallbacks { get { throw null; } }
+ public Microsoft.Extensions.Caching.Memory.CacheItemPriority Priority { get { throw null; } set { } }
public long? Size { get { throw null; } set { } }
public System.TimeSpan? SlidingExpiration { get { throw null; } set { } }
}
public partial class PostEvictionCallbackRegistration
{
public PostEvictionCallbackRegistration() { }
- public Microsoft.Extensions.Caching.Memory.PostEvictionDelegate EvictionCallback { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public object State { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public Microsoft.Extensions.Caching.Memory.PostEvictionDelegate EvictionCallback { get { throw null; } set { } }
+ public object State { get { throw null; } set { } }
}
public delegate void PostEvictionDelegate(object key, object value, Microsoft.Extensions.Caching.Memory.EvictionReason reason, object state);
}
-<!-- This file is automatically generated. -->
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
</PropertyGroup>
- <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
- <Compile Include="Microsoft.Extensions.Caching.Abstractions.netstandard2.0.cs" />
- <Reference Include="Microsoft.Extensions.Primitives" />
- </ItemGroup>
-<ItemGroup Condition="'$(TargetFramework)' == '$(DefaultNetCoreTargetFramework)'">
- <Compile Include="Microsoft.Extensions.Caching.Abstractions.netcoreapp.cs" />
- <Reference Include="Microsoft.Extensions.Primitives" />
+ <ItemGroup>
+ <Compile Include="Microsoft.Extensions.Caching.Abstractions.cs" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Primitives\ref\Microsoft.Extensions.Primitives.csproj" />
</ItemGroup>
</Project>
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace Microsoft.Extensions.Caching.Distributed
-{
- public static partial class DistributedCacheEntryExtensions
- {
- public static Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions SetAbsoluteExpiration(this Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options, System.DateTimeOffset absolute) { throw null; }
- public static Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions SetAbsoluteExpiration(this Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options, System.TimeSpan relative) { throw null; }
- public static Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions SetSlidingExpiration(this Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options, System.TimeSpan offset) { throw null; }
- }
- public partial class DistributedCacheEntryOptions
- {
- public DistributedCacheEntryOptions() { }
- public System.DateTimeOffset? AbsoluteExpiration { get { throw null; } set { } }
- public System.TimeSpan? AbsoluteExpirationRelativeToNow { get { throw null; } set { } }
- public System.TimeSpan? SlidingExpiration { get { throw null; } set { } }
- }
- public static partial class DistributedCacheExtensions
- {
- public static string GetString(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key) { throw null; }
- [System.Diagnostics.DebuggerStepThroughAttribute]
- public static System.Threading.Tasks.Task<string> GetStringAsync(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- public static void Set(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, byte[] value) { }
- public static System.Threading.Tasks.Task SetAsync(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, byte[] value, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- public static void SetString(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, string value) { }
- public static void SetString(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, string value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options) { }
- public static System.Threading.Tasks.Task SetStringAsync(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, string value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- public static System.Threading.Tasks.Task SetStringAsync(this Microsoft.Extensions.Caching.Distributed.IDistributedCache cache, string key, string value, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- }
- public partial interface IDistributedCache
- {
- byte[] Get(string key);
- System.Threading.Tasks.Task<byte[]> GetAsync(string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken));
- void Refresh(string key);
- System.Threading.Tasks.Task RefreshAsync(string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken));
- void Remove(string key);
- System.Threading.Tasks.Task RemoveAsync(string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken));
- void Set(string key, byte[] value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options);
- System.Threading.Tasks.Task SetAsync(string key, byte[] value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options, System.Threading.CancellationToken token = default(System.Threading.CancellationToken));
- }
-}
-namespace Microsoft.Extensions.Caching.Memory
-{
- public static partial class CacheEntryExtensions
- {
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry AddExpirationToken(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, Microsoft.Extensions.Primitives.IChangeToken expirationToken) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry RegisterPostEvictionCallback(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, Microsoft.Extensions.Caching.Memory.PostEvictionDelegate callback) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry RegisterPostEvictionCallback(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, Microsoft.Extensions.Caching.Memory.PostEvictionDelegate callback, object state) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry SetAbsoluteExpiration(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, System.DateTimeOffset absolute) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry SetAbsoluteExpiration(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, System.TimeSpan relative) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry SetOptions(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry SetPriority(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, Microsoft.Extensions.Caching.Memory.CacheItemPriority priority) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry SetSize(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, long size) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry SetSlidingExpiration(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, System.TimeSpan offset) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.ICacheEntry SetValue(this Microsoft.Extensions.Caching.Memory.ICacheEntry entry, object value) { throw null; }
- }
- public static partial class CacheExtensions
- {
- public static object Get(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key) { throw null; }
- [System.Diagnostics.DebuggerStepThroughAttribute]
- public static System.Threading.Tasks.Task<TItem> GetOrCreateAsync<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, System.Func<Microsoft.Extensions.Caching.Memory.ICacheEntry, System.Threading.Tasks.Task<TItem>> factory) { throw null; }
- public static TItem GetOrCreate<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, System.Func<Microsoft.Extensions.Caching.Memory.ICacheEntry, TItem> factory) { throw null; }
- public static TItem Get<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key) { throw null; }
- public static TItem Set<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, TItem value) { throw null; }
- public static TItem Set<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, TItem value, Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options) { throw null; }
- public static TItem Set<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, TItem value, Microsoft.Extensions.Primitives.IChangeToken expirationToken) { throw null; }
- public static TItem Set<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, TItem value, System.DateTimeOffset absoluteExpiration) { throw null; }
- public static TItem Set<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, TItem value, System.TimeSpan absoluteExpirationRelativeToNow) { throw null; }
- public static bool TryGetValue<TItem>(this Microsoft.Extensions.Caching.Memory.IMemoryCache cache, object key, out TItem value) { throw null; }
- }
- public enum CacheItemPriority
- {
- Low = 0,
- Normal = 1,
- High = 2,
- NeverRemove = 3,
- }
- public enum EvictionReason
- {
- None = 0,
- Removed = 1,
- Replaced = 2,
- Expired = 3,
- TokenExpired = 4,
- Capacity = 5,
- }
- public partial interface ICacheEntry : System.IDisposable
- {
- System.DateTimeOffset? AbsoluteExpiration { get; set; }
- System.TimeSpan? AbsoluteExpirationRelativeToNow { get; set; }
- System.Collections.Generic.IList<Microsoft.Extensions.Primitives.IChangeToken> ExpirationTokens { get; }
- object Key { get; }
- System.Collections.Generic.IList<Microsoft.Extensions.Caching.Memory.PostEvictionCallbackRegistration> PostEvictionCallbacks { get; }
- Microsoft.Extensions.Caching.Memory.CacheItemPriority Priority { get; set; }
- long? Size { get; set; }
- System.TimeSpan? SlidingExpiration { get; set; }
- object Value { get; set; }
- }
- public partial interface IMemoryCache : System.IDisposable
- {
- Microsoft.Extensions.Caching.Memory.ICacheEntry CreateEntry(object key);
- void Remove(object key);
- bool TryGetValue(object key, out object value);
- }
- public static partial class MemoryCacheEntryExtensions
- {
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions AddExpirationToken(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, Microsoft.Extensions.Primitives.IChangeToken expirationToken) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions RegisterPostEvictionCallback(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, Microsoft.Extensions.Caching.Memory.PostEvictionDelegate callback) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions RegisterPostEvictionCallback(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, Microsoft.Extensions.Caching.Memory.PostEvictionDelegate callback, object state) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions SetAbsoluteExpiration(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, System.DateTimeOffset absolute) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions SetAbsoluteExpiration(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, System.TimeSpan relative) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions SetPriority(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, Microsoft.Extensions.Caching.Memory.CacheItemPriority priority) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions SetSize(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, long size) { throw null; }
- public static Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions SetSlidingExpiration(this Microsoft.Extensions.Caching.Memory.MemoryCacheEntryOptions options, System.TimeSpan offset) { throw null; }
- }
- public partial class MemoryCacheEntryOptions
- {
- public MemoryCacheEntryOptions() { }
- public System.DateTimeOffset? AbsoluteExpiration { get { throw null; } set { } }
- public System.TimeSpan? AbsoluteExpirationRelativeToNow { get { throw null; } set { } }
- public System.Collections.Generic.IList<Microsoft.Extensions.Primitives.IChangeToken> ExpirationTokens { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Collections.Generic.IList<Microsoft.Extensions.Caching.Memory.PostEvictionCallbackRegistration> PostEvictionCallbacks { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public Microsoft.Extensions.Caching.Memory.CacheItemPriority Priority { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public long? Size { get { throw null; } set { } }
- public System.TimeSpan? SlidingExpiration { get { throw null; } set { } }
- }
- public partial class PostEvictionCallbackRegistration
- {
- public PostEvictionCallbackRegistration() { }
- public Microsoft.Extensions.Caching.Memory.PostEvictionDelegate EvictionCallback { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public object State { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- }
- public delegate void PostEvictionDelegate(object key, object value, Microsoft.Extensions.Caching.Memory.EvictionReason reason, object state);
-}
-namespace Microsoft.Extensions.Internal
-{
- public partial interface ISystemClock
- {
- System.DateTimeOffset UtcNow { get; }
- }
- public partial class SystemClock : Microsoft.Extensions.Internal.ISystemClock
- {
- public SystemClock() { }
- public System.DateTimeOffset UtcNow { get { throw null; } }
- }
-}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <Description>Caching abstractions for in-memory cache and distributed cache.
-Commonly used types:
-Microsoft.Extensions.Caching.Distributed.IDistributedCache
-Microsoft.Extensions.Caching.Memory.IMemoryCache</Description>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
<NoWarn>$(NoWarn);CS1591</NoWarn>
- <GenerateDocumentationFile>true</GenerateDocumentationFile>
- <PackageTags>cache;memorycache;distributedcache</PackageTags>
- <IsPackable>true</IsPackable>
- <IsShipping>true</IsShipping>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.Extensions.Primitives" />
- <Reference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" PrivateAssets="All" />
</ItemGroup>
</Project>
<!-- This file is automatically generated. -->
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
</PropertyGroup>
- <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
- <Compile Include="Microsoft.Extensions.Caching.Memory.netstandard2.0.cs" />
- <Reference Include="Microsoft.Extensions.Caching.Abstractions" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
- <Reference Include="Microsoft.Extensions.Logging.Abstractions" />
- <Reference Include="Microsoft.Extensions.Options" />
- </ItemGroup>
-<ItemGroup Condition="'$(TargetFramework)' == '$(DefaultNetCoreTargetFramework)'">
- <Compile Include="Microsoft.Extensions.Caching.Memory.netcoreapp.cs" />
- <Reference Include="Microsoft.Extensions.Caching.Abstractions" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
- <Reference Include="Microsoft.Extensions.Logging.Abstractions" />
- <Reference Include="Microsoft.Extensions.Options" />
+<ItemGroup>
+ <Compile Include="Microsoft.Extensions.Caching.Memory.cs" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Caching.Abstractions\ref\Microsoft.Extensions.Caching.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.DependencyInjection.Abstractions\ref\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Logging.Abstractions\ref\Microsoft.Extensions.Logging.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Options\ref\Microsoft.Extensions.Options.csproj" />
</ItemGroup>
</Project>
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace Microsoft.Extensions.Caching.Distributed
-{
- public partial class MemoryDistributedCache : Microsoft.Extensions.Caching.Distributed.IDistributedCache
- {
- public MemoryDistributedCache(Microsoft.Extensions.Options.IOptions<Microsoft.Extensions.Caching.Memory.MemoryDistributedCacheOptions> optionsAccessor) { }
- public MemoryDistributedCache(Microsoft.Extensions.Options.IOptions<Microsoft.Extensions.Caching.Memory.MemoryDistributedCacheOptions> optionsAccessor, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory) { }
- public byte[] Get(string key) { throw null; }
- public System.Threading.Tasks.Task<byte[]> GetAsync(string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- public void Refresh(string key) { }
- public System.Threading.Tasks.Task RefreshAsync(string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- public void Remove(string key) { }
- public System.Threading.Tasks.Task RemoveAsync(string key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- public void Set(string key, byte[] value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options) { }
- public System.Threading.Tasks.Task SetAsync(string key, byte[] value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions options, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
- }
-}
-namespace Microsoft.Extensions.Caching.Memory
-{
- public partial class MemoryCache : Microsoft.Extensions.Caching.Memory.IMemoryCache, System.IDisposable
- {
- public MemoryCache(Microsoft.Extensions.Options.IOptions<Microsoft.Extensions.Caching.Memory.MemoryCacheOptions> optionsAccessor) { }
- public MemoryCache(Microsoft.Extensions.Options.IOptions<Microsoft.Extensions.Caching.Memory.MemoryCacheOptions> optionsAccessor, Microsoft.Extensions.Logging.ILoggerFactory loggerFactory) { }
- public int Count { get { throw null; } }
- public void Compact(double percentage) { }
- public Microsoft.Extensions.Caching.Memory.ICacheEntry CreateEntry(object key) { throw null; }
- public void Dispose() { }
- protected virtual void Dispose(bool disposing) { }
- ~MemoryCache() { }
- public void Remove(object key) { }
- public bool TryGetValue(object key, out object result) { throw null; }
- }
- public partial class MemoryCacheOptions : Microsoft.Extensions.Options.IOptions<Microsoft.Extensions.Caching.Memory.MemoryCacheOptions>
- {
- public MemoryCacheOptions() { }
- public Microsoft.Extensions.Internal.ISystemClock Clock { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public double CompactionPercentage { get { throw null; } set { } }
- public System.TimeSpan ExpirationScanFrequency { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] 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 { } }
- }
- public partial class MemoryDistributedCacheOptions : Microsoft.Extensions.Caching.Memory.MemoryCacheOptions
- {
- public MemoryDistributedCacheOptions() { }
- }
-}
-namespace Microsoft.Extensions.DependencyInjection
-{
- public static partial class MemoryCacheServiceCollectionExtensions
- {
- public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddDistributedMemoryCache(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddDistributedMemoryCache(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<Microsoft.Extensions.Caching.Memory.MemoryDistributedCacheOptions> setupAction) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddMemoryCache(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddMemoryCache(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<Microsoft.Extensions.Caching.Memory.MemoryCacheOptions> setupAction) { throw null; }
- }
-}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <Description>In-memory cache implementation of Microsoft.Extensions.Caching.Memory.IMemoryCache.</Description>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
<NoWarn>$(NoWarn);CS1591</NoWarn>
- <GenerateDocumentationFile>true</GenerateDocumentationFile>
- <PackageTags>cache;memorycache</PackageTags>
- <IsPackable>true</IsPackable>
- <IsShipping>true</IsShipping>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Caching.Memory.Tests" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.Caching.Abstractions" />
<Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
<Reference Include="Microsoft.Extensions.Logging.Abstractions" />
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Caching.Memory.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Configuration.Abstractions.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.Configuration
{
</PropertyGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Configuration.Abstractions.cs" />
- <Reference Include="Microsoft.Extensions.Primitives" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Primitives\ref\Microsoft.Extensions.Primitives.csproj" />
</ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
</PropertyGroup>
<ItemGroup>
+ <Compile Include="*.cs" />
+ </ItemGroup>
+
+ <ItemGroup>
<Reference Include="Microsoft.Extensions.Primitives" />
</ItemGroup>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Configuration.Binder.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.Configuration
{
public partial class BinderOptions
{
public BinderOptions() { }
- public bool BindNonPublicProperties { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public bool BindNonPublicProperties { get { throw null; } set { } }
}
public static partial class ConfigurationBinder
{
</PropertyGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Configuration.Binder.cs" />
- <Reference Include="Microsoft.Extensions.Configuration" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration\ref\Microsoft.Extensions.Configuration.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
</ItemGroup>
</Project>
using System.ComponentModel;
using System.Linq;
using System.Reflection;
-using Microsoft.Extensions.Configuration.Binder;
namespace Microsoft.Extensions.Configuration
{
if (typeInfo.IsInterface || typeInfo.IsAbstract)
{
- throw new InvalidOperationException(Resources.FormatError_CannotActivateAbstractOrInterface(type));
+ throw new InvalidOperationException(SR.Format(SR.Error_CannotActivateAbstractOrInterface, type));
}
if (type.IsArray)
{
if (typeInfo.GetArrayRank() > 1)
{
- throw new InvalidOperationException(Resources.FormatError_UnsupportedMultidimensionalArray(type));
+ throw new InvalidOperationException(SR.Format(SR.Error_UnsupportedMultidimensionalArray, type));
}
return Array.CreateInstance(typeInfo.GetElementType(), 0);
var hasDefaultConstructor = typeInfo.DeclaredConstructors.Any(ctor => ctor.IsPublic && ctor.GetParameters().Length == 0);
if (!hasDefaultConstructor)
{
- throw new InvalidOperationException(Resources.FormatError_MissingParameterlessConstructor(type));
+ throw new InvalidOperationException(SR.Format(SR.Error_MissingParameterlessConstructor, type));
}
try
}
catch (Exception ex)
{
- throw new InvalidOperationException(Resources.FormatError_FailedToActivate(type), ex);
+ throw new InvalidOperationException(SR.Format(SR.Error_FailedToActivate, type), ex);
}
}
}
catch (Exception ex)
{
- error = new InvalidOperationException(Resources.FormatError_FailedBinding(path, type), ex);
+ error = new InvalidOperationException(SR.Format(SR.Error_FailedBinding, path, type), ex);
}
return true;
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Configuration.Binder.Tests" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.Configuration" />
+ <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
</ItemGroup>
</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Configuration.Binder.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
Assert.NotNull(exception.InnerException);
Assert.NotNull(getException.InnerException);
Assert.Equal(
- Resources.FormatError_FailedBinding(ConfigKey, type),
+ SR.Format(SR.Error_FailedBinding, ConfigKey, type),
exception.Message);
Assert.Equal(
- Resources.FormatError_FailedBinding(ConfigKey, type),
+ SR.Format(SR.Error_FailedBinding, ConfigKey, type),
getException.Message);
Assert.Equal(
- Resources.FormatError_FailedBinding(ConfigKey, type),
+ SR.Format(SR.Error_FailedBinding, ConfigKey, type),
getValueException.Message);
}
var exception = Assert.Throws<InvalidOperationException>(
() => config.Bind(options));
- Assert.Equal(Resources.FormatError_FailedBinding(ConfigKey, typeof(int)),
+ Assert.Equal(SR.Format(SR.Error_FailedBinding, ConfigKey, typeof(int)),
exception.Message);
}
var exception = Assert.Throws<InvalidOperationException>(
() => config.Bind(new TestOptions()));
Assert.Equal(
- Resources.FormatError_CannotActivateAbstractOrInterface(typeof(ISomeInterface)),
+ SR.Format(SR.Error_CannotActivateAbstractOrInterface, typeof(ISomeInterface)),
exception.Message);
}
var exception = Assert.Throws<InvalidOperationException>(
() => config.Bind(new TestOptions()));
Assert.Equal(
- Resources.FormatError_MissingParameterlessConstructor(typeof(ClassWithoutPublicConstructor)),
+ SR.Format(SR.Error_MissingParameterlessConstructor, typeof(ClassWithoutPublicConstructor)),
exception.Message);
}
() => config.Bind(new TestOptions()));
Assert.NotNull(exception.InnerException);
Assert.Equal(
- Resources.FormatError_FailedToActivate(typeof(ThrowsWhenActivated)),
+ SR.Format(SR.Error_FailedToActivate, typeof(ThrowsWhenActivated)),
exception.Message);
}
var exception = Assert.Throws<InvalidOperationException>(
() => config.Bind(new TestOptions()));
Assert.Equal(
- Resources.FormatError_CannotActivateAbstractOrInterface(typeof(ISomeInterface)),
+ SR.Format(SR.Error_CannotActivateAbstractOrInterface, typeof(ISomeInterface)),
exception.Message);
}
var exception = Assert.Throws<InvalidOperationException>(
() => config.Bind(options));
Assert.Equal(
- Resources.FormatError_UnsupportedMultidimensionalArray(typeof(string[,])),
+ SR.Format(SR.Error_UnsupportedMultidimensionalArray, typeof(string[,])),
exception.Message);
}
<PropertyGroup>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <ProjectReference Include="..\..\testassets\Test.Common\Microsoft.Extensions.Configuration.Test.Common.csproj" />
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\Common\ConfigurationProviderExtensions.cs">
+ <Link>Common\ConfigurationProviderExtensions.cs</Link>
+ </Compile>
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\Common\TestStreamHelpers.cs">
+ <Link>Common\TestStreamHelpers.cs</Link>
+ </Compile>
</ItemGroup>
<ItemGroup>
- <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
- <Reference Include="Microsoft.Extensions.Configuration.Binder" />
- <Reference Include="Microsoft.Extensions.Configuration" />
+ <ReferenceFromRuntime Include="Microsoft.Extensions.Configuration.Binder" />
</ItemGroup>
</Project>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Configuration.CommandLine.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.Configuration
{
public partial class CommandLineConfigurationProvider : Microsoft.Extensions.Configuration.ConfigurationProvider
{
public CommandLineConfigurationProvider(System.Collections.Generic.IEnumerable<string> args, System.Collections.Generic.IDictionary<string, string> switchMappings = null) { }
- protected System.Collections.Generic.IEnumerable<string> Args { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ protected System.Collections.Generic.IEnumerable<string> Args { get { throw null; } }
public override void Load() { }
}
public partial class CommandLineConfigurationSource : Microsoft.Extensions.Configuration.IConfigurationSource
{
public CommandLineConfigurationSource() { }
- public System.Collections.Generic.IEnumerable<string> Args { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public System.Collections.Generic.IDictionary<string, string> SwitchMappings { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public System.Collections.Generic.IEnumerable<string> Args { get { throw null; } set { } }
+ public System.Collections.Generic.IDictionary<string, string> SwitchMappings { get { throw null; } set { } }
public Microsoft.Extensions.Configuration.IConfigurationProvider Build(Microsoft.Extensions.Configuration.IConfigurationBuilder builder) { throw null; }
}
}
</PropertyGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Configuration.CommandLine.cs" />
- <Reference Include="Microsoft.Extensions.Configuration" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration\ref\Microsoft.Extensions.Configuration.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
</ItemGroup>
</Project>
// If the switch starts with a single "-" and it isn't in given mappings , it is an invalid usage
else if (keyStartIndex == 1)
{
- throw new FormatException(Resources.FormatError_ShortSwitchNotDefined(currentArg));
+ throw new FormatException(SR.Format(SR.Error_ShortSwitchNotDefined, currentArg));
}
// Otherwise, use the switch name directly as a key
else
if (!mapping.Key.StartsWith("-") && !mapping.Key.StartsWith("--"))
{
throw new ArgumentException(
- Resources.FormatError_InvalidSwitchMapping(mapping.Key),
+ SR.Format(SR.Error_InvalidSwitchMapping, mapping.Key),
nameof(switchMappings));
}
if (switchMappingsCopy.ContainsKey(mapping.Key))
{
throw new ArgumentException(
- Resources.FormatError_DuplicatedKeyInSwitchMappings(mapping.Key),
+ SR.Format(SR.Error_DuplicatedKeyInSwitchMappings, mapping.Key),
nameof(switchMappings));
}
<PropertyGroup>
<TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Configuration.CommandLine.Tests" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.Configuration" />
+ <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
</ItemGroup>
</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Configuration.CommandLine.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
set.Add(mapping.Key);
}
- var expectedMsg = new ArgumentException(Resources.
- FormatError_DuplicatedKeyInSwitchMappings(expectedDup), "switchMappings").Message;
+ var expectedMsg = new ArgumentException(SR.
+ Format(SR.Error_DuplicatedKeyInSwitchMappings, expectedDup), "switchMappings").Message;
// Act
var exception = Assert.Throws<ArgumentException>(
{ "--Key2", "SuperLongKey2" },
{ "/Key3", "AnotherSuperLongKey3" }
};
- var expectedMsg = new ArgumentException(Resources.FormatError_InvalidSwitchMapping("/Key3"),
+ var expectedMsg = new ArgumentException(SR.Format(SR.Error_InvalidSwitchMapping,"/Key3"),
"switchMappings").Message;
var exception = Assert.Throws<ArgumentException>(
<PropertyGroup>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <ProjectReference Include="..\..\Config\test\Microsoft.Extensions.Configuration.Tests.csproj" />
- <ProjectReference Include="..\..\testassets\Test.Common\Microsoft.Extensions.Configuration.Test.Common.csproj" />
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\ConfigurationProviderTestBase.cs">
+ <Link>Common\ConfigurationProviderTestBase.cs</Link>
+ </Compile>
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\Common\ConfigurationProviderExtensions.cs">
+ <Link>Common\ConfigurationProviderExtensions.cs</Link>
+ </Compile>
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\Common\TestStreamHelpers.cs">
+ <Link>Common\TestStreamHelpers.cs</Link>
+ </Compile>
</ItemGroup>
<ItemGroup>
- <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
- <Reference Include="Microsoft.Extensions.Configuration.CommandLine" />
- <Reference Include="Microsoft.Extensions.Configuration" />
+ <ReferenceFromRuntime Include="Microsoft.Extensions.Configuration.CommandLine" />
</ItemGroup>
</Project>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Configuration.EnvironmentVariables.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.Configuration
{
public partial class EnvironmentVariablesConfigurationSource : Microsoft.Extensions.Configuration.IConfigurationSource
{
public EnvironmentVariablesConfigurationSource() { }
- public string Prefix { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public string Prefix { get { throw null; } set { } }
public Microsoft.Extensions.Configuration.IConfigurationProvider Build(Microsoft.Extensions.Configuration.IConfigurationBuilder builder) { throw null; }
}
}
</PropertyGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Configuration.EnvironmentVariables.cs" />
- <Reference Include="Microsoft.Extensions.Configuration" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration\ref\Microsoft.Extensions.Configuration.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
</ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Configuration.EnvironmentVariables.Tests" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.Configuration" />
+ <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
</ItemGroup>
</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Configuration.EnvironmentVariables.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
<PropertyGroup>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <ProjectReference Include="..\..\Config\test\Microsoft.Extensions.Configuration.Tests.csproj" />
- <ProjectReference Include="..\..\testassets\Test.Common\Microsoft.Extensions.Configuration.Test.Common.csproj" />
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\ConfigurationProviderTestBase.cs">
+ <Link>Common\ConfigurationProviderTestBase.cs</Link>
+ </Compile>
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\Common\ConfigurationProviderExtensions.cs">
+ <Link>Common\ConfigurationProviderExtensions.cs</Link>
+ </Compile>
+ <Compile Include="$(LibrariesProjectRoot)Microsoft.Extensions.Configuration\tests\Common\TestStreamHelpers.cs">
+ <Link>Common\TestStreamHelpers.cs</Link>
+ </Compile>
</ItemGroup>
<ItemGroup>
- <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
- <Reference Include="Microsoft.Extensions.Configuration.Binder" />
- <Reference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" />
- <Reference Include="Microsoft.Extensions.Configuration" />
+ <ReferenceFromRuntime Include="Microsoft.Extensions.Configuration.EnvironmentVariables" />
</ItemGroup>
-
+
</Project>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Configuration.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.Configuration
{
public partial class ChainedConfigurationSource : Microsoft.Extensions.Configuration.IConfigurationSource
{
public ChainedConfigurationSource() { }
- public Microsoft.Extensions.Configuration.IConfiguration Configuration { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public bool ShouldDisposeConfiguration { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public Microsoft.Extensions.Configuration.IConfiguration Configuration { get { throw null; } set { } }
+ public bool ShouldDisposeConfiguration { get { throw null; } set { } }
public Microsoft.Extensions.Configuration.IConfigurationProvider Build(Microsoft.Extensions.Configuration.IConfigurationBuilder builder) { throw null; }
}
public partial class ConfigurationBuilder : Microsoft.Extensions.Configuration.IConfigurationBuilder
{
public ConfigurationBuilder() { }
- public System.Collections.Generic.IDictionary<string, object> Properties { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Collections.Generic.IList<Microsoft.Extensions.Configuration.IConfigurationSource> Sources { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Collections.Generic.IDictionary<string, object> Properties { get { throw null; } }
+ public System.Collections.Generic.IList<Microsoft.Extensions.Configuration.IConfigurationSource> Sources { get { throw null; } }
public Microsoft.Extensions.Configuration.IConfigurationBuilder Add(Microsoft.Extensions.Configuration.IConfigurationSource source) { throw null; }
public Microsoft.Extensions.Configuration.IConfigurationRoot Build() { throw null; }
}
public partial class ConfigurationKeyComparer : System.Collections.Generic.IComparer<string>
{
public ConfigurationKeyComparer() { }
- public static Microsoft.Extensions.Configuration.ConfigurationKeyComparer Instance { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public static Microsoft.Extensions.Configuration.ConfigurationKeyComparer Instance { get { throw null; } }
public int Compare(string x, string y) { throw null; }
}
public abstract partial class ConfigurationProvider : Microsoft.Extensions.Configuration.IConfigurationProvider
{
protected ConfigurationProvider() { }
- protected System.Collections.Generic.IDictionary<string, string> Data { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ protected System.Collections.Generic.IDictionary<string, string> Data { get { throw null; } set { } }
public virtual System.Collections.Generic.IEnumerable<string> GetChildKeys(System.Collections.Generic.IEnumerable<string> earlierKeys, string parentPath) { throw null; }
public Microsoft.Extensions.Primitives.IChangeToken GetReloadToken() { throw null; }
public virtual void Load() { }
public abstract partial class StreamConfigurationProvider : Microsoft.Extensions.Configuration.ConfigurationProvider
{
public StreamConfigurationProvider(Microsoft.Extensions.Configuration.StreamConfigurationSource source) { }
- public Microsoft.Extensions.Configuration.StreamConfigurationSource Source { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public Microsoft.Extensions.Configuration.StreamConfigurationSource Source { get { throw null; } }
public override void Load() { }
public abstract void Load(System.IO.Stream stream);
}
public abstract partial class StreamConfigurationSource : Microsoft.Extensions.Configuration.IConfigurationSource
{
protected StreamConfigurationSource() { }
- public System.IO.Stream Stream { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public System.IO.Stream Stream { get { throw null; } set { } }
public abstract Microsoft.Extensions.Configuration.IConfigurationProvider Build(Microsoft.Extensions.Configuration.IConfigurationBuilder builder);
}
}
public partial class MemoryConfigurationSource : Microsoft.Extensions.Configuration.IConfigurationSource
{
public MemoryConfigurationSource() { }
- public System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, string>> InitialData { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
+ public System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, string>> InitialData { get { throw null; } set { } }
public Microsoft.Extensions.Configuration.IConfigurationProvider Build(Microsoft.Extensions.Configuration.IConfigurationBuilder builder) { throw null; }
}
}
</PropertyGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Configuration.cs" />
- <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Primitives\ref\Microsoft.Extensions.Primitives.csproj" />
</ItemGroup>
</Project>
{
if (!_providers.Any())
{
- throw new InvalidOperationException(Resources.Error_NoSources);
+ throw new InvalidOperationException(SR.Error_NoSources);
}
foreach (var provider in _providers)
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Configuration.Tests" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
+ <Reference Include="Microsoft.Extensions.Primitives" />
</ItemGroup>
</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Configuration.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
var configurationBuilder = new ConfigurationBuilder();
var config = configurationBuilder.Build();
- var expectedMsg = Resources.Error_NoSources;
+ var expectedMsg = SR.Error_NoSources;
// Act
var ex = Assert.Throws<InvalidOperationException>(() => config["Title"] = "Welcome");
</PropertyGroup>
<ItemGroup>
- <ProjectReference Include="..\..\Config.Binder\src\Microsoft.Extensions.Configuration.Binder.csproj" />
- <ProjectReference Include="..\..\testassets\Test.Common\Microsoft.Extensions.Configuration.Test.Common.csproj" />
+ <Compile Include="Common/*.cs" />
+ <Compile Include="*.cs" />
</ItemGroup>
<ItemGroup>
- <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
- <Reference Include="Microsoft.Extensions.Configuration.FileExtensions" />
- <Reference Include="Microsoft.Extensions.Configuration" />
- <Reference Include="Microsoft.Extensions.Primitives" />
+ <PackageReference Include="Moq" Version="$(MoqVersion)" />
+ <ReferenceFromRuntime Include="Microsoft.Extensions.Configuration" />
</ItemGroup>
</Project>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.DependencyInjection.Abstractions.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.DependencyInjection
{
public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddTransient<TService, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) where TService : class where TImplementation : class, TService { throw null; }
public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddTransient<TService, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Func<System.IServiceProvider, TImplementation> implementationFactory) where TService : class where TImplementation : class, TService { throw null; }
}
- [System.Diagnostics.DebuggerDisplayAttribute("Lifetime = {Lifetime}, ServiceType = {ServiceType}, ImplementationType = {ImplementationType}")]
public partial class ServiceDescriptor
{
public ServiceDescriptor(System.Type serviceType, System.Func<System.IServiceProvider, object> factory, Microsoft.Extensions.DependencyInjection.ServiceLifetime lifetime) { }
public ServiceDescriptor(System.Type serviceType, object instance) { }
public ServiceDescriptor(System.Type serviceType, System.Type implementationType, Microsoft.Extensions.DependencyInjection.ServiceLifetime lifetime) { }
- public System.Func<System.IServiceProvider, object> ImplementationFactory { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public object ImplementationInstance { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Type ImplementationType { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public Microsoft.Extensions.DependencyInjection.ServiceLifetime Lifetime { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Type ServiceType { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Func<System.IServiceProvider, object> ImplementationFactory { get { throw null; } }
+ public object ImplementationInstance { get { throw null; } }
+ public System.Type ImplementationType { get { throw null; } }
+ public Microsoft.Extensions.DependencyInjection.ServiceLifetime Lifetime { get { throw null; } }
+ public System.Type ServiceType { get { throw null; } }
public static Microsoft.Extensions.DependencyInjection.ServiceDescriptor Describe(System.Type serviceType, System.Func<System.IServiceProvider, object> implementationFactory, Microsoft.Extensions.DependencyInjection.ServiceLifetime lifetime) { throw null; }
public static Microsoft.Extensions.DependencyInjection.ServiceDescriptor Describe(System.Type serviceType, System.Type implementationType, Microsoft.Extensions.DependencyInjection.ServiceLifetime lifetime) { throw null; }
public static Microsoft.Extensions.DependencyInjection.ServiceDescriptor Scoped(System.Type service, System.Func<System.IServiceProvider, object> implementationFactory) { throw null; }
using System;
using System.Collections.Generic;
using System.Linq;
-using Microsoft.Extensions.DependencyInjection.Abstractions;
namespace Microsoft.Extensions.DependencyInjection.Extensions
{
implementationType == descriptor.ServiceType)
{
throw new ArgumentException(
- Resources.FormatTryAddIndistinguishableTypeToEnumerable(
+ SR.Format(SR.TryAddIndistinguishableTypeToEnumerable,
implementationType,
descriptor.ServiceType),
nameof(descriptor));
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFramework>netstandard2.0</TargetFramework>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
<DefineConstants>$(DefineConstants);ActivatorUtilities_In_DependencyInjection</DefineConstants>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.DependencyInjection.Tests" />
- </ItemGroup>
-
- <ItemGroup>
- <Compile Include="$(SharedSourceRoot)ParameterDefaultValue\*.cs" />
- <Compile Include="$(SharedSourceRoot)ActivatorUtilities\*.cs" />
+ <Compile Include="$(CommonPath)Extensions\ParameterDefaultValue\ParameterDefaultValue.cs">
+ <Link>Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\ActivatorUtilities\ActivatorUtilities.cs">
+ <Link>Common\src\Extensions\ActivatorUtilities\ActivatorUtilities.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\ActivatorUtilities\ActivatorUtilitiesConstructorAttribute.cs">
+ <Link>Common\src\Extensions\ActivatorUtilities\ActivatorUtilitiesConstructorAttribute.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\ActivatorUtilities\ObjectFactory.cs">
+ <Link>Common\src\Extensions\ActivatorUtilities\ObjectFactory.cs</Link>
+ </Compile>
</ItemGroup>
</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyInjection.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
using System;
using System.Collections.Generic;
-using Microsoft.Extensions.DependencyInjection.Abstractions;
namespace Microsoft.Extensions.DependencyInjection
{
var service = provider.GetService(serviceType);
if (service == null)
{
- throw new InvalidOperationException(Resources.FormatNoServiceRegistered(serviceType));
+ throw new InvalidOperationException(SR.Format(SR.NoServiceRegistered, serviceType));
}
return service;
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.DependencyInjection.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
</PropertyGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.DependencyInjection.cs" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.DependencyInjection.Abstractions\ref\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+ <Reference Include="System.Threading.Tasks.Extensions" />
<Reference Include="Microsoft.Bcl.AsyncInterfaces" />
</ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>$(DefaultNetCoreTargetFramework);net461;netstandard2.0;netstandard2.1</TargetFrameworks>
- <GenerateDocumentationFile>true</GenerateDocumentationFile>
+ <TargetFrameworks>net461;netstandard2.0;netstandard2.1</TargetFrameworks>
<ILEmitBackend Condition="$(TargetFramework) != 'netstandard2.0'">True</ILEmitBackend>
<DefineConstants Condition="'$(ILEmitBackend)' == 'True'">$(DefineConstants);IL_EMIT</DefineConstants>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.DependencyInjection.Tests" />
- <InternalsVisibleTo Include="Microsoft.Extensions.DependencyInjection.Performance" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'net461' Or '$(TargetFramework)' == 'netstandard2.0'">
<Reference Include="Microsoft.Bcl.AsyncInterfaces" />
+ <Reference Include="System.Threading.Tasks.Extensions" />
+ </ItemGroup>
+
+ <ItemGroup Condition="'$(TargetsNetFx)' == 'true'">
+ <Reference Include="mscorlib" />
+ <Reference Include="System.Linq.Expressions" />
+ <Reference Include="System" />
+ <Reference Include="System.Core" />
</ItemGroup>
<ItemGroup>
+ <Compile Include="**\*.cs" />
<Compile Remove="ServiceLookup\ILEmit\**\*.cs" />
<Compile Condition="'$(ILEmitBackend)' == 'True'" Include="ServiceLookup\ILEmit\*.cs" />
- <Compile Include="$(SharedSourceRoot)ParameterDefaultValue\*.cs" />
- <Compile Include="$(SharedSourceRoot)TypeNameHelper\*.cs" />
+ <Compile Include="$(CommonPath)Extensions\ParameterDefaultValue\ParameterDefaultValue.cs">
+ <Link>Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\TypeNameHelper\TypeNameHelper.cs">
+ <Link>Common\src\Extensions\TypeNameHelper\TypeNameHelper.cs</Link>
+ </Compile>
</ItemGroup>
</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyInjection.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
+[assembly: InternalsVisibleTo("Microsoft.Extensions.DependencyInjection.Performance, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
\ No newline at end of file
private string CreateCircularDependencyExceptionMessage(Type type)
{
var messageBuilder = new StringBuilder();
- messageBuilder.AppendFormat(Resources.CircularDependencyException, TypeNameHelper.GetTypeDisplayName(type));
+ messageBuilder.AppendFormat(SR.CircularDependencyException, TypeNameHelper.GetTypeDisplayName(type));
messageBuilder.AppendLine();
AppendResolutionPath(messageBuilder, type);
if (implementationTypeInfo == null || !implementationTypeInfo.IsGenericTypeDefinition)
{
throw new ArgumentException(
- Resources.FormatOpenGenericServiceRequiresOpenGenericImplementation(descriptor.ServiceType),
+ SR.Format(SR.OpenGenericServiceRequiresOpenGenericImplementation, descriptor.ServiceType),
"descriptors");
}
if (implementationTypeInfo.IsAbstract || implementationTypeInfo.IsInterface)
{
throw new ArgumentException(
- Resources.FormatTypeCannotBeActivated(descriptor.ImplementationType, descriptor.ServiceType));
+ SR.Format(SR.TypeCannotBeActivated, descriptor.ImplementationType, descriptor.ServiceType));
}
}
else if (descriptor.ImplementationInstance == null && descriptor.ImplementationFactory == null)
implementationTypeInfo.IsInterface)
{
throw new ArgumentException(
- Resources.FormatTypeCannotBeActivated(descriptor.ImplementationType, descriptor.ServiceType));
+ SR.Format(SR.TypeCannotBeActivated, descriptor.ImplementationType, descriptor.ServiceType));
}
}
if (constructors.Length == 0)
{
- throw new InvalidOperationException(Resources.FormatNoConstructorMatch(implementationType));
+ throw new InvalidOperationException(SR.Format(SR.NoConstructorMatch, implementationType));
}
else if (constructors.Length == 1)
{
// Ambiguous match exception
var message = string.Join(
Environment.NewLine,
- Resources.FormatAmbiguousConstructorException(implementationType),
+ SR.Format(SR.AmbiguousConstructorException, implementationType),
bestConstructor,
constructors[i]);
throw new InvalidOperationException(message);
if (bestConstructor == null)
{
throw new InvalidOperationException(
- Resources.FormatUnableToActivateTypeException(implementationType));
+ SR.Format(SR.UnableToActivateTypeException, implementationType));
}
else
{
{
if (throwIfCallSiteNotFound)
{
- throw new InvalidOperationException(Resources.FormatCannotResolveService(
+ throw new InvalidOperationException(SR.Format(SR.CannotResolveService,
parameterType,
implementationType));
}
if (serviceType == scopedService)
{
throw new InvalidOperationException(
- Resources.FormatDirectScopedResolvedFromRootException(serviceType,
+ SR.Format(SR.DirectScopedResolvedFromRootException, serviceType,
nameof(ServiceLifetime.Scoped).ToLowerInvariant()));
}
throw new InvalidOperationException(
- Resources.FormatScopedResolvedFromRootException(
+ SR.Format(SR.ScopedResolvedFromRootException,
serviceType,
scopedService,
nameof(ServiceLifetime.Scoped).ToLowerInvariant()));
}
if (state.Singleton != null)
{
- throw new InvalidOperationException(Resources.FormatScopedInSingletonException(
+ throw new InvalidOperationException(SR.Format(SR.ScopedInSingletonException,
scopedCallSite.ServiceType,
state.Singleton.ServiceType,
nameof(ServiceLifetime.Scoped).ToLowerInvariant(),
{
if (defaultValue != null && !serviceType.IsInstanceOfType(defaultValue))
{
- throw new ArgumentException(Resources.FormatConstantCantBeConvertedToServiceType(defaultValue.GetType(), serviceType));
+ throw new ArgumentException(SR.Format(SR.ConstantCantBeConvertedToServiceType, defaultValue.GetType(), serviceType));
}
DefaultValue = defaultValue;
{
if (!serviceType.IsAssignableFrom(constructorInfo.DeclaringType))
{
- throw new ArgumentException(Resources.FormatImplementationTypeCantBeConvertedToServiceType(constructorInfo.DeclaringType, serviceType));
+ throw new ArgumentException(SR.Format(SR.ImplementationTypeCantBeConvertedToServiceType, constructorInfo.DeclaringType, serviceType));
}
ServiceType = serviceType;
}
else
{
- throw new InvalidOperationException(Resources.FormatAsyncDisposableServiceDispose(TypeNameHelper.GetTypeDisplayName(toDispose[i])));
+ throw new InvalidOperationException(SR.Format(SR.AsyncDisposableServiceDispose, TypeNameHelper.GetTypeDisplayName(toDispose[i])));
}
}
}
<PropertyGroup>
<RootNamespace>Microsoft.Extensions.FileProviders</RootNamespace>
<TargetFrameworks>netstandard2.0</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
<Compile Include="$(CommonPath)Extensions\EmptyDisposable.cs">
<Link>Common\src\Extensions\EmptyDisposable.cs</Link>
</Compile>
- <Compile Include="**\*.cs" />
</ItemGroup>
<ItemGroup>
<PropertyGroup>
<RootNamespace>Microsoft.Extensions.FileProviders</RootNamespace>
<TargetFrameworks>netstandard2.0</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <Compile Include="**\*.cs" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.FileProviders.Abstractions" />
<Reference Include="Microsoft.Extensions.Primitives" />
</ItemGroup>
<PropertyGroup>
<RootNamespace>Microsoft.Extensions.FileProviders.Composite</RootNamespace>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <Compile Include="**\*.cs" />
- </ItemGroup>
-
- <ItemGroup>
<PackageReference Include="Moq" Version="$(MoqVersion)" />
</ItemGroup>
- <ItemGroup>
- <Reference Include="Microsoft.Extensions.FileProviders.Abstractions" />
- <Reference Include="Microsoft.Extensions.FileProviders.Composite" />
- <Reference Include="Microsoft.Extensions.Primitives" />
- </ItemGroup>
-
</Project>
<RootNamespace>Microsoft.Extensions.FileProviders</RootNamespace>
<TargetFrameworks>netstandard2.0</TargetFrameworks>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
<Compile Include="$(CommonPath)Extensions\NonCapturingTimer\NonCapturingTimer.cs">
<Link>Common\src\Extensions\NonCapturingTimer\NonCapturingTimer.cs</Link>
</Compile>
- <Compile Include="**\*.cs" />
</ItemGroup>
<ItemGroup>
<PropertyGroup>
<RootNamespace>Microsoft.Extensions.FileProviders.Physical</RootNamespace>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <Compile Include="**\*.cs" />
<Compile Include="$(CommonTestPath)Extensions\TestingUtils\Microsoft.AspNetCore.Testing\src\xunit\ITestCondition.cs">
<Link>Common\tests\Extensions\TestingUtils\Microsoft.AspNetCore.Testing\src\xunit\ITestCondition.cs</Link>
</Compile>
<ItemGroup>
<PackageReference Include="Moq" Version="$(MoqVersion)" />
- </ItemGroup>
-
- <ItemGroup>
- <!-- Some internal types are needed, so we reference the implementation assembly, rather than the reference assembly. -->
- <DefaultReferenceExclusions Include="Microsoft.Extensions.FileProviders.Physical" />
<ReferenceFromRuntime Include="Microsoft.Extensions.FileProviders.Physical" />
</ItemGroup>
- <ItemGroup>
- <Reference Include="Microsoft.Extensions.FileProviders.Abstractions" />
- <Reference Include="Microsoft.Extensions.FileProviders.Physical" />
- <Reference Include="Microsoft.Extensions.FileSystemGlobbing" />
- <Reference Include="Microsoft.Extensions.Primitives" />
- </ItemGroup>
-
</Project>
<PropertyGroup>
<TargetFrameworks>netstandard2.0</TargetFrameworks>
<NoWarn>$(NoWarn);CS1591</NoWarn>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
<Compile Include="$(CommonPath)Extensions\HashCodeCombiner\HashCodeCombiner.cs">
<Link>Common\src\Extensions\HashCodeCombiner\HashCodeCombiner.cs</Link>
</Compile>
- <Compile Include="**\*.cs"></Compile>
</ItemGroup>
</Project>
<PropertyGroup>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
- <ItemGroup>
- <Reference Include="Microsoft.Extensions.FileSystemGlobbing" />
- </ItemGroup>
-
- <ItemGroup>
- <Compile Include="**\*.cs" />
- </ItemGroup>
-
</Project>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Hosting.Abstractions.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.DependencyInjection
{
public virtual void Dispose() { }
protected abstract System.Threading.Tasks.Task ExecuteAsync(System.Threading.CancellationToken stoppingToken);
public virtual System.Threading.Tasks.Task StartAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
- [System.Diagnostics.DebuggerStepThroughAttribute]
public virtual System.Threading.Tasks.Task StopAsync(System.Threading.CancellationToken cancellationToken) { throw null; }
}
[System.ObsoleteAttribute("This type is obsolete and will be removed in a future version. The recommended alternative is Microsoft.Extensions.Hosting.Environments.", false)]
public partial class HostBuilderContext
{
public HostBuilderContext(System.Collections.Generic.IDictionary<object, object> properties) { }
- public Microsoft.Extensions.Configuration.IConfiguration Configuration { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public Microsoft.Extensions.Hosting.IHostEnvironment HostingEnvironment { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public System.Collections.Generic.IDictionary<object, object> Properties { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public Microsoft.Extensions.Configuration.IConfiguration Configuration { get { throw null; } set { } }
+ public Microsoft.Extensions.Hosting.IHostEnvironment HostingEnvironment { get { throw null; } set { } }
+ public System.Collections.Generic.IDictionary<object, object> Properties { get { throw null; } }
}
public static partial class HostDefaults
{
public static partial class HostingAbstractionsHostBuilderExtensions
{
public static Microsoft.Extensions.Hosting.IHost Start(this Microsoft.Extensions.Hosting.IHostBuilder hostBuilder) { throw null; }
- [System.Diagnostics.DebuggerStepThroughAttribute]
public static System.Threading.Tasks.Task<Microsoft.Extensions.Hosting.IHost> StartAsync(this Microsoft.Extensions.Hosting.IHostBuilder hostBuilder, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
}
public static partial class HostingAbstractionsHostExtensions
{
public static void Run(this Microsoft.Extensions.Hosting.IHost host) { }
- [System.Diagnostics.DebuggerStepThroughAttribute]
public static System.Threading.Tasks.Task RunAsync(this Microsoft.Extensions.Hosting.IHost host, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
public static void Start(this Microsoft.Extensions.Hosting.IHost host) { }
public static System.Threading.Tasks.Task StopAsync(this Microsoft.Extensions.Hosting.IHost host, System.TimeSpan timeout) { throw null; }
public static void WaitForShutdown(this Microsoft.Extensions.Hosting.IHost host) { }
- [System.Diagnostics.DebuggerStepThroughAttribute]
public static System.Threading.Tasks.Task WaitForShutdownAsync(this Microsoft.Extensions.Hosting.IHost host, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) { throw null; }
}
public static partial class HostingEnvironmentExtensions
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
</PropertyGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
<Reference Include="Microsoft.Bcl.AsyncInterfaces" />
</ItemGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Hosting.Abstractions.cs" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.DependencyInjection.Abstractions\ref\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.FileProviders.Abstractions\ref\Microsoft.Extensions.FileProviders.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Logging.Abstractions\ref\Microsoft.Extensions.Logging.Abstractions.csproj" />
</ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0;$(NetCoreAppCurrent)</TargetFrameworks>
<NoWarn>$(NoWarn);CS1591</NoWarn>
<RootNamespace>Microsoft.Extensions.Hosting</RootNamespace>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
<Reference Include="Microsoft.Extensions.FileProviders.Abstractions" />
<Reference Include="Microsoft.Extensions.Logging.Abstractions" />
+ <Reference Include="System.ComponentModel" />
+ <Reference Include="System.Runtime" />
</ItemGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
<Reference Include="Microsoft.Bcl.AsyncInterfaces" />
+ <Reference Include="System.Threading.Tasks.Extensions" />
</ItemGroup>
</Project>
-<!-- This file is automatically generated. -->
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
</PropertyGroup>
- <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
- <Compile Include="Microsoft.Extensions.Http.netstandard2.0.cs" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
- <Reference Include="Microsoft.Extensions.Logging" />
- <Reference Include="Microsoft.Extensions.Options" />
- </ItemGroup>
-<ItemGroup Condition="'$(TargetFramework)' == '$(DefaultNetCoreTargetFramework)'">
- <Compile Include="Microsoft.Extensions.Http.netcoreapp.cs" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
- <Reference Include="Microsoft.Extensions.Logging" />
- <Reference Include="Microsoft.Extensions.Options" />
+<ItemGroup>
+ <Compile Include="Microsoft.Extensions.Http.cs" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.DependencyInjection.Abstractions\ref\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Logging\ref\Microsoft.Extensions.Logging.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Options\ref\Microsoft.Extensions.Options.csproj" />
</ItemGroup>
</Project>
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-namespace Microsoft.Extensions.DependencyInjection
-{
- public static partial class HttpClientBuilderExtensions
- {
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpMessageHandler(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Func<System.IServiceProvider, System.Net.Http.DelegatingHandler> configureHandler) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpMessageHandler(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Func<System.Net.Http.DelegatingHandler> configureHandler) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpMessageHandler<THandler>(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder) where THandler : System.Net.Http.DelegatingHandler { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddTypedClient<TClient>(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddTypedClient<TClient>(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Func<System.Net.Http.HttpClient, System.IServiceProvider, TClient> factory) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddTypedClient<TClient>(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Func<System.Net.Http.HttpClient, TClient> factory) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddTypedClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder ConfigureHttpClient(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Action<System.IServiceProvider, System.Net.Http.HttpClient> configureClient) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder ConfigureHttpClient(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Action<System.Net.Http.HttpClient> configureClient) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder ConfigureHttpMessageHandlerBuilder(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Action<Microsoft.Extensions.Http.HttpMessageHandlerBuilder> configureBuilder) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder ConfigurePrimaryHttpMessageHandler(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Func<System.IServiceProvider, System.Net.Http.HttpMessageHandler> configureHandler) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder ConfigurePrimaryHttpMessageHandler(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Func<System.Net.Http.HttpMessageHandler> configureHandler) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder ConfigurePrimaryHttpMessageHandler<THandler>(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder) where THandler : System.Net.Http.HttpMessageHandler { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder RedactLoggedHeaders(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Collections.Generic.IEnumerable<string> redactedLoggedHeaderNames) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder RedactLoggedHeaders(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.Func<string, bool> shouldRedactHeaderValue) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder SetHandlerLifetime(this Microsoft.Extensions.DependencyInjection.IHttpClientBuilder builder, System.TimeSpan handlerLifetime) { throw null; }
- }
- public static partial class HttpClientFactoryServiceCollectionExtensions
- {
- public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddHttpClient(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Action<System.IServiceProvider, System.Net.Http.HttpClient> configureClient) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Action<System.Net.Http.HttpClient> configureClient) { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<System.IServiceProvider, System.Net.Http.HttpClient> configureClient) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<System.Net.Http.HttpClient> configureClient) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Action<System.IServiceProvider, System.Net.Http.HttpClient> configureClient) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Action<System.Net.Http.HttpClient> configureClient) where TClient : class { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<System.IServiceProvider, System.Net.Http.HttpClient> configureClient) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Action<System.Net.Http.HttpClient> configureClient) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Func<System.Net.Http.HttpClient, System.IServiceProvider, TImplementation> factory) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, System.Func<System.Net.Http.HttpClient, TImplementation> factory) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Action<System.IServiceProvider, System.Net.Http.HttpClient> configureClient) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Action<System.Net.Http.HttpClient> configureClient) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Func<System.Net.Http.HttpClient, System.IServiceProvider, TImplementation> factory) where TClient : class where TImplementation : class, TClient { throw null; }
- public static Microsoft.Extensions.DependencyInjection.IHttpClientBuilder AddHttpClient<TClient, TImplementation>(this Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name, System.Func<System.Net.Http.HttpClient, TImplementation> factory) where TClient : class where TImplementation : class, TClient { throw null; }
- }
- public partial interface IHttpClientBuilder
- {
- string Name { get; }
- Microsoft.Extensions.DependencyInjection.IServiceCollection Services { get; }
- }
-}
-namespace Microsoft.Extensions.Http
-{
- public partial class HttpClientFactoryOptions
- {
- public HttpClientFactoryOptions() { }
- public System.TimeSpan HandlerLifetime { get { throw null; } set { } }
- public System.Collections.Generic.IList<System.Action<System.Net.Http.HttpClient>> HttpClientActions { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Collections.Generic.IList<System.Action<Microsoft.Extensions.Http.HttpMessageHandlerBuilder>> HttpMessageHandlerBuilderActions { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Func<string, bool> ShouldRedactHeaderValue { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- public bool SuppressHandlerScope { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] set { } }
- }
- public abstract partial class HttpMessageHandlerBuilder
- {
- protected HttpMessageHandlerBuilder() { }
- public abstract System.Collections.Generic.IList<System.Net.Http.DelegatingHandler> AdditionalHandlers { get; }
- public abstract string Name { get; set; }
- public abstract System.Net.Http.HttpMessageHandler PrimaryHandler { get; set; }
- public virtual System.IServiceProvider Services { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public abstract System.Net.Http.HttpMessageHandler Build();
- protected internal static System.Net.Http.HttpMessageHandler CreateHandlerPipeline(System.Net.Http.HttpMessageHandler primaryHandler, System.Collections.Generic.IEnumerable<System.Net.Http.DelegatingHandler> additionalHandlers) { throw null; }
- }
- public partial interface IHttpMessageHandlerBuilderFilter
- {
- System.Action<Microsoft.Extensions.Http.HttpMessageHandlerBuilder> Configure(System.Action<Microsoft.Extensions.Http.HttpMessageHandlerBuilder> next);
- }
- public partial interface ITypedHttpClientFactory<TClient>
- {
- TClient CreateClient(System.Net.Http.HttpClient httpClient);
- }
-}
-namespace Microsoft.Extensions.Http.Logging
-{
- public partial class LoggingHttpMessageHandler : System.Net.Http.DelegatingHandler
- {
- public LoggingHttpMessageHandler(Microsoft.Extensions.Logging.ILogger logger) { }
- public LoggingHttpMessageHandler(Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Http.HttpClientFactoryOptions options) { }
- [System.Diagnostics.DebuggerStepThroughAttribute]
- protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw null; }
- }
- public partial class LoggingScopeHttpMessageHandler : System.Net.Http.DelegatingHandler
- {
- public LoggingScopeHttpMessageHandler(Microsoft.Extensions.Logging.ILogger logger) { }
- public LoggingScopeHttpMessageHandler(Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Http.HttpClientFactoryOptions options) { }
- [System.Diagnostics.DebuggerStepThroughAttribute]
- protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw null; }
- }
-}
-namespace System.Net.Http
-{
- public static partial class HttpClientFactoryExtensions
- {
- public static System.Net.Http.HttpClient CreateClient(this System.Net.Http.IHttpClientFactory factory) { throw null; }
- }
- public static partial class HttpMessageHandlerFactoryExtensions
- {
- public static System.Net.Http.HttpMessageHandler CreateHandler(this System.Net.Http.IHttpMessageHandlerFactory factory) { throw null; }
- }
- public partial interface IHttpClientFactory
- {
- System.Net.Http.HttpClient CreateClient(string name);
- }
- public partial interface IHttpMessageHandlerFactory
- {
- System.Net.Http.HttpMessageHandler CreateHandler(string name);
- }
-}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <Description>
- The HttpClient factory is a pattern for configuring and retrieving named HttpClients in a composable way. The HttpClient factory provides extensibility to plug in DelegatingHandlers that address cross-cutting concerns such as service location, load balancing, and reliability. The default HttpClient factory provides built-in diagnostics and logging and manages the lifetimes of connections in a performant way.
- Commonly used types:
- System.Net.Http.IHttpClientFactory
- </Description>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
<NoWarn>$(NoWarn);CS1591</NoWarn>
- <GenerateDocumentationFile>true</GenerateDocumentationFile>
- <PackageTags>aspnetcore;httpclient</PackageTags>
- <IsPackable>true</IsPackable>
- <IsShipping>true</IsShipping>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Http.Tests" />
- <InternalsVisibleTo Include="DynamicProxyGenAssembly2" />
- </ItemGroup>
-
- <ItemGroup>
- <Compile Include="$(SharedSourceRoot)NonCapturingTimer\**\*.cs" />
- <Compile Include="$(SharedSourceRoot)TypeNameHelper\**\*.cs" />
- <Compile Include="$(SharedSourceRoot)ValueStopwatch\**\*.cs" />
+ <Compile Include="$(CommonPath)Extensions\NonCapturingTimer\NonCapturingTimer.cs">
+ <Link>Common\src\Extensions\NonCapturingTimer\NonCapturingTimer.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\TypeNameHelper.cs">
+ <Link>Common\src\Extensions\TypeNameHelper.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\ValueStopwatch\ValueStopwatch.cs">
+ <Link>Common\src\Extensions\ValueStopwatch\ValueStopwatch.cs</Link>
+ </Compile>
</ItemGroup>
<ItemGroup>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Http.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Logging.Abstractions.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.Logging
{
- [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
public readonly partial struct EventId
{
private readonly object _dummy;
private readonly int _dummyPrimitive;
public EventId(int id, string name = null) { throw null; }
- public int Id { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public int Id { 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 int GetHashCode() { throw null; }
public partial class NullLogger : Microsoft.Extensions.Logging.ILogger
{
internal NullLogger() { }
- public static Microsoft.Extensions.Logging.Abstractions.NullLogger Instance { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ 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 partial class NullLoggerProvider : Microsoft.Extensions.Logging.ILoggerProvider, System.IDisposable
{
internal NullLoggerProvider() { }
- public static Microsoft.Extensions.Logging.Abstractions.NullLoggerProvider Instance { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public static Microsoft.Extensions.Logging.Abstractions.NullLoggerProvider Instance { get { throw null; } }
public Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName) { throw null; }
public void Dispose() { }
}
if (actualCount != expectedNamedParameterCount)
{
throw new ArgumentException(
- Resource.FormatUnexpectedNumberOfNamedParameters(formatString, expectedNamedParameterCount, actualCount));
+ SR.Format(SR.UnexpectedNumberOfNamedParameters, expectedNamedParameterCount, actualCount));
}
return logValuesFormatter;
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFramework>netstandard2.0</TargetFramework>
+ <TargetFrameworks>netstandard2.0</TargetFrameworks>
<NoWarn>$(NoWarn);CS1591</NoWarn>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Logging.Tests" />
- </ItemGroup>
-
- <ItemGroup>
- <Compile Include="../../shared/*.cs" />
- <Compile Include="../../../Shared/src/TypeNameHelper/TypeNameHelper.cs" />
+ <Compile Include="$(CommonPath)Extensions\TypeNameHelper\TypeNameHelper.cs">
+ <Link>Common\src\Extensions\TypeNameHelper\TypeNameHelper.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\Logging\NullExternalScopeProvider.cs">
+ <Link>Common\src\Extensions\Logging\NullExternalScopeProvider.cs</Link>
+ </Compile>
+ <Compile Include="$(CommonPath)Extensions\Logging\NullScope.cs">
+ <Link>Common\src\Extensions\Logging\NullScope.cs</Link>
+ </Compile>
</ItemGroup>
</Project>
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Logging.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Options.ConfigurationExtensions.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.DependencyInjection
{
{
public ConfigurationChangeTokenSource(Microsoft.Extensions.Configuration.IConfiguration config) { }
public ConfigurationChangeTokenSource(string name, Microsoft.Extensions.Configuration.IConfiguration config) { }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public string Name { get { throw null; } }
public Microsoft.Extensions.Primitives.IChangeToken GetChangeToken() { throw null; }
}
public partial class ConfigureFromConfigurationOptions<TOptions> : Microsoft.Extensions.Options.ConfigureOptions<TOptions> where TOptions : class
</PropertyGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Options.ConfigurationExtensions.cs" />
- <Reference Include="Microsoft.Extensions.Configuration.Abstractions" />
- <Reference Include="Microsoft.Extensions.Configuration.Binder" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
- <Reference Include="Microsoft.Extensions.Options" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration.Abstractions\ref\Microsoft.Extensions.Configuration.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Configuration.Binder\ref\Microsoft.Extensions.Configuration.Binder.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.DependencyInjection.Abstractions\ref\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Options\ref\Microsoft.Extensions.Options.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Primitives\ref\Microsoft.Extensions.Primitives.csproj" />
</ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0;$(NetCoreAppCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.Extensions.Configuration.Binder" />
<Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
<Reference Include="Microsoft.Extensions.Options" />
+ <Reference Include="Microsoft.Extensions.Primitives" />
+ </ItemGroup>
+
+ <ItemGroup Condition="'$(TargetsNetCoreApp)' == 'true'">
+ <Reference Include="System.ComponentModel" />
+ <Reference Include="System.Runtime" />
</ItemGroup>
</Project>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Options.DataAnnotations.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.DependencyInjection
{
public partial class DataAnnotationValidateOptions<TOptions> : Microsoft.Extensions.Options.IValidateOptions<TOptions> where TOptions : class
{
public DataAnnotationValidateOptions(string name) { }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public string Name { get { throw null; } }
public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string name, TOptions options) { throw null; }
}
}
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
</PropertyGroup>
- <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
- <Reference Include="System.ComponentModel.Annotations" />
- </ItemGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Options.DataAnnotations.cs" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
- <Reference Include="Microsoft.Extensions.Options" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.DependencyInjection.Abstractions\ref\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Options\ref\Microsoft.Extensions.Options.csproj" />
</ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0;$(NetCoreAppCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.Extensions.Options" />
</ItemGroup>
- <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+ <ItemGroup>
<Reference Include="System.ComponentModel.Annotations" />
</ItemGroup>
+ <ItemGroup Condition="'$(TargetsNetCoreApp)' == 'true'">
+ <Reference Include="System.Collections" />
+ <Reference Include="System.ComponentModel" />
+ <Reference Include="System.Runtime" />
+ </ItemGroup>
+
</Project>
--- /dev/null
+<Project DefaultTargets="Build">
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.props))" />
+ <ItemGroup>
+ <ProjectReference Include="..\src\Microsoft.Extensions.Options.csproj">
+ <SupportedFramework>net461;netcoreapp2.0;uap10.0.16299;$(AllXamarinFrameworks)</SupportedFramework>
+ </ProjectReference>
+ </ItemGroup>
+ <Import Project="$([MSBuild]::GetPathOfFileAbove(Directory.Build.targets))" />
+</Project>
\ No newline at end of file
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+// ------------------------------------------------------------------------------
+// Changes to this file must follow the https://aka.ms/api-review process.
+// ------------------------------------------------------------------------------
namespace Microsoft.Extensions.DependencyInjection
{
public partial class ConfigureNamedOptions<TOptions> : Microsoft.Extensions.Options.IConfigureNamedOptions<TOptions>, Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class
{
public ConfigureNamedOptions(string name, System.Action<TOptions> action) { }
- public System.Action<TOptions> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions> Action { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void Configure(string name, TOptions options) { }
public void Configure(TOptions options) { }
}
public partial class ConfigureNamedOptions<TOptions, TDep> : Microsoft.Extensions.Options.IConfigureNamedOptions<TOptions>, Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class where TDep : class
{
public ConfigureNamedOptions(string name, TDep dependency, System.Action<TOptions, TDep> action) { }
- public System.Action<TOptions, TDep> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep Dependency { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep> Action { get { throw null; } }
+ public TDep Dependency { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void Configure(string name, TOptions options) { }
public void Configure(TOptions options) { }
}
public partial class ConfigureNamedOptions<TOptions, TDep1, TDep2> : Microsoft.Extensions.Options.IConfigureNamedOptions<TOptions>, Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class
{
public ConfigureNamedOptions(string name, TDep1 dependency, TDep2 dependency2, System.Action<TOptions, TDep1, TDep2> action) { }
- public System.Action<TOptions, TDep1, TDep2> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void Configure(string name, TOptions options) { }
public void Configure(TOptions options) { }
}
public partial class ConfigureNamedOptions<TOptions, TDep1, TDep2, TDep3> : Microsoft.Extensions.Options.IConfigureNamedOptions<TOptions>, Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class where TDep3 : class
{
public ConfigureNamedOptions(string name, TDep1 dependency, TDep2 dependency2, TDep3 dependency3, System.Action<TOptions, TDep1, TDep2, TDep3> action) { }
- public System.Action<TOptions, TDep1, TDep2, TDep3> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2, TDep3> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void Configure(string name, TOptions options) { }
public void Configure(TOptions options) { }
}
public partial class ConfigureNamedOptions<TOptions, TDep1, TDep2, TDep3, TDep4> : Microsoft.Extensions.Options.IConfigureNamedOptions<TOptions>, Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class where TDep3 : class where TDep4 : class
{
public ConfigureNamedOptions(string name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, System.Action<TOptions, TDep1, TDep2, TDep3, TDep4> action) { }
- public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep4 Dependency4 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public TDep4 Dependency4 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void Configure(string name, TOptions options) { }
public void Configure(TOptions options) { }
}
public partial class ConfigureNamedOptions<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> : Microsoft.Extensions.Options.IConfigureNamedOptions<TOptions>, Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class where TDep3 : class where TDep4 : class where TDep5 : class
{
public ConfigureNamedOptions(string name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, TDep5 dependency5, System.Action<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> action) { }
- public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep4 Dependency4 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep5 Dependency5 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public TDep4 Dependency4 { get { throw null; } }
+ public TDep5 Dependency5 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void Configure(string name, TOptions options) { }
public void Configure(TOptions options) { }
}
public partial class ConfigureOptions<TOptions> : Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class
{
public ConfigureOptions(System.Action<TOptions> action) { }
- public System.Action<TOptions> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions> Action { get { throw null; } }
public virtual void Configure(TOptions options) { }
}
public partial interface IConfigureNamedOptions<in TOptions> : Microsoft.Extensions.Options.IConfigureOptions<TOptions> where TOptions : class
public partial class OptionsBuilder<TOptions> where TOptions : class
{
public OptionsBuilder(Microsoft.Extensions.DependencyInjection.IServiceCollection services, string name) { }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public Microsoft.Extensions.DependencyInjection.IServiceCollection Services { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public string Name { get { throw null; } }
+ public Microsoft.Extensions.DependencyInjection.IServiceCollection Services { get { throw null; } }
public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Configure(System.Action<TOptions> configureOptions) { throw null; }
public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Configure<TDep>(System.Action<TOptions, TDep> configureOptions) where TDep : class { throw null; }
public virtual Microsoft.Extensions.Options.OptionsBuilder<TOptions> Configure<TDep1, TDep2>(System.Action<TOptions, TDep1, TDep2> configureOptions) where TDep1 : class where TDep2 : class { throw null; }
public partial class OptionsValidationException : System.Exception
{
public OptionsValidationException(string optionsName, System.Type optionsType, System.Collections.Generic.IEnumerable<string> failureMessages) { }
- public System.Collections.Generic.IEnumerable<string> Failures { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Collections.Generic.IEnumerable<string> Failures { get { throw null; } }
public override string Message { get { throw null; } }
- public string OptionsName { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Type OptionsType { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public string OptionsName { get { throw null; } }
+ public System.Type OptionsType { get { throw null; } }
}
public partial class OptionsWrapper<TOptions> : Microsoft.Extensions.Options.IOptions<TOptions> where TOptions : class
{
public OptionsWrapper(TOptions options) { }
- public TOptions Value { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public TOptions Value { get { throw null; } }
}
public partial class PostConfigureOptions<TOptions> : Microsoft.Extensions.Options.IPostConfigureOptions<TOptions> where TOptions : class
{
public PostConfigureOptions(string name, System.Action<TOptions> action) { }
- public System.Action<TOptions> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions> Action { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void PostConfigure(string name, TOptions options) { }
}
public partial class PostConfigureOptions<TOptions, TDep> : Microsoft.Extensions.Options.IPostConfigureOptions<TOptions> where TOptions : class where TDep : class
{
public PostConfigureOptions(string name, TDep dependency, System.Action<TOptions, TDep> action) { }
- public System.Action<TOptions, TDep> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep Dependency { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep> Action { get { throw null; } }
+ public TDep Dependency { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void PostConfigure(string name, TOptions options) { }
public void PostConfigure(TOptions options) { }
}
public partial class PostConfigureOptions<TOptions, TDep1, TDep2> : Microsoft.Extensions.Options.IPostConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class
{
public PostConfigureOptions(string name, TDep1 dependency, TDep2 dependency2, System.Action<TOptions, TDep1, TDep2> action) { }
- public System.Action<TOptions, TDep1, TDep2> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void PostConfigure(string name, TOptions options) { }
public void PostConfigure(TOptions options) { }
}
public partial class PostConfigureOptions<TOptions, TDep1, TDep2, TDep3> : Microsoft.Extensions.Options.IPostConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class where TDep3 : class
{
public PostConfigureOptions(string name, TDep1 dependency, TDep2 dependency2, TDep3 dependency3, System.Action<TOptions, TDep1, TDep2, TDep3> action) { }
- public System.Action<TOptions, TDep1, TDep2, TDep3> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2, TDep3> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void PostConfigure(string name, TOptions options) { }
public void PostConfigure(TOptions options) { }
}
public partial class PostConfigureOptions<TOptions, TDep1, TDep2, TDep3, TDep4> : Microsoft.Extensions.Options.IPostConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class where TDep3 : class where TDep4 : class
{
public PostConfigureOptions(string name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, System.Action<TOptions, TDep1, TDep2, TDep3, TDep4> action) { }
- public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep4 Dependency4 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public TDep4 Dependency4 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void PostConfigure(string name, TOptions options) { }
public void PostConfigure(TOptions options) { }
}
public partial class PostConfigureOptions<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> : Microsoft.Extensions.Options.IPostConfigureOptions<TOptions> where TOptions : class where TDep1 : class where TDep2 : class where TDep3 : class where TDep4 : class where TDep5 : class
{
public PostConfigureOptions(string name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, TDep5 dependency5, System.Action<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> action) { }
- public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> Action { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep4 Dependency4 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep5 Dependency5 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public System.Action<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> Action { get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public TDep4 Dependency4 { get { throw null; } }
+ public TDep5 Dependency5 { get { throw null; } }
+ public string Name { get { throw null; } }
public virtual void PostConfigure(string name, TOptions options) { }
public void PostConfigure(TOptions options) { }
}
public static readonly Microsoft.Extensions.Options.ValidateOptionsResult Skip;
public static readonly Microsoft.Extensions.Options.ValidateOptionsResult Success;
public ValidateOptionsResult() { }
- public bool Failed { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] protected set { } }
- public string FailureMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] protected set { } }
- public System.Collections.Generic.IEnumerable<string> Failures { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] protected set { } }
- public bool Skipped { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] protected set { } }
- public bool Succeeded { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute] protected set { } }
+ public bool Failed { get { throw null; } protected set { } }
+ public string FailureMessage { get { throw null; } protected set { } }
+ public System.Collections.Generic.IEnumerable<string> Failures { get { throw null; } protected set { } }
+ public bool Skipped { get { throw null; } protected set { } }
+ public bool Succeeded { get { throw null; } protected set { } }
public static Microsoft.Extensions.Options.ValidateOptionsResult Fail(System.Collections.Generic.IEnumerable<string> failures) { throw null; }
public static Microsoft.Extensions.Options.ValidateOptionsResult Fail(string failureMessage) { throw null; }
}
public partial class ValidateOptions<TOptions> : Microsoft.Extensions.Options.IValidateOptions<TOptions> where TOptions : class
{
public ValidateOptions(string name, System.Func<TOptions, bool> validation, string failureMessage) { }
- public string FailureMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Func<TOptions, bool> Validation { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public string FailureMessage { get { throw null; } }
+ public string Name { get { throw null; } }
+ public System.Func<TOptions, bool> Validation { get { throw null; } }
public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string name, TOptions options) { throw null; }
}
public partial class ValidateOptions<TOptions, TDep> : Microsoft.Extensions.Options.IValidateOptions<TOptions> where TOptions : class
{
public ValidateOptions(string name, TDep dependency, System.Func<TOptions, TDep, bool> validation, string failureMessage) { }
- public TDep Dependency { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string FailureMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Func<TOptions, TDep, bool> Validation { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public TDep Dependency { get { throw null; } }
+ public string FailureMessage { get { throw null; } }
+ public string Name { get { throw null; } }
+ public System.Func<TOptions, TDep, bool> Validation { get { throw null; } }
public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string name, TOptions options) { throw null; }
}
public partial class ValidateOptions<TOptions, TDep1, TDep2> : Microsoft.Extensions.Options.IValidateOptions<TOptions> where TOptions : class
{
public ValidateOptions(string name, TDep1 dependency1, TDep2 dependency2, System.Func<TOptions, TDep1, TDep2, bool> validation, string failureMessage) { }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string FailureMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Func<TOptions, TDep1, TDep2, bool> Validation { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public string FailureMessage { get { throw null; } }
+ public string Name { get { throw null; } }
+ public System.Func<TOptions, TDep1, TDep2, bool> Validation { get { throw null; } }
public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string name, TOptions options) { throw null; }
}
public partial class ValidateOptions<TOptions, TDep1, TDep2, TDep3> : Microsoft.Extensions.Options.IValidateOptions<TOptions> where TOptions : class
{
public ValidateOptions(string name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, System.Func<TOptions, TDep1, TDep2, TDep3, bool> validation, string failureMessage) { }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string FailureMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Func<TOptions, TDep1, TDep2, TDep3, bool> Validation { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public string FailureMessage { get { throw null; } }
+ public string Name { get { throw null; } }
+ public System.Func<TOptions, TDep1, TDep2, TDep3, bool> Validation { get { throw null; } }
public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string name, TOptions options) { throw null; }
}
public partial class ValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4> : Microsoft.Extensions.Options.IValidateOptions<TOptions> where TOptions : class
{
public ValidateOptions(string name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, bool> validation, string failureMessage) { }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep4 Dependency4 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string FailureMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, bool> Validation { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public TDep4 Dependency4 { get { throw null; } }
+ public string FailureMessage { get { throw null; } }
+ public string Name { get { throw null; } }
+ public System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, bool> Validation { get { throw null; } }
public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string name, TOptions options) { throw null; }
}
public partial class ValidateOptions<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5> : Microsoft.Extensions.Options.IValidateOptions<TOptions> where TOptions : class
{
public ValidateOptions(string name, TDep1 dependency1, TDep2 dependency2, TDep3 dependency3, TDep4 dependency4, TDep5 dependency5, System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, bool> validation, string failureMessage) { }
- public TDep1 Dependency1 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep2 Dependency2 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep3 Dependency3 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep4 Dependency4 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public TDep5 Dependency5 { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string FailureMessage { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public string Name { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
- public System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, bool> Validation { [System.Runtime.CompilerServices.CompilerGeneratedAttribute] get { throw null; } }
+ public TDep1 Dependency1 { get { throw null; } }
+ public TDep2 Dependency2 { get { throw null; } }
+ public TDep3 Dependency3 { get { throw null; } }
+ public TDep4 Dependency4 { get { throw null; } }
+ public TDep5 Dependency5 { get { throw null; } }
+ public string FailureMessage { get { throw null; } }
+ public string Name { get { throw null; } }
+ public System.Func<TOptions, TDep1, TDep2, TDep3, TDep4, TDep5, bool> Validation { get { throw null; } }
public Microsoft.Extensions.Options.ValidateOptionsResult Validate(string name, TOptions options) { throw null; }
}
}
<TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
</PropertyGroup>
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
- <Reference Include="System.ComponentModel.Annotations" />
+ <Reference Include="System.ComponentModel.Annotations" />
</ItemGroup>
<ItemGroup>
<Compile Include="Microsoft.Extensions.Options.cs" />
- <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
- <Reference Include="Microsoft.Extensions.Primitives" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.DependencyInjection.Abstractions\ref\Microsoft.Extensions.DependencyInjection.Abstractions.csproj" />
+ <ProjectReference Include="..\..\Microsoft.Extensions.Primitives\ref\Microsoft.Extensions.Primitives.csproj" />
</ItemGroup>
</Project>
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
- <TargetFrameworks>netstandard2.0;$(DefaultNetCoreTargetFramework)</TargetFrameworks>
- <TargetFrameworks Condition="'$(DotNetBuildFromSource)' == 'true'">$(DefaultNetCoreTargetFramework)</TargetFrameworks>
+ <TargetFrameworks>netstandard2.0;$(NetCoreAppCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
- <InternalsVisibleTo Include="Microsoft.Extensions.Options.Tests" />
- </ItemGroup>
-
- <ItemGroup>
<Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
<Reference Include="Microsoft.Extensions.Primitives" />
</ItemGroup>
+ <ItemGroup Condition="'$(TargetsNetCoreApp)' == 'true'">
+ <Reference Include="System.Collections" />
+ <Reference Include="System.Collections.Concurrent" />
+ <Reference Include="System.ComponentModel" />
+ <Reference Include="System.Linq" />
+ <Reference Include="System.Runtime" />
+ <Reference Include="System.Threading" />
+ </ItemGroup>
+
<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
<Reference Include="System.ComponentModel.Annotations" />
</ItemGroup>
{
throw new InvalidOperationException(
IsAction(type)
- ? Resources.Error_NoIConfigureOptionsAndAction
- : Resources.Error_NoIConfigureOptions);
+ ? SR.Error_NoIConfigureOptionsAndAction
+ : SR.Error_NoIConfigureOptions);
}
return serviceTypes;
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("Microsoft.Extensions.Options.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")]
<PropertyGroup>
<TargetFrameworks>$(NetCoreAppCurrent);$(NetFrameworkCurrent)</TargetFrameworks>
+ <EnableDefaultItems>true</EnableDefaultItems>
</PropertyGroup>
<ItemGroup>
bool HasChanged { get; }
System.IDisposable RegisterChangeCallback(System.Action<object> callback, object state);
}
+ [System.ObsoleteAttribute("This type is obsolete and will be removed in a future version.")]
public partial struct InplaceStringBuilder
{
private object _dummy;
<ItemGroup>
<PackageReference Include="Moq" Version="$(MoqVersion)" />
</ItemGroup>
-
- <ItemGroup>
- <Reference Include="Microsoft.Extensions.Primitives" />
- </ItemGroup>
</Project>
"5.0.0.0": "5.0.0"
}
},
+ "Microsoft.Extensions.Caching.Abstractions": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.1.2",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Configuration": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Configuration.Abstractions": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Configuration.Binder": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.1.10",
+ "2.2.0",
+ "2.2.4",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Configuration.CommandLine": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Configuration.EnvironmentVariables": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "2.2.4",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.DependencyInjection": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "2.0.0",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.DependencyInjection.Abstractions": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "2.0.0",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
"Microsoft.Extensions.FileProviders.Abstractions": {
"StableVersions": [
"1.0.0",
"5.0.0.0": "5.0.0"
}
},
+ "Microsoft.Extensions.Hosting.Abstractions": {
+ "StableVersions": [
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.0.3",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Logging.Abstractions": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Options": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Options.ConfigurationExtensions": {
+ "StableVersions": [
+ "1.0.0",
+ "1.0.1",
+ "1.0.2",
+ "1.1.0",
+ "1.1.1",
+ "1.1.2",
+ "2.0.0",
+ "2.0.1",
+ "2.0.2",
+ "2.1.0",
+ "2.1.1",
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
+ "Microsoft.Extensions.Options.DataAnnotations": {
+ "StableVersions": [
+ "2.2.0",
+ "3.0.0",
+ "3.0.1",
+ "3.0.2",
+ "3.0.3",
+ "3.1.0",
+ "3.1.1",
+ "3.1.2"
+ ],
+ "InboxOn": {},
+ "AssemblyVersionInPackageVersion": {
+ "5.0.0.0": "5.0.0"
+ }
+ },
"Microsoft.Extensions.Primitives": {
"StableVersions": [
"1.0.0",
"CommonTypes": []
},
{
+ "Name": "Microsoft.Extensions.Caching.Abstractions",
+ "Description": "Caching abstractions for in-memory cache and distributed cache.",
+ "CommonTypes": [
+ "Microsoft.Extensions.Caching.Distributed.IDistributedCache",
+ "Microsoft.Extensions.Caching.Memory.IMemoryCache"
+ ]
+ },
+ {
+ "Name": "Microsoft.Extensions.Caching.Memory",
+ "Description": "In-memory cache implementation of Microsoft.Extensions.Caching.Memory.IMemoryCache.",
+ "CommonTypes": []
+ },
+ {
"Name": "Microsoft.Extensions.Configuration",
"Description": "Implementation of key-value pair based configuration for Microsoft.Extensions.Configuration. Includes the memory configuration provider.",
"CommonTypes": []
},
{
- "Name": "Microsoft.Extensions.Configuration.Abstraction",
+ "Name": "Microsoft.Extensions.Configuration.Abstractions",
"Description": "Abstractions of key-value pair based configuration.",
"CommonTypes": [
"Microsoft.Extensions.Configuration.IConfiguration",
]
},
{
- "Name": "Microsoft.Extensions.Configuration.Bindar",
+ "Name": "Microsoft.Extensions.Configuration.Binder",
"Description": "Functionality to bind an object to data in configuration providers for Microsoft.Extensions.Configuration.",
"CommonTypes": []
},
"CommonTypes": []
},
{
+ "Name": "Microsoft.Extensions.Http",
+ "Description": "The HttpClient factory is a pattern for configuring and retrieving named HttpClients in a composable way. The HttpClient factory provides extensibility to plug in DelegatingHandlers that address cross-cutting concerns such as service location, load balancing, and reliability. The default HttpClient factory provides built-in diagnostics and logging and manages the lifetimes of connections in a performant way.",
+ "CommonTypes": [
+ "System.Net.Http.IHttpClientFactory"
+ ]
+ },
+ {
"Name": "Microsoft.Extensions.Logging",
"Description": "Logging infrastructure default implementation for Microsoft.Extensions.Logging.",
"CommonTypes": []
<PackageReference Include="System.Data.SqlClient">
<Version>4.7.0</Version>
</PackageReference>
+ <PackageReference Include="System.ComponentModel.Annotations">
+ <Version>4.7.0</Version>
+ </PackageReference>
</ItemGroup>
<ItemGroup>
projects / platform / upstream / dotnet / runtime.git / commitdiff