diff --git a/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/Microsoft.Extensions.Logging.Abstractions.7.0.0.csproj b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/Microsoft.Extensions.Logging.Abstractions.7.0.0.csproj new file mode 100644 index 0000000000..3b19d4b2c7 --- /dev/null +++ b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/Microsoft.Extensions.Logging.Abstractions.7.0.0.csproj @@ -0,0 +1,40 @@ + + + + + netstandard2.0;net462 + $(ArtifactsBinDir)microsoft.extensions.logging.abstractions/7.0.0/microsoft.extensions.logging.abstractions.nuspec + MicrosoftAspNetCore + + + + $(ArtifactsBinDir)microsoft.extensions.logging.abstractions/7.0.0/ref/ + $(ArtifactsObjDir)microsoft.extensions.logging.abstractions/7.0.0 + + + + $(ArtifactsBinDir)microsoft.extensions.logging.abstractions/7.0.0/lib/ + + + + $(ArtifactsBinDir)microsoft.extensions.logging.abstractions/7.0.0/lib/ + + + + + + + + + + + + + + + + + + + + diff --git a/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/lib/net462/Microsoft.Extensions.Logging.Abstractions.cs b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/lib/net462/Microsoft.Extensions.Logging.Abstractions.cs new file mode 100644 index 0000000000..dee16692b5 --- /dev/null +++ b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/lib/net462/Microsoft.Extensions.Logging.Abstractions.cs @@ -0,0 +1,223 @@ +// 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 http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: AllowPartiallyTrustedCallers] +[assembly: ReferenceAssembly] +[assembly: AssemblyTitle("Microsoft.Extensions.Logging.Abstractions")] +[assembly: AssemblyDescription("Microsoft.Extensions.Logging.Abstractions")] +[assembly: AssemblyDefaultAlias("Microsoft.Extensions.Logging.Abstractions")] +[assembly: AssemblyCompany("Microsoft Corporation")] +[assembly: AssemblyProduct("Microsoft® .NET Framework")] +[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: AssemblyFileVersion("7.0.22.51805")] +[assembly: AssemblyInformationalVersion("7.0.22.51805 built by: SOURCEBUILD")] +[assembly: CLSCompliant(true)] +[assembly: AssemblyMetadata("", "")] +[assembly: AssemblyVersion("7.0.0.0")] + + + + +namespace Microsoft.Extensions.Logging +{ + public readonly partial struct EventId : System.IEquatable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public EventId(int id, string? name = null) { 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 static bool operator ==(Microsoft.Extensions.Logging.EventId left, Microsoft.Extensions.Logging.EventId right) { throw null; } + public static implicit operator Microsoft.Extensions.Logging.EventId (int i) { throw null; } + public static bool operator !=(Microsoft.Extensions.Logging.EventId left, Microsoft.Extensions.Logging.EventId right) { throw null; } + public override string ToString() { throw null; } + } + public partial interface IExternalScopeProvider + { + void ForEachScope(System.Action callback, TState state); + System.IDisposable Push(object? state); + } + public partial interface ILogger + { + System.IDisposable? BeginScope(TState state) where TState : notnull; + bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel); + void Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter); + } + public partial interface ILoggerFactory : System.IDisposable + { + void AddProvider(Microsoft.Extensions.Logging.ILoggerProvider provider); + Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName); + } + public partial interface ILoggerProvider : System.IDisposable + { + Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName); + } + public partial interface ILogger : Microsoft.Extensions.Logging.ILogger + { + } + public partial interface ISupportExternalScope + { + void SetScopeProvider(Microsoft.Extensions.Logging.IExternalScopeProvider scopeProvider); + } + public partial class LogDefineOptions + { + public LogDefineOptions() { } + public bool SkipEnabledCheck { get { throw null; } set { } } + } + public static partial class LoggerExtensions + { + public static System.IDisposable? BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[] args) { throw null; } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception? exception, string? message, params object?[] args) { } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + } + public partial class LoggerExternalScopeProvider : Microsoft.Extensions.Logging.IExternalScopeProvider + { + public LoggerExternalScopeProvider() { } + public void ForEachScope(System.Action callback, TState state) { } + public System.IDisposable Push(object? state) { throw null; } + } + public static partial class LoggerFactoryExtensions + { + public static Microsoft.Extensions.Logging.ILogger CreateLogger(this Microsoft.Extensions.Logging.ILoggerFactory factory, System.Type type) { throw null; } + public static Microsoft.Extensions.Logging.ILogger CreateLogger(this Microsoft.Extensions.Logging.ILoggerFactory factory) { throw null; } + } + public static partial class LoggerMessage + { + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + } + [System.AttributeUsageAttribute(System.AttributeTargets.Method)] + public sealed partial class LoggerMessageAttribute : System.Attribute + { + public LoggerMessageAttribute() { } + public LoggerMessageAttribute(int eventId, Microsoft.Extensions.Logging.LogLevel level, string message) { } + public int EventId { get { throw null; } set { } } + public string? EventName { get { throw null; } set { } } + public Microsoft.Extensions.Logging.LogLevel Level { get { throw null; } set { } } + public string Message { get { throw null; } set { } } + public bool SkipEnabledCheck { get { throw null; } set { } } + } + public partial class Logger : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger + { + public Logger(Microsoft.Extensions.Logging.ILoggerFactory factory) { } + System.IDisposable Microsoft.Extensions.Logging.ILogger.BeginScope(TState state) { throw null; } + bool Microsoft.Extensions.Logging.ILogger.IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; } + void Microsoft.Extensions.Logging.ILogger.Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception exception, System.Func formatter) { } + } + public enum LogLevel + { + Trace = 0, + Debug = 1, + Information = 2, + Warning = 3, + Error = 4, + Critical = 5, + None = 6, + } +} +namespace Microsoft.Extensions.Logging.Abstractions +{ + public readonly partial struct LogEntry + { + private readonly TState _State_k__BackingField; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter) { throw null; } + public string Category { get { throw null; } } + public Microsoft.Extensions.Logging.EventId EventId { get { throw null; } } + public System.Exception? Exception { get { throw null; } } + public System.Func Formatter { get { throw null; } } + public Microsoft.Extensions.Logging.LogLevel LogLevel { get { throw null; } } + public TState State { get { throw null; } } + } + public partial class NullLogger : Microsoft.Extensions.Logging.ILogger + { + internal NullLogger() { } + public static Microsoft.Extensions.Logging.Abstractions.NullLogger Instance { get { throw null; } } + public System.IDisposable BeginScope(TState state) where TState : notnull { throw null; } + public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; } + public void Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter) { } + } + public partial class NullLoggerFactory : Microsoft.Extensions.Logging.ILoggerFactory, System.IDisposable + { + public static readonly Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory Instance; + public NullLoggerFactory() { } + public void AddProvider(Microsoft.Extensions.Logging.ILoggerProvider provider) { } + public Microsoft.Extensions.Logging.ILogger CreateLogger(string name) { throw null; } + public void Dispose() { } + } + public partial class NullLoggerProvider : Microsoft.Extensions.Logging.ILoggerProvider, System.IDisposable + { + internal NullLoggerProvider() { } + public static Microsoft.Extensions.Logging.Abstractions.NullLoggerProvider Instance { get { throw null; } } + public Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName) { throw null; } + public void Dispose() { } + } + public partial class NullLogger : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger + { + public static readonly Microsoft.Extensions.Logging.Abstractions.NullLogger Instance; + public NullLogger() { } + public System.IDisposable BeginScope(TState state) where TState : notnull { throw null; } + public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; } + public void Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter) { } + } +} diff --git a/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.cs b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.cs new file mode 100644 index 0000000000..dee16692b5 --- /dev/null +++ b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/lib/netstandard2.0/Microsoft.Extensions.Logging.Abstractions.cs @@ -0,0 +1,223 @@ +// 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 http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: AllowPartiallyTrustedCallers] +[assembly: ReferenceAssembly] +[assembly: AssemblyTitle("Microsoft.Extensions.Logging.Abstractions")] +[assembly: AssemblyDescription("Microsoft.Extensions.Logging.Abstractions")] +[assembly: AssemblyDefaultAlias("Microsoft.Extensions.Logging.Abstractions")] +[assembly: AssemblyCompany("Microsoft Corporation")] +[assembly: AssemblyProduct("Microsoft® .NET Framework")] +[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: AssemblyFileVersion("7.0.22.51805")] +[assembly: AssemblyInformationalVersion("7.0.22.51805 built by: SOURCEBUILD")] +[assembly: CLSCompliant(true)] +[assembly: AssemblyMetadata("", "")] +[assembly: AssemblyVersion("7.0.0.0")] + + + + +namespace Microsoft.Extensions.Logging +{ + public readonly partial struct EventId : System.IEquatable + { + private readonly object _dummy; + private readonly int _dummyPrimitive; + public EventId(int id, string? name = null) { 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 static bool operator ==(Microsoft.Extensions.Logging.EventId left, Microsoft.Extensions.Logging.EventId right) { throw null; } + public static implicit operator Microsoft.Extensions.Logging.EventId (int i) { throw null; } + public static bool operator !=(Microsoft.Extensions.Logging.EventId left, Microsoft.Extensions.Logging.EventId right) { throw null; } + public override string ToString() { throw null; } + } + public partial interface IExternalScopeProvider + { + void ForEachScope(System.Action callback, TState state); + System.IDisposable Push(object? state); + } + public partial interface ILogger + { + System.IDisposable? BeginScope(TState state) where TState : notnull; + bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel); + void Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter); + } + public partial interface ILoggerFactory : System.IDisposable + { + void AddProvider(Microsoft.Extensions.Logging.ILoggerProvider provider); + Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName); + } + public partial interface ILoggerProvider : System.IDisposable + { + Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName); + } + public partial interface ILogger : Microsoft.Extensions.Logging.ILogger + { + } + public partial interface ISupportExternalScope + { + void SetScopeProvider(Microsoft.Extensions.Logging.IExternalScopeProvider scopeProvider); + } + public partial class LogDefineOptions + { + public LogDefineOptions() { } + public bool SkipEnabledCheck { get { throw null; } set { } } + } + public static partial class LoggerExtensions + { + public static System.IDisposable? BeginScope(this Microsoft.Extensions.Logging.ILogger logger, string messageFormat, params object?[] args) { throw null; } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, System.Exception? exception, string? message, params object?[] args) { } + public static void Log(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.LogLevel logLevel, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogCritical(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogDebug(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogError(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogInformation(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogTrace(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, System.Exception? exception, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, Microsoft.Extensions.Logging.EventId eventId, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, System.Exception? exception, string? message, params object?[] args) { } + public static void LogWarning(this Microsoft.Extensions.Logging.ILogger logger, string? message, params object?[] args) { } + } + public partial class LoggerExternalScopeProvider : Microsoft.Extensions.Logging.IExternalScopeProvider + { + public LoggerExternalScopeProvider() { } + public void ForEachScope(System.Action callback, TState state) { } + public System.IDisposable Push(object? state) { throw null; } + } + public static partial class LoggerFactoryExtensions + { + public static Microsoft.Extensions.Logging.ILogger CreateLogger(this Microsoft.Extensions.Logging.ILoggerFactory factory, System.Type type) { throw null; } + public static Microsoft.Extensions.Logging.ILogger CreateLogger(this Microsoft.Extensions.Logging.ILoggerFactory factory) { throw null; } + } + public static partial class LoggerMessage + { + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Func DefineScope(string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString) { throw null; } + public static System.Action Define(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, string formatString, Microsoft.Extensions.Logging.LogDefineOptions? options) { throw null; } + } + [System.AttributeUsageAttribute(System.AttributeTargets.Method)] + public sealed partial class LoggerMessageAttribute : System.Attribute + { + public LoggerMessageAttribute() { } + public LoggerMessageAttribute(int eventId, Microsoft.Extensions.Logging.LogLevel level, string message) { } + public int EventId { get { throw null; } set { } } + public string? EventName { get { throw null; } set { } } + public Microsoft.Extensions.Logging.LogLevel Level { get { throw null; } set { } } + public string Message { get { throw null; } set { } } + public bool SkipEnabledCheck { get { throw null; } set { } } + } + public partial class Logger : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger + { + public Logger(Microsoft.Extensions.Logging.ILoggerFactory factory) { } + System.IDisposable Microsoft.Extensions.Logging.ILogger.BeginScope(TState state) { throw null; } + bool Microsoft.Extensions.Logging.ILogger.IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; } + void Microsoft.Extensions.Logging.ILogger.Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception exception, System.Func formatter) { } + } + public enum LogLevel + { + Trace = 0, + Debug = 1, + Information = 2, + Warning = 3, + Error = 4, + Critical = 5, + None = 6, + } +} +namespace Microsoft.Extensions.Logging.Abstractions +{ + public readonly partial struct LogEntry + { + private readonly TState _State_k__BackingField; + private readonly object _dummy; + private readonly int _dummyPrimitive; + public LogEntry(Microsoft.Extensions.Logging.LogLevel logLevel, string category, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter) { throw null; } + public string Category { get { throw null; } } + public Microsoft.Extensions.Logging.EventId EventId { get { throw null; } } + public System.Exception? Exception { get { throw null; } } + public System.Func Formatter { get { throw null; } } + public Microsoft.Extensions.Logging.LogLevel LogLevel { get { throw null; } } + public TState State { get { throw null; } } + } + public partial class NullLogger : Microsoft.Extensions.Logging.ILogger + { + internal NullLogger() { } + public static Microsoft.Extensions.Logging.Abstractions.NullLogger Instance { get { throw null; } } + public System.IDisposable BeginScope(TState state) where TState : notnull { throw null; } + public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; } + public void Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter) { } + } + public partial class NullLoggerFactory : Microsoft.Extensions.Logging.ILoggerFactory, System.IDisposable + { + public static readonly Microsoft.Extensions.Logging.Abstractions.NullLoggerFactory Instance; + public NullLoggerFactory() { } + public void AddProvider(Microsoft.Extensions.Logging.ILoggerProvider provider) { } + public Microsoft.Extensions.Logging.ILogger CreateLogger(string name) { throw null; } + public void Dispose() { } + } + public partial class NullLoggerProvider : Microsoft.Extensions.Logging.ILoggerProvider, System.IDisposable + { + internal NullLoggerProvider() { } + public static Microsoft.Extensions.Logging.Abstractions.NullLoggerProvider Instance { get { throw null; } } + public Microsoft.Extensions.Logging.ILogger CreateLogger(string categoryName) { throw null; } + public void Dispose() { } + } + public partial class NullLogger : Microsoft.Extensions.Logging.ILogger, Microsoft.Extensions.Logging.ILogger + { + public static readonly Microsoft.Extensions.Logging.Abstractions.NullLogger Instance; + public NullLogger() { } + public System.IDisposable BeginScope(TState state) where TState : notnull { throw null; } + public bool IsEnabled(Microsoft.Extensions.Logging.LogLevel logLevel) { throw null; } + public void Log(Microsoft.Extensions.Logging.LogLevel logLevel, Microsoft.Extensions.Logging.EventId eventId, TState state, System.Exception? exception, System.Func formatter) { } + } +} diff --git a/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/microsoft.extensions.logging.abstractions.nuspec b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/microsoft.extensions.logging.abstractions.nuspec new file mode 100755 index 0000000000..3a27e5c5bf --- /dev/null +++ b/src/referencePackages/src/microsoft.extensions.logging.abstractions/7.0.0/microsoft.extensions.logging.abstractions.nuspec @@ -0,0 +1,37 @@ + + + + Microsoft.Extensions.Logging.Abstractions + 7.0.0 + Microsoft + MIT + https://licenses.nuget.org/MIT + https://dot.net/ + Logging abstractions for Microsoft.Extensions.Logging. + +Commonly Used Types: +Microsoft.Extensions.Logging.ILogger +Microsoft.Extensions.Logging.ILoggerFactory +Microsoft.Extensions.Logging.ILogger<TCategoryName> +Microsoft.Extensions.Logging.LogLevel +Microsoft.Extensions.Logging.Logger<T> +Microsoft.Extensions.Logging.LoggerMessage +Microsoft.Extensions.Logging.Abstractions.NullLogger + https://go.microsoft.com/fwlink/?LinkID=799421 + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/referencePackages/src/system.reflection.metadata/4.3.0/System.Threading.Tasks.4.3.0.csproj b/src/referencePackages/src/system.reflection.metadata/4.3.0/System.Threading.Tasks.4.3.0.csproj new file mode 100644 index 0000000000..8ae9d8d050 --- /dev/null +++ b/src/referencePackages/src/system.reflection.metadata/4.3.0/System.Threading.Tasks.4.3.0.csproj @@ -0,0 +1,31 @@ + + + + + netstandard1.0;netstandard1.3 + $(ArtifactsBinDir)system.threading.tasks/4.3.0/system.threading.tasks.nuspec + + + + $(ArtifactsBinDir)system.threading.tasks/4.3.0/ref/ + $(ArtifactsObjDir)system.threading.tasks/4.3.0 + + + + + + + + + + + + + + + + + + + + diff --git a/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/net45/_._ b/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/net45/_._ new file mode 100755 index 0000000000..e69de29bb2 diff --git a/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/netstandard1.0/System.Threading.Tasks.cs b/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/netstandard1.0/System.Threading.Tasks.cs new file mode 100644 index 0000000000..14375b9c97 --- /dev/null +++ b/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/netstandard1.0/System.Threading.Tasks.cs @@ -0,0 +1,561 @@ +// 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 http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: AllowPartiallyTrustedCallers] +[assembly: ReferenceAssembly] +[assembly: AssemblyTitle("System.Threading.Tasks")] +[assembly: AssemblyDescription("System.Threading.Tasks")] +[assembly: AssemblyDefaultAlias("System.Threading.Tasks")] +[assembly: AssemblyCompany("Microsoft Corporation")] +[assembly: AssemblyProduct("Microsoft® .NET Framework")] +[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: AssemblyFileVersion("4.0.30319.17929")] +[assembly: AssemblyInformationalVersion("4.0.30319.17929 built by: SOURCEBUILD")] +[assembly: CLSCompliant(true)] +[assembly: AssemblyMetadata("", "")] +[assembly: AssemblyVersion("4.0.0.0")] + + + + +namespace System +{ + public partial class AggregateException : System.Exception + { + public AggregateException() { } + public AggregateException(System.Collections.Generic.IEnumerable innerExceptions) { } + public AggregateException(params System.Exception[] innerExceptions) { } + public AggregateException(string message) { } + public AggregateException(string message, System.Collections.Generic.IEnumerable innerExceptions) { } + public AggregateException(string message, System.Exception innerException) { } + public AggregateException(string message, params System.Exception[] innerExceptions) { } + public System.Collections.ObjectModel.ReadOnlyCollection InnerExceptions { get { throw null; } } + public System.AggregateException Flatten() { throw null; } + public override System.Exception GetBaseException() { throw null; } + public void Handle(System.Func predicate) { } + public override string ToString() { throw null; } + } + public partial class OperationCanceledException : System.Exception + { + public OperationCanceledException() { } + public OperationCanceledException(string message) { } + public OperationCanceledException(string message, System.Exception innerException) { } + public OperationCanceledException(string message, System.Exception innerException, System.Threading.CancellationToken token) { } + public OperationCanceledException(string message, System.Threading.CancellationToken token) { } + public OperationCanceledException(System.Threading.CancellationToken token) { } + public System.Threading.CancellationToken CancellationToken { get { throw null; } } + } +} +namespace System.Runtime.CompilerServices +{ + public partial struct AsyncTaskMethodBuilder + { + public System.Threading.Tasks.Task Task { get { throw null; } } + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public static System.Runtime.CompilerServices.AsyncTaskMethodBuilder Create() { throw null; } + public void SetException(System.Exception exception) { } + public void SetResult() { } + public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine) { } + public void Start(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + } + public partial struct AsyncTaskMethodBuilder + { + public System.Threading.Tasks.Task Task { get { throw null; } } + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public static System.Runtime.CompilerServices.AsyncTaskMethodBuilder Create() { throw null; } + public void SetException(System.Exception exception) { } + public void SetResult(TResult result) { } + public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine) { } + public void Start(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + } + public partial struct AsyncVoidMethodBuilder + { + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public static System.Runtime.CompilerServices.AsyncVoidMethodBuilder Create() { throw null; } + public void SetException(System.Exception exception) { } + public void SetResult() { } + public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine) { } + public void Start(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + } + public partial struct ConfiguredTaskAwaitable + { + public System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter() { throw null; } + public partial struct ConfiguredTaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public void GetResult() { } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + } + public partial struct ConfiguredTaskAwaitable + { + public System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter() { throw null; } + public partial struct ConfiguredTaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public TResult GetResult() { throw null; } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + } + public partial interface IAsyncStateMachine + { + void MoveNext(); + void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine); + } + public partial interface ICriticalNotifyCompletion : System.Runtime.CompilerServices.INotifyCompletion + { + void UnsafeOnCompleted(System.Action continuation); + } + public partial interface INotifyCompletion + { + void OnCompleted(System.Action continuation); + } + public partial struct TaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public void GetResult() { } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + public partial struct TaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public TResult GetResult() { throw null; } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + public partial struct YieldAwaitable + { + public System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter GetAwaiter() { throw null; } + public partial struct YieldAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public void GetResult() { } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + } +} +namespace System.Threading +{ + public partial struct CancellationToken + { + public CancellationToken(bool canceled) { throw null; } + public bool CanBeCanceled { get { throw null; } } + public bool IsCancellationRequested { get { throw null; } } + public static System.Threading.CancellationToken None { get { throw null; } } + public System.Threading.WaitHandle WaitHandle { get { throw null; } } + public override bool Equals(object other) { throw null; } + public bool Equals(System.Threading.CancellationToken other) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Threading.CancellationToken left, System.Threading.CancellationToken right) { throw null; } + public static bool operator !=(System.Threading.CancellationToken left, System.Threading.CancellationToken right) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback, bool useSynchronizationContext) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback, object state) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback, object state, bool useSynchronizationContext) { throw null; } + public void ThrowIfCancellationRequested() { } + } + public partial struct CancellationTokenRegistration : System.IDisposable, System.IEquatable + { + public void Dispose() { } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Threading.CancellationTokenRegistration other) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Threading.CancellationTokenRegistration left, System.Threading.CancellationTokenRegistration right) { throw null; } + public static bool operator !=(System.Threading.CancellationTokenRegistration left, System.Threading.CancellationTokenRegistration right) { throw null; } + } + public partial class CancellationTokenSource : System.IDisposable + { + public CancellationTokenSource() { } + public CancellationTokenSource(int millisecondsDelay) { } + public CancellationTokenSource(System.TimeSpan delay) { } + public bool IsCancellationRequested { get { throw null; } } + public System.Threading.CancellationToken Token { get { throw null; } } + public void Cancel() { } + public void Cancel(bool throwOnFirstException) { } + public void CancelAfter(int millisecondsDelay) { } + public void CancelAfter(System.TimeSpan delay) { } + public static System.Threading.CancellationTokenSource CreateLinkedTokenSource(System.Threading.CancellationToken token1, System.Threading.CancellationToken token2) { throw null; } + public static System.Threading.CancellationTokenSource CreateLinkedTokenSource(params System.Threading.CancellationToken[] tokens) { throw null; } + public void Dispose() { } + protected virtual void Dispose(bool disposing) { } + } +} +namespace System.Threading.Tasks +{ + public partial class ConcurrentExclusiveSchedulerPair + { + public ConcurrentExclusiveSchedulerPair() { } + public ConcurrentExclusiveSchedulerPair(System.Threading.Tasks.TaskScheduler taskScheduler) { } + public ConcurrentExclusiveSchedulerPair(System.Threading.Tasks.TaskScheduler taskScheduler, int maxConcurrencyLevel) { } + public ConcurrentExclusiveSchedulerPair(System.Threading.Tasks.TaskScheduler taskScheduler, int maxConcurrencyLevel, int maxItemsPerTask) { } + public System.Threading.Tasks.Task Completion { get { throw null; } } + public System.Threading.Tasks.TaskScheduler ConcurrentScheduler { get { throw null; } } + public System.Threading.Tasks.TaskScheduler ExclusiveScheduler { get { throw null; } } + public void Complete() { } + } + public partial class Task : System.IAsyncResult + { + public Task(System.Action action) { } + public Task(System.Action action, System.Threading.CancellationToken cancellationToken) { } + public Task(System.Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public Task(System.Action action, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public Task(System.Action action, object state) { } + public Task(System.Action action, object state, System.Threading.CancellationToken cancellationToken) { } + public Task(System.Action action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public Task(System.Action action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public object AsyncState { get { throw null; } } + public System.Threading.Tasks.TaskCreationOptions CreationOptions { get { throw null; } } + public static System.Nullable CurrentId { get { throw null; } } + public System.AggregateException Exception { get { throw null; } } + public static System.Threading.Tasks.TaskFactory Factory { get { throw null; } } + public int Id { get { throw null; } } + public bool IsCanceled { get { throw null; } } + public bool IsCompleted { get { throw null; } } + public bool IsFaulted { get { throw null; } } + public System.Threading.Tasks.TaskStatus Status { get { throw null; } } + System.Threading.WaitHandle System.IAsyncResult.AsyncWaitHandle { get { throw null; } } + bool System.IAsyncResult.CompletedSynchronously { get { throw null; } } + public System.Runtime.CompilerServices.ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public static System.Threading.Tasks.Task Delay(int millisecondsDelay) { throw null; } + public static System.Threading.Tasks.Task Delay(int millisecondsDelay, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task Delay(System.TimeSpan delay) { throw null; } + public static System.Threading.Tasks.Task Delay(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task FromResult(TResult result) { throw null; } + public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter() { throw null; } + public static System.Threading.Tasks.Task Run(System.Action action) { throw null; } + public static System.Threading.Tasks.Task Run(System.Action action, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public void RunSynchronously() { } + public void RunSynchronously(System.Threading.Tasks.TaskScheduler scheduler) { } + public static System.Threading.Tasks.Task Run(System.Func> function) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func> function, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public void Start() { } + public void Start(System.Threading.Tasks.TaskScheduler scheduler) { } + public void Wait() { } + public bool Wait(int millisecondsTimeout) { throw null; } + public bool Wait(int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { throw null; } + public void Wait(System.Threading.CancellationToken cancellationToken) { } + public bool Wait(System.TimeSpan timeout) { throw null; } + public static void WaitAll(params System.Threading.Tasks.Task[] tasks) { } + public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout) { throw null; } + public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { throw null; } + public static void WaitAll(System.Threading.Tasks.Task[] tasks, System.Threading.CancellationToken cancellationToken) { } + public static bool WaitAll(System.Threading.Tasks.Task[] tasks, System.TimeSpan timeout) { throw null; } + public static int WaitAny(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, System.Threading.CancellationToken cancellationToken) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, System.TimeSpan timeout) { throw null; } + public static System.Threading.Tasks.Task WhenAll(System.Collections.Generic.IEnumerable tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAll(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAll(System.Collections.Generic.IEnumerable> tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAll(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAny(System.Collections.Generic.IEnumerable tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAny(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Threading.Tasks.Task> WhenAny(System.Collections.Generic.IEnumerable> tasks) { throw null; } + public static System.Threading.Tasks.Task> WhenAny(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Runtime.CompilerServices.YieldAwaitable Yield() { throw null; } + } + public partial class TaskCanceledException : System.OperationCanceledException + { + public TaskCanceledException() { } + public TaskCanceledException(string message) { } + public TaskCanceledException(string message, System.Exception innerException) { } + public TaskCanceledException(System.Threading.Tasks.Task task) { } + public System.Threading.Tasks.Task Task { get { throw null; } } + } + public partial class TaskCompletionSource + { + public TaskCompletionSource() { } + public TaskCompletionSource(object state) { } + public TaskCompletionSource(object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public TaskCompletionSource(System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public System.Threading.Tasks.Task Task { get { throw null; } } + public void SetCanceled() { } + public void SetException(System.Collections.Generic.IEnumerable exceptions) { } + public void SetException(System.Exception exception) { } + public void SetResult(TResult result) { } + public bool TrySetCanceled() { throw null; } + public bool TrySetException(System.Collections.Generic.IEnumerable exceptions) { throw null; } + public bool TrySetException(System.Exception exception) { throw null; } + public bool TrySetResult(TResult result) { throw null; } + } + [System.FlagsAttribute] + public enum TaskContinuationOptions + { + AttachedToParent = 4, + DenyChildAttach = 8, + ExecuteSynchronously = 524288, + HideScheduler = 16, + LazyCancellation = 32, + LongRunning = 2, + None = 0, + NotOnCanceled = 262144, + NotOnFaulted = 131072, + NotOnRanToCompletion = 65536, + OnlyOnCanceled = 196608, + OnlyOnFaulted = 327680, + OnlyOnRanToCompletion = 393216, + PreferFairness = 1, + } + [System.FlagsAttribute] + public enum TaskCreationOptions + { + AttachedToParent = 4, + DenyChildAttach = 8, + HideScheduler = 16, + LongRunning = 2, + None = 0, + PreferFairness = 1, + } + public static partial class TaskExtensions + { + public static System.Threading.Tasks.Task Unwrap(this System.Threading.Tasks.Task task) { throw null; } + public static System.Threading.Tasks.Task Unwrap(this System.Threading.Tasks.Task> task) { throw null; } + } + public partial class TaskFactory + { + public TaskFactory() { } + public TaskFactory(System.Threading.CancellationToken cancellationToken) { } + public TaskFactory(System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { } + public TaskFactory(System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { } + public TaskFactory(System.Threading.Tasks.TaskScheduler scheduler) { } + public System.Threading.CancellationToken CancellationToken { get { throw null; } } + public System.Threading.Tasks.TaskContinuationOptions ContinuationOptions { get { throw null; } } + public System.Threading.Tasks.TaskCreationOptions CreationOptions { get { throw null; } } + public System.Threading.Tasks.TaskScheduler Scheduler { get { throw null; } } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Action endMethod) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Action endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Action endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + } + public partial class TaskFactory + { + public TaskFactory() { } + public TaskFactory(System.Threading.CancellationToken cancellationToken) { } + public TaskFactory(System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { } + public TaskFactory(System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { } + public TaskFactory(System.Threading.Tasks.TaskScheduler scheduler) { } + public System.Threading.CancellationToken CancellationToken { get { throw null; } } + public System.Threading.Tasks.TaskContinuationOptions ContinuationOptions { get { throw null; } } + public System.Threading.Tasks.TaskCreationOptions CreationOptions { get { throw null; } } + public System.Threading.Tasks.TaskScheduler Scheduler { get { throw null; } } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + } + public abstract partial class TaskScheduler + { + protected TaskScheduler() { } + public static System.Threading.Tasks.TaskScheduler Current { get { throw null; } } + public static System.Threading.Tasks.TaskScheduler Default { get { throw null; } } + public int Id { get { throw null; } } + public virtual int MaximumConcurrencyLevel { get { throw null; } } + public static event System.EventHandler UnobservedTaskException { add { } remove { } } + public static System.Threading.Tasks.TaskScheduler FromCurrentSynchronizationContext() { throw null; } + protected abstract System.Collections.Generic.IEnumerable GetScheduledTasks(); + protected internal abstract void QueueTask(System.Threading.Tasks.Task task); + protected internal virtual bool TryDequeue(System.Threading.Tasks.Task task) { throw null; } + protected bool TryExecuteTask(System.Threading.Tasks.Task task) { throw null; } + protected abstract bool TryExecuteTaskInline(System.Threading.Tasks.Task task, bool taskWasPreviouslyQueued); + } + public partial class TaskSchedulerException : System.Exception + { + public TaskSchedulerException() { } + public TaskSchedulerException(System.Exception innerException) { } + public TaskSchedulerException(string message) { } + public TaskSchedulerException(string message, System.Exception innerException) { } + } + public enum TaskStatus + { + Canceled = 6, + Created = 0, + Faulted = 7, + RanToCompletion = 5, + Running = 3, + WaitingForActivation = 1, + WaitingForChildrenToComplete = 4, + WaitingToRun = 2, + } + public partial class Task : System.Threading.Tasks.Task + { + public Task(System.Func function, object state) : base (default(System.Action)) { } + public Task(System.Func function, object state, System.Threading.CancellationToken cancellationToken) : base (default(System.Action)) { } + public Task(System.Func function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public Task(System.Func function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public Task(System.Func function) : base (default(System.Action)) { } + public Task(System.Func function, System.Threading.CancellationToken cancellationToken) : base (default(System.Action)) { } + public Task(System.Func function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public Task(System.Func function, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public static new System.Threading.Tasks.TaskFactory Factory { get { throw null; } } + public TResult Result { get { throw null; } } + public new System.Runtime.CompilerServices.ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public new System.Runtime.CompilerServices.TaskAwaiter GetAwaiter() { throw null; } + } + public partial class UnobservedTaskExceptionEventArgs : System.EventArgs + { + public UnobservedTaskExceptionEventArgs(System.AggregateException exception) { } + public System.AggregateException Exception { get { throw null; } } + public bool Observed { get { throw null; } } + public void SetObserved() { } + } +} diff --git a/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/netstandard1.3/System.Threading.Tasks.cs b/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/netstandard1.3/System.Threading.Tasks.cs new file mode 100644 index 0000000000..686dfdb93a --- /dev/null +++ b/src/referencePackages/src/system.reflection.metadata/4.3.0/ref/netstandard1.3/System.Threading.Tasks.cs @@ -0,0 +1,569 @@ +// 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 http://aka.ms/api-review process. +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Security; + +[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: AllowPartiallyTrustedCallers] +[assembly: ReferenceAssembly] +[assembly: AssemblyTitle("System.Threading.Tasks")] +[assembly: AssemblyDescription("System.Threading.Tasks")] +[assembly: AssemblyDefaultAlias("System.Threading.Tasks")] +[assembly: AssemblyCompany("Microsoft Corporation")] +[assembly: AssemblyProduct("Microsoft® .NET Framework")] +[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: AssemblyFileVersion("1.0.24212.01")] +[assembly: AssemblyInformationalVersion("1.0.24212.01 built by: SOURCEBUILD")] +[assembly: CLSCompliant(true)] +[assembly: AssemblyMetadata("", "")] +[assembly: AssemblyVersion("4.0.10.0")] + + + + +namespace System +{ + public partial class AggregateException : System.Exception + { + public AggregateException() { } + public AggregateException(System.Collections.Generic.IEnumerable innerExceptions) { } + public AggregateException(params System.Exception[] innerExceptions) { } + public AggregateException(string message) { } + public AggregateException(string message, System.Collections.Generic.IEnumerable innerExceptions) { } + public AggregateException(string message, System.Exception innerException) { } + public AggregateException(string message, params System.Exception[] innerExceptions) { } + public System.Collections.ObjectModel.ReadOnlyCollection InnerExceptions { get { throw null; } } + public System.AggregateException Flatten() { throw null; } + public override System.Exception GetBaseException() { throw null; } + public void Handle(System.Func predicate) { } + public override string ToString() { throw null; } + } + public partial class OperationCanceledException : System.Exception + { + public OperationCanceledException() { } + public OperationCanceledException(string message) { } + public OperationCanceledException(string message, System.Exception innerException) { } + public OperationCanceledException(string message, System.Exception innerException, System.Threading.CancellationToken token) { } + public OperationCanceledException(string message, System.Threading.CancellationToken token) { } + public OperationCanceledException(System.Threading.CancellationToken token) { } + public System.Threading.CancellationToken CancellationToken { get { throw null; } } + } +} +namespace System.Runtime.CompilerServices +{ + public partial struct AsyncTaskMethodBuilder + { + public System.Threading.Tasks.Task Task { get { throw null; } } + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public static System.Runtime.CompilerServices.AsyncTaskMethodBuilder Create() { throw null; } + public void SetException(System.Exception exception) { } + public void SetResult() { } + public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine) { } + public void Start(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + } + public partial struct AsyncTaskMethodBuilder + { + public System.Threading.Tasks.Task Task { get { throw null; } } + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public static System.Runtime.CompilerServices.AsyncTaskMethodBuilder Create() { throw null; } + public void SetException(System.Exception exception) { } + public void SetResult(TResult result) { } + public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine) { } + public void Start(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + } + public partial struct AsyncVoidMethodBuilder + { + public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.INotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + public static System.Runtime.CompilerServices.AsyncVoidMethodBuilder Create() { throw null; } + public void SetException(System.Exception exception) { } + public void SetResult() { } + public void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine) { } + public void Start(ref TStateMachine stateMachine) where TStateMachine : System.Runtime.CompilerServices.IAsyncStateMachine { } + } + public partial struct ConfiguredTaskAwaitable + { + public System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter() { throw null; } + public partial struct ConfiguredTaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public void GetResult() { } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + } + public partial struct ConfiguredTaskAwaitable + { + public System.Runtime.CompilerServices.ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter() { throw null; } + public partial struct ConfiguredTaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public TResult GetResult() { throw null; } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + } + public partial interface IAsyncStateMachine + { + void MoveNext(); + void SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine stateMachine); + } + public partial interface ICriticalNotifyCompletion : System.Runtime.CompilerServices.INotifyCompletion + { + void UnsafeOnCompleted(System.Action continuation); + } + public partial interface INotifyCompletion + { + void OnCompleted(System.Action continuation); + } + public partial struct TaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public void GetResult() { } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + public partial struct TaskAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public TResult GetResult() { throw null; } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + public partial struct YieldAwaitable + { + public System.Runtime.CompilerServices.YieldAwaitable.YieldAwaiter GetAwaiter() { throw null; } + public partial struct YieldAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + public bool IsCompleted { get { throw null; } } + public void GetResult() { } + public void OnCompleted(System.Action continuation) { } + public void UnsafeOnCompleted(System.Action continuation) { } + } + } +} +namespace System.Threading +{ + public partial struct CancellationToken + { + public CancellationToken(bool canceled) { throw null; } + public bool CanBeCanceled { get { throw null; } } + public bool IsCancellationRequested { get { throw null; } } + public static System.Threading.CancellationToken None { get { throw null; } } + public System.Threading.WaitHandle WaitHandle { get { throw null; } } + public override bool Equals(object other) { throw null; } + public bool Equals(System.Threading.CancellationToken other) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Threading.CancellationToken left, System.Threading.CancellationToken right) { throw null; } + public static bool operator !=(System.Threading.CancellationToken left, System.Threading.CancellationToken right) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback, bool useSynchronizationContext) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback, object state) { throw null; } + public System.Threading.CancellationTokenRegistration Register(System.Action callback, object state, bool useSynchronizationContext) { throw null; } + public void ThrowIfCancellationRequested() { } + } + public partial struct CancellationTokenRegistration : System.IDisposable, System.IEquatable + { + public void Dispose() { } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Threading.CancellationTokenRegistration other) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Threading.CancellationTokenRegistration left, System.Threading.CancellationTokenRegistration right) { throw null; } + public static bool operator !=(System.Threading.CancellationTokenRegistration left, System.Threading.CancellationTokenRegistration right) { throw null; } + } + public partial class CancellationTokenSource : System.IDisposable + { + public CancellationTokenSource() { } + public CancellationTokenSource(int millisecondsDelay) { } + public CancellationTokenSource(System.TimeSpan delay) { } + public bool IsCancellationRequested { get { throw null; } } + public System.Threading.CancellationToken Token { get { throw null; } } + public void Cancel() { } + public void Cancel(bool throwOnFirstException) { } + public void CancelAfter(int millisecondsDelay) { } + public void CancelAfter(System.TimeSpan delay) { } + public static System.Threading.CancellationTokenSource CreateLinkedTokenSource(System.Threading.CancellationToken token1, System.Threading.CancellationToken token2) { throw null; } + public static System.Threading.CancellationTokenSource CreateLinkedTokenSource(params System.Threading.CancellationToken[] tokens) { throw null; } + public void Dispose() { } + protected virtual void Dispose(bool disposing) { } + } +} +namespace System.Threading.Tasks +{ + public partial class ConcurrentExclusiveSchedulerPair + { + public ConcurrentExclusiveSchedulerPair() { } + public ConcurrentExclusiveSchedulerPair(System.Threading.Tasks.TaskScheduler taskScheduler) { } + public ConcurrentExclusiveSchedulerPair(System.Threading.Tasks.TaskScheduler taskScheduler, int maxConcurrencyLevel) { } + public ConcurrentExclusiveSchedulerPair(System.Threading.Tasks.TaskScheduler taskScheduler, int maxConcurrencyLevel, int maxItemsPerTask) { } + public System.Threading.Tasks.Task Completion { get { throw null; } } + public System.Threading.Tasks.TaskScheduler ConcurrentScheduler { get { throw null; } } + public System.Threading.Tasks.TaskScheduler ExclusiveScheduler { get { throw null; } } + public void Complete() { } + } + public partial class Task : System.IAsyncResult + { + public Task(System.Action action) { } + public Task(System.Action action, System.Threading.CancellationToken cancellationToken) { } + public Task(System.Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public Task(System.Action action, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public Task(System.Action action, object state) { } + public Task(System.Action action, object state, System.Threading.CancellationToken cancellationToken) { } + public Task(System.Action action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public Task(System.Action action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public object AsyncState { get { throw null; } } + public static System.Threading.Tasks.Task CompletedTask { get { throw null; } } + public System.Threading.Tasks.TaskCreationOptions CreationOptions { get { throw null; } } + public static System.Nullable CurrentId { get { throw null; } } + public System.AggregateException Exception { get { throw null; } } + public static System.Threading.Tasks.TaskFactory Factory { get { throw null; } } + public int Id { get { throw null; } } + public bool IsCanceled { get { throw null; } } + public bool IsCompleted { get { throw null; } } + public bool IsFaulted { get { throw null; } } + public System.Threading.Tasks.TaskStatus Status { get { throw null; } } + System.Threading.WaitHandle System.IAsyncResult.AsyncWaitHandle { get { throw null; } } + bool System.IAsyncResult.CompletedSynchronously { get { throw null; } } + public System.Runtime.CompilerServices.ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action continuationAction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func continuationFunction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public static System.Threading.Tasks.Task Delay(int millisecondsDelay) { throw null; } + public static System.Threading.Tasks.Task Delay(int millisecondsDelay, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task Delay(System.TimeSpan delay) { throw null; } + public static System.Threading.Tasks.Task Delay(System.TimeSpan delay, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task FromCanceled(System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task FromCanceled(System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task FromException(System.Exception exception) { throw null; } + public static System.Threading.Tasks.Task FromException(System.Exception exception) { throw null; } + public static System.Threading.Tasks.Task FromResult(TResult result) { throw null; } + public System.Runtime.CompilerServices.TaskAwaiter GetAwaiter() { throw null; } + public static System.Threading.Tasks.Task Run(System.Action action) { throw null; } + public static System.Threading.Tasks.Task Run(System.Action action, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public void RunSynchronously() { } + public void RunSynchronously(System.Threading.Tasks.TaskScheduler scheduler) { } + public static System.Threading.Tasks.Task Run(System.Func> function) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func> function, System.Threading.CancellationToken cancellationToken) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function) { throw null; } + public static System.Threading.Tasks.Task Run(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public void Start() { } + public void Start(System.Threading.Tasks.TaskScheduler scheduler) { } + public void Wait() { } + public bool Wait(int millisecondsTimeout) { throw null; } + public bool Wait(int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { throw null; } + public void Wait(System.Threading.CancellationToken cancellationToken) { } + public bool Wait(System.TimeSpan timeout) { throw null; } + public static void WaitAll(params System.Threading.Tasks.Task[] tasks) { } + public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout) { throw null; } + public static bool WaitAll(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { throw null; } + public static void WaitAll(System.Threading.Tasks.Task[] tasks, System.Threading.CancellationToken cancellationToken) { } + public static bool WaitAll(System.Threading.Tasks.Task[] tasks, System.TimeSpan timeout) { throw null; } + public static int WaitAny(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, int millisecondsTimeout, System.Threading.CancellationToken cancellationToken) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, System.Threading.CancellationToken cancellationToken) { throw null; } + public static int WaitAny(System.Threading.Tasks.Task[] tasks, System.TimeSpan timeout) { throw null; } + public static System.Threading.Tasks.Task WhenAll(System.Collections.Generic.IEnumerable tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAll(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAll(System.Collections.Generic.IEnumerable> tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAll(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAny(System.Collections.Generic.IEnumerable tasks) { throw null; } + public static System.Threading.Tasks.Task WhenAny(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Threading.Tasks.Task> WhenAny(System.Collections.Generic.IEnumerable> tasks) { throw null; } + public static System.Threading.Tasks.Task> WhenAny(params System.Threading.Tasks.Task[] tasks) { throw null; } + public static System.Runtime.CompilerServices.YieldAwaitable Yield() { throw null; } + } + public partial class TaskCanceledException : System.OperationCanceledException + { + public TaskCanceledException() { } + public TaskCanceledException(string message) { } + public TaskCanceledException(string message, System.Exception innerException) { } + public TaskCanceledException(System.Threading.Tasks.Task task) { } + public System.Threading.Tasks.Task Task { get { throw null; } } + } + public partial class TaskCompletionSource + { + public TaskCompletionSource() { } + public TaskCompletionSource(object state) { } + public TaskCompletionSource(object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public TaskCompletionSource(System.Threading.Tasks.TaskCreationOptions creationOptions) { } + public System.Threading.Tasks.Task Task { get { throw null; } } + public void SetCanceled() { } + public void SetException(System.Collections.Generic.IEnumerable exceptions) { } + public void SetException(System.Exception exception) { } + public void SetResult(TResult result) { } + public bool TrySetCanceled() { throw null; } + public bool TrySetCanceled(System.Threading.CancellationToken cancellationToken) { throw null; } + public bool TrySetException(System.Collections.Generic.IEnumerable exceptions) { throw null; } + public bool TrySetException(System.Exception exception) { throw null; } + public bool TrySetResult(TResult result) { throw null; } + } + [System.FlagsAttribute] + public enum TaskContinuationOptions + { + AttachedToParent = 4, + DenyChildAttach = 8, + ExecuteSynchronously = 524288, + HideScheduler = 16, + LazyCancellation = 32, + LongRunning = 2, + None = 0, + NotOnCanceled = 262144, + NotOnFaulted = 131072, + NotOnRanToCompletion = 65536, + OnlyOnCanceled = 196608, + OnlyOnFaulted = 327680, + OnlyOnRanToCompletion = 393216, + PreferFairness = 1, + RunContinuationsAsynchronously = 64, + } + [System.FlagsAttribute] + public enum TaskCreationOptions + { + AttachedToParent = 4, + DenyChildAttach = 8, + HideScheduler = 16, + LongRunning = 2, + None = 0, + PreferFairness = 1, + RunContinuationsAsynchronously = 64, + } + public static partial class TaskExtensions + { + public static System.Threading.Tasks.Task Unwrap(this System.Threading.Tasks.Task task) { throw null; } + public static System.Threading.Tasks.Task Unwrap(this System.Threading.Tasks.Task> task) { throw null; } + } + public partial class TaskFactory + { + public TaskFactory() { } + public TaskFactory(System.Threading.CancellationToken cancellationToken) { } + public TaskFactory(System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { } + public TaskFactory(System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { } + public TaskFactory(System.Threading.Tasks.TaskScheduler scheduler) { } + public System.Threading.CancellationToken CancellationToken { get { throw null; } } + public System.Threading.Tasks.TaskContinuationOptions ContinuationOptions { get { throw null; } } + public System.Threading.Tasks.TaskCreationOptions CreationOptions { get { throw null; } } + public System.Threading.Tasks.TaskScheduler Scheduler { get { throw null; } } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Action[]> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Action> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Action endMethod) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Action endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Action endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Action endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Action action, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + } + public partial class TaskFactory + { + public TaskFactory() { } + public TaskFactory(System.Threading.CancellationToken cancellationToken) { } + public TaskFactory(System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { } + public TaskFactory(System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { } + public TaskFactory(System.Threading.Tasks.TaskScheduler scheduler) { } + public System.Threading.CancellationToken CancellationToken { get { throw null; } } + public System.Threading.Tasks.TaskContinuationOptions ContinuationOptions { get { throw null; } } + public System.Threading.Tasks.TaskCreationOptions CreationOptions { get { throw null; } } + public System.Threading.Tasks.TaskScheduler Scheduler { get { throw null; } } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAll(System.Threading.Tasks.Task[] tasks, System.Func[], TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWhenAny(System.Threading.Tasks.Task[] tasks, System.Func, TResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.IAsyncResult asyncResult, System.Func endMethod, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state) { throw null; } + public System.Threading.Tasks.Task FromAsync(System.Func beginMethod, System.Func endMethod, TArg1 arg1, TArg2 arg2, TArg3 arg3, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task StartNew(System.Func function, System.Threading.Tasks.TaskCreationOptions creationOptions) { throw null; } + } + public abstract partial class TaskScheduler + { + protected TaskScheduler() { } + public static System.Threading.Tasks.TaskScheduler Current { get { throw null; } } + public static System.Threading.Tasks.TaskScheduler Default { get { throw null; } } + public int Id { get { throw null; } } + public virtual int MaximumConcurrencyLevel { get { throw null; } } + public static event System.EventHandler UnobservedTaskException { add { } remove { } } + public static System.Threading.Tasks.TaskScheduler FromCurrentSynchronizationContext() { throw null; } + protected abstract System.Collections.Generic.IEnumerable GetScheduledTasks(); + protected internal abstract void QueueTask(System.Threading.Tasks.Task task); + protected internal virtual bool TryDequeue(System.Threading.Tasks.Task task) { throw null; } + protected bool TryExecuteTask(System.Threading.Tasks.Task task) { throw null; } + protected abstract bool TryExecuteTaskInline(System.Threading.Tasks.Task task, bool taskWasPreviouslyQueued); + } + public partial class TaskSchedulerException : System.Exception + { + public TaskSchedulerException() { } + public TaskSchedulerException(System.Exception innerException) { } + public TaskSchedulerException(string message) { } + public TaskSchedulerException(string message, System.Exception innerException) { } + } + public enum TaskStatus + { + Canceled = 6, + Created = 0, + Faulted = 7, + RanToCompletion = 5, + Running = 3, + WaitingForActivation = 1, + WaitingForChildrenToComplete = 4, + WaitingToRun = 2, + } + public partial class Task : System.Threading.Tasks.Task + { + public Task(System.Func function, object state) : base (default(System.Action)) { } + public Task(System.Func function, object state, System.Threading.CancellationToken cancellationToken) : base (default(System.Action)) { } + public Task(System.Func function, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public Task(System.Func function, object state, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public Task(System.Func function) : base (default(System.Action)) { } + public Task(System.Func function, System.Threading.CancellationToken cancellationToken) : base (default(System.Action)) { } + public Task(System.Func function, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public Task(System.Func function, System.Threading.Tasks.TaskCreationOptions creationOptions) : base (default(System.Action)) { } + public static new System.Threading.Tasks.TaskFactory Factory { get { throw null; } } + public TResult Result { get { throw null; } } + public new System.Runtime.CompilerServices.ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action, object> continuationAction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Action> continuationAction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, object, TNewResult> continuationFunction, object state, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.CancellationToken cancellationToken) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.CancellationToken cancellationToken, System.Threading.Tasks.TaskContinuationOptions continuationOptions, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.Tasks.TaskContinuationOptions continuationOptions) { throw null; } + public System.Threading.Tasks.Task ContinueWith(System.Func, TNewResult> continuationFunction, System.Threading.Tasks.TaskScheduler scheduler) { throw null; } + public new System.Runtime.CompilerServices.TaskAwaiter GetAwaiter() { throw null; } + } + public partial class UnobservedTaskExceptionEventArgs : System.EventArgs + { + public UnobservedTaskExceptionEventArgs(System.AggregateException exception) { } + public System.AggregateException Exception { get { throw null; } } + public bool Observed { get { throw null; } } + public void SetObserved() { } + } +} diff --git a/src/referencePackages/src/system.reflection.metadata/4.3.0/system.threading.tasks.nuspec b/src/referencePackages/src/system.reflection.metadata/4.3.0/system.threading.tasks.nuspec new file mode 100755 index 0000000000..870c8698ef --- /dev/null +++ b/src/referencePackages/src/system.reflection.metadata/4.3.0/system.threading.tasks.nuspec @@ -0,0 +1,59 @@ + + + + System.Threading.Tasks + 4.3.0 + System.Threading.Tasks + Microsoft + microsoft,dotnetframework + true + https://microsoft.mit-license.org/ + https://dot.net/ + http://go.microsoft.com/fwlink/?LinkID=288859 + Provides types that simplify the work of writing concurrent and asynchronous code. + +Commonly Used Types: +System.Threading.Tasks.Task<TResult> +System.Runtime.CompilerServices.TaskAwaiter<TResult> +System.Threading.Tasks.TaskCompletionSource<TResult> +System.Threading.Tasks.Task +System.OperationCanceledException +System.AggregateException + +When using NuGet 3.x this package requires at least version 3.4. + https://go.microsoft.com/fwlink/?LinkID=799421 + © Microsoft Corporation. All rights reserved. + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file