diff --git a/NuGet.config b/NuGet.config new file mode 100644 index 0000000000..db7fb36a0b --- /dev/null +++ b/NuGet.config @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/build.sh b/build.sh new file mode 100755 index 0000000000..e16be02a94 --- /dev/null +++ b/build.sh @@ -0,0 +1,15 @@ +#!/usr/bin/env bash + +__scriptpath=$(cd "$(dirname "$0")"; pwd -P) +__log_path="$__scriptpath/artifacts/log" + +# Use Arcade script to initialize dotnet cli only +source ./eng/common/tools.sh +InitializeDotNetCli true + +export __DOTNET_CMD="$_InitializeDotNetCli/dotnet" +__SDK_PATH="$DOTNET_INSTALL_DIR/sdk/$_ReadGlobalVersion" + +export RepoRoot="$__scriptpath/" + +$__DOTNET_CMD $__SDK_PATH/MSBuild.dll $__scriptpath/src/referencePackages/buildReferencePackages.proj /bl:"$__log_path/BuildReferencePackages.binlog" $@ diff --git a/clean.sh b/clean.sh new file mode 100755 index 0000000000..0a0b53b470 --- /dev/null +++ b/clean.sh @@ -0,0 +1,2 @@ +rm -rf ./.dotnet +rm -rf ./artifacts diff --git a/eng/common/CIBuild.cmd b/eng/common/CIBuild.cmd new file mode 100644 index 0000000000..56c2f25ac2 --- /dev/null +++ b/eng/common/CIBuild.cmd @@ -0,0 +1,2 @@ +@echo off +powershell -ExecutionPolicy ByPass -NoProfile -command "& """%~dp0Build.ps1""" -restore -build -test -sign -pack -publish -ci %*" \ No newline at end of file diff --git a/eng/common/PublishToPackageFeed.proj b/eng/common/PublishToPackageFeed.proj new file mode 100644 index 0000000000..25362ff060 --- /dev/null +++ b/eng/common/PublishToPackageFeed.proj @@ -0,0 +1,69 @@ + + + + netcoreapp2.1 + + + + + + + + + + + + + + + + + + + + + + + + + https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json + https://dotnetfeed.blob.core.windows.net/arcade-validation/index.json + + + + + + + + + + + + diff --git a/eng/common/README.md b/eng/common/README.md new file mode 100644 index 0000000000..ff49c37152 --- /dev/null +++ b/eng/common/README.md @@ -0,0 +1,28 @@ +# Don't touch this folder + + uuuuuuuuuuuuuuuuuuuu + u" uuuuuuuuuuuuuuuuuu "u + u" u$$$$$$$$$$$$$$$$$$$$u "u + u" u$$$$$$$$$$$$$$$$$$$$$$$$u "u + u" u$$$$$$$$$$$$$$$$$$$$$$$$$$$$u "u + u" u$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$u "u + u" u$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$u "u + $ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ + $ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ + $ $$$" ... "$... ...$" ... "$$$ ... "$$$ $ + $ $$$u `"$$$$$$$ $$$ $$$$$ $$ $$$ $$$ $ + $ $$$$$$uu "$$$$ $$$ $$$$$ $$ """ u$$$ $ + $ $$$""$$$ $$$$ $$$u "$$$" u$$ $$$$$$$$ $ + $ $$$$....,$$$$$..$$$$$....,$$$$..$$$$$$$$ $ + $ $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ + "u "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" u" + "u "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" u" + "u "$$$$$$$$$$$$$$$$$$$$$$$$$$$$" u" + "u "$$$$$$$$$$$$$$$$$$$$$$$$" u" + "u "$$$$$$$$$$$$$$$$$$$$" u" + "u """""""""""""""""" u" + """""""""""""""""""" + +!!! Changes made in this directory are subject to being overwritten by automation !!! + +The files in this directory are shared by all Arcade repos and managed by automation. If you need to make changes to these files, open an issue or submit a pull request to https://github.com/dotnet/arcade first. diff --git a/eng/common/build.ps1 b/eng/common/build.ps1 new file mode 100644 index 0000000000..d0147db4bd --- /dev/null +++ b/eng/common/build.ps1 @@ -0,0 +1,134 @@ +[CmdletBinding(PositionalBinding=$false)] +Param( + [string][Alias('c')]$configuration = "Debug", + [string] $projects, + [string][Alias('v')]$verbosity = "minimal", + [string] $msbuildEngine = $null, + [bool] $warnAsError = $true, + [bool] $nodeReuse = $true, + [switch][Alias('r')]$restore, + [switch] $deployDeps, + [switch][Alias('b')]$build, + [switch] $rebuild, + [switch] $deploy, + [switch][Alias('t')]$test, + [switch] $integrationTest, + [switch] $performanceTest, + [switch] $sign, + [switch] $pack, + [switch] $publish, + [switch][Alias('bl')]$binaryLog, + [switch] $ci, + [switch] $prepareMachine, + [switch] $help, + [Parameter(ValueFromRemainingArguments=$true)][String[]]$properties +) + +. $PSScriptRoot\tools.ps1 + +function Print-Usage() { + Write-Host "Common settings:" + Write-Host " -configuration Build configuration: 'Debug' or 'Release' (short: -c)" + Write-Host " -verbosity Msbuild verbosity: q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic] (short: -v)" + Write-Host " -binaryLog Output binary log (short: -bl)" + Write-Host " -help Print help and exit" + Write-Host "" + + Write-Host "Actions:" + Write-Host " -restore Restore dependencies (short: -r)" + Write-Host " -build Build solution (short: -b)" + Write-Host " -rebuild Rebuild solution" + Write-Host " -deploy Deploy built VSIXes" + Write-Host " -deployDeps Deploy dependencies (e.g. VSIXes for integration tests)" + Write-Host " -test Run all unit tests in the solution (short: -t)" + Write-Host " -integrationTest Run all integration tests in the solution" + Write-Host " -performanceTest Run all performance tests in the solution" + Write-Host " -pack Package build outputs into NuGet packages and Willow components" + Write-Host " -sign Sign build outputs" + Write-Host " -publish Publish artifacts (e.g. symbols)" + Write-Host "" + + Write-Host "Advanced settings:" + Write-Host " -projects Semi-colon delimited list of sln/proj's to build. Globbing is supported (*.sln)" + Write-Host " -ci Set when running on CI server" + Write-Host " -prepareMachine Prepare machine for CI run, clean up processes after build" + Write-Host " -warnAsError Sets warnaserror msbuild parameter ('true' or 'false')" + Write-Host " -msbuildEngine Msbuild engine to use to run build ('dotnet', 'vs', or unspecified)." + Write-Host "" + + Write-Host "Command line arguments not listed above are passed thru to msbuild." + Write-Host "The above arguments can be shortened as much as to be unambiguous (e.g. -co for configuration, -t for test, etc.)." +} + +function InitializeCustomToolset { + if (-not $restore) { + return + } + + $script = Join-Path $EngRoot "restore-toolset.ps1" + + if (Test-Path $script) { + . $script + } +} + +function Build { + $toolsetBuildProj = InitializeToolset + InitializeCustomToolset + + $bl = if ($binaryLog) { "/bl:" + (Join-Path $LogDir "Build.binlog") } else { "" } + + if ($projects) { + # Re-assign properties to a new variable because PowerShell doesn't let us append properties directly for unclear reasons. + # Explicitly set the type as string[] because otherwise PowerShell would make this char[] if $properties is empty. + [string[]] $msbuildArgs = $properties + $msbuildArgs += "/p:Projects=$projects" + $properties = $msbuildArgs + } + + MSBuild $toolsetBuildProj ` + $bl ` + /p:Configuration=$configuration ` + /p:RepoRoot=$RepoRoot ` + /p:Restore=$restore ` + /p:DeployDeps=$deployDeps ` + /p:Build=$build ` + /p:Rebuild=$rebuild ` + /p:Deploy=$deploy ` + /p:Test=$test ` + /p:Pack=$pack ` + /p:IntegrationTest=$integrationTest ` + /p:PerformanceTest=$performanceTest ` + /p:Sign=$sign ` + /p:Publish=$publish ` + @properties +} + +try { + if ($help -or (($null -ne $properties) -and ($properties.Contains("/help") -or $properties.Contains("/?")))) { + Print-Usage + exit 0 + } + + if ($ci) { + $binaryLog = $true + $nodeReuse = $false + } + + # Import custom tools configuration, if present in the repo. + # Note: Import in global scope so that the script set top-level variables without qualification. + $configureToolsetScript = Join-Path $EngRoot "configure-toolset.ps1" + if (Test-Path $configureToolsetScript) { + . $configureToolsetScript + } + + Build +} +catch { + Write-Host $_ + Write-Host $_.Exception + Write-Host $_.ScriptStackTrace + ExitWithExitCode 1 +} + +ExitWithExitCode 0 diff --git a/eng/common/build.sh b/eng/common/build.sh new file mode 100755 index 0000000000..40b1e8ec73 --- /dev/null +++ b/eng/common/build.sh @@ -0,0 +1,221 @@ +#!/usr/bin/env bash + +# Stop script if unbound variable found (use ${var:-} if intentional) +set -u + +# Stop script if command returns non-zero exit code. +# Prevents hidden errors caused by missing error code propagation. +set -e + +usage() +{ + echo "Common settings:" + echo " --configuration Build configuration: 'Debug' or 'Release' (short: -c)" + echo " --verbosity Msbuild verbosity: q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic] (short: -v)" + echo " --binaryLog Create MSBuild binary log (short: -bl)" + echo " --help Print help and exit (short: -h)" + echo "" + + echo "Actions:" + echo " --restore Restore dependencies (short: -r)" + echo " --build Build solution (short: -b)" + echo " --rebuild Rebuild solution" + echo " --test Run all unit tests in the solution (short: -t)" + echo " --integrationTest Run all integration tests in the solution" + echo " --performanceTest Run all performance tests in the solution" + echo " --pack Package build outputs into NuGet packages and Willow components" + echo " --sign Sign build outputs" + echo " --publish Publish artifacts (e.g. symbols)" + echo "" + + echo "Advanced settings:" + echo " --projects Project or solution file(s) to build" + echo " --ci Set when running on CI server" + echo " --prepareMachine Prepare machine for CI run, clean up processes after build" + echo " --nodeReuse Sets nodereuse msbuild parameter ('true' or 'false')" + echo " --warnAsError Sets warnaserror msbuild parameter ('true' or 'false')" + echo "" + echo "Command line arguments starting with '/p:' are passed through to MSBuild." + echo "Arguments can also be passed in with a single hyphen." +} + +source="${BASH_SOURCE[0]}" + +# resolve $source until the file is no longer a symlink +while [[ -h "$source" ]]; do + scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + source="$(readlink "$source")" + # if $source was a relative symlink, we need to resolve it relative to the path where the + # symlink file was located + [[ $source != /* ]] && source="$scriptroot/$source" +done +scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + +restore=false +build=false +rebuild=false +test=false +integration_test=false +performance_test=false +pack=false +publish=false +sign=false +public=false +ci=false + +warn_as_error=true +node_reuse=true +binary_log=false + +projects='' +configuration='Debug' +prepare_machine=false +verbosity='minimal' + +properties='' + +while [[ $# > 0 ]]; do + opt="$(echo "${1/#--/-}" | awk '{print tolower($0)}')" + case "$opt" in + -help|-h) + usage + exit 0 + ;; + -configuration|-c) + configuration=$2 + shift + ;; + -verbosity|-v) + verbosity=$2 + shift + ;; + -binarylog|-bl) + binary_log=true + ;; + -restore|-r) + restore=true + ;; + -build|-b) + build=true + ;; + -rebuild) + rebuild=true + ;; + -pack) + pack=true + ;; + -test|-t) + test=true + ;; + -integrationtest) + integration_test=true + ;; + -performancetest) + performance_test=true + ;; + -sign) + sign=true + ;; + -publish) + publish=true + ;; + -preparemachine) + prepare_machine=true + ;; + -projects) + projects=$2 + shift + ;; + -ci) + ci=true + ;; + -warnaserror) + warn_as_error=$2 + shift + ;; + -nodereuse) + node_reuse=$2 + shift + ;; + -p:*|/p:*) + properties="$properties $1" + ;; + -m:*|/m:*) + properties="$properties $1" + ;; + -bl:*|/bl:*) + properties="$properties $1" + ;; + -dl:*|/dl:*) + properties="$properties $1" + ;; + *) + echo "Invalid argument: $1" + usage + exit 1 + ;; + esac + + shift +done + +if [[ "$ci" == true ]]; then + binary_log=true + node_reuse=false +fi + +. "$scriptroot/tools.sh" + +function InitializeCustomToolset { + local script="$eng_root/restore-toolset.sh" + + if [[ -a "$script" ]]; then + . "$script" + fi +} + +function Build { + InitializeToolset + InitializeCustomToolset + + if [[ ! -z "$projects" ]]; then + properties="$properties /p:Projects=$projects" + fi + + local bl="" + if [[ "$binary_log" == true ]]; then + bl="/bl:\"$log_dir/Build.binlog\"" + fi + + MSBuild $_InitializeToolset \ + $bl \ + /p:Configuration=$configuration \ + /p:RepoRoot="$repo_root" \ + /p:Restore=$restore \ + /p:Build=$build \ + /p:Rebuild=$rebuild \ + /p:Test=$test \ + /p:Pack=$pack \ + /p:IntegrationTest=$integration_test \ + /p:PerformanceTest=$performance_test \ + /p:Sign=$sign \ + /p:Publish=$publish \ + $properties + + ExitWithExitCode 0 +} + +# Import custom tools configuration, if present in the repo. +configure_toolset_script="$eng_root/configure-toolset.sh" +if [[ -a "$configure_toolset_script" ]]; then + . "$configure_toolset_script" +fi + +# TODO: https://github.com/dotnet/arcade/issues/1468 +# Temporary workaround to avoid breaking change. +# Remove once repos are updated. +if [[ -n "${useInstalledDotNetCli:-}" ]]; then + use_installed_dotnet_cli="$useInstalledDotNetCli" +fi + +Build diff --git a/eng/common/cibuild.sh b/eng/common/cibuild.sh new file mode 100755 index 0000000000..1a02c0dec8 --- /dev/null +++ b/eng/common/cibuild.sh @@ -0,0 +1,16 @@ +#!/usr/bin/env bash + +source="${BASH_SOURCE[0]}" + +# resolve $SOURCE until the file is no longer a symlink +while [[ -h $source ]]; do + scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + source="$(readlink "$source")" + + # if $source was a relative symlink, we need to resolve it relative to the path where + # the symlink file was located + [[ $source != /* ]] && source="$scriptroot/$source" +done +scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + +. "$scriptroot/build.sh" --restore --build --test --pack --publish --ci $@ \ No newline at end of file diff --git a/eng/common/cross/android/arm/toolchain.cmake b/eng/common/cross/android/arm/toolchain.cmake new file mode 100644 index 0000000000..a7e1c73501 --- /dev/null +++ b/eng/common/cross/android/arm/toolchain.cmake @@ -0,0 +1,41 @@ +set(CROSS_NDK_TOOLCHAIN $ENV{ROOTFS_DIR}/../) +set(CROSS_ROOTFS ${CROSS_NDK_TOOLCHAIN}/sysroot) +set(CLR_CMAKE_PLATFORM_ANDROID "Android") + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_VERSION 1) +set(CMAKE_SYSTEM_PROCESSOR arm) + +## Specify the toolchain +set(TOOLCHAIN "arm-linux-androideabi") +set(CMAKE_PREFIX_PATH ${CROSS_NDK_TOOLCHAIN}) +set(TOOLCHAIN_PREFIX ${TOOLCHAIN}-) + +find_program(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}clang) +find_program(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}clang++) +find_program(CMAKE_ASM_COMPILER ${TOOLCHAIN_PREFIX}clang) +find_program(CMAKE_AR ${TOOLCHAIN_PREFIX}ar) +find_program(CMAKE_LD ${TOOLCHAIN_PREFIX}ar) +find_program(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy) +find_program(CMAKE_OBJDUMP ${TOOLCHAIN_PREFIX}objdump) + +add_compile_options(--sysroot=${CROSS_ROOTFS}) +add_compile_options(-fPIE) +add_compile_options(-mfloat-abi=soft) +include_directories(SYSTEM ${CROSS_NDK_TOOLCHAIN}/include/c++/4.9.x/) +include_directories(SYSTEM ${CROSS_NDK_TOOLCHAIN}/include/c++/4.9.x/arm-linux-androideabi/) + +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} -B ${CROSS_ROOTFS}/usr/lib/gcc/${TOOLCHAIN}") +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} -L${CROSS_ROOTFS}/lib/${TOOLCHAIN}") +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} --sysroot=${CROSS_ROOTFS}") +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} -fPIE -pie") + +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CROSS_LINK_FLAGS}" CACHE STRING "" FORCE) +set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CROSS_LINK_FLAGS}" CACHE STRING "" FORCE) +set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${CROSS_LINK_FLAGS}" CACHE STRING "" FORCE) + +set(CMAKE_FIND_ROOT_PATH "${CROSS_ROOTFS}") +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) diff --git a/eng/common/cross/android/arm64/toolchain.cmake b/eng/common/cross/android/arm64/toolchain.cmake new file mode 100644 index 0000000000..29415899c1 --- /dev/null +++ b/eng/common/cross/android/arm64/toolchain.cmake @@ -0,0 +1,42 @@ +set(CROSS_NDK_TOOLCHAIN $ENV{ROOTFS_DIR}/../) +set(CROSS_ROOTFS ${CROSS_NDK_TOOLCHAIN}/sysroot) +set(CLR_CMAKE_PLATFORM_ANDROID "Android") + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_VERSION 1) +set(CMAKE_SYSTEM_PROCESSOR aarch64) + +## Specify the toolchain +set(TOOLCHAIN "aarch64-linux-android") +set(CMAKE_PREFIX_PATH ${CROSS_NDK_TOOLCHAIN}) +set(TOOLCHAIN_PREFIX ${TOOLCHAIN}-) + +find_program(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}clang) +find_program(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}clang++) +find_program(CMAKE_ASM_COMPILER ${TOOLCHAIN_PREFIX}clang) +find_program(CMAKE_AR ${TOOLCHAIN_PREFIX}ar) +find_program(CMAKE_LD ${TOOLCHAIN_PREFIX}ar) +find_program(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy) +find_program(CMAKE_OBJDUMP ${TOOLCHAIN_PREFIX}objdump) + +add_compile_options(--sysroot=${CROSS_ROOTFS}) +add_compile_options(-fPIE) + +## Needed for Android or bionic specific conditionals +add_compile_options(-D__ANDROID__) +add_compile_options(-D__BIONIC__) + +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} -B ${CROSS_ROOTFS}/usr/lib/gcc/${TOOLCHAIN}") +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} -L${CROSS_ROOTFS}/lib/${TOOLCHAIN}") +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} --sysroot=${CROSS_ROOTFS}") +set(CROSS_LINK_FLAGS "${CROSS_LINK_FLAGS} -fPIE -pie") + +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${CROSS_LINK_FLAGS}" CACHE STRING "" FORCE) +set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${CROSS_LINK_FLAGS}" CACHE STRING "" FORCE) +set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${CROSS_LINK_FLAGS}" CACHE STRING "" FORCE) + +set(CMAKE_FIND_ROOT_PATH "${CROSS_ROOTFS}") +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) diff --git a/eng/common/cross/arm/sources.list.bionic b/eng/common/cross/arm/sources.list.bionic new file mode 100644 index 0000000000..2109557409 --- /dev/null +++ b/eng/common/cross/arm/sources.list.bionic @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ bionic main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ bionic-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ bionic-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ bionic-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic-security main restricted universe multiverse diff --git a/eng/common/cross/arm/sources.list.jessie b/eng/common/cross/arm/sources.list.jessie new file mode 100644 index 0000000000..4d142ac9b1 --- /dev/null +++ b/eng/common/cross/arm/sources.list.jessie @@ -0,0 +1,3 @@ +# Debian (sid) # UNSTABLE +deb http://ftp.debian.org/debian/ sid main contrib non-free +deb-src http://ftp.debian.org/debian/ sid main contrib non-free diff --git a/eng/common/cross/arm/sources.list.trusty b/eng/common/cross/arm/sources.list.trusty new file mode 100644 index 0000000000..07d8f88d82 --- /dev/null +++ b/eng/common/cross/arm/sources.list.trusty @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ trusty-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ trusty-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ trusty-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm/sources.list.vivid b/eng/common/cross/arm/sources.list.vivid new file mode 100644 index 0000000000..0b1215e475 --- /dev/null +++ b/eng/common/cross/arm/sources.list.vivid @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ vivid main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ vivid-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ vivid-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ vivid-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm/sources.list.wily b/eng/common/cross/arm/sources.list.wily new file mode 100644 index 0000000000..e23d1e02a0 --- /dev/null +++ b/eng/common/cross/arm/sources.list.wily @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ wily main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ wily-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ wily-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ wily-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm/sources.list.xenial b/eng/common/cross/arm/sources.list.xenial new file mode 100644 index 0000000000..eacd86b7df --- /dev/null +++ b/eng/common/cross/arm/sources.list.xenial @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ xenial main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ xenial-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ xenial-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ xenial-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm/sources.list.zesty b/eng/common/cross/arm/sources.list.zesty new file mode 100644 index 0000000000..ea2c14a787 --- /dev/null +++ b/eng/common/cross/arm/sources.list.zesty @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ zesty main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ zesty-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ zesty-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ zesty-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty-security main restricted universe multiverse diff --git a/eng/common/cross/arm/trusty-lttng-2.4.patch b/eng/common/cross/arm/trusty-lttng-2.4.patch new file mode 100644 index 0000000000..8e4dd7ae71 --- /dev/null +++ b/eng/common/cross/arm/trusty-lttng-2.4.patch @@ -0,0 +1,71 @@ +From e72c9d7ead60e3317bd6d1fade995c07021c947b Mon Sep 17 00:00:00 2001 +From: Mathieu Desnoyers +Date: Thu, 7 May 2015 13:25:04 -0400 +Subject: [PATCH] Fix: building probe providers with C++ compiler + +Robert Daniels wrote: +> > I'm attempting to use lttng userspace tracing with a C++ application +> > on an ARM platform. I'm using GCC 4.8.4 on Linux 3.14 with the 2.6 +> > release of lttng. I've compiled lttng-modules, lttng-ust, and +> > lttng-tools and have been able to get a simple test working with C +> > code. When I attempt to run the hello.cxx test on my target it will +> > segfault. +> +> +> I spent a little time digging into this issue and finally discovered the +> cause of my segfault with ARM C++ tracepoints. +> +> There is a struct called 'lttng_event' in ust-events.h which contains an +> empty union 'u'. This was the cause of my issue. Under C, this empty union +> compiles to a zero byte member while under C++ it compiles to a one byte +> member, and in my case was four-byte aligned which caused my C++ code to +> have the 'cds_list_head node' offset incorrectly by four bytes. This lead +> to an incorrect linked list structure which caused my issue. +> +> Since this union is empty, I simply removed it from the struct and everything +> worked correctly. +> +> I don't know the history or purpose behind this empty union so I'd like to +> know if this is a safe fix. If it is I can submit a patch with the union +> removed. + +That's a very nice catch! + +We do not support building tracepoint probe provider with +g++ yet, as stated in lttng-ust(3): + +"- Note for C++ support: although an application instrumented with + tracepoints can be compiled with g++, tracepoint probes should be + compiled with gcc (only tested with gcc so far)." + +However, if it works fine with this fix, then I'm tempted to take it, +especially because removing the empty union does not appear to affect +the layout of struct lttng_event as seen from liblttng-ust, which must +be compiled with a C compiler, and from probe providers compiled with +a C compiler. So all we are changing is the layout of a probe provider +compiled with a C++ compiler, which is anyway buggy at the moment, +because it is not compatible with the layout expected by liblttng-ust +compiled with a C compiler. + +Reported-by: Robert Daniels +Signed-off-by: Mathieu Desnoyers +--- + include/lttng/ust-events.h | 2 -- + 1 file changed, 2 deletions(-) + +diff --git a/usr/include/lttng/ust-events.h b/usr/include/lttng/ust-events.h +index 328a875..3d7a274 100644 +--- a/usr/include/lttng/ust-events.h ++++ b/usr/include/lttng/ust-events.h +@@ -407,8 +407,6 @@ struct lttng_event { + void *_deprecated1; + struct lttng_ctx *ctx; + enum lttng_ust_instrumentation instrumentation; +- union { +- } u; + struct cds_list_head node; /* Event list in session */ + struct cds_list_head _deprecated2; + void *_deprecated3; +-- +2.7.4 + diff --git a/eng/common/cross/arm/trusty.patch b/eng/common/cross/arm/trusty.patch new file mode 100644 index 0000000000..2f2972f8eb --- /dev/null +++ b/eng/common/cross/arm/trusty.patch @@ -0,0 +1,97 @@ +diff -u -r a/usr/include/urcu/uatomic/generic.h b/usr/include/urcu/uatomic/generic.h +--- a/usr/include/urcu/uatomic/generic.h 2014-03-28 06:04:42.000000000 +0900 ++++ b/usr/include/urcu/uatomic/generic.h 2017-02-13 10:35:21.189927116 +0900 +@@ -65,17 +65,17 @@ + switch (len) { + #ifdef UATOMIC_HAS_ATOMIC_BYTE + case 1: +- return __sync_val_compare_and_swap_1(addr, old, _new); ++ return __sync_val_compare_and_swap_1((uint8_t *) addr, old, _new); + #endif + #ifdef UATOMIC_HAS_ATOMIC_SHORT + case 2: +- return __sync_val_compare_and_swap_2(addr, old, _new); ++ return __sync_val_compare_and_swap_2((uint16_t *) addr, old, _new); + #endif + case 4: +- return __sync_val_compare_and_swap_4(addr, old, _new); ++ return __sync_val_compare_and_swap_4((uint32_t *) addr, old, _new); + #if (CAA_BITS_PER_LONG == 64) + case 8: +- return __sync_val_compare_and_swap_8(addr, old, _new); ++ return __sync_val_compare_and_swap_8((uint64_t *) addr, old, _new); + #endif + } + _uatomic_link_error(); +@@ -100,20 +100,20 @@ + switch (len) { + #ifdef UATOMIC_HAS_ATOMIC_BYTE + case 1: +- __sync_and_and_fetch_1(addr, val); ++ __sync_and_and_fetch_1((uint8_t *) addr, val); + return; + #endif + #ifdef UATOMIC_HAS_ATOMIC_SHORT + case 2: +- __sync_and_and_fetch_2(addr, val); ++ __sync_and_and_fetch_2((uint16_t *) addr, val); + return; + #endif + case 4: +- __sync_and_and_fetch_4(addr, val); ++ __sync_and_and_fetch_4((uint32_t *) addr, val); + return; + #if (CAA_BITS_PER_LONG == 64) + case 8: +- __sync_and_and_fetch_8(addr, val); ++ __sync_and_and_fetch_8((uint64_t *) addr, val); + return; + #endif + } +@@ -139,20 +139,20 @@ + switch (len) { + #ifdef UATOMIC_HAS_ATOMIC_BYTE + case 1: +- __sync_or_and_fetch_1(addr, val); ++ __sync_or_and_fetch_1((uint8_t *) addr, val); + return; + #endif + #ifdef UATOMIC_HAS_ATOMIC_SHORT + case 2: +- __sync_or_and_fetch_2(addr, val); ++ __sync_or_and_fetch_2((uint16_t *) addr, val); + return; + #endif + case 4: +- __sync_or_and_fetch_4(addr, val); ++ __sync_or_and_fetch_4((uint32_t *) addr, val); + return; + #if (CAA_BITS_PER_LONG == 64) + case 8: +- __sync_or_and_fetch_8(addr, val); ++ __sync_or_and_fetch_8((uint64_t *) addr, val); + return; + #endif + } +@@ -180,17 +180,17 @@ + switch (len) { + #ifdef UATOMIC_HAS_ATOMIC_BYTE + case 1: +- return __sync_add_and_fetch_1(addr, val); ++ return __sync_add_and_fetch_1((uint8_t *) addr, val); + #endif + #ifdef UATOMIC_HAS_ATOMIC_SHORT + case 2: +- return __sync_add_and_fetch_2(addr, val); ++ return __sync_add_and_fetch_2((uint16_t *) addr, val); + #endif + case 4: +- return __sync_add_and_fetch_4(addr, val); ++ return __sync_add_and_fetch_4((uint32_t *) addr, val); + #if (CAA_BITS_PER_LONG == 64) + case 8: +- return __sync_add_and_fetch_8(addr, val); ++ return __sync_add_and_fetch_8((uint64_t *) addr, val); + #endif + } + _uatomic_link_error(); diff --git a/eng/common/cross/arm64/sources.list.bionic b/eng/common/cross/arm64/sources.list.bionic new file mode 100644 index 0000000000..2109557409 --- /dev/null +++ b/eng/common/cross/arm64/sources.list.bionic @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ bionic main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ bionic-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ bionic-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ bionic-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ bionic-security main restricted universe multiverse diff --git a/eng/common/cross/arm64/sources.list.trusty b/eng/common/cross/arm64/sources.list.trusty new file mode 100644 index 0000000000..07d8f88d82 --- /dev/null +++ b/eng/common/cross/arm64/sources.list.trusty @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ trusty-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ trusty-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ trusty-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ trusty-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm64/sources.list.vivid b/eng/common/cross/arm64/sources.list.vivid new file mode 100644 index 0000000000..0b1215e475 --- /dev/null +++ b/eng/common/cross/arm64/sources.list.vivid @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ vivid main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ vivid-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ vivid-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ vivid-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ vivid-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm64/sources.list.wily b/eng/common/cross/arm64/sources.list.wily new file mode 100644 index 0000000000..e23d1e02a0 --- /dev/null +++ b/eng/common/cross/arm64/sources.list.wily @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ wily main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ wily-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ wily-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ wily-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ wily-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm64/sources.list.xenial b/eng/common/cross/arm64/sources.list.xenial new file mode 100644 index 0000000000..eacd86b7df --- /dev/null +++ b/eng/common/cross/arm64/sources.list.xenial @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ xenial main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ xenial-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ xenial-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ xenial-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ xenial-security main restricted universe multiverse \ No newline at end of file diff --git a/eng/common/cross/arm64/sources.list.zesty b/eng/common/cross/arm64/sources.list.zesty new file mode 100644 index 0000000000..ea2c14a787 --- /dev/null +++ b/eng/common/cross/arm64/sources.list.zesty @@ -0,0 +1,11 @@ +deb http://ports.ubuntu.com/ubuntu-ports/ zesty main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ zesty-updates main restricted universe +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty-updates main restricted universe + +deb http://ports.ubuntu.com/ubuntu-ports/ zesty-backports main restricted +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty-backports main restricted + +deb http://ports.ubuntu.com/ubuntu-ports/ zesty-security main restricted universe multiverse +deb-src http://ports.ubuntu.com/ubuntu-ports/ zesty-security main restricted universe multiverse diff --git a/eng/common/cross/armel/sources.list.jessie b/eng/common/cross/armel/sources.list.jessie new file mode 100644 index 0000000000..3d9c3059d8 --- /dev/null +++ b/eng/common/cross/armel/sources.list.jessie @@ -0,0 +1,3 @@ +# Debian (jessie) # Stable +deb http://ftp.debian.org/debian/ jessie main contrib non-free +deb-src http://ftp.debian.org/debian/ jessie main contrib non-free diff --git a/eng/common/cross/armel/tizen-build-rootfs.sh b/eng/common/cross/armel/tizen-build-rootfs.sh new file mode 100644 index 0000000000..87c48e78fb --- /dev/null +++ b/eng/common/cross/armel/tizen-build-rootfs.sh @@ -0,0 +1,44 @@ +#!/usr/bin/env bash +set -e + +__ARM_SOFTFP_CrossDir=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd ) +__TIZEN_CROSSDIR="$__ARM_SOFTFP_CrossDir/tizen" + +if [[ -z "$ROOTFS_DIR" ]]; then + echo "ROOTFS_DIR is not defined." + exit 1; +fi + +# Clean-up (TODO-Cleanup: We may already delete $ROOTFS_DIR at ./cross/build-rootfs.sh.) +# hk0110 +if [ -d "$ROOTFS_DIR" ]; then + umount $ROOTFS_DIR/* + rm -rf $ROOTFS_DIR +fi + +TIZEN_TMP_DIR=$ROOTFS_DIR/tizen_tmp +mkdir -p $TIZEN_TMP_DIR + +# Download files +echo ">>Start downloading files" +VERBOSE=1 $__ARM_SOFTFP_CrossDir/tizen-fetch.sh $TIZEN_TMP_DIR +echo "<>Start constructing Tizen rootfs" +TIZEN_RPM_FILES=`ls $TIZEN_TMP_DIR/*.rpm` +cd $ROOTFS_DIR +for f in $TIZEN_RPM_FILES; do + rpm2cpio $f | cpio -idm --quiet +done +echo "<>Start configuring Tizen rootfs" +rm ./usr/lib/libunwind.so +ln -s libunwind.so.8 ./usr/lib/libunwind.so +ln -sfn asm-arm ./usr/include/asm +patch -p1 < $__TIZEN_CROSSDIR/tizen.patch +echo "</dev/null; then + VERBOSE=0 +fi + +Log() +{ + if [ $VERBOSE -ge $1 ]; then + echo ${@:2} + fi +} + +Inform() +{ + Log 1 -e "\x1B[0;34m$@\x1B[m" +} + +Debug() +{ + Log 2 -e "\x1B[0;32m$@\x1B[m" +} + +Error() +{ + >&2 Log 0 -e "\x1B[0;31m$@\x1B[m" +} + +Fetch() +{ + URL=$1 + FILE=$2 + PROGRESS=$3 + if [ $VERBOSE -ge 1 ] && [ $PROGRESS ]; then + CURL_OPT="--progress-bar" + else + CURL_OPT="--silent" + fi + curl $CURL_OPT $URL > $FILE +} + +hash curl 2> /dev/null || { Error "Require 'curl' Aborting."; exit 1; } +hash xmllint 2> /dev/null || { Error "Require 'xmllint' Aborting."; exit 1; } +hash sha256sum 2> /dev/null || { Error "Require 'sha256sum' Aborting."; exit 1; } + +TMPDIR=$1 +if [ ! -d $TMPDIR ]; then + TMPDIR=./tizen_tmp + Debug "Create temporary directory : $TMPDIR" + mkdir -p $TMPDIR +fi + +TIZEN_URL=http://download.tizen.org/releases/milestone/tizen +BUILD_XML=build.xml +REPOMD_XML=repomd.xml +PRIMARY_XML=primary.xml +TARGET_URL="http://__not_initialized" + +Xpath_get() +{ + XPATH_RESULT='' + XPATH=$1 + XML_FILE=$2 + RESULT=$(xmllint --xpath $XPATH $XML_FILE) + if [[ -z ${RESULT// } ]]; then + Error "Can not find target from $XML_FILE" + Debug "Xpath = $XPATH" + exit 1 + fi + XPATH_RESULT=$RESULT +} + +fetch_tizen_pkgs_init() +{ + TARGET=$1 + PROFILE=$2 + Debug "Initialize TARGET=$TARGET, PROFILE=$PROFILE" + + TMP_PKG_DIR=$TMPDIR/tizen_${PROFILE}_pkgs + if [ -d $TMP_PKG_DIR ]; then rm -rf $TMP_PKG_DIR; fi + mkdir -p $TMP_PKG_DIR + + PKG_URL=$TIZEN_URL/$PROFILE/latest + + BUILD_XML_URL=$PKG_URL/$BUILD_XML + TMP_BUILD=$TMP_PKG_DIR/$BUILD_XML + TMP_REPOMD=$TMP_PKG_DIR/$REPOMD_XML + TMP_PRIMARY=$TMP_PKG_DIR/$PRIMARY_XML + TMP_PRIMARYGZ=${TMP_PRIMARY}.gz + + Fetch $BUILD_XML_URL $TMP_BUILD + + Debug "fetch $BUILD_XML_URL to $TMP_BUILD" + + TARGET_XPATH="//build/buildtargets/buildtarget[@name=\"$TARGET\"]/repo[@type=\"binary\"]/text()" + Xpath_get $TARGET_XPATH $TMP_BUILD + TARGET_PATH=$XPATH_RESULT + TARGET_URL=$PKG_URL/$TARGET_PATH + + REPOMD_URL=$TARGET_URL/repodata/repomd.xml + PRIMARY_XPATH='string(//*[local-name()="data"][@type="primary"]/*[local-name()="location"]/@href)' + + Fetch $REPOMD_URL $TMP_REPOMD + + Debug "fetch $REPOMD_URL to $TMP_REPOMD" + + Xpath_get $PRIMARY_XPATH $TMP_REPOMD + PRIMARY_XML_PATH=$XPATH_RESULT + PRIMARY_URL=$TARGET_URL/$PRIMARY_XML_PATH + + Fetch $PRIMARY_URL $TMP_PRIMARYGZ + + Debug "fetch $PRIMARY_URL to $TMP_PRIMARYGZ" + + gunzip $TMP_PRIMARYGZ + + Debug "unzip $TMP_PRIMARYGZ to $TMP_PRIMARY" +} + +fetch_tizen_pkgs() +{ + ARCH=$1 + PACKAGE_XPATH_TPL='string(//*[local-name()="metadata"]/*[local-name()="package"][*[local-name()="name"][text()="_PKG_"]][*[local-name()="arch"][text()="_ARCH_"]]/*[local-name()="location"]/@href)' + + PACKAGE_CHECKSUM_XPATH_TPL='string(//*[local-name()="metadata"]/*[local-name()="package"][*[local-name()="name"][text()="_PKG_"]][*[local-name()="arch"][text()="_ARCH_"]]/*[local-name()="checksum"]/text())' + + for pkg in ${@:2} + do + Inform "Fetching... $pkg" + XPATH=${PACKAGE_XPATH_TPL/_PKG_/$pkg} + XPATH=${XPATH/_ARCH_/$ARCH} + Xpath_get $XPATH $TMP_PRIMARY + PKG_PATH=$XPATH_RESULT + + XPATH=${PACKAGE_CHECKSUM_XPATH_TPL/_PKG_/$pkg} + XPATH=${XPATH/_ARCH_/$ARCH} + Xpath_get $XPATH $TMP_PRIMARY + CHECKSUM=$XPATH_RESULT + + PKG_URL=$TARGET_URL/$PKG_PATH + PKG_FILE=$(basename $PKG_PATH) + PKG_PATH=$TMPDIR/$PKG_FILE + + Debug "Download $PKG_URL to $PKG_PATH" + Fetch $PKG_URL $PKG_PATH true + + echo "$CHECKSUM $PKG_PATH" | sha256sum -c - > /dev/null + if [ $? -ne 0 ]; then + Error "Fail to fetch $PKG_URL to $PKG_PATH" + Debug "Checksum = $CHECKSUM" + exit 1 + fi + done +} + +Inform "Initialize arm base" +fetch_tizen_pkgs_init standard base +Inform "fetch common packages" +fetch_tizen_pkgs armv7l gcc glibc glibc-devel libicu libicu-devel +fetch_tizen_pkgs noarch linux-glibc-devel +Inform "fetch coreclr packages" +fetch_tizen_pkgs armv7l lldb lldb-devel libgcc libstdc++ libstdc++-devel libunwind libunwind-devel tizen-release lttng-ust-devel lttng-ust userspace-rcu-devel userspace-rcu +Inform "fetch corefx packages" +fetch_tizen_pkgs armv7l libcom_err libcom_err-devel zlib zlib-devel libopenssl libopenssl-devel krb5 krb5-devel libcurl libcurl-devel + +Inform "Initialize standard unified" +fetch_tizen_pkgs_init standard unified +Inform "fetch corefx packages" +fetch_tizen_pkgs armv7l gssdp gssdp-devel + diff --git a/eng/common/cross/armel/tizen/tizen-dotnet.ks b/eng/common/cross/armel/tizen/tizen-dotnet.ks new file mode 100644 index 0000000000..506d455bd4 --- /dev/null +++ b/eng/common/cross/armel/tizen/tizen-dotnet.ks @@ -0,0 +1,50 @@ +lang en_US.UTF-8 +keyboard us +timezone --utc Asia/Seoul + +part / --fstype="ext4" --size=3500 --ondisk=mmcblk0 --label rootfs --fsoptions=defaults,noatime + +rootpw tizen +desktop --autologinuser=root +user --name root --groups audio,video --password 'tizen' + +repo --name=standard --baseurl=http://download.tizen.org/releases/milestone/tizen/unified/latest/repos/standard/packages/ --ssl_verify=no +repo --name=base --baseurl=http://download.tizen.org/releases/milestone/tizen/base/latest/repos/standard/packages/ --ssl_verify=no + +%packages +tar +gzip + +sed +grep +gawk +perl + +binutils +findutils +util-linux +lttng-ust +userspace-rcu +procps-ng +tzdata +ca-certificates + + +### Core FX +libicu +libunwind +iputils +zlib +krb5 +libcurl +libopenssl + +%end + +%post + +### Update /tmp privilege +chmod 777 /tmp +#################################### + +%end diff --git a/eng/common/cross/armel/tizen/tizen.patch b/eng/common/cross/armel/tizen/tizen.patch new file mode 100644 index 0000000000..d223427c97 --- /dev/null +++ b/eng/common/cross/armel/tizen/tizen.patch @@ -0,0 +1,18 @@ +diff -u -r a/usr/lib/libc.so b/usr/lib/libc.so +--- a/usr/lib/libc.so 2016-12-30 23:00:08.284951863 +0900 ++++ b/usr/lib/libc.so 2016-12-30 23:00:32.140951815 +0900 +@@ -2,4 +2,4 @@ + Use the shared library, but some functions are only in + the static library, so try that secondarily. */ + OUTPUT_FORMAT(elf32-littlearm) +-GROUP ( /lib/libc.so.6 /usr/lib/libc_nonshared.a AS_NEEDED ( /lib/ld-linux.so.3 ) ) ++GROUP ( libc.so.6 libc_nonshared.a AS_NEEDED ( ld-linux.so.3 ) ) +diff -u -r a/usr/lib/libpthread.so b/usr/lib/libpthread.so +--- a/usr/lib/libpthread.so 2016-12-30 23:00:19.408951841 +0900 ++++ b/usr/lib/libpthread.so 2016-12-30 23:00:39.068951801 +0900 +@@ -2,4 +2,4 @@ + Use the shared library, but some functions are only in + the static library, so try that secondarily. */ + OUTPUT_FORMAT(elf32-littlearm) +-GROUP ( /lib/libpthread.so.0 /usr/lib/libpthread_nonshared.a ) ++GROUP ( libpthread.so.0 libpthread_nonshared.a ) diff --git a/eng/common/cross/build-android-rootfs.sh b/eng/common/cross/build-android-rootfs.sh new file mode 100644 index 0000000000..adceda877a --- /dev/null +++ b/eng/common/cross/build-android-rootfs.sh @@ -0,0 +1,137 @@ +#!/usr/bin/env bash +set -e +__NDK_Version=r14 + +usage() +{ + echo "Creates a toolchain and sysroot used for cross-compiling for Android." + echo. + echo "Usage: $0 [BuildArch] [ApiLevel]" + echo. + echo "BuildArch is the target architecture of Android. Currently only arm64 is supported." + echo "ApiLevel is the target Android API level. API levels usually match to Android releases. See https://source.android.com/source/build-numbers.html" + echo. + echo "By default, the toolchain and sysroot will be generated in cross/android-rootfs/toolchain/[BuildArch]. You can change this behavior" + echo "by setting the TOOLCHAIN_DIR environment variable" + echo. + echo "By default, the NDK will be downloaded into the cross/android-rootfs/android-ndk-$__NDK_Version directory. If you already have an NDK installation," + echo "you can set the NDK_DIR environment variable to have this script use that installation of the NDK." + echo "By default, this script will generate a file, android_platform, in the root of the ROOTFS_DIR directory that contains the RID for the supported and tested Android build: android.21-arm64. This file is to replace '/etc/os-release', which is not available for Android." + exit 1 +} + +__ApiLevel=21 # The minimum platform for arm64 is API level 21 +__BuildArch=arm64 +__AndroidArch=aarch64 +__AndroidToolchain=aarch64-linux-android + +for i in "$@" + do + lowerI="$(echo $i | awk '{print tolower($0)}')" + case $lowerI in + -?|-h|--help) + usage + exit 1 + ;; + arm64) + __BuildArch=arm64 + __AndroidArch=aarch64 + __AndroidToolchain=aarch64-linux-android + ;; + arm) + __BuildArch=arm + __AndroidArch=arm + __AndroidToolchain=arm-linux-androideabi + ;; + *[0-9]) + __ApiLevel=$i + ;; + *) + __UnprocessedBuildArgs="$__UnprocessedBuildArgs $i" + ;; + esac +done + +# Obtain the location of the bash script to figure out where the root of the repo is. +__CrossDir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +__Android_Cross_Dir="$__CrossDir/android-rootfs" +__NDK_Dir="$__Android_Cross_Dir/android-ndk-$__NDK_Version" +__libunwind_Dir="$__Android_Cross_Dir/libunwind" +__lldb_Dir="$__Android_Cross_Dir/lldb" +__ToolchainDir="$__Android_Cross_Dir/toolchain/$__BuildArch" + +if [[ -n "$TOOLCHAIN_DIR" ]]; then + __ToolchainDir=$TOOLCHAIN_DIR +fi + +if [[ -n "$NDK_DIR" ]]; then + __NDK_Dir=$NDK_DIR +fi + +echo "Target API level: $__ApiLevel" +echo "Target architecture: $__BuildArch" +echo "NDK location: $__NDK_Dir" +echo "Target Toolchain location: $__ToolchainDir" + +# Download the NDK if required +if [ ! -d $__NDK_Dir ]; then + echo Downloading the NDK into $__NDK_Dir + mkdir -p $__NDK_Dir + wget -nv -nc --show-progress https://dl.google.com/android/repository/android-ndk-$__NDK_Version-linux-x86_64.zip -O $__Android_Cross_Dir/android-ndk-$__NDK_Version-linux-x86_64.zip + unzip -q $__Android_Cross_Dir/android-ndk-$__NDK_Version-linux-x86_64.zip -d $__Android_Cross_Dir +fi + +if [ ! -d $__lldb_Dir ]; then + mkdir -p $__lldb_Dir + echo Downloading LLDB into $__lldb_Dir + wget -nv -nc --show-progress https://dl.google.com/android/repository/lldb-2.3.3614996-linux-x86_64.zip -O $__Android_Cross_Dir/lldb-2.3.3614996-linux-x86_64.zip + unzip -q $__Android_Cross_Dir/lldb-2.3.3614996-linux-x86_64.zip -d $__lldb_Dir +fi + +# Create the RootFS for both arm64 as well as aarch +rm -rf $__Android_Cross_Dir/toolchain + +echo Generating the $__BuildArch toolchain +$__NDK_Dir/build/tools/make_standalone_toolchain.py --arch $__BuildArch --api $__ApiLevel --install-dir $__ToolchainDir + +# Install the required packages into the toolchain +# TODO: Add logic to get latest pkg version instead of specific version number +rm -rf $__Android_Cross_Dir/deb/ +rm -rf $__Android_Cross_Dir/tmp + +mkdir -p $__Android_Cross_Dir/deb/ +mkdir -p $__Android_Cross_Dir/tmp/$arch/ +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libicu_60.2_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libicu_60.2_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libicu-dev_60.2_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libicu-dev_60.2_$__AndroidArch.deb + +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-glob-dev_0.4_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-glob-dev_0.4_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-glob_0.4_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-glob_0.4_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-support-dev_22_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-support-dev_22_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libandroid-support_22_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libandroid-support_22_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/liblzma-dev_5.2.3_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/liblzma-dev_5.2.3_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/liblzma_5.2.3_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/liblzma_5.2.3_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libunwind-dev_1.2.20170304_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libunwind-dev_1.2.20170304_$__AndroidArch.deb +wget -nv -nc http://termux.net/dists/stable/main/binary-$__AndroidArch/libunwind_1.2.20170304_$__AndroidArch.deb -O $__Android_Cross_Dir/deb/libunwind_1.2.20170304_$__AndroidArch.deb + +echo Unpacking Termux packages +dpkg -x $__Android_Cross_Dir/deb/libicu_60.2_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/libicu-dev_60.2_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/libandroid-glob-dev_0.4_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/libandroid-glob_0.4_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/libandroid-support-dev_22_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/libandroid-support_22_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/liblzma-dev_5.2.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/liblzma_5.2.3_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/libunwind-dev_1.2.20170304_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ +dpkg -x $__Android_Cross_Dir/deb/libunwind_1.2.20170304_$__AndroidArch.deb $__Android_Cross_Dir/tmp/$__AndroidArch/ + +cp -R $__Android_Cross_Dir/tmp/$__AndroidArch/data/data/com.termux/files/usr/* $__ToolchainDir/sysroot/usr/ + +# Generate platform file for build.sh script to assign to __DistroRid +echo "Generating platform file..." + +echo "RID=android.21-arm64" > $__ToolchainDir/sysroot/android_platform +echo Now run: +echo CONFIG_DIR=\`realpath cross/android/$__BuildArch\` ROOTFS_DIR=\`realpath $__ToolchainDir/sysroot\` ./build.sh cross $__BuildArch skipgenerateversion skipnuget cmakeargs -DENABLE_LLDBPLUGIN=0 + diff --git a/eng/common/cross/build-rootfs.sh b/eng/common/cross/build-rootfs.sh new file mode 100644 index 0000000000..805948ca83 --- /dev/null +++ b/eng/common/cross/build-rootfs.sh @@ -0,0 +1,210 @@ +#!/usr/bin/env bash + +usage() +{ + echo "Usage: $0 [BuildArch] [LinuxCodeName] [lldbx.y] [--skipunmount]" + echo "BuildArch can be: arm(default), armel, arm64, x86" + echo "LinuxCodeName - optional, Code name for Linux, can be: trusty(default), vivid, wily, xenial, zesty, bionic, alpine. If BuildArch is armel, LinuxCodeName is jessie(default) or tizen." + echo "lldbx.y - optional, LLDB version, can be: lldb3.6(default), lldb3.8, lldb3.9, lldb4.0, no-lldb. Ignored for alpine" + echo "--skipunmount - optional, will skip the unmount of rootfs folder." + exit 1 +} + +__LinuxCodeName=trusty +__CrossDir=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd ) +__InitialDir=$PWD +__BuildArch=arm +__UbuntuArch=armhf +__UbuntuRepo="http://ports.ubuntu.com/" +__LLDB_Package="lldb-3.6-dev" +__SkipUnmount=0 + +# base development support +__UbuntuPackages="build-essential" + +__AlpinePackages="alpine-base" +__AlpinePackages+=" build-base" +__AlpinePackages+=" linux-headers" +__AlpinePackages+=" lldb-dev" +__AlpinePackages+=" llvm-dev" + +# symlinks fixer +__UbuntuPackages+=" symlinks" + +# CoreCLR and CoreFX dependencies +__UbuntuPackages+=" libicu-dev" +__UbuntuPackages+=" liblttng-ust-dev" +__UbuntuPackages+=" libunwind8-dev" + +__AlpinePackages+=" gettext-dev" +__AlpinePackages+=" icu-dev" +__AlpinePackages+=" libunwind-dev" +__AlpinePackages+=" lttng-ust-dev" + +# CoreFX dependencies +__UbuntuPackages+=" libcurl4-openssl-dev" +__UbuntuPackages+=" libkrb5-dev" +__UbuntuPackages+=" libssl-dev" +__UbuntuPackages+=" zlib1g-dev" + +__AlpinePackages+=" curl-dev" +__AlpinePackages+=" krb5-dev" +__AlpinePackages+=" openssl-dev" +__AlpinePackages+=" zlib-dev" + +__UnprocessedBuildArgs= +for i in "$@" ; do + lowerI="$(echo $i | awk '{print tolower($0)}')" + case $lowerI in + -?|-h|--help) + usage + exit 1 + ;; + arm) + __BuildArch=arm + __UbuntuArch=armhf + __AlpineArch=armhf + __QEMUArch=arm + ;; + arm64) + __BuildArch=arm64 + __UbuntuArch=arm64 + __AlpineArch=aarch64 + __QEMUArch=aarch64 + ;; + armel) + __BuildArch=armel + __UbuntuArch=armel + __UbuntuRepo="http://ftp.debian.org/debian/" + __LinuxCodeName=jessie + ;; + x86) + __BuildArch=x86 + __UbuntuArch=i386 + __UbuntuRepo="http://archive.ubuntu.com/ubuntu/" + ;; + lldb3.6) + __LLDB_Package="lldb-3.6-dev" + ;; + lldb3.8) + __LLDB_Package="lldb-3.8-dev" + ;; + lldb3.9) + __LLDB_Package="liblldb-3.9-dev" + ;; + lldb4.0) + __LLDB_Package="liblldb-4.0-dev" + ;; + no-lldb) + unset __LLDB_Package + ;; + vivid) + if [ "$__LinuxCodeName" != "jessie" ]; then + __LinuxCodeName=vivid + fi + ;; + wily) + if [ "$__LinuxCodeName" != "jessie" ]; then + __LinuxCodeName=wily + fi + ;; + xenial) + if [ "$__LinuxCodeName" != "jessie" ]; then + __LinuxCodeName=xenial + fi + ;; + zesty) + if [ "$__LinuxCodeName" != "jessie" ]; then + __LinuxCodeName=zesty + fi + ;; + bionic) + if [ "$__LinuxCodeName" != "jessie" ]; then + __LinuxCodeName=bionic + fi + ;; + jessie) + __LinuxCodeName=jessie + __UbuntuRepo="http://ftp.debian.org/debian/" + ;; + tizen) + if [ "$__BuildArch" != "armel" ]; then + echo "Tizen is available only for armel." + usage; + exit 1; + fi + __LinuxCodeName= + __UbuntuRepo= + __Tizen=tizen + ;; + alpine) + __LinuxCodeName=alpine + __UbuntuRepo= + ;; + --skipunmount) + __SkipUnmount=1 + ;; + *) + __UnprocessedBuildArgs="$__UnprocessedBuildArgs $i" + ;; + esac +done + +if [ "$__BuildArch" == "armel" ]; then + __LLDB_Package="lldb-3.5-dev" +fi +__UbuntuPackages+=" ${__LLDB_Package:-}" + +__RootfsDir="$__CrossDir/rootfs/$__BuildArch" + +if [[ -n "$ROOTFS_DIR" ]]; then + __RootfsDir=$ROOTFS_DIR +fi + +if [ -d "$__RootfsDir" ]; then + if [ $__SkipUnmount == 0 ]; then + umount $__RootfsDir/* + fi + rm -rf $__RootfsDir +fi + +if [[ "$__LinuxCodeName" == "alpine" ]]; then + __ApkToolsVersion=2.9.1 + __AlpineVersion=3.7 + __ApkToolsDir=$(mktemp -d) + wget https://github.com/alpinelinux/apk-tools/releases/download/v$__ApkToolsVersion/apk-tools-$__ApkToolsVersion-x86_64-linux.tar.gz -P $__ApkToolsDir + tar -xf $__ApkToolsDir/apk-tools-$__ApkToolsVersion-x86_64-linux.tar.gz -C $__ApkToolsDir + mkdir -p $__RootfsDir/usr/bin + cp -v /usr/bin/qemu-$__QEMUArch-static $__RootfsDir/usr/bin + $__ApkToolsDir/apk-tools-$__ApkToolsVersion/apk \ + -X http://dl-cdn.alpinelinux.org/alpine/v$__AlpineVersion/main \ + -X http://dl-cdn.alpinelinux.org/alpine/v$__AlpineVersion/community \ + -X http://dl-cdn.alpinelinux.org/alpine/edge/testing \ + -U --allow-untrusted --root $__RootfsDir --arch $__AlpineArch --initdb \ + add $__AlpinePackages + rm -r $__ApkToolsDir +elif [[ -n $__LinuxCodeName ]]; then + qemu-debootstrap --arch $__UbuntuArch $__LinuxCodeName $__RootfsDir $__UbuntuRepo + cp $__CrossDir/$__BuildArch/sources.list.$__LinuxCodeName $__RootfsDir/etc/apt/sources.list + chroot $__RootfsDir apt-get update + chroot $__RootfsDir apt-get -f -y install + chroot $__RootfsDir apt-get -y install $__UbuntuPackages + chroot $__RootfsDir symlinks -cr /usr + + if [ $__SkipUnmount == 0 ]; then + umount $__RootfsDir/* + fi + + if [[ "$__BuildArch" == "arm" && "$__LinuxCodeName" == "trusty" ]]; then + pushd $__RootfsDir + patch -p1 < $__CrossDir/$__BuildArch/trusty.patch + patch -p1 < $__CrossDir/$__BuildArch/trusty-lttng-2.4.patch + popd + fi +elif [ "$__Tizen" == "tizen" ]; then + ROOTFS_DIR=$__RootfsDir $__CrossDir/$__BuildArch/tizen-build-rootfs.sh +else + echo "Unsupported target platform." + usage; + exit 1 +fi diff --git a/eng/common/cross/toolchain.cmake b/eng/common/cross/toolchain.cmake new file mode 100644 index 0000000000..071d411241 --- /dev/null +++ b/eng/common/cross/toolchain.cmake @@ -0,0 +1,138 @@ +set(CROSS_ROOTFS $ENV{ROOTFS_DIR}) + +set(TARGET_ARCH_NAME $ENV{TARGET_BUILD_ARCH}) +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_VERSION 1) + +if(TARGET_ARCH_NAME STREQUAL "armel") + set(CMAKE_SYSTEM_PROCESSOR armv7l) + set(TOOLCHAIN "arm-linux-gnueabi") + if("$ENV{__DistroRid}" MATCHES "tizen.*") + set(TIZEN_TOOLCHAIN "armv7l-tizen-linux-gnueabi/6.2.1") + endif() +elseif(TARGET_ARCH_NAME STREQUAL "arm") + set(CMAKE_SYSTEM_PROCESSOR armv7l) + if(EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/armv6-alpine-linux-musleabihf) + set(TOOLCHAIN "armv6-alpine-linux-musleabihf") + else() + set(TOOLCHAIN "arm-linux-gnueabihf") + endif() +elseif(TARGET_ARCH_NAME STREQUAL "arm64") + set(CMAKE_SYSTEM_PROCESSOR aarch64) + if(EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/aarch64-alpine-linux-musl) + set(TOOLCHAIN "aarch64-alpine-linux-musl") + else() + set(TOOLCHAIN "aarch64-linux-gnu") + endif() +elseif(TARGET_ARCH_NAME STREQUAL "x86") + set(CMAKE_SYSTEM_PROCESSOR i686) + set(TOOLCHAIN "i686-linux-gnu") +else() + message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only armel, arm, arm64 and x86 are supported!") +endif() + +# Specify include paths +if(TARGET_ARCH_NAME STREQUAL "armel") + if(DEFINED TIZEN_TOOLCHAIN) + include_directories(SYSTEM ${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}/include/c++/) + include_directories(SYSTEM ${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}/include/c++/armv7l-tizen-linux-gnueabi) + endif() +endif() + +# add_compile_param - adds only new options without duplicates. +# arg0 - list with result options, arg1 - list with new options. +# arg2 - optional argument, quick summary string for optional using CACHE FORCE mode. +macro(add_compile_param) + if(NOT ${ARGC} MATCHES "^(2|3)$") + message(FATAL_ERROR "Wrong using add_compile_param! Two or three parameters must be given! See add_compile_param description.") + endif() + foreach(OPTION ${ARGV1}) + if(NOT ${ARGV0} MATCHES "${OPTION}($| )") + set(${ARGV0} "${${ARGV0}} ${OPTION}") + if(${ARGC} EQUAL "3") # CACHE FORCE mode + set(${ARGV0} "${${ARGV0}}" CACHE STRING "${ARGV2}" FORCE) + endif() + endif() + endforeach() +endmacro() + +# Specify link flags +add_compile_param(CROSS_LINK_FLAGS "--sysroot=${CROSS_ROOTFS}") +add_compile_param(CROSS_LINK_FLAGS "--gcc-toolchain=${CROSS_ROOTFS}/usr") +add_compile_param(CROSS_LINK_FLAGS "--target=${TOOLCHAIN}") +add_compile_param(CROSS_LINK_FLAGS "-fuse-ld=gold") + +if(TARGET_ARCH_NAME STREQUAL "armel") + if(DEFINED TIZEN_TOOLCHAIN) # For Tizen only + add_compile_param(CROSS_LINK_FLAGS "-B${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}") + add_compile_param(CROSS_LINK_FLAGS "-L${CROSS_ROOTFS}/lib") + add_compile_param(CROSS_LINK_FLAGS "-L${CROSS_ROOTFS}/usr/lib") + add_compile_param(CROSS_LINK_FLAGS "-L${CROSS_ROOTFS}/usr/lib/gcc/${TIZEN_TOOLCHAIN}") + endif() +elseif(TARGET_ARCH_NAME STREQUAL "x86") + add_compile_param(CROSS_LINK_FLAGS "-m32") +endif() + +add_compile_param(CMAKE_EXE_LINKER_FLAGS "${CROSS_LINK_FLAGS}" "TOOLCHAIN_EXE_LINKER_FLAGS") +add_compile_param(CMAKE_SHARED_LINKER_FLAGS "${CROSS_LINK_FLAGS}" "TOOLCHAIN_EXE_LINKER_FLAGS") +add_compile_param(CMAKE_MODULE_LINKER_FLAGS "${CROSS_LINK_FLAGS}" "TOOLCHAIN_EXE_LINKER_FLAGS") + +# Specify compile options +add_compile_options("--sysroot=${CROSS_ROOTFS}") +add_compile_options("--target=${TOOLCHAIN}") +add_compile_options("--gcc-toolchain=${CROSS_ROOTFS}/usr") + +if(TARGET_ARCH_NAME MATCHES "^(arm|armel|arm64)$") + set(CMAKE_C_COMPILER_TARGET ${TOOLCHAIN}) + set(CMAKE_CXX_COMPILER_TARGET ${TOOLCHAIN}) + set(CMAKE_ASM_COMPILER_TARGET ${TOOLCHAIN}) +endif() + +if(TARGET_ARCH_NAME MATCHES "^(arm|armel)$") + add_compile_options(-mthumb) + add_compile_options(-mfpu=vfpv3) + if(TARGET_ARCH_NAME STREQUAL "armel") + add_compile_options(-mfloat-abi=softfp) + if(DEFINED TIZEN_TOOLCHAIN) + add_compile_options(-Wno-deprecated-declarations) # compile-time option + add_compile_options(-D__extern_always_inline=inline) # compile-time option + endif() + endif() +elseif(TARGET_ARCH_NAME STREQUAL "x86") + add_compile_options(-m32) + add_compile_options(-Wno-error=unused-command-line-argument) +endif() + +# Set LLDB include and library paths +if(TARGET_ARCH_NAME MATCHES "^(arm|armel|x86)$") + if(TARGET_ARCH_NAME STREQUAL "x86") + set(LLVM_CROSS_DIR "$ENV{LLVM_CROSS_HOME}") + else() # arm/armel case + set(LLVM_CROSS_DIR "$ENV{LLVM_ARM_HOME}") + endif() + if(LLVM_CROSS_DIR) + set(WITH_LLDB_LIBS "${LLVM_CROSS_DIR}/lib/" CACHE STRING "") + set(WITH_LLDB_INCLUDES "${LLVM_CROSS_DIR}/include" CACHE STRING "") + set(LLDB_H "${WITH_LLDB_INCLUDES}" CACHE STRING "") + set(LLDB "${LLVM_CROSS_DIR}/lib/liblldb.so" CACHE STRING "") + else() + if(TARGET_ARCH_NAME STREQUAL "x86") + set(WITH_LLDB_LIBS "${CROSS_ROOTFS}/usr/lib/i386-linux-gnu" CACHE STRING "") + set(CHECK_LLVM_DIR "${CROSS_ROOTFS}/usr/lib/llvm-3.8/include") + if(EXISTS "${CHECK_LLVM_DIR}" AND IS_DIRECTORY "${CHECK_LLVM_DIR}") + set(WITH_LLDB_INCLUDES "${CHECK_LLVM_DIR}") + else() + set(WITH_LLDB_INCLUDES "${CROSS_ROOTFS}/usr/lib/llvm-3.6/include") + endif() + else() # arm/armel case + set(WITH_LLDB_LIBS "${CROSS_ROOTFS}/usr/lib/${TOOLCHAIN}" CACHE STRING "") + set(WITH_LLDB_INCLUDES "${CROSS_ROOTFS}/usr/lib/llvm-3.6/include" CACHE STRING "") + endif() + endif() +endif() + +set(CMAKE_FIND_ROOT_PATH "${CROSS_ROOTFS}") +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) diff --git a/eng/common/darc-init.ps1 b/eng/common/darc-init.ps1 new file mode 100644 index 0000000000..2467ebdd42 --- /dev/null +++ b/eng/common/darc-init.ps1 @@ -0,0 +1,32 @@ +param ( + $darcVersion = $null +) + +$verbosity = "m" +. $PSScriptRoot\tools.ps1 + +function InstallDarcCli ($darcVersion) { + $darcCliPackageName = "microsoft.dotnet.darc" + + $dotnetRoot = InitializeDotNetCli -install:$true + $dotnet = "$dotnetRoot\dotnet.exe" + $toolList = Invoke-Expression "& `"$dotnet`" tool list -g" + + if ($toolList -like "*$darcCliPackageName*") { + Invoke-Expression "& `"$dotnet`" tool uninstall $darcCliPackageName -g" + } + + # Until we can anonymously query the BAR API for the latest arcade-services + # build applied to the PROD channel, this is hardcoded. + if (-not $darcVersion) { + $darcVersion = '1.1.0-beta.19151.3' + } + + $arcadeServicesSource = 'https://dotnetfeed.blob.core.windows.net/dotnet-arcade/index.json' + + Write-Host "Installing Darc CLI version $darcVersion..." + Write-Host "You may need to restart your command window if this is the first dotnet tool you have installed." + Invoke-Expression "& `"$dotnet`" tool install $darcCliPackageName --version $darcVersion --add-source '$arcadeServicesSource' -v $verbosity -g" +} + +InstallDarcCli $darcVersion diff --git a/eng/common/darc-init.sh b/eng/common/darc-init.sh new file mode 100755 index 0000000000..8d63dd711b --- /dev/null +++ b/eng/common/darc-init.sh @@ -0,0 +1,55 @@ +#!/usr/bin/env bash + +source="${BASH_SOURCE[0]}" +darcVersion="1.1.0-beta.19151.3" + +while [[ $# > 0 ]]; do + opt="$(echo "$1" | awk '{print tolower($0)}')" + case "$opt" in + --darcversion) + darcVersion=$2 + shift + ;; + *) + echo "Invalid argument: $1" + usage + exit 1 + ;; + esac + + shift +done + +# resolve $source until the file is no longer a symlink +while [[ -h "$source" ]]; do + scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + source="$(readlink "$source")" + # if $source was a relative symlink, we need to resolve it relative to the path where the + # symlink file was located + [[ $source != /* ]] && source="$scriptroot/$source" +done +scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" +verbosity=m + +. "$scriptroot/tools.sh" + +function InstallDarcCli { + local darc_cli_package_name="microsoft.dotnet.darc" + + InitializeDotNetCli + local dotnet_root=$_InitializeDotNetCli + + local uninstall_command=`$dotnet_root/dotnet tool uninstall $darc_cli_package_name -g` + local tool_list=$($dotnet_root/dotnet tool list -g) + if [[ $tool_list = *$darc_cli_package_name* ]]; then + echo $($dotnet_root/dotnet tool uninstall $darc_cli_package_name -g) + fi + + local arcadeServicesSource="https://dotnetfeed.blob.core.windows.net/dotnet-arcade/index.json" + + echo "Installing Darc CLI version $toolset_version..." + echo "You may need to restart your command shell if this is the first dotnet tool you have installed." + echo $($dotnet_root/dotnet tool install $darc_cli_package_name --version $darcVersion --add-source "$arcadeServicesSource" -v $verbosity -g) +} + +InstallDarcCli diff --git a/eng/common/generate-graph-files.ps1 b/eng/common/generate-graph-files.ps1 new file mode 100644 index 0000000000..e09c64e9f6 --- /dev/null +++ b/eng/common/generate-graph-files.ps1 @@ -0,0 +1,61 @@ +Param( + [Parameter(Mandatory=$true)][string] $barToken, # Token generated at https://maestro-prod.westus2.cloudapp.azure.com/Account/Tokens + [Parameter(Mandatory=$true)][string] $gitHubPat, # GitHub personal access token from https://github.com/settings/tokens (no auth scopes needed) + [Parameter(Mandatory=$true)][string] $azdoPat, # Azure Dev Ops tokens from https://dev.azure.com/dnceng/_details/security/tokens (code read scope needed) + [Parameter(Mandatory=$true)][string] $outputFolder, # Where the graphviz.txt file will be created + [string] $darcVersion = '1.1.0-beta.19156.4', # darc's version + [switch] $includeToolset # Whether the graph should include toolset dependencies or not. i.e. arcade, optimization. For more about + # toolset dependencies see https://github.com/dotnet/arcade/blob/master/Documentation/Darc.md#toolset-vs-product-dependencies +) + +$ErrorActionPreference = "Stop" +. $PSScriptRoot\tools.ps1 + +function CheckExitCode ([string]$stage) +{ + $exitCode = $LASTEXITCODE + if ($exitCode -ne 0) { + Write-Host "Something failed in stage: '$stage'. Check for errors above. Exiting now..." + ExitWithExitCode $exitCode + } +} + +try { + Push-Location $PSScriptRoot + + Write-Host "Installing darc..." + . .\darc-init.ps1 -darcVersion $darcVersion + CheckExitCode "Running darc-init" + + $darcExe = "$env:USERPROFILE\.dotnet\tools" + $darcExe = Resolve-Path "$darcExe\darc.exe" + + Create-Directory $outputFolder + + $graphVizFilePath = "$outputFolder\graphviz.txt" + $graphFilePath = "$outputFolder\graph.txt" + $options = "get-dependency-graph --graphviz '$graphVizFilePath' --github-pat $gitHubPat --azdev-pat $azdoPat --password $barToken --output-file $graphFilePath" + + if ($includeToolset) { + Write-Host "Toolsets will be included in the graph..." + $options += " --include-toolset" + } + + Write-Host "Generating dependency graph..." + Invoke-Expression "& `"$darcExe`" $options" + CheckExitCode "Generating dependency graph" + + $graph = Get-Content $graphVizFilePath + Set-Content $graphVizFilePath -Value "Paste the following digraph object in http://www.webgraphviz.com `r`n", $graph + Write-Host "'$graphVizFilePath' and '$graphFilePath' created!" +} +catch { + if (!$includeToolset) { + Write-Host "This might be a toolset repo which includes only toolset dependencies. " -NoNewline -ForegroundColor Yellow + Write-Host "Since -includeToolset is not set there is no graph to create. Include -includeToolset and try again..." -ForegroundColor Yellow + } + Write-Host $_ + Write-Host $_.Exception + Write-Host $_.ScriptStackTrace + ExitWithExitCode 1 +} \ No newline at end of file diff --git a/eng/common/helixpublish.proj b/eng/common/helixpublish.proj new file mode 100644 index 0000000000..d7f185856e --- /dev/null +++ b/eng/common/helixpublish.proj @@ -0,0 +1,26 @@ + + + + msbuild + + + + + %(Identity) + + + + + + $(WorkItemDirectory) + $(WorkItemCommand) + $(WorkItemTimeout) + + + + + + + + + diff --git a/eng/common/init-tools-native.cmd b/eng/common/init-tools-native.cmd new file mode 100644 index 0000000000..438cd548c4 --- /dev/null +++ b/eng/common/init-tools-native.cmd @@ -0,0 +1,3 @@ +@echo off +powershell -NoProfile -NoLogo -ExecutionPolicy ByPass -command "& """%~dp0init-tools-native.ps1""" %*" +exit /b %ErrorLevel% \ No newline at end of file diff --git a/eng/common/init-tools-native.ps1 b/eng/common/init-tools-native.ps1 new file mode 100644 index 0000000000..495a563a75 --- /dev/null +++ b/eng/common/init-tools-native.ps1 @@ -0,0 +1,138 @@ +<# +.SYNOPSIS +Entry point script for installing native tools + +.DESCRIPTION +Reads $RepoRoot\global.json file to determine native assets to install +and executes installers for those tools + +.PARAMETER BaseUri +Base file directory or Url from which to acquire tool archives + +.PARAMETER InstallDirectory +Directory to install native toolset. This is a command-line override for the default +Install directory precedence order: +- InstallDirectory command-line override +- NETCOREENG_INSTALL_DIRECTORY environment variable +- (default) %USERPROFILE%/.netcoreeng/native + +.PARAMETER Clean +Switch specifying to not install anything, but cleanup native asset folders + +.PARAMETER Force +Clean and then install tools + +.PARAMETER DownloadRetries +Total number of retry attempts + +.PARAMETER RetryWaitTimeInSeconds +Wait time between retry attempts in seconds + +.PARAMETER GlobalJsonFile +File path to global.json file + +.NOTES +#> +[CmdletBinding(PositionalBinding=$false)] +Param ( + [string] $BaseUri = "https://netcorenativeassets.blob.core.windows.net/resource-packages/external", + [string] $InstallDirectory, + [switch] $Clean = $False, + [switch] $Force = $False, + [int] $DownloadRetries = 5, + [int] $RetryWaitTimeInSeconds = 30, + [string] $GlobalJsonFile = "$PSScriptRoot\..\..\global.json" +) + +Set-StrictMode -version 2.0 +$ErrorActionPreference="Stop" + +Import-Module -Name (Join-Path $PSScriptRoot "native\CommonLibrary.psm1") + +try { + # Define verbose switch if undefined + $Verbose = $VerbosePreference -Eq "Continue" + + $EngCommonBaseDir = Join-Path $PSScriptRoot "native\" + $NativeBaseDir = $InstallDirectory + if (!$NativeBaseDir) { + $NativeBaseDir = CommonLibrary\Get-NativeInstallDirectory + } + $Env:CommonLibrary_NativeInstallDir = $NativeBaseDir + $InstallBin = Join-Path $NativeBaseDir "bin" + $InstallerPath = Join-Path $EngCommonBaseDir "install-tool.ps1" + + # Process tools list + Write-Host "Processing $GlobalJsonFile" + If (-Not (Test-Path $GlobalJsonFile)) { + Write-Host "Unable to find '$GlobalJsonFile'" + exit 0 + } + $NativeTools = Get-Content($GlobalJsonFile) -Raw | + ConvertFrom-Json | + Select-Object -Expand "native-tools" -ErrorAction SilentlyContinue + if ($NativeTools) { + $NativeTools.PSObject.Properties | ForEach-Object { + $ToolName = $_.Name + $ToolVersion = $_.Value + $LocalInstallerCommand = $InstallerPath + $LocalInstallerCommand += " -ToolName $ToolName" + $LocalInstallerCommand += " -InstallPath $InstallBin" + $LocalInstallerCommand += " -BaseUri $BaseUri" + $LocalInstallerCommand += " -CommonLibraryDirectory $EngCommonBaseDir" + $LocalInstallerCommand += " -Version $ToolVersion" + + if ($Verbose) { + $LocalInstallerCommand += " -Verbose" + } + if (Get-Variable 'Force' -ErrorAction 'SilentlyContinue') { + if($Force) { + $LocalInstallerCommand += " -Force" + } + } + if ($Clean) { + $LocalInstallerCommand += " -Clean" + } + + Write-Verbose "Installing $ToolName version $ToolVersion" + Write-Verbose "Executing '$LocalInstallerCommand'" + Invoke-Expression "$LocalInstallerCommand" + if ($LASTEXITCODE -Ne "0") { + $errMsg = "$ToolName installation failed" + if ((Get-Variable 'DoNotAbortNativeToolsInstallationOnFailure' -ErrorAction 'SilentlyContinue') -and $DoNotAbortNativeToolsInstallationOnFailure) { + Write-Warning $errMsg + $toolInstallationFailure = $true + } else { + Write-Error $errMsg + exit 1 + } + } + } + + if ((Get-Variable 'toolInstallationFailure' -ErrorAction 'SilentlyContinue') -and $toolInstallationFailure) { + exit 1 + } + } + else { + Write-Host "No native tools defined in global.json" + exit 0 + } + + if ($Clean) { + exit 0 + } + if (Test-Path $InstallBin) { + Write-Host "Native tools are available from" (Convert-Path -Path $InstallBin) + Write-Host "##vso[task.prependpath]$(Convert-Path -Path $InstallBin)" + } + else { + Write-Error "Native tools install directory does not exist, installation failed" + exit 1 + } + exit 0 +} +catch { + Write-Host $_ + Write-Host $_.Exception + exit 1 +} diff --git a/eng/common/init-tools-native.sh b/eng/common/init-tools-native.sh new file mode 100644 index 0000000000..54b70f678b --- /dev/null +++ b/eng/common/init-tools-native.sh @@ -0,0 +1,145 @@ +#!/usr/bin/env bash + +source="${BASH_SOURCE[0]}" +scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + +base_uri='https://netcorenativeassets.blob.core.windows.net/resource-packages/external' +install_directory='' +clean=false +force=false +download_retries=5 +retry_wait_time_seconds=30 +global_json_file="${scriptroot}/../../global.json" +declare -A native_assets + +. $scriptroot/native/common-library.sh + +while (($# > 0)); do + lowerI="$(echo $1 | awk '{print tolower($0)}')" + case $lowerI in + --baseuri) + base_uri=$2 + shift 2 + ;; + --installdirectory) + install_directory=$2 + shift 2 + ;; + --clean) + clean=true + shift 1 + ;; + --force) + force=true + shift 1 + ;; + --downloadretries) + download_retries=$2 + shift 2 + ;; + --retrywaittimeseconds) + retry_wait_time_seconds=$2 + shift 2 + ;; + --help) + echo "Common settings:" + echo " --installdirectory Directory to install native toolset." + echo " This is a command-line override for the default" + echo " Install directory precedence order:" + echo " - InstallDirectory command-line override" + echo " - NETCOREENG_INSTALL_DIRECTORY environment variable" + echo " - (default) %USERPROFILE%/.netcoreeng/native" + echo "" + echo " --clean Switch specifying not to install anything, but cleanup native asset folders" + echo " --force Clean and then install tools" + echo " --help Print help and exit" + echo "" + echo "Advanced settings:" + echo " --baseuri Base URI for where to download native tools from" + echo " --downloadretries Number of times a download should be attempted" + echo " --retrywaittimeseconds Wait time between download attempts" + echo "" + exit 0 + ;; + esac +done + +function ReadGlobalJsonNativeTools { + # Get the native-tools section from the global.json. + local native_tools_section=$(cat $global_json_file | awk '/"native-tools"/,/}/') + # Only extract the contents of the object. + local native_tools_list=$(echo $native_tools_section | awk -F"[{}]" '{print $2}') + native_tools_list=${native_tools_list//[\" ]/} + native_tools_list=${native_tools_list//,/$'\n'} + + local old_IFS=$IFS + while read -r line; do + # Lines are of the form: 'tool:version' + IFS=: + while read -r key value; do + native_assets[$key]=$value + done <<< "$line" + done <<< "$native_tools_list" + IFS=$old_IFS + + return 0; +} + +native_base_dir=$install_directory +if [[ -z $install_directory ]]; then + native_base_dir=$(GetNativeInstallDirectory) +fi + +install_bin="${native_base_dir}/bin" + +ReadGlobalJsonNativeTools + +if [[ ${#native_assets[@]} -eq 0 ]]; then + echo "No native tools defined in global.json" + exit 0; +else + native_installer_dir="$scriptroot/native" + for tool in "${!native_assets[@]}" + do + tool_version=${native_assets[$tool]} + installer_name="install-$tool.sh" + installer_command="$native_installer_dir/$installer_name" + installer_command+=" --baseuri $base_uri" + installer_command+=" --installpath $install_bin" + installer_command+=" --version $tool_version" + + if [[ $force = true ]]; then + installer_command+=" --force" + fi + + if [[ $clean = true ]]; then + installer_command+=" --clean" + fi + + echo "Installing $tool version $tool_version" + echo "Executing '$installer_command'" + $installer_command + + if [[ $? != 0 ]]; then + echo "Execution Failed" >&2 + exit 1 + fi + done +fi + +if [[ ! -z $clean ]]; then + exit 0 +fi + +if [[ -d $install_bin ]]; then + echo "Native tools are available from $install_bin" + if [[ !-z BUILD_BUILDNUMBER ]]; then + echo "##vso[task.prependpath]$install_bin" + fi +else + echo "Native tools install directory does not exist, installation failed" >&2 + exit 1 +fi + +exit 0 + diff --git a/eng/common/internal/Directory.Build.props b/eng/common/internal/Directory.Build.props new file mode 100644 index 0000000000..e33179ef37 --- /dev/null +++ b/eng/common/internal/Directory.Build.props @@ -0,0 +1,4 @@ + + + + diff --git a/eng/common/internal/Tools.csproj b/eng/common/internal/Tools.csproj new file mode 100644 index 0000000000..1a81ff906f --- /dev/null +++ b/eng/common/internal/Tools.csproj @@ -0,0 +1,23 @@ + + + + + net472 + false + + + + + + + + + + https://devdiv.pkgs.visualstudio.com/_packaging/8f470c7e-ac49-4afe-a6ee-cf784e438b93/nuget/v3/index.json; + https://devdiv.pkgs.visualstudio.com/_packaging/VS/nuget/v3/index.json; + + + + + + diff --git a/eng/common/msbuild.ps1 b/eng/common/msbuild.ps1 new file mode 100644 index 0000000000..b37fd3d5e9 --- /dev/null +++ b/eng/common/msbuild.ps1 @@ -0,0 +1,27 @@ +[CmdletBinding(PositionalBinding=$false)] +Param( + [string] $verbosity = "minimal", + [bool] $warnAsError = $true, + [bool] $nodeReuse = $true, + [switch] $ci, + [switch] $prepareMachine, + [Parameter(ValueFromRemainingArguments=$true)][String[]]$extraArgs +) + +. $PSScriptRoot\tools.ps1 + +try { + if ($ci) { + $nodeReuse = $false + } + + MSBuild @extraArgs +} +catch { + Write-Host $_ + Write-Host $_.Exception + Write-Host $_.ScriptStackTrace + ExitWithExitCode 1 +} + +ExitWithExitCode 0 \ No newline at end of file diff --git a/eng/common/msbuild.sh b/eng/common/msbuild.sh new file mode 100755 index 0000000000..8160cd5a59 --- /dev/null +++ b/eng/common/msbuild.sh @@ -0,0 +1,58 @@ +#!/usr/bin/env bash + +source="${BASH_SOURCE[0]}" + +# resolve $source until the file is no longer a symlink +while [[ -h "$source" ]]; do + scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + source="$(readlink "$source")" + # if $source was a relative symlink, we need to resolve it relative to the path where the + # symlink file was located + [[ $source != /* ]] && source="$scriptroot/$source" +done +scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + +verbosity='minimal' +warn_as_error=true +node_reuse=true +prepare_machine=false +extra_args='' + +while (($# > 0)); do + lowerI="$(echo $1 | awk '{print tolower($0)}')" + case $lowerI in + --verbosity) + verbosity=$2 + shift 2 + ;; + --warnaserror) + warn_as_error=$2 + shift 2 + ;; + --nodereuse) + node_reuse=$2 + shift 2 + ;; + --ci) + ci=true + shift 1 + ;; + --preparemachine) + prepare_machine=true + shift 1 + ;; + *) + extra_args="$extra_args $1" + shift 1 + ;; + esac +done + +. "$scriptroot/tools.sh" + +if [[ "$ci" == true ]]; then + node_reuse=false +fi + +MSBuild $extra_args +ExitWithExitCode 0 diff --git a/eng/common/native/CommonLibrary.psm1 b/eng/common/native/CommonLibrary.psm1 new file mode 100644 index 0000000000..f286ae0cde --- /dev/null +++ b/eng/common/native/CommonLibrary.psm1 @@ -0,0 +1,358 @@ +<# +.SYNOPSIS +Helper module to install an archive to a directory + +.DESCRIPTION +Helper module to download and extract an archive to a specified directory + +.PARAMETER Uri +Uri of artifact to download + +.PARAMETER InstallDirectory +Directory to extract artifact contents to + +.PARAMETER Force +Force download / extraction if file or contents already exist. Default = False + +.PARAMETER DownloadRetries +Total number of retry attempts. Default = 5 + +.PARAMETER RetryWaitTimeInSeconds +Wait time between retry attempts in seconds. Default = 30 + +.NOTES +Returns False if download or extraction fail, True otherwise +#> +function DownloadAndExtract { + [CmdletBinding(PositionalBinding=$false)] + Param ( + [Parameter(Mandatory=$True)] + [string] $Uri, + [Parameter(Mandatory=$True)] + [string] $InstallDirectory, + [switch] $Force = $False, + [int] $DownloadRetries = 5, + [int] $RetryWaitTimeInSeconds = 30 + ) + # Define verbose switch if undefined + $Verbose = $VerbosePreference -Eq "Continue" + + $TempToolPath = CommonLibrary\Get-TempPathFilename -Path $Uri + + # Download native tool + $DownloadStatus = CommonLibrary\Get-File -Uri $Uri ` + -Path $TempToolPath ` + -DownloadRetries $DownloadRetries ` + -RetryWaitTimeInSeconds $RetryWaitTimeInSeconds ` + -Force:$Force ` + -Verbose:$Verbose + + if ($DownloadStatus -Eq $False) { + Write-Error "Download failed" + return $False + } + + # Extract native tool + $UnzipStatus = CommonLibrary\Expand-Zip -ZipPath $TempToolPath ` + -OutputDirectory $InstallDirectory ` + -Force:$Force ` + -Verbose:$Verbose + + if ($UnzipStatus -Eq $False) { + Write-Error "Unzip failed" + return $False + } + return $True +} + +<# +.SYNOPSIS +Download a file, retry on failure + +.DESCRIPTION +Download specified file and retry if attempt fails + +.PARAMETER Uri +Uri of file to download. If Uri is a local path, the file will be copied instead of downloaded + +.PARAMETER Path +Path to download or copy uri file to + +.PARAMETER Force +Overwrite existing file if present. Default = False + +.PARAMETER DownloadRetries +Total number of retry attempts. Default = 5 + +.PARAMETER RetryWaitTimeInSeconds +Wait time between retry attempts in seconds Default = 30 + +#> +function Get-File { + [CmdletBinding(PositionalBinding=$false)] + Param ( + [Parameter(Mandatory=$True)] + [string] $Uri, + [Parameter(Mandatory=$True)] + [string] $Path, + [int] $DownloadRetries = 5, + [int] $RetryWaitTimeInSeconds = 30, + [switch] $Force = $False + ) + $Attempt = 0 + + if ($Force) { + if (Test-Path $Path) { + Remove-Item $Path -Force + } + } + if (Test-Path $Path) { + Write-Host "File '$Path' already exists, skipping download" + return $True + } + + $DownloadDirectory = Split-Path -ErrorAction Ignore -Path "$Path" -Parent + if (-Not (Test-Path $DownloadDirectory)) { + New-Item -path $DownloadDirectory -force -itemType "Directory" | Out-Null + } + + if (Test-Path -IsValid -Path $Uri) { + Write-Verbose "'$Uri' is a file path, copying file to '$Path'" + Copy-Item -Path $Uri -Destination $Path + return $? + } + else { + Write-Verbose "Downloading $Uri" + while($Attempt -Lt $DownloadRetries) + { + try { + Invoke-WebRequest -UseBasicParsing -Uri $Uri -OutFile $Path + Write-Verbose "Downloaded to '$Path'" + return $True + } + catch { + $Attempt++ + if ($Attempt -Lt $DownloadRetries) { + $AttemptsLeft = $DownloadRetries - $Attempt + Write-Warning "Download failed, $AttemptsLeft attempts remaining, will retry in $RetryWaitTimeInSeconds seconds" + Start-Sleep -Seconds $RetryWaitTimeInSeconds + } + else { + Write-Error $_ + Write-Error $_.Exception + } + } + } + } + + return $False +} + +<# +.SYNOPSIS +Generate a shim for a native tool + +.DESCRIPTION +Creates a wrapper script (shim) that passes arguments forward to native tool assembly + +.PARAMETER ShimName +The name of the shim + +.PARAMETER ShimDirectory +The directory where shims are stored + +.PARAMETER ToolFilePath +Path to file that shim forwards to + +.PARAMETER Force +Replace shim if already present. Default = False + +.NOTES +Returns $True if generating shim succeeds, $False otherwise +#> +function New-ScriptShim { + [CmdletBinding(PositionalBinding=$false)] + Param ( + [Parameter(Mandatory=$True)] + [string] $ShimName, + [Parameter(Mandatory=$True)] + [string] $ShimDirectory, + [Parameter(Mandatory=$True)] + [string] $ToolFilePath, + [Parameter(Mandatory=$True)] + [string] $BaseUri, + [switch] $Force + ) + try { + Write-Verbose "Generating '$ShimName' shim" + + if (-Not (Test-Path $ToolFilePath)){ + Write-Error "Specified tool file path '$ToolFilePath' does not exist" + return $False + } + + # WinShimmer is a small .NET Framework program that creates .exe shims to bootstrapped programs + # Many of the checks for installed programs expect a .exe extension for Windows tools, rather + # than a .bat or .cmd file. + # Source: https://github.com/dotnet/arcade/tree/master/src/WinShimmer + if (-Not (Test-Path "$ShimDirectory\WinShimmer\winshimmer.exe")) { + $InstallStatus = DownloadAndExtract -Uri "$BaseUri/windows/winshimmer/WinShimmer.zip" ` + -InstallDirectory $ShimDirectory\WinShimmer ` + -Force:$Force ` + -DownloadRetries 2 ` + -RetryWaitTimeInSeconds 5 ` + -Verbose:$Verbose + } + + if ((Test-Path (Join-Path $ShimDirectory "$ShimName.exe"))) { + Write-Host "$ShimName.exe already exists; replacing..." + Remove-Item (Join-Path $ShimDirectory "$ShimName.exe") + } + + Invoke-Expression "$ShimDirectory\WinShimmer\winshimmer.exe $ShimName $ToolFilePath $ShimDirectory" + return $True + } + catch { + Write-Host $_ + Write-Host $_.Exception + return $False + } +} + +<# +.SYNOPSIS +Returns the machine architecture of the host machine + +.NOTES +Returns 'x64' on 64 bit machines + Returns 'x86' on 32 bit machines +#> +function Get-MachineArchitecture { + $ProcessorArchitecture = $Env:PROCESSOR_ARCHITECTURE + $ProcessorArchitectureW6432 = $Env:PROCESSOR_ARCHITEW6432 + if($ProcessorArchitecture -Eq "X86") + { + if(($ProcessorArchitectureW6432 -Eq "") -Or + ($ProcessorArchitectureW6432 -Eq "X86")) { + return "x86" + } + $ProcessorArchitecture = $ProcessorArchitectureW6432 + } + if (($ProcessorArchitecture -Eq "AMD64") -Or + ($ProcessorArchitecture -Eq "IA64") -Or + ($ProcessorArchitecture -Eq "ARM64")) { + return "x64" + } + return "x86" +} + +<# +.SYNOPSIS +Get the name of a temporary folder under the native install directory +#> +function Get-TempDirectory { + return Join-Path (Get-NativeInstallDirectory) "temp/" +} + +function Get-TempPathFilename { + [CmdletBinding(PositionalBinding=$false)] + Param ( + [Parameter(Mandatory=$True)] + [string] $Path + ) + $TempDir = CommonLibrary\Get-TempDirectory + $TempFilename = Split-Path $Path -leaf + $TempPath = Join-Path $TempDir $TempFilename + return $TempPath +} + +<# +.SYNOPSIS +Returns the base directory to use for native tool installation + +.NOTES +Returns the value of the NETCOREENG_INSTALL_DIRECTORY if that environment variable +is set, or otherwise returns an install directory under the %USERPROFILE% +#> +function Get-NativeInstallDirectory { + $InstallDir = $Env:NETCOREENG_INSTALL_DIRECTORY + if (!$InstallDir) { + $InstallDir = Join-Path $Env:USERPROFILE ".netcoreeng/native/" + } + return $InstallDir +} + +<# +.SYNOPSIS +Unzip an archive + +.DESCRIPTION +Powershell module to unzip an archive to a specified directory + +.PARAMETER ZipPath (Required) +Path to archive to unzip + +.PARAMETER OutputDirectory (Required) +Output directory for archive contents + +.PARAMETER Force +Overwrite output directory contents if they already exist + +.NOTES +- Returns True and does not perform an extraction if output directory already exists but Overwrite is not True. +- Returns True if unzip operation is successful +- Returns False if Overwrite is True and it is unable to remove contents of OutputDirectory +- Returns False if unable to extract zip archive +#> +function Expand-Zip { + [CmdletBinding(PositionalBinding=$false)] + Param ( + [Parameter(Mandatory=$True)] + [string] $ZipPath, + [Parameter(Mandatory=$True)] + [string] $OutputDirectory, + [switch] $Force + ) + + Write-Verbose "Extracting '$ZipPath' to '$OutputDirectory'" + try { + if ((Test-Path $OutputDirectory) -And (-Not $Force)) { + Write-Host "Directory '$OutputDirectory' already exists, skipping extract" + return $True + } + if (Test-Path $OutputDirectory) { + Write-Verbose "'Force' is 'True', but '$OutputDirectory' exists, removing directory" + Remove-Item $OutputDirectory -Force -Recurse + if ($? -Eq $False) { + Write-Error "Unable to remove '$OutputDirectory'" + return $False + } + } + if (-Not (Test-Path $OutputDirectory)) { + New-Item -path $OutputDirectory -Force -itemType "Directory" | Out-Null + } + + Add-Type -assembly "system.io.compression.filesystem" + [io.compression.zipfile]::ExtractToDirectory("$ZipPath", "$OutputDirectory") + if ($? -Eq $False) { + Write-Error "Unable to extract '$ZipPath'" + return $False + } + } + catch { + Write-Host $_ + Write-Host $_.Exception + + return $False + } + return $True +} + +export-modulemember -function DownloadAndExtract +export-modulemember -function Expand-Zip +export-modulemember -function Get-File +export-modulemember -function Get-MachineArchitecture +export-modulemember -function Get-NativeInstallDirectory +export-modulemember -function Get-TempDirectory +export-modulemember -function Get-TempPathFilename +export-modulemember -function New-ScriptShim diff --git a/eng/common/native/common-library.sh b/eng/common/native/common-library.sh new file mode 100644 index 0000000000..271bddfac5 --- /dev/null +++ b/eng/common/native/common-library.sh @@ -0,0 +1,168 @@ +#!/usr/bin/env bash + +function GetNativeInstallDirectory { + local install_dir + + if [[ -z $NETCOREENG_INSTALL_DIRECTORY ]]; then + install_dir=$HOME/.netcoreeng/native/ + else + install_dir=$NETCOREENG_INSTALL_DIRECTORY + fi + + echo $install_dir + return 0 +} + +function GetTempDirectory { + + echo $(GetNativeInstallDirectory)temp/ + return 0 +} + +function ExpandZip { + local zip_path=$1 + local output_directory=$2 + local force=${3:-false} + + echo "Extracting $zip_path to $output_directory" + if [[ -d $output_directory ]] && [[ $force = false ]]; then + echo "Directory '$output_directory' already exists, skipping extract" + return 0 + fi + + if [[ -d $output_directory ]]; then + echo "'Force flag enabled, but '$output_directory' exists. Removing directory" + rm -rf $output_directory + if [[ $? != 0 ]]; then + echo Unable to remove '$output_directory'>&2 + return 1 + fi + fi + + echo "Creating directory: '$output_directory'" + mkdir -p $output_directory + + echo "Extracting archive" + tar -xf $zip_path -C $output_directory + if [[ $? != 0 ]]; then + echo "Unable to extract '$zip_path'" >&2 + return 1 + fi + + return 0 +} + +function GetCurrentOS { + local unameOut="$(uname -s)" + case $unameOut in + Linux*) echo "Linux";; + Darwin*) echo "MacOS";; + esac + return 0 +} + +function GetFile { + local uri=$1 + local path=$2 + local force=${3:-false} + local download_retries=${4:-5} + local retry_wait_time_seconds=${5:-30} + + if [[ -f $path ]]; then + if [[ $force = false ]]; then + echo "File '$path' already exists. Skipping download" + return 0 + else + rm -rf $path + fi + fi + + if [[ -f $uri ]]; then + echo "'$uri' is a file path, copying file to '$path'" + cp $uri $path + return $? + fi + + echo "Downloading $uri" + # Use curl if available, otherwise use wget + if command -v curl > /dev/null; then + curl "$uri" -sSL --retry $download_retries --retry-delay $retry_wait_time_seconds --create-dirs -o "$path" --fail + else + wget -q -O "$path" "$uri" --tries="$download_retries" + fi + + return $? +} + +function GetTempPathFileName { + local path=$1 + + local temp_dir=$(GetTempDirectory) + local temp_file_name=$(basename $path) + echo $temp_dir$temp_file_name + return 0 +} + +function DownloadAndExtract { + local uri=$1 + local installDir=$2 + local force=${3:-false} + local download_retries=${4:-5} + local retry_wait_time_seconds=${5:-30} + + local temp_tool_path=$(GetTempPathFileName $uri) + + echo "downloading to: $temp_tool_path" + + # Download file + GetFile "$uri" "$temp_tool_path" $force $download_retries $retry_wait_time_seconds + if [[ $? != 0 ]]; then + echo "Failed to download '$uri' to '$temp_tool_path'." >&2 + return 1 + fi + + # Extract File + echo "extracting from $temp_tool_path to $installDir" + ExpandZip "$temp_tool_path" "$installDir" $force $download_retries $retry_wait_time_seconds + if [[ $? != 0 ]]; then + echo "Failed to extract '$temp_tool_path' to '$installDir'." >&2 + return 1 + fi + + return 0 +} + +function NewScriptShim { + local shimpath=$1 + local tool_file_path=$2 + local force=${3:-false} + + echo "Generating '$shimpath' shim" + if [[ -f $shimpath ]]; then + if [[ $force = false ]]; then + echo "File '$shimpath' already exists." >&2 + return 1 + else + rm -rf $shimpath + fi + fi + + if [[ ! -f $tool_file_path ]]; then + echo "Specified tool file path:'$tool_file_path' does not exist" >&2 + return 1 + fi + + local shim_contents=$'#!/usr/bin/env bash\n' + shim_contents+="SHIMARGS="$'$1\n' + shim_contents+="$tool_file_path"$' $SHIMARGS\n' + + # Write shim file + echo "$shim_contents" > $shimpath + + chmod +x $shimpath + + echo "Finished generating shim '$shimpath'" + + return $? +} + diff --git a/eng/common/native/install-cmake.sh b/eng/common/native/install-cmake.sh new file mode 100644 index 0000000000..293af6017d --- /dev/null +++ b/eng/common/native/install-cmake.sh @@ -0,0 +1,117 @@ +#!/usr/bin/env bash + +source="${BASH_SOURCE[0]}" +scriptroot="$( cd -P "$( dirname "$source" )" && pwd )" + +. $scriptroot/common-library.sh + +base_uri= +install_path= +version= +clean=false +force=false +download_retries=5 +retry_wait_time_seconds=30 + +while (($# > 0)); do + lowerI="$(echo $1 | awk '{print tolower($0)}')" + case $lowerI in + --baseuri) + base_uri=$2 + shift 2 + ;; + --installpath) + install_path=$2 + shift 2 + ;; + --version) + version=$2 + shift 2 + ;; + --clean) + clean=true + shift 1 + ;; + --force) + force=true + shift 1 + ;; + --downloadretries) + download_retries=$2 + shift 2 + ;; + --retrywaittimeseconds) + retry_wait_time_seconds=$2 + shift 2 + ;; + --help) + echo "Common settings:" + echo " --baseuri Base file directory or Url wrom which to acquire tool archives" + echo " --installpath Base directory to install native tool to" + echo " --clean Don't install the tool, just clean up the current install of the tool" + echo " --force Force install of tools even if they previously exist" + echo " --help Print help and exit" + echo "" + echo "Advanced settings:" + echo " --downloadretries Total number of retry attempts" + echo " --retrywaittimeseconds Wait time between retry attempts in seconds" + echo "" + exit 0 + ;; + esac +done + +tool_name="cmake" +tool_os=$(GetCurrentOS) +tool_folder=$(echo $tool_os | awk '{print tolower($0)}') +tool_arch="x86_64" +tool_name_moniker="$tool_name-$version-$tool_os-$tool_arch" +tool_install_directory="$install_path/$tool_name/$version" +tool_file_path="$tool_install_directory/$tool_name_moniker/bin/$tool_name" +shim_path="$install_path/$tool_name.sh" +uri="${base_uri}/$tool_folder/cmake/$tool_name_moniker.tar.gz" + +# Clean up tool and installers +if [[ $clean = true ]]; then + echo "Cleaning $tool_install_directory" + if [[ -d $tool_install_directory ]]; then + rm -rf $tool_install_directory + fi + + echo "Cleaning $shim_path" + if [[ -f $shim_path ]]; then + rm -rf $shim_path + fi + + tool_temp_path=$(GetTempPathFileName $uri) + echo "Cleaning $tool_temp_path" + if [[ -f $tool_temp_path ]]; then + rm -rf $tool_temp_path + fi + + exit 0 +fi + +# Install tool +if [[ -f $tool_file_path ]] && [[ $force = false ]]; then + echo "$tool_name ($version) already exists, skipping install" + exit 0 +fi + +DownloadAndExtract $uri $tool_install_directory $force $download_retries $retry_wait_time_seconds + +if [[ $? != 0 ]]; then + echo "Installation failed" >&2 + exit 1 +fi + +# Generate Shim +# Always rewrite shims so that we are referencing the expected version +NewScriptShim $shim_path $tool_file_path true + +if [[ $? != 0 ]]; then + echo "Shim generation failed" >&2 + exit 1 +fi + +exit 0 \ No newline at end of file diff --git a/eng/common/native/install-tool.ps1 b/eng/common/native/install-tool.ps1 new file mode 100644 index 0000000000..635ab3fd41 --- /dev/null +++ b/eng/common/native/install-tool.ps1 @@ -0,0 +1,130 @@ +<# +.SYNOPSIS +Install native tool + +.DESCRIPTION +Install cmake native tool from Azure blob storage + +.PARAMETER InstallPath +Base directory to install native tool to + +.PARAMETER BaseUri +Base file directory or Url from which to acquire tool archives + +.PARAMETER CommonLibraryDirectory +Path to folder containing common library modules + +.PARAMETER Force +Force install of tools even if they previously exist + +.PARAMETER Clean +Don't install the tool, just clean up the current install of the tool + +.PARAMETER DownloadRetries +Total number of retry attempts + +.PARAMETER RetryWaitTimeInSeconds +Wait time between retry attempts in seconds + +.NOTES +Returns 0 if install succeeds, 1 otherwise +#> +[CmdletBinding(PositionalBinding=$false)] +Param ( + [Parameter(Mandatory=$True)] + [string] $ToolName, + [Parameter(Mandatory=$True)] + [string] $InstallPath, + [Parameter(Mandatory=$True)] + [string] $BaseUri, + [Parameter(Mandatory=$True)] + [string] $Version, + [string] $CommonLibraryDirectory = $PSScriptRoot, + [switch] $Force = $False, + [switch] $Clean = $False, + [int] $DownloadRetries = 5, + [int] $RetryWaitTimeInSeconds = 30 +) + +# Import common library modules +Import-Module -Name (Join-Path $CommonLibraryDirectory "CommonLibrary.psm1") + +try { + # Define verbose switch if undefined + $Verbose = $VerbosePreference -Eq "Continue" + + $Arch = CommonLibrary\Get-MachineArchitecture + $ToolOs = "win64" + if($Arch -Eq "x32") { + $ToolOs = "win32" + } + $ToolNameMoniker = "$ToolName-$Version-$ToolOs-$Arch" + $ToolInstallDirectory = Join-Path $InstallPath "$ToolName\$Version\" + $Uri = "$BaseUri/windows/$ToolName/$ToolNameMoniker.zip" + $ShimPath = Join-Path $InstallPath "$ToolName.exe" + + if ($Clean) { + Write-Host "Cleaning $ToolInstallDirectory" + if (Test-Path $ToolInstallDirectory) { + Remove-Item $ToolInstallDirectory -Force -Recurse + } + Write-Host "Cleaning $ShimPath" + if (Test-Path $ShimPath) { + Remove-Item $ShimPath -Force + } + $ToolTempPath = CommonLibrary\Get-TempPathFilename -Path $Uri + Write-Host "Cleaning $ToolTempPath" + if (Test-Path $ToolTempPath) { + Remove-Item $ToolTempPath -Force + } + exit 0 + } + + # Install tool + if ((Test-Path $ToolInstallDirectory) -And (-Not $Force)) { + Write-Verbose "$ToolName ($Version) already exists, skipping install" + } + else { + $InstallStatus = CommonLibrary\DownloadAndExtract -Uri $Uri ` + -InstallDirectory $ToolInstallDirectory ` + -Force:$Force ` + -DownloadRetries $DownloadRetries ` + -RetryWaitTimeInSeconds $RetryWaitTimeInSeconds ` + -Verbose:$Verbose + + if ($InstallStatus -Eq $False) { + Write-Error "Installation failed" + exit 1 + } + } + + $ToolFilePath = Get-ChildItem $ToolInstallDirectory -Recurse -Filter "$ToolName.exe" | % { $_.FullName } + if (@($ToolFilePath).Length -Gt 1) { + Write-Error "There are multiple copies of $ToolName in $($ToolInstallDirectory): `n$(@($ToolFilePath | out-string))" + exit 1 + } elseif (@($ToolFilePath).Length -Lt 1) { + Write-Error "$ToolName was not found in $ToolFilePath." + exit 1 + } + + # Generate shim + # Always rewrite shims so that we are referencing the expected version + $GenerateShimStatus = CommonLibrary\New-ScriptShim -ShimName $ToolName ` + -ShimDirectory $InstallPath ` + -ToolFilePath "$ToolFilePath" ` + -BaseUri $BaseUri ` + -Force:$Force ` + -Verbose:$Verbose + + if ($GenerateShimStatus -Eq $False) { + Write-Error "Generate shim failed" + return 1 + } + + exit 0 +} +catch { + Write-Host $_ + Write-Host $_.Exception + exit 1 +} diff --git a/eng/common/sdk-task.ps1 b/eng/common/sdk-task.ps1 new file mode 100644 index 0000000000..d0eec5163e --- /dev/null +++ b/eng/common/sdk-task.ps1 @@ -0,0 +1,79 @@ +[CmdletBinding(PositionalBinding=$false)] +Param( + [string] $configuration = "Debug", + [string] $task, + [string] $verbosity = "minimal", + [string] $msbuildEngine = $null, + [switch] $restore, + [switch] $prepareMachine, + [switch] $help, + [Parameter(ValueFromRemainingArguments=$true)][String[]]$properties +) + +$ci = $true +$binaryLog = $true +$warnAsError = $true + +. $PSScriptRoot\tools.ps1 + +function Print-Usage() { + Write-Host "Common settings:" + Write-Host " -task Name of Arcade task (name of a project in SdkTasks directory of the Arcade SDK package)" + Write-Host " -restore Restore dependencies" + Write-Host " -verbosity Msbuild verbosity: q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic]" + Write-Host " -help Print help and exit" + Write-Host "" + + Write-Host "Advanced settings:" + Write-Host " -prepareMachine Prepare machine for CI run" + Write-Host " -msbuildEngine Msbuild engine to use to run build ('dotnet', 'vs', or unspecified)." + Write-Host "" + Write-Host "Command line arguments not listed above are passed thru to msbuild." +} + +function Build([string]$target) { + $logSuffix = if ($target -eq "Execute") { "" } else { ".$target" } + $log = Join-Path $LogDir "$task$logSuffix.binlog" + $outputPath = Join-Path $ToolsetDir "$task\\" + + MSBuild $taskProject ` + /bl:$log ` + /t:$target ` + /p:Configuration=$configuration ` + /p:RepoRoot=$RepoRoot ` + /p:BaseIntermediateOutputPath=$outputPath ` + @properties +} + +try { + if ($help -or (($null -ne $properties) -and ($properties.Contains("/help") -or $properties.Contains("/?")))) { + Print-Usage + exit 0 + } + + if ($task -eq "") { + Write-Host "Missing required parameter '-task '" -ForegroundColor Red + Print-Usage + ExitWithExitCode 1 + } + + $taskProject = GetSdkTaskProject $task + if (!(Test-Path $taskProject)) { + Write-Host "Unknown task: $task" -ForegroundColor Red + ExitWithExitCode 1 + } + + if ($restore) { + Build "Restore" + } + + Build "Execute" +} +catch { + Write-Host $_ + Write-Host $_.Exception + Write-Host $_.ScriptStackTrace + ExitWithExitCode 1 +} + +ExitWithExitCode 0 diff --git a/eng/common/templates/job/generate-graph-files.yml b/eng/common/templates/job/generate-graph-files.yml new file mode 100644 index 0000000000..e54ce956f9 --- /dev/null +++ b/eng/common/templates/job/generate-graph-files.yml @@ -0,0 +1,48 @@ +parameters: + # Optional: dependencies of the job + dependsOn: '' + + # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool + pool: {} + + # Optional: Include toolset dependencies in the generated graph files + includeToolset: false + +jobs: +- job: Generate_Graph_Files + + dependsOn: ${{ parameters.dependsOn }} + + displayName: Generate Graph Files + + pool: ${{ parameters.pool }} + + variables: + # Publish-Build-Assets provides: MaestroAccessToken, BotAccount-dotnet-maestro-bot-PAT + # DotNet-AllOrgs-Darc-Pats provides: dn-bot-devdiv-dnceng-rw-code-pat + - group: Publish-Build-Assets + - group: DotNet-AllOrgs-Darc-Pats + - name: _GraphArguments + value: -gitHubPat $(BotAccount-dotnet-maestro-bot-PAT) + -azdoPat $(dn-bot-devdiv-dnceng-rw-code-pat) + -barToken $(MaestroAccessToken) + -outputFolder '$(Build.StagingDirectory)/GraphFiles/' + - ${{ if ne(parameters.includeToolset, 'false') }}: + - name: _GraphArguments + value: ${{ variables._GraphArguments }} -includeToolset + + steps: + - task: PowerShell@2 + displayName: Generate Graph Files + inputs: + filePath: eng\common\generate-graph-files.ps1 + arguments: $(_GraphArguments) + continueOnError: true + - task: PublishBuildArtifacts@1 + displayName: Publish Graph to Artifacts + inputs: + PathtoPublish: '$(Build.StagingDirectory)/GraphFiles' + PublishLocation: Container + ArtifactName: GraphFiles + continueOnError: true + condition: always() diff --git a/eng/common/templates/job/job.yml b/eng/common/templates/job/job.yml new file mode 100644 index 0000000000..74dd81fdc0 --- /dev/null +++ b/eng/common/templates/job/job.yml @@ -0,0 +1,197 @@ +parameters: +# Job schema parameters - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job + cancelTimeoutInMinutes: '' + + condition: '' + + continueOnError: false + + container: '' + + dependsOn: '' + + displayName: '' + + steps: [] + + pool: '' + + strategy: '' + + timeoutInMinutes: '' + + variables: [] + + workspace: '' + +# Job base template specific parameters + # Optional: Enable installing Microbuild plugin + # if 'true', these "variables" must be specified in the variables object or as part of the queue matrix + # _TeamName - the name of your team + # _SignType - 'test' or 'real' + enableMicrobuild: false + + # Optional: Include PublishBuildArtifacts task + enablePublishBuildArtifacts: false + + # Optional: Enable publishing to the build asset registry + enablePublishBuildAssets: false + + # Optional: Include PublishTestResults task + enablePublishTestResults: false + + # Optional: enable sending telemetry + enableTelemetry: false + + # Optional: define the helix repo for telemeetry (example: 'dotnet/arcade') + helixRepo: '' + + # Required: name of the job + name: '' + + # Optional: should run as a public build even in the internal project + # if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects. + runAsPublic: false + +# Internal resources (telemetry, microbuild) can only be accessed from non-public projects, +# and some (Microbuild) should only be applied to non-PR cases for internal builds. + +jobs: +- job: ${{ parameters.name }} + + ${{ if ne(parameters.cancelTimeoutInMinutes, '') }}: + cancelTimeoutInMinutes: ${{ parameters.cancelTimeoutInMinutes }} + + ${{ if ne(parameters.condition, '') }}: + condition: ${{ parameters.condition }} + + ${{ if ne(parameters.container, '') }}: + container: ${{ parameters.container }} + + ${{ if ne(parameters.continueOnError, '') }}: + continueOnError: ${{ parameters.continueOnError }} + + ${{ if ne(parameters.dependsOn, '') }}: + dependsOn: ${{ parameters.dependsOn }} + + ${{ if ne(parameters.displayName, '') }}: + displayName: ${{ parameters.displayName }} + + ${{ if ne(parameters.pool, '') }}: + pool: ${{ parameters.pool }} + + ${{ if ne(parameters.strategy, '') }}: + strategy: ${{ parameters.strategy }} + + ${{ if ne(parameters.timeoutInMinutes, '') }}: + timeoutInMinutes: ${{ parameters.timeoutInMinutes }} + + variables: + - ${{ each variable in parameters.variables }}: + # handle name-value variable syntax + # example: + # - name: [key] + # value: [value] + - ${{ if ne(variable.name, '') }}: + - name: ${{ variable.name }} + value: ${{ variable.value }} + + # handle variable groups + - ${{ if ne(variable.group, '') }}: + - group: ${{ variable.group }} + + # handle key-value variable syntax. + # example: + # - [key]: [value] + - ${{ if and(eq(variable.name, ''), eq(variable.group, '')) }}: + - ${{ each pair in variable }}: + - name: ${{ pair.key }} + value: ${{ pair.value }} + + # DotNet-HelixApi-Access provides 'HelixApiAccessToken' for internal builds + - ${{ if and(eq(parameters.enableTelemetry, 'true'), eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - group: DotNet-HelixApi-Access + + ${{ if ne(parameters.workspace, '') }}: + workspace: ${{ parameters.workspace }} + + steps: + - ${{ if eq(parameters.enableTelemetry, 'true') }}: + # Telemetry tasks are built from https://github.com/dotnet/arcade-extensions + - task: sendStartTelemetry@0 + displayName: 'Send Helix Start Telemetry' + inputs: + helixRepo: ${{ parameters.helixRepo }} + buildConfig: $(_BuildConfig) + runAsPublic: ${{ parameters.runAsPublic }} + continueOnError: ${{ parameters.continueOnError }} + condition: always() + + - ${{ if eq(parameters.enableMicrobuild, 'true') }}: + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: MicroBuildSigningPlugin@2 + displayName: Install MicroBuild plugin + inputs: + signType: $(_SignType) + zipSources: false + feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json + env: + TeamName: $(_TeamName) + continueOnError: ${{ parameters.continueOnError }} + condition: and(succeeded(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT')) + + - ${{ each step in parameters.steps }}: + - ${{ step }} + + - ${{ if eq(parameters.enableMicrobuild, 'true') }}: + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: MicroBuildCleanup@1 + displayName: Execute Microbuild cleanup tasks + condition: and(always(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT')) + continueOnError: ${{ parameters.continueOnError }} + env: + TeamName: $(_TeamName) + + - ${{ if eq(parameters.enableTelemetry, 'true') }}: + # Telemetry tasks are built from https://github.com/dotnet/arcade-extensions + - task: sendEndTelemetry@0 + displayName: 'Send Helix End Telemetry' + continueOnError: ${{ parameters.continueOnError }} + condition: always() + + - ${{ if eq(parameters.enablePublishBuildArtifacts, 'true') }}: + - task: PublishBuildArtifacts@1 + displayName: Publish Logs + inputs: + PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)' + PublishLocation: Container + ArtifactName: $(Agent.Os)_$(Agent.JobName) + continueOnError: true + condition: always() + + - ${{ if eq(parameters.enablePublishTestResults, 'true') }}: + - task: PublishTestResults@2 + displayName: Publish Test Results + inputs: + testResultsFormat: 'xUnit' + testResultsFiles: '*.xml' + searchFolder: '$(Build.SourcesDirectory)/artifacts/TestResults/$(_BuildConfig)' + continueOnError: true + condition: always() + + - ${{ if and(eq(parameters.enablePublishBuildAssets, true), ne(variables['_PublishUsingPipelines'], 'true'), eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: CopyFiles@2 + displayName: Gather Asset Manifests + inputs: + SourceFolder: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)/AssetManifest' + TargetFolder: '$(Build.StagingDirectory)/AssetManifests' + continueOnError: ${{ parameters.continueOnError }} + condition: and(succeeded(), eq(variables['_DotNetPublishToBlobFeed'], 'true')) + - task: PublishBuildArtifacts@1 + displayName: Push Asset Manifests + inputs: + PathtoPublish: '$(Build.StagingDirectory)/AssetManifests' + PublishLocation: Container + ArtifactName: AssetManifests + continueOnError: ${{ parameters.continueOnError }} + condition: and(succeeded(), eq(variables['_DotNetPublishToBlobFeed'], 'true')) diff --git a/eng/common/templates/job/publish-build-assets.yml b/eng/common/templates/job/publish-build-assets.yml new file mode 100644 index 0000000000..620bd3c62e --- /dev/null +++ b/eng/common/templates/job/publish-build-assets.yml @@ -0,0 +1,70 @@ +parameters: + configuration: 'Debug' + + # Optional: condition for the job to run + condition: '' + + # Optional: 'true' if future jobs should run even if this job fails + continueOnError: false + + # Optional: dependencies of the job + dependsOn: '' + + # Optional: Include PublishBuildArtifacts task + enablePublishBuildArtifacts: false + + # Optional: A defined YAML pool - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#pool + pool: {} + + # Optional: should run as a public build even in the internal project + # if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects. + runAsPublic: false + + # Optional: whether the build's artifacts will be published using release pipelines or direct feed publishing + publishUsingPipelines: false + +jobs: +- job: Asset_Registry_Publish + + dependsOn: ${{ parameters.dependsOn }} + + displayName: Publish to Build Asset Registry + + pool: ${{ parameters.pool }} + + variables: + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - name: _BuildConfig + value: ${{ parameters.configuration }} + - group: Publish-Build-Assets + + steps: + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: DownloadBuildArtifacts@0 + displayName: Download artifact + inputs: + artifactName: AssetManifests + downloadPath: '$(Build.StagingDirectory)/Download' + condition: ${{ parameters.condition }} + continueOnError: ${{ parameters.continueOnError }} + - task: PowerShell@2 + displayName: Publish Build Assets + inputs: + filePath: eng\common\sdk-task.ps1 + arguments: -task PublishBuildAssets -restore -msbuildEngine dotnet + /p:ManifestsPath='$(Build.StagingDirectory)/Download/AssetManifests' + /p:BuildAssetRegistryToken=$(MaestroAccessToken) + /p:MaestroApiEndpoint=https://maestro-prod.westus2.cloudapp.azure.com + /p:PublishUsingPipelines=${{ parameters.publishUsingPipelines }} + /p:Configuration=$(_BuildConfig) + condition: ${{ parameters.condition }} + continueOnError: ${{ parameters.continueOnError }} + - ${{ if eq(parameters.enablePublishBuildArtifacts, 'true') }}: + - task: PublishBuildArtifacts@1 + displayName: Publish Logs to VSTS + inputs: + PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)' + PublishLocation: Container + ArtifactName: $(Agent.Os)_PublishBuildAssets + continueOnError: true + condition: always() diff --git a/eng/common/templates/jobs/jobs.yml b/eng/common/templates/jobs/jobs.yml new file mode 100644 index 0000000000..6a2f98c036 --- /dev/null +++ b/eng/common/templates/jobs/jobs.yml @@ -0,0 +1,90 @@ +parameters: + # Optional: 'true' if failures in job.yml job should not fail the job + continueOnError: false + + # Optional: Enable installing Microbuild plugin + # if 'true', these "variables" must be specified in the variables object or as part of the queue matrix + # _TeamName - the name of your team + # _SignType - 'test' or 'real' + enableMicrobuild: false + + # Optional: Include PublishBuildArtifacts task + enablePublishBuildArtifacts: false + + # Optional: Enable publishing to the build asset registry + enablePublishBuildAssets: false + + # Optional: Enable publishing using release pipelines + enablePublishUsingPipelines: false + + graphFileGeneration: + # Optional: Enable generating the graph files at the end of the build + enabled: false + # Optional: Include toolset dependencies in the generated graph files + includeToolset: false + + # Optional: Include PublishTestResults task + enablePublishTestResults: false + + # Optional: enable sending telemetry + # if enabled then the 'helixRepo' parameter should also be specified + enableTelemetry: false + + # Required: A collection of jobs to run - https://docs.microsoft.com/en-us/azure/devops/pipelines/yaml-schema?view=vsts&tabs=schema#job + jobs: [] + + # Optional: define the helix repo for telemetry (example: 'dotnet/arcade') + helixRepo: '' + + # Optional: Override automatically derived dependsOn value for "publish build assets" job + publishBuildAssetsDependsOn: '' + + # Optional: should run as a public build even in the internal project + # if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects. + runAsPublic: false + +# Internal resources (telemetry, microbuild) can only be accessed from non-public projects, +# and some (Microbuild) should only be applied to non-PR cases for internal builds. + +jobs: +- ${{ each job in parameters.jobs }}: + - template: ../job/job.yml + parameters: + # pass along parameters + ${{ each parameter in parameters }}: + ${{ if ne(parameter.key, 'jobs') }}: + ${{ parameter.key }}: ${{ parameter.value }} + + # pass along job properties + ${{ each property in job }}: + ${{ if ne(property.key, 'job') }}: + ${{ property.key }}: ${{ property.value }} + + name: ${{ job.job }} + +- ${{ if and(eq(parameters.enablePublishBuildAssets, true), eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - template: ../job/publish-build-assets.yml + parameters: + continueOnError: ${{ parameters.continueOnError }} + dependsOn: + - ${{ if ne(parameters.publishBuildAssetsDependsOn, '') }}: + - ${{ each job in parameters.publishBuildAssetsDependsOn }}: + - ${{ job.job }} + - ${{ if eq(parameters.publishBuildAssetsDependsOn, '') }}: + - ${{ each job in parameters.jobs }}: + - ${{ job.job }} + pool: + vmImage: vs2017-win2016 + runAsPublic: ${{ parameters.runAsPublic }} + publishUsingPipelines: ${{ parameters.enablePublishUsingPipelines }} + enablePublishBuildArtifacts: ${{ parameters.enablePublishBuildArtifacts }} + +- ${{ if and(eq(parameters.graphFileGeneration.enabled, true), eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - template: ../job/generate-graph-files.yml + parameters: + continueOnError: ${{ parameters.continueOnError }} + includeToolset: ${{ parameters.graphFileGeneration.includeToolset }} + dependsOn: + - Asset_Registry_Publish + pool: + vmImage: vs2017-win2016 diff --git a/eng/common/templates/phases/base.yml b/eng/common/templates/phases/base.yml new file mode 100644 index 0000000000..0123cf43b1 --- /dev/null +++ b/eng/common/templates/phases/base.yml @@ -0,0 +1,130 @@ +parameters: + # Optional: Clean sources before building + clean: true + + # Optional: Git fetch depth + fetchDepth: '' + + # Optional: name of the phase (not specifying phase name may cause name collisions) + name: '' + # Optional: display name of the phase + displayName: '' + + # Optional: condition for the job to run + condition: '' + + # Optional: dependencies of the phase + dependsOn: '' + + # Required: A defined YAML queue + queue: {} + + # Required: build steps + steps: [] + + # Optional: variables + variables: {} + + # Optional: should run as a public build even in the internal project + # if 'true', the build won't run any of the internal only steps, even if it is running in non-public projects. + runAsPublic: false + + ## Telemetry variables + + # Optional: enable sending telemetry + # if 'true', these "variables" must be specified in the variables object or as part of the queue matrix + # _HelixBuildConfig - differentiate between Debug, Release, other + # _HelixSource - Example: build/product + # _HelixType - Example: official/dotnet/arcade/$(Build.SourceBranch) + enableTelemetry: false + + # Optional: Enable installing Microbuild plugin + # if 'true', these "variables" must be specified in the variables object or as part of the queue matrix + # _TeamName - the name of your team + # _SignType - 'test' or 'real' + enableMicrobuild: false + +# Internal resources (telemetry, microbuild) can only be accessed from non-public projects, +# and some (Microbuild) should only be applied to non-PR cases for internal builds. + +phases: +- phase: ${{ parameters.name }} + + ${{ if ne(parameters.displayName, '') }}: + displayName: ${{ parameters.displayName }} + + ${{ if ne(parameters.condition, '') }}: + condition: ${{ parameters.condition }} + + ${{ if ne(parameters.dependsOn, '') }}: + dependsOn: ${{ parameters.dependsOn }} + + queue: ${{ parameters.queue }} + + ${{ if ne(parameters.variables, '') }}: + variables: + ${{ insert }}: ${{ parameters.variables }} + + steps: + - checkout: self + clean: ${{ parameters.clean }} + ${{ if ne(parameters.fetchDepth, '') }}: + fetchDepth: ${{ parameters.fetchDepth }} + + - ${{ if eq(parameters.enableTelemetry, 'true') }}: + - template: /eng/common/templates/steps/telemetry-start.yml + parameters: + buildConfig: $(_HelixBuildConfig) + helixSource: $(_HelixSource) + helixType: $(_HelixType) + runAsPublic: ${{ parameters.runAsPublic }} + + - ${{ if eq(parameters.enableMicrobuild, 'true') }}: + # Internal only resource, and Microbuild signing shouldn't be applied to PRs. + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: MicroBuildSigningPlugin@2 + displayName: Install MicroBuild plugin + inputs: + signType: $(_SignType) + zipSources: false + feedSource: https://dnceng.pkgs.visualstudio.com/_packaging/MicroBuildToolset/nuget/v3/index.json + + env: + TeamName: $(_TeamName) + continueOnError: false + condition: and(succeeded(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT')) + + # Run provided build steps + - ${{ parameters.steps }} + + - ${{ if eq(parameters.enableMicrobuild, 'true') }}: + # Internal only resources + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: MicroBuildCleanup@1 + displayName: Execute Microbuild cleanup tasks + condition: and(always(), in(variables['_SignType'], 'real', 'test'), eq(variables['Agent.Os'], 'Windows_NT')) + env: + TeamName: $(_TeamName) + + - ${{ if eq(parameters.enableTelemetry, 'true') }}: + - template: /eng/common/templates/steps/telemetry-end.yml + parameters: + helixSource: $(_HelixSource) + helixType: $(_HelixType) + + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: CopyFiles@2 + displayName: Gather Asset Manifests + inputs: + SourceFolder: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)/AssetManifest' + TargetFolder: '$(Build.StagingDirectory)/AssetManifests' + continueOnError: false + condition: and(succeeded(), eq(variables['_DotNetPublishToBlobFeed'], 'true')) + - task: PublishBuildArtifacts@1 + displayName: Push Asset Manifests + inputs: + PathtoPublish: '$(Build.StagingDirectory)/AssetManifests' + PublishLocation: Container + ArtifactName: AssetManifests + continueOnError: false + condition: and(succeeded(), eq(variables['_DotNetPublishToBlobFeed'], 'true')) diff --git a/eng/common/templates/phases/publish-build-assets.yml b/eng/common/templates/phases/publish-build-assets.yml new file mode 100644 index 0000000000..211967deba --- /dev/null +++ b/eng/common/templates/phases/publish-build-assets.yml @@ -0,0 +1,49 @@ +parameters: + dependsOn: '' + queue: {} + configuration: 'Debug' + condition: succeeded() + continueOnError: false + runAsPublic: false +phases: + - phase: Asset_Registry_Publish + displayName: Publish to Build Asset Registry + dependsOn: ${{ parameters.dependsOn }} + queue: ${{ parameters.queue }} + variables: + _BuildConfig: ${{ parameters.configuration }} + steps: + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: DownloadBuildArtifacts@0 + displayName: Download artifact + inputs: + artifactName: AssetManifests + downloadPath: '$(Build.StagingDirectory)/Download' + condition: ${{ parameters.condition }} + continueOnError: ${{ parameters.continueOnError }} + - task: AzureKeyVault@1 + inputs: + azureSubscription: 'DotNet-Engineering-Services_KeyVault' + KeyVaultName: EngKeyVault + SecretsFilter: 'MaestroAccessToken' + condition: ${{ parameters.condition }} + continueOnError: ${{ parameters.continueOnError }} + - task: PowerShell@2 + displayName: Publish Build Assets + inputs: + filePath: eng\common\sdk-task.ps1 + arguments: -task PublishBuildAssets -restore -msbuildEngine dotnet + /p:ManifestsPath='$(Build.StagingDirectory)/Download/AssetManifests' + /p:BuildAssetRegistryToken=$(MaestroAccessToken) + /p:MaestroApiEndpoint=https://maestro-prod.westus2.cloudapp.azure.com + /p:Configuration=$(_BuildConfig) + condition: ${{ parameters.condition }} + continueOnError: ${{ parameters.continueOnError }} + - task: PublishBuildArtifacts@1 + displayName: Publish Logs to VSTS + inputs: + PathtoPublish: '$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)' + PublishLocation: Container + ArtifactName: $(Agent.Os)_Asset_Registry_Publish + continueOnError: true + condition: always() diff --git a/eng/common/templates/steps/build-reason.yml b/eng/common/templates/steps/build-reason.yml new file mode 100644 index 0000000000..eba58109b5 --- /dev/null +++ b/eng/common/templates/steps/build-reason.yml @@ -0,0 +1,12 @@ +# build-reason.yml +# Description: runs steps if build.reason condition is valid. conditions is a string of valid build reasons +# to include steps (',' separated). +parameters: + conditions: '' + steps: [] + +steps: + - ${{ if and( not(startsWith(parameters.conditions, 'not')), contains(parameters.conditions, variables['build.reason'])) }}: + - ${{ parameters.steps }} + - ${{ if and( startsWith(parameters.conditions, 'not'), not(contains(parameters.conditions, variables['build.reason']))) }}: + - ${{ parameters.steps }} diff --git a/eng/common/templates/steps/helix-publish.yml b/eng/common/templates/steps/helix-publish.yml new file mode 100644 index 0000000000..470ab65da0 --- /dev/null +++ b/eng/common/templates/steps/helix-publish.yml @@ -0,0 +1,51 @@ +parameters: + HelixSource: 'pr/dotnet-github-anon-kaonashi-bot' + HelixType: ̓'tests/default' + HelixBuild: $(Build.BuildNumber) + HelixTargetQueues: '' + HelixAccessToken: '' + HelixPreCommands: '' + HelixPostCommands: '' + WorkItemDirectory: '' + WorkItemCommand: '' + CorrelationPayloadDirectory: '' + XUnitProjects: '' + XUnitTargetFramework: '' + XUnitRunnerVersion: '' + IncludeDotNetCli: false + DotNetCliPackageType: '' + DotNetCliVersion: '' + EnableXUnitReporter: false + WaitForWorkItemCompletion: true + condition: succeeded() + continueOnError: false + +steps: + - task: DotNetCoreCLI@2 + inputs: + command: custom + projects: eng/common/helixpublish.proj + custom: msbuild + arguments: '/bl:$(Build.SourcesDirectory)/artifacts/log/$(_BuildConfig)/SendToHelix.binlog' + displayName: Send job to Helix + env: + HelixSource: ${{ parameters.HelixSource }} + HelixType: ${{ parameters.HelixType }} + HelixBuild: ${{ parameters.HelixBuild }} + HelixTargetQueues: ${{ parameters.HelixTargetQueues }} + HelixAccessToken: ${{ parameters.HelixAccessToken }} + HelixPreCommands: ${{ parameters.HelixPreCommands }} + HelixPostCommands: ${{ parameters.HelixPostCommands }} + WorkItemDirectory: ${{ parameters.WorkItemDirectory }} + WorkItemCommand: ${{ parameters.WorkItemCommand }} + CorrelationPayloadDirectory: ${{ parameters.CorrelationPayloadDirectory }} + XUnitProjects: ${{ parameters.XUnitProjects }} + XUnitRuntimeTargetFramework: ${{ parameters.XUnitTargetFramework }} + XUnitRunnerVersion: ${{ parameters.XUnitRunnerVersion }} + IncludeDotNetCli: ${{ parameters.IncludeDotNetCli }} + DotNetCliPackageType: ${{ parameters.DotNetCliPackageType }} + DotNetCliVersion: ${{ parameters.DotNetCliVersion }} + EnableXUnitReporter: ${{ parameters.EnableXUnitReporter }} + WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }} + condition: ${{ parameters.condition }} + continueOnError: ${{ parameters.continueOnError }} diff --git a/eng/common/templates/steps/run-on-unix.yml b/eng/common/templates/steps/run-on-unix.yml new file mode 100644 index 0000000000..e1733814f6 --- /dev/null +++ b/eng/common/templates/steps/run-on-unix.yml @@ -0,0 +1,7 @@ +parameters: + agentOs: '' + steps: [] + +steps: +- ${{ if ne(parameters.agentOs, 'Windows_NT') }}: + - ${{ parameters.steps }} diff --git a/eng/common/templates/steps/run-on-windows.yml b/eng/common/templates/steps/run-on-windows.yml new file mode 100644 index 0000000000..73e7e9c275 --- /dev/null +++ b/eng/common/templates/steps/run-on-windows.yml @@ -0,0 +1,7 @@ +parameters: + agentOs: '' + steps: [] + +steps: +- ${{ if eq(parameters.agentOs, 'Windows_NT') }}: + - ${{ parameters.steps }} diff --git a/eng/common/templates/steps/run-script-ifequalelse.yml b/eng/common/templates/steps/run-script-ifequalelse.yml new file mode 100644 index 0000000000..3d1242f558 --- /dev/null +++ b/eng/common/templates/steps/run-script-ifequalelse.yml @@ -0,0 +1,33 @@ +parameters: + # if parameter1 equals parameter 2, run 'ifScript' command, else run 'elsescript' command + parameter1: '' + parameter2: '' + ifScript: '' + elseScript: '' + + # name of script step + name: Script + + # display name of script step + displayName: If-Equal-Else Script + + # environment + env: {} + + # conditional expression for step execution + condition: '' + +steps: +- ${{ if and(ne(parameters.ifScript, ''), eq(parameters.parameter1, parameters.parameter2)) }}: + - script: ${{ parameters.ifScript }} + name: ${{ parameters.name }} + displayName: ${{ parameters.displayName }} + env: ${{ parameters.env }} + condition: ${{ parameters.condition }} + +- ${{ if and(ne(parameters.elseScript, ''), ne(parameters.parameter1, parameters.parameter2)) }}: + - script: ${{ parameters.elseScript }} + name: ${{ parameters.name }} + displayName: ${{ parameters.displayName }} + env: ${{ parameters.env }} + condition: ${{ parameters.condition }} \ No newline at end of file diff --git a/eng/common/templates/steps/send-to-helix.yml b/eng/common/templates/steps/send-to-helix.yml new file mode 100644 index 0000000000..0187597681 --- /dev/null +++ b/eng/common/templates/steps/send-to-helix.yml @@ -0,0 +1,87 @@ +parameters: + HelixSource: 'pr/default' # required -- sources must start with pr/, official/, prodcon/, or agent/ + HelixType: 'tests/default/' # required -- Helix telemetry which identifies what type of data this is; should include "test" for clarity and must end in '/' + HelixBuild: $(Build.BuildNumber) # required -- the build number Helix will use to identify this -- automatically set to the AzDO build number + HelixTargetQueues: '' # required -- semicolon delimited list of Helix queues to test on; see https://helix.dot.net/ for a list of queues + HelixAccessToken: '' # required -- access token to make Helix API requests; should be provided by the appropriate variable group + HelixPreCommands: '' # optional -- commands to run before Helix work item execution + HelixPostCommands: '' # optional -- commands to run after Helix work item execution + WorkItemDirectory: '' # optional -- a payload directory to zip up and send to Helix; requires WorkItemCommand; incompatible with XUnitProjects + WorkItemCommand: '' # optional -- a command to execute on the payload; requires WorkItemDirectory; incompatible with XUnitProjects + WorkItemTimeout: '' # optional -- a timeout in seconds for the work item command; requires WorkItemDirectory; incompatible with XUnitProjects + CorrelationPayloadDirectory: '' # optional -- a directory to zip up and send to Helix as a correlation payload + XUnitProjects: '' # optional -- semicolon delimited list of XUnitProjects to parse and send to Helix; requires XUnitRuntimeTargetFramework, XUnitPublishTargetFramework, XUnitRunnerVersion, and IncludeDotNetCli=true + XUnitWorkItemTimeout: '' # optional -- the workitem timeout in seconds for all workitems created from the xUnit projects specified by XUnitProjects + XUnitPublishTargetFramework: '' # optional -- framework to use to publish your xUnit projects + XUnitRuntimeTargetFramework: '' # optional -- framework to use for the xUnit console runner + XUnitRunnerVersion: '' # optional -- version of the xUnit nuget package you wish to use on Helix; required for XUnitProjects + IncludeDotNetCli: false # optional -- true will download a version of the .NET CLI onto the Helix machine as a correlation payload; requires DotNetCliPackageType and DotNetCliVersion + DotNetCliPackageType: '' # optional -- either 'sdk' or 'runtime'; determines whether the sdk or runtime will be sent to Helix; see https://raw.githubusercontent.com/dotnet/core/master/release-notes/releases.json + DotNetCliVersion: '' # optional -- version of the CLI to send to Helix; based on this: https://raw.githubusercontent.com/dotnet/core/master/release-notes/releases.json + EnableXUnitReporter: false # optional -- true enables XUnit result reporting to Mission Control + WaitForWorkItemCompletion: true # optional -- true will make the task wait until work items have been completed and fail the build if work items fail. False is "fire and forget." + IsExternal: false # [DEPRECATED] -- doesn't do anything, jobs are external if HelixAccessToken is empty and Creator is set + Creator: '' # optional -- if the build is external, use this to specify who is sending the job + DisplayNamePrefix: 'Send job to Helix' # optional -- rename the beginning of the displayName of the steps in AzDO + condition: succeeded() # optional -- condition for step to execute; defaults to succeeded() + continueOnError: false # optional -- determines whether to continue the build if the step errors; defaults to false + +steps: + - powershell: 'powershell "$env:BUILD_SOURCESDIRECTORY\eng\common\msbuild.ps1 $env:BUILD_SOURCESDIRECTORY\eng\common\helixpublish.proj /restore /t:Test /bl:$env:BUILD_SOURCESDIRECTORY\artifacts\log\$env:BuildConfig\SendToHelix.binlog"' + displayName: ${{ parameters.DisplayNamePrefix }} (Windows) + env: + BuildConfig: $(_BuildConfig) + HelixSource: ${{ parameters.HelixSource }} + HelixType: ${{ parameters.HelixType }} + HelixBuild: ${{ parameters.HelixBuild }} + HelixTargetQueues: ${{ parameters.HelixTargetQueues }} + HelixAccessToken: ${{ parameters.HelixAccessToken }} + HelixPreCommands: ${{ parameters.HelixPreCommands }} + HelixPostCommands: ${{ parameters.HelixPostCommands }} + WorkItemDirectory: ${{ parameters.WorkItemDirectory }} + WorkItemCommand: ${{ parameters.WorkItemCommand }} + WorkItemTimeout: ${{ parameters.WorkItemTimeout }} + CorrelationPayloadDirectory: ${{ parameters.CorrelationPayloadDirectory }} + XUnitProjects: ${{ parameters.XUnitProjects }} + XUnitWorkItemTimeout: ${{ parameters.XUnitWorkItemTimeout }} + XUnitPublishTargetFramework: ${{ parameters.XUnitPublishTargetFramework }} + XUnitRuntimeTargetFramework: ${{ parameters.XUnitRuntimeTargetFramework }} + XUnitRunnerVersion: ${{ parameters.XUnitRunnerVersion }} + IncludeDotNetCli: ${{ parameters.IncludeDotNetCli }} + DotNetCliPackageType: ${{ parameters.DotNetCliPackageType }} + DotNetCliVersion: ${{ parameters.DotNetCliVersion }} + EnableXUnitReporter: ${{ parameters.EnableXUnitReporter }} + WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }} + Creator: ${{ parameters.Creator }} + SYSTEM_ACCESSTOKEN: $(System.AccessToken) + condition: and(${{ parameters.condition }}, eq(variables['Agent.Os'], 'Windows_NT')) + continueOnError: ${{ parameters.continueOnError }} + - script: $BUILD_SOURCESDIRECTORY/eng/common/msbuild.sh $BUILD_SOURCESDIRECTORY/eng/common/helixpublish.proj /restore /t:Test /bl:$BUILD_SOURCESDIRECTORY/artifacts/log/$BuildConfig/SendToHelix.binlog + displayName: ${{ parameters.DisplayNamePrefix }} (Unix) + env: + BuildConfig: $(_BuildConfig) + HelixSource: ${{ parameters.HelixSource }} + HelixType: ${{ parameters.HelixType }} + HelixBuild: ${{ parameters.HelixBuild }} + HelixTargetQueues: ${{ parameters.HelixTargetQueues }} + HelixAccessToken: ${{ parameters.HelixAccessToken }} + HelixPreCommands: ${{ parameters.HelixPreCommands }} + HelixPostCommands: ${{ parameters.HelixPostCommands }} + WorkItemDirectory: ${{ parameters.WorkItemDirectory }} + WorkItemCommand: ${{ parameters.WorkItemCommand }} + WorkItemTimeout: ${{ parameters.WorkItemTimeout }} + CorrelationPayloadDirectory: ${{ parameters.CorrelationPayloadDirectory }} + XUnitProjects: ${{ parameters.XUnitProjects }} + XUnitWorkItemTimeout: ${{ parameters.XUnitWorkItemTimeout }} + XUnitPublishTargetFramework: ${{ parameters.XUnitPublishTargetFramework }} + XUnitRuntimeTargetFramework: ${{ parameters.XUnitRuntimeTargetFramework }} + XUnitRunnerVersion: ${{ parameters.XUnitRunnerVersion }} + IncludeDotNetCli: ${{ parameters.IncludeDotNetCli }} + DotNetCliPackageType: ${{ parameters.DotNetCliPackageType }} + DotNetCliVersion: ${{ parameters.DotNetCliVersion }} + EnableXUnitReporter: ${{ parameters.EnableXUnitReporter }} + WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }} + Creator: ${{ parameters.Creator }} + SYSTEM_ACCESSTOKEN: $(System.AccessToken) + condition: and(${{ parameters.condition }}, ne(variables['Agent.Os'], 'Windows_NT')) + continueOnError: ${{ parameters.continueOnError }} \ No newline at end of file diff --git a/eng/common/templates/steps/telemetry-end.yml b/eng/common/templates/steps/telemetry-end.yml new file mode 100644 index 0000000000..fadc04ca1b --- /dev/null +++ b/eng/common/templates/steps/telemetry-end.yml @@ -0,0 +1,102 @@ +parameters: + maxRetries: 5 + retryDelay: 10 # in seconds + +steps: +- bash: | + if [ "$AGENT_JOBSTATUS" = "Succeeded" ] || [ "$AGENT_JOBSTATUS" = "PartiallySucceeded" ]; then + errorCount=0 + else + errorCount=1 + fi + warningCount=0 + + curlStatus=1 + retryCount=0 + # retry loop to harden against spotty telemetry connections + # we don't retry successes and 4xx client errors + until [[ $curlStatus -eq 0 || ( $curlStatus -ge 400 && $curlStatus -le 499 ) || $retryCount -ge $MaxRetries ]] + do + if [ $retryCount -gt 0 ]; then + echo "Failed to send telemetry to Helix; waiting $RetryDelay seconds before retrying..." + sleep $RetryDelay + fi + + # create a temporary file for curl output + res=`mktemp` + + curlResult=` + curl --verbose --output $res --write-out "%{http_code}"\ + -H 'Content-Type: application/json' \ + -H "X-Helix-Job-Token: $Helix_JobToken" \ + -H 'Content-Length: 0' \ + -X POST -G "https://helix.dot.net/api/2018-03-14/telemetry/job/build/$Helix_WorkItemId/finish" \ + --data-urlencode "errorCount=$errorCount" \ + --data-urlencode "warningCount=$warningCount"` + curlStatus=$? + + if [ $curlStatus -eq 0 ]; then + if [ $curlResult -gt 299 ] || [ $curlResult -lt 200 ]; then + curlStatus=$curlResult + fi + fi + + let retryCount++ + done + + if [ $curlStatus -ne 0 ]; then + echo "Failed to Send Build Finish information after $retryCount retries" + vstsLogOutput="vso[task.logissue type=error;sourcepath=templates/steps/telemetry-end.yml;code=1;]Failed to Send Build Finish information: $curlStatus" + echo "##$vstsLogOutput" + exit 1 + fi + displayName: Send Unix Build End Telemetry + env: + # defined via VSTS variables in start-job.sh + Helix_JobToken: $(Helix_JobToken) + Helix_WorkItemId: $(Helix_WorkItemId) + MaxRetries: ${{ parameters.maxRetries }} + RetryDelay: ${{ parameters.retryDelay }} + condition: and(always(), ne(variables['Agent.Os'], 'Windows_NT')) +- powershell: | + if (($env:Agent_JobStatus -eq 'Succeeded') -or ($env:Agent_JobStatus -eq 'PartiallySucceeded')) { + $ErrorCount = 0 + } else { + $ErrorCount = 1 + } + $WarningCount = 0 + + # Basic retry loop to harden against server flakiness + $retryCount = 0 + while ($retryCount -lt $env:MaxRetries) { + try { + Invoke-RestMethod -Uri "https://helix.dot.net/api/2018-03-14/telemetry/job/build/$env:Helix_WorkItemId/finish?errorCount=$ErrorCount&warningCount=$WarningCount" -Method Post -ContentType "application/json" -Body "" ` + -Headers @{ 'X-Helix-Job-Token'=$env:Helix_JobToken } + break + } + catch { + $statusCode = $_.Exception.Response.StatusCode.value__ + if ($statusCode -ge 400 -and $statusCode -le 499) { + Write-Host "##vso[task.logissue]error Failed to send telemetry to Helix (status code $statusCode); not retrying (4xx client error)" + Write-Host "##vso[task.logissue]error ", $_.Exception.GetType().FullName, $_.Exception.Message + exit 1 + } + Write-Host "Failed to send telemetry to Helix (status code $statusCode); waiting $env:RetryDelay seconds before retrying..." + $retryCount++ + sleep $env:RetryDelay + continue + } + } + + if ($retryCount -ge $env:MaxRetries) { + Write-Host "##vso[task.logissue]error Failed to send telemetry to Helix after $retryCount retries." + exit 1 + } + displayName: Send Windows Build End Telemetry + env: + # defined via VSTS variables in start-job.ps1 + Helix_JobToken: $(Helix_JobToken) + Helix_WorkItemId: $(Helix_WorkItemId) + MaxRetries: ${{ parameters.maxRetries }} + RetryDelay: ${{ parameters.retryDelay }} + condition: and(always(),eq(variables['Agent.Os'], 'Windows_NT')) diff --git a/eng/common/templates/steps/telemetry-start.yml b/eng/common/templates/steps/telemetry-start.yml new file mode 100644 index 0000000000..32c01ef0b5 --- /dev/null +++ b/eng/common/templates/steps/telemetry-start.yml @@ -0,0 +1,241 @@ +parameters: + helixSource: 'undefined_defaulted_in_telemetry.yml' + helixType: 'undefined_defaulted_in_telemetry.yml' + buildConfig: '' + runAsPublic: false + maxRetries: 5 + retryDelay: 10 # in seconds + +steps: +- ${{ if and(eq(parameters.runAsPublic, 'false'), not(eq(variables['System.TeamProject'], 'public'))) }}: + - task: AzureKeyVault@1 + inputs: + azureSubscription: 'HelixProd_KeyVault' + KeyVaultName: HelixProdKV + SecretsFilter: 'HelixApiAccessToken' + condition: always() +- bash: | + # create a temporary file + jobInfo=`mktemp` + + # write job info content to temporary file + cat > $jobInfo <" } + & $installScript -Version $version -InstallDir $dotnetRoot -Architecture $archArg + if ($lastExitCode -ne 0) { + Write-Host "Failed to install dotnet cli (exit code '$lastExitCode')." -ForegroundColor Red + ExitWithExitCode $lastExitCode + } +} + +# +# Locates Visual Studio MSBuild installation. +# The preference order for MSBuild to use is as follows: +# +# 1. MSBuild from an active VS command prompt +# 2. MSBuild from a compatible VS installation +# 3. MSBuild from the xcopy tool package +# +# Returns full path to msbuild.exe. +# Throws on failure. +# +function InitializeVisualStudioMSBuild([bool]$install, [object]$vsRequirements = $null) { + if (Test-Path variable:global:_MSBuildExe) { + return $global:_MSBuildExe + } + + if (!$vsRequirements) { $vsRequirements = $GlobalJson.tools.vs } + $vsMinVersionStr = if ($vsRequirements.version) { $vsRequirements.version } else { "15.9" } + $vsMinVersion = [Version]::new($vsMinVersionStr) + + # Try msbuild command available in the environment. + if ($env:VSINSTALLDIR -ne $null) { + $msbuildCmd = Get-Command "msbuild.exe" -ErrorAction SilentlyContinue + if ($msbuildCmd -ne $null) { + if ($msbuildCmd.Version -ge $vsMinVersion) { + return $global:_MSBuildExe = $msbuildCmd.Path + } + + # Report error - the developer environment is initialized with incompatible VS version. + throw "Developer Command Prompt for VS $($env:VisualStudioVersion) is not recent enough. Please upgrade to $vsMinVersionStr or build from a plain CMD window" + } + } + + # Locate Visual Studio installation or download x-copy msbuild. + $vsInfo = LocateVisualStudio $vsRequirements + if ($vsInfo -ne $null) { + $vsInstallDir = $vsInfo.installationPath + $vsMajorVersion = $vsInfo.installationVersion.Split('.')[0] + + InitializeVisualStudioEnvironmentVariables $vsInstallDir $vsMajorVersion + } else { + + if (Get-Member -InputObject $GlobalJson.tools -Name "xcopy-msbuild") { + $xcopyMSBuildVersion = $GlobalJson.tools.'xcopy-msbuild' + $vsMajorVersion = $xcopyMSBuildVersion.Split('.')[0] + } else { + $vsMajorVersion = $vsMinVersion.Major + $xcopyMSBuildVersion = "$vsMajorVersion.$($vsMinVersion.Minor).0-alpha" + } + + $vsInstallDir = InitializeXCopyMSBuild $xcopyMSBuildVersion $install + if ($vsInstallDir -eq $null) { + throw "Unable to find Visual Studio that has required version and components installed" + } + } + + $msbuildVersionDir = if ([int]$vsMajorVersion -lt 16) { "$vsMajorVersion.0" } else { "Current" } + return $global:_MSBuildExe = Join-Path $vsInstallDir "MSBuild\$msbuildVersionDir\Bin\msbuild.exe" +} + +function InitializeVisualStudioEnvironmentVariables([string] $vsInstallDir, [string] $vsMajorVersion) { + $env:VSINSTALLDIR = $vsInstallDir + Set-Item "env:VS$($vsMajorVersion)0COMNTOOLS" (Join-Path $vsInstallDir "Common7\Tools\") + + $vsSdkInstallDir = Join-Path $vsInstallDir "VSSDK\" + if (Test-Path $vsSdkInstallDir) { + Set-Item "env:VSSDK$($vsMajorVersion)0Install" $vsSdkInstallDir + $env:VSSDKInstall = $vsSdkInstallDir + } +} + +function InstallXCopyMSBuild([string]$packageVersion) { + return InitializeXCopyMSBuild $packageVersion -install $true +} + +function InitializeXCopyMSBuild([string]$packageVersion, [bool]$install) { + $packageName = "RoslynTools.MSBuild" + $packageDir = Join-Path $ToolsDir "msbuild\$packageVersion" + $packagePath = Join-Path $packageDir "$packageName.$packageVersion.nupkg" + + if (!(Test-Path $packageDir)) { + if (!$install) { + return $null + } + + Create-Directory $packageDir + Write-Host "Downloading $packageName $packageVersion" + Invoke-WebRequest "https://dotnet.myget.org/F/roslyn-tools/api/v2/package/$packageName/$packageVersion/" -OutFile $packagePath + Unzip $packagePath $packageDir + } + + return Join-Path $packageDir "tools" +} + +# +# Locates Visual Studio instance that meets the minimal requirements specified by tools.vs object in global.json. +# +# The following properties of tools.vs are recognized: +# "version": "{major}.{minor}" +# Two part minimal VS version, e.g. "15.9", "16.0", etc. +# "components": ["componentId1", "componentId2", ...] +# Array of ids of workload components that must be available in the VS instance. +# See e.g. https://docs.microsoft.com/en-us/visualstudio/install/workload-component-id-vs-enterprise?view=vs-2017 +# +# Returns JSON describing the located VS instance (same format as returned by vswhere), +# or $null if no instance meeting the requirements is found on the machine. +# +function LocateVisualStudio([object]$vsRequirements = $null){ + if (Get-Member -InputObject $GlobalJson.tools -Name "vswhere") { + $vswhereVersion = $GlobalJson.tools.vswhere + } else { + $vswhereVersion = "2.5.2" + } + + $vsWhereDir = Join-Path $ToolsDir "vswhere\$vswhereVersion" + $vsWhereExe = Join-Path $vsWhereDir "vswhere.exe" + + if (!(Test-Path $vsWhereExe)) { + Create-Directory $vsWhereDir + Write-Host "Downloading vswhere" + Invoke-WebRequest "https://github.com/Microsoft/vswhere/releases/download/$vswhereVersion/vswhere.exe" -OutFile $vswhereExe + } + + if (!$vsRequirements) { $vsRequirements = $GlobalJson.tools.vs } + $args = @("-latest", "-prerelease", "-format", "json", "-requires", "Microsoft.Component.MSBuild") + + if (Get-Member -InputObject $vsRequirements -Name "version") { + $args += "-version" + $args += $vsRequirements.version + } + + if (Get-Member -InputObject $vsRequirements -Name "components") { + foreach ($component in $vsRequirements.components) { + $args += "-requires" + $args += $component + } + } + + $vsInfo =& $vsWhereExe $args | ConvertFrom-Json + + if ($lastExitCode -ne 0) { + return $null + } + + # use first matching instance + return $vsInfo[0] +} + +function InitializeBuildTool() { + if (Test-Path variable:global:_BuildTool) { + return $global:_BuildTool + } + + if (-not $msbuildEngine) { + $msbuildEngine = GetDefaultMSBuildEngine + } + + # Initialize dotnet cli if listed in 'tools' + $dotnetRoot = $null + if (Get-Member -InputObject $GlobalJson.tools -Name "dotnet") { + $dotnetRoot = InitializeDotNetCli -install:$restore + } + + if ($msbuildEngine -eq "dotnet") { + if (!$dotnetRoot) { + Write-Host "/global.json must specify 'tools.dotnet'." -ForegroundColor Red + ExitWithExitCode 1 + } + + $buildTool = @{ Path = Join-Path $dotnetRoot "dotnet.exe"; Command = "msbuild" } + } elseif ($msbuildEngine -eq "vs") { + try { + $msbuildPath = InitializeVisualStudioMSBuild -install:$restore + } catch { + Write-Host $_ -ForegroundColor Red + ExitWithExitCode 1 + } + + $buildTool = @{ Path = $msbuildPath; Command = "" } + } else { + Write-Host "Unexpected value of -msbuildEngine: '$msbuildEngine'." -ForegroundColor Red + ExitWithExitCode 1 + } + + return $global:_BuildTool = $buildTool +} + +function GetDefaultMSBuildEngine() { + # Presence of tools.vs indicates the repo needs to build using VS msbuild on Windows. + if (Get-Member -InputObject $GlobalJson.tools -Name "vs") { + return "vs" + } + + if (Get-Member -InputObject $GlobalJson.tools -Name "dotnet") { + return "dotnet" + } + + Write-Host "-msbuildEngine must be specified, or /global.json must specify 'tools.dotnet' or 'tools.vs'." -ForegroundColor Red + ExitWithExitCode 1 +} + +function GetNuGetPackageCachePath() { + if ($env:NUGET_PACKAGES -eq $null) { + # Use local cache on CI to ensure deterministic build, + # use global cache in dev builds to avoid cost of downloading packages. + if ($useGlobalNuGetCache) { + $env:NUGET_PACKAGES = Join-Path $env:UserProfile ".nuget\packages" + } else { + $env:NUGET_PACKAGES = Join-Path $RepoRoot ".packages" + } + } + + return $env:NUGET_PACKAGES +} + +# Returns a full path to an Arcade SDK task project file. +function GetSdkTaskProject([string]$taskName) { + return Join-Path (Split-Path (InitializeToolset) -Parent) "SdkTasks\$taskName.proj" +} + +function InitializeToolset() { + if (Test-Path variable:global:_ToolsetBuildProj) { + return $global:_ToolsetBuildProj + } + + $nugetCache = GetNuGetPackageCachePath + + $toolsetVersion = $GlobalJson.'msbuild-sdks'.'Microsoft.DotNet.Arcade.Sdk' + $toolsetLocationFile = Join-Path $ToolsetDir "$toolsetVersion.txt" + + if (Test-Path $toolsetLocationFile) { + $path = Get-Content $toolsetLocationFile -TotalCount 1 + if (Test-Path $path) { + return $global:_ToolsetBuildProj = $path + } + } + + if (-not $restore) { + Write-Host "Toolset version $toolsetVersion has not been restored." -ForegroundColor Red + ExitWithExitCode 1 + } + + $buildTool = InitializeBuildTool + + $proj = Join-Path $ToolsetDir "restore.proj" + $bl = if ($binaryLog) { "/bl:" + (Join-Path $LogDir "ToolsetRestore.binlog") } else { "" } + + '' | Set-Content $proj + MSBuild $proj $bl /t:__WriteToolsetLocation /clp:ErrorsOnly`;NoSummary /p:__ToolsetLocationOutputFile=$toolsetLocationFile + + $path = Get-Content $toolsetLocationFile -TotalCount 1 + if (!(Test-Path $path)) { + throw "Invalid toolset path: $path" + } + + return $global:_ToolsetBuildProj = $path +} + +function ExitWithExitCode([int] $exitCode) { + if ($ci -and $prepareMachine) { + Stop-Processes + } + exit $exitCode +} + +function Stop-Processes() { + Write-Host "Killing running build processes..." + foreach ($processName in $processesToStopOnExit) { + Get-Process -Name $processName -ErrorAction SilentlyContinue | Stop-Process + } +} + +# +# Executes msbuild (or 'dotnet msbuild') with arguments passed to the function. +# The arguments are automatically quoted. +# Terminates the script if the build fails. +# +function MSBuild() { + if ($ci) { + if (!$binaryLog) { + throw "Binary log must be enabled in CI build." + } + + if ($nodeReuse) { + throw "Node reuse must be disabled in CI build." + } + } + + $buildTool = InitializeBuildTool + + $cmdArgs = "$($buildTool.Command) /m /nologo /clp:Summary /v:$verbosity /nr:$nodeReuse /p:ContinuousIntegrationBuild=$ci" + + if ($warnAsError) { + $cmdArgs += " /warnaserror /p:TreatWarningsAsErrors=true" + } + + foreach ($arg in $args) { + if ($arg -ne $null -and $arg.Trim() -ne "") { + $cmdArgs += " `"$arg`"" + } + } + + $exitCode = Exec-Process $buildTool.Path $cmdArgs + + if ($exitCode -ne 0) { + Write-Host "Build failed." -ForegroundColor Red + + $buildLog = GetMSBuildBinaryLogCommandLineArgument $args + if ($buildLog -ne $null) { + Write-Host "See log: $buildLog" -ForegroundColor DarkGray + } + + ExitWithExitCode $exitCode + } +} + +function GetMSBuildBinaryLogCommandLineArgument($arguments) { + foreach ($argument in $arguments) { + if ($argument -ne $null) { + $arg = $argument.Trim() + if ($arg.StartsWith("/bl:", "OrdinalIgnoreCase")) { + return $arg.Substring("/bl:".Length) + } + + if ($arg.StartsWith("/binaryLogger:", "OrdinalIgnoreCase")) { + return $arg.Substring("/binaryLogger:".Length) + } + } + } + + return $null +} + +$RepoRoot = Resolve-Path (Join-Path $PSScriptRoot "..\..") +$EngRoot = Resolve-Path (Join-Path $PSScriptRoot "..") +$ArtifactsDir = Join-Path $RepoRoot "artifacts" +$ToolsetDir = Join-Path $ArtifactsDir "toolset" +$ToolsDir = Join-Path $RepoRoot ".tools" +$LogDir = Join-Path (Join-Path $ArtifactsDir "log") $configuration +$TempDir = Join-Path (Join-Path $ArtifactsDir "tmp") $configuration +$GlobalJson = Get-Content -Raw -Path (Join-Path $RepoRoot "global.json") | ConvertFrom-Json + +Create-Directory $ToolsetDir +Create-Directory $TempDir +Create-Directory $LogDir + +if ($ci) { + $env:TEMP = $TempDir + $env:TMP = $TempDir +} diff --git a/eng/common/tools.sh b/eng/common/tools.sh new file mode 100644 index 0000000000..ecdece1f85 --- /dev/null +++ b/eng/common/tools.sh @@ -0,0 +1,328 @@ +# Initialize variables if they aren't already defined. + +# CI mode - set to true on CI server for PR validation build or official build. +ci=${ci:-false} + +# Build configuration. Common values include 'Debug' and 'Release', but the repository may use other names. +configuration=${configuration:-'Debug'} + +# Set to true to output binary log from msbuild. Note that emitting binary log slows down the build. +# Binary log must be enabled on CI. +binary_log=${binary_log:-$ci} + +# Turns on machine preparation/clean up code that changes the machine state (e.g. kills build processes). +prepare_machine=${prepare_machine:-false} + +# True to restore toolsets and dependencies. +restore=${restore:-true} + +# Adjusts msbuild verbosity level. +verbosity=${verbosity:-'minimal'} + +# Set to true to reuse msbuild nodes. Recommended to not reuse on CI. +if [[ "$ci" == true ]]; then + node_reuse=${node_reuse:-false} +else + node_reuse=${node_reuse:-true} +fi + +# Configures warning treatment in msbuild. +warn_as_error=${warn_as_error:-true} + +# True to attempt using .NET Core already that meets requirements specified in global.json +# installed on the machine instead of downloading one. +use_installed_dotnet_cli=${use_installed_dotnet_cli:-true} + +# True to use global NuGet cache instead of restoring packages to repository-local directory. +if [[ "$ci" == true ]]; then + use_global_nuget_cache=${use_global_nuget_cache:-false} +else + use_global_nuget_cache=${use_global_nuget_cache:-true} +fi + +# Resolve any symlinks in the given path. +function ResolvePath { + local path=$1 + + while [[ -h $path ]]; do + local dir="$( cd -P "$( dirname "$path" )" && pwd )" + path="$(readlink "$path")" + + # if $path was a relative symlink, we need to resolve it relative to the path where the + # symlink file was located + [[ $path != /* ]] && path="$dir/$path" + done + + # return value + _ResolvePath="$path" +} + +# ReadVersionFromJson [json key] +function ReadGlobalVersion { + local key=$1 + + local line=`grep -m 1 "$key" "$global_json_file"` + local pattern="\"$key\" *: *\"(.*)\"" + + if [[ ! $line =~ $pattern ]]; then + echo "Error: Cannot find \"$key\" in $global_json_file" >&2 + ExitWithExitCode 1 + fi + + # return value + _ReadGlobalVersion=${BASH_REMATCH[1]} +} + +function InitializeDotNetCli { + if [[ -n "${_InitializeDotNetCli:-}" ]]; then + return + fi + + local install=$1 + + # Don't resolve runtime, shared framework, or SDK from other locations to ensure build determinism + export DOTNET_MULTILEVEL_LOOKUP=0 + + # Disable first run since we want to control all package sources + export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 + + # Disable telemetry on CI + if [[ $ci == true ]]; then + export DOTNET_CLI_TELEMETRY_OPTOUT=1 + fi + + # LTTNG is the logging infrastructure used by Core CLR. Need this variable set + # so it doesn't output warnings to the console. + export LTTNG_HOME="$HOME" + + # Source Build uses DotNetCoreSdkDir variable + if [[ -n "${DotNetCoreSdkDir:-}" ]]; then + export DOTNET_INSTALL_DIR="$DotNetCoreSdkDir" + fi + + # Find the first path on $PATH that contains the dotnet.exe + if [[ "$use_installed_dotnet_cli" == true && -z "${DOTNET_INSTALL_DIR:-}" ]]; then + local dotnet_path=`command -v dotnet` + if [[ -n "$dotnet_path" ]]; then + ResolvePath "$dotnet_path" + export DOTNET_INSTALL_DIR=`dirname "$_ResolvePath"` + fi + fi + + ReadGlobalVersion "dotnet" + local dotnet_sdk_version=$_ReadGlobalVersion + local dotnet_root="" + + # Use dotnet installation specified in DOTNET_INSTALL_DIR if it contains the required SDK version, + # otherwise install the dotnet CLI and SDK to repo local .dotnet directory to avoid potential permission issues. + if [[ -n "${DOTNET_INSTALL_DIR:-}" && -d "$DOTNET_INSTALL_DIR/sdk/$dotnet_sdk_version" ]]; then + dotnet_root="$DOTNET_INSTALL_DIR" + else + dotnet_root="$repo_root/.dotnet" + export DOTNET_INSTALL_DIR="$dotnet_root" + + if [[ ! -d "$DOTNET_INSTALL_DIR/sdk/$dotnet_sdk_version" ]]; then + if [[ "$install" == true ]]; then + InstallDotNetSdk "$dotnet_root" "$dotnet_sdk_version" + else + echo "Unable to find dotnet with SDK version '$dotnet_sdk_version'" >&2 + ExitWithExitCode 1 + fi + fi + fi + + # Add dotnet to PATH. This prevents any bare invocation of dotnet in custom + # build steps from using anything other than what we've downloaded. + export PATH="$dotnet_root:$PATH" + + if [[ $ci == true ]]; then + # Make Sure that our bootstrapped dotnet cli is avaliable in future steps of the Azure Pipelines build + echo "##vso[task.prependpath]$dotnet_root" + echo "##vso[task.setvariable variable=DOTNET_MULTILEVEL_LOOKUP]0" + echo "##vso[task.setvariable variable=DOTNET_SKIP_FIRST_TIME_EXPERIENCE]1" + fi + + # return value + _InitializeDotNetCli="$dotnet_root" +} + +function InstallDotNetSdk { + local root=$1 + local version=$2 + + GetDotNetInstallScript "$root" + local install_script=$_GetDotNetInstallScript + + local arch_arg="" + if [[ $# == 3 ]]; then + arch_arg="--architecture $3" + fi + + bash "$install_script" --version $version --install-dir "$root" $arch_arg || { + local exit_code=$? + echo "Failed to install dotnet SDK (exit code '$exit_code')." >&2 + ExitWithExitCode $exit_code + } +} + +function GetDotNetInstallScript { + local root=$1 + local install_script="$root/dotnet-install.sh" + local install_script_url="https://dot.net/v1/dotnet-install.sh" + + if [[ ! -a "$install_script" ]]; then + mkdir -p "$root" + + echo "Downloading '$install_script_url'" + + # Use curl if available, otherwise use wget + if command -v curl > /dev/null; then + curl "$install_script_url" -sSL --retry 10 --create-dirs -o "$install_script" + else + wget -q -O "$install_script" "$install_script_url" + fi + fi + + # return value + _GetDotNetInstallScript="$install_script" +} + +function InitializeBuildTool { + if [[ -n "${_InitializeBuildTool:-}" ]]; then + return + fi + + InitializeDotNetCli $restore + + # return values + _InitializeBuildTool="$_InitializeDotNetCli/dotnet" + _InitializeBuildToolCommand="msbuild" +} + +function GetNuGetPackageCachePath { + if [[ -z ${NUGET_PACKAGES:-} ]]; then + if [[ "$use_global_nuget_cache" == true ]]; then + export NUGET_PACKAGES="$HOME/.nuget/packages" + else + export NUGET_PACKAGES="$repo_root/.packages" + fi + fi + + # return value + _GetNuGetPackageCachePath=$NUGET_PACKAGES +} + +function InitializeToolset { + if [[ -n "${_InitializeToolset:-}" ]]; then + return + fi + + GetNuGetPackageCachePath + + ReadGlobalVersion "Microsoft.DotNet.Arcade.Sdk" + + local toolset_version=$_ReadGlobalVersion + local toolset_location_file="$toolset_dir/$toolset_version.txt" + + if [[ -a "$toolset_location_file" ]]; then + local path=`cat "$toolset_location_file"` + if [[ -a "$path" ]]; then + # return value + _InitializeToolset="$path" + return + fi + fi + + if [[ "$restore" != true ]]; then + echo "Toolset version $toolsetVersion has not been restored." >&2 + ExitWithExitCode 2 + fi + + local proj="$toolset_dir/restore.proj" + + local bl="" + if [[ "$binary_log" == true ]]; then + bl="/bl:$log_dir/ToolsetRestore.binlog" + fi + + echo '' > "$proj" + MSBuild "$proj" $bl /t:__WriteToolsetLocation /clp:ErrorsOnly\;NoSummary /p:__ToolsetLocationOutputFile="$toolset_location_file" + + local toolset_build_proj=`cat "$toolset_location_file"` + + if [[ ! -a "$toolset_build_proj" ]]; then + echo "Invalid toolset path: $toolset_build_proj" >&2 + ExitWithExitCode 3 + fi + + # return value + _InitializeToolset="$toolset_build_proj" +} + +function ExitWithExitCode { + if [[ "$ci" == true && "$prepare_machine" == true ]]; then + StopProcesses + fi + exit $1 +} + +function StopProcesses { + echo "Killing running build processes..." + pkill -9 "dotnet" || true + pkill -9 "vbcscompiler" || true + return 0 +} + +function MSBuild { + if [[ "$ci" == true ]]; then + if [[ "$binary_log" != true ]]; then + echo "Binary log must be enabled in CI build." >&2 + ExitWithExitCode 1 + fi + + if [[ "$node_reuse" == true ]]; then + echo "Node reuse must be disabled in CI build." >&2 + ExitWithExitCode 1 + fi + fi + + InitializeBuildTool + + local warnaserror_switch="" + if [[ $warn_as_error == true ]]; then + warnaserror_switch="/warnaserror" + fi + + "$_InitializeBuildTool" "$_InitializeBuildToolCommand" /m /nologo /clp:Summary /v:$verbosity /nr:$node_reuse $warnaserror_switch /p:TreatWarningsAsErrors=$warn_as_error /p:ContinuousIntegrationBuild=$ci "$@" || { + local exit_code=$? + echo "Build failed (exit code '$exit_code')." >&2 + ExitWithExitCode $exit_code + } +} + +ResolvePath "${BASH_SOURCE[0]}" +_script_dir=`dirname "$_ResolvePath"` + +eng_root=`cd -P "$_script_dir/.." && pwd` +repo_root=`cd -P "$_script_dir/../.." && pwd` +artifacts_dir="$repo_root/artifacts" +toolset_dir="$artifacts_dir/toolset" +log_dir="$artifacts_dir/log/$configuration" +temp_dir="$artifacts_dir/tmp/$configuration" + +global_json_file="$repo_root/global.json" + +# HOME may not be defined in some scenarios, but it is required by NuGet +if [[ -z $HOME ]]; then + export HOME="$repo_root/artifacts/.home/" + mkdir -p "$HOME" +fi + +mkdir -p "$toolset_dir" +mkdir -p "$temp_dir" +mkdir -p "$log_dir" + +if [[ $ci == true ]]; then + export TEMP="$temp_dir" + export TMP="$temp_dir" +fi diff --git a/global.json b/global.json new file mode 100644 index 0000000000..3f422d5309 --- /dev/null +++ b/global.json @@ -0,0 +1,8 @@ +{ + "tools": { + "dotnet": "3.0.100-preview3-010431" + }, + "msbuild-sdks": { + "Microsoft.DotNet.Arcade.Sdk": "1.0.0-beta.19167.10" + } +} diff --git a/src/referencePackages/MSFT.snk b/src/referencePackages/MSFT.snk new file mode 100755 index 0000000000..110b59c7b0 Binary files /dev/null and b/src/referencePackages/MSFT.snk differ diff --git a/src/referencePackages/buildReferencePackages.proj b/src/referencePackages/buildReferencePackages.proj new file mode 100644 index 0000000000..1153651fbc --- /dev/null +++ b/src/referencePackages/buildReferencePackages.proj @@ -0,0 +1,53 @@ + + + + + $(RepoRoot)src/referencePackages/src/ + $(RepoRoot)src/textOnlyPackages/ + $(RepoRoot)/artifacts/bin/ + $(RepoRoot)/artifacts/obj/ + $(RepoRoot)/artifacts/log/ + $(RepoRoot)/artifacts/packages/ + + + + + + + + + + + + + + + + + + + + + + + + + + + + /p:ArtifactsBinDir=$(ArtifactsBinDir) + $(PackCommandArgs) /p:ArtifactsObjDir=$(ArtifactsObjDir) + $(PackCommandArgs) /p:RepoRoot=$(RepoRoot) + + + $(PackCommandArgs) /nowarn:NU1603,NU5125 + + + + + + + + + + diff --git a/src/referencePackages/src/ProjectsToBuild.props b/src/referencePackages/src/ProjectsToBuild.props new file mode 100644 index 0000000000..b8ee294197 --- /dev/null +++ b/src/referencePackages/src/ProjectsToBuild.props @@ -0,0 +1,6 @@ + + + + + + diff --git a/src/referencePackages/src/dir.props b/src/referencePackages/src/dir.props new file mode 100644 index 0000000000..cbc9595c1c --- /dev/null +++ b/src/referencePackages/src/dir.props @@ -0,0 +1,27 @@ + + + + + None + false + true + true + + $(RepoRoot)src/referencePackages/MSFT.snk + true + true + + false + Release + false + + true + true + false + false + v4.0.30319 + + false + false + + diff --git a/src/referencePackages/src/system.runtime/4.3.0/System.Runtime.csproj b/src/referencePackages/src/system.runtime/4.3.0/System.Runtime.csproj new file mode 100644 index 0000000000..1a08fa0bd5 --- /dev/null +++ b/src/referencePackages/src/system.runtime/4.3.0/System.Runtime.csproj @@ -0,0 +1,42 @@ + + + + netstandard1.0;netstandard1.2;netstandard1.3;netstandard1.5;net462 + $(ArtifactsBinDir)system.runtime/4.3.0/system.runtime.nuspec + + + + $(ArtifactsBinDir)system.runtime/4.3.0/ref/ + $(ArtifactsObjDir)system.runtime/4.3.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/referencePackages/src/system.runtime/4.3.0/ref/net45/_._ b/src/referencePackages/src/system.runtime/4.3.0/ref/net45/_._ new file mode 100755 index 0000000000..e69de29bb2 diff --git a/src/referencePackages/src/system.runtime/4.3.0/ref/net462/System.Runtime.cs b/src/referencePackages/src/system.runtime/4.3.0/ref/net462/System.Runtime.cs new file mode 100644 index 0000000000..ddc454aaf5 --- /dev/null +++ b/src/referencePackages/src/system.runtime/4.3.0/ref/net462/System.Runtime.cs @@ -0,0 +1,318 @@ +// 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.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Reflection; +using System.Runtime; +using System.Runtime.CompilerServices; +using System.Runtime.ExceptionServices; +using System.Runtime.InteropServices; +using System.Runtime.Versioning; +using System.Security; +using System.Text; +using System.Threading; + +[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] +[assembly: AllowPartiallyTrustedCallers] +[assembly: ReferenceAssembly] +[assembly: AssemblyTitle("System.Runtime")] +[assembly: AssemblyDescription("System.Runtime")] +[assembly: AssemblyDefaultAlias("System.Runtime")] +[assembly: AssemblyCompany("Microsoft Corporation")] +[assembly: AssemblyProduct("Microsoft® .NET Framework")] +[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: AssemblyFileVersion("4.6.24705.01")] +[assembly: AssemblyInformationalVersion("4.6.24705.01 built by: SOURCEBUILD")] +[assembly: CLSCompliant(true)] +[assembly: AssemblyMetadata("", "")] +[assembly: AssemblyVersion("4.1.1.0")] + +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.GCHandle))] +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.GCHandleType))] +[assembly: TypeForwardedTo(typeof(System.Action))] +[assembly: TypeForwardedTo(typeof(System.Action<>))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Action<, , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Activator))] +[assembly: TypeForwardedTo(typeof(System.ArgumentException))] +[assembly: TypeForwardedTo(typeof(System.ArgumentNullException))] +[assembly: TypeForwardedTo(typeof(System.ArgumentOutOfRangeException))] +[assembly: TypeForwardedTo(typeof(System.ArithmeticException))] +[assembly: TypeForwardedTo(typeof(System.Array))] +[assembly: TypeForwardedTo(typeof(System.ArraySegment<>))] +[assembly: TypeForwardedTo(typeof(System.ArrayTypeMismatchException))] +[assembly: TypeForwardedTo(typeof(System.AsyncCallback))] +[assembly: TypeForwardedTo(typeof(System.Attribute))] +[assembly: TypeForwardedTo(typeof(System.AttributeTargets))] +[assembly: TypeForwardedTo(typeof(System.AttributeUsageAttribute))] +[assembly: TypeForwardedTo(typeof(System.BadImageFormatException))] +[assembly: TypeForwardedTo(typeof(System.Boolean))] +[assembly: TypeForwardedTo(typeof(System.Buffer))] +[assembly: TypeForwardedTo(typeof(System.Byte))] +[assembly: TypeForwardedTo(typeof(System.Char))] +[assembly: TypeForwardedTo(typeof(System.CLSCompliantAttribute))] +[assembly: TypeForwardedTo(typeof(System.Collections.DictionaryEntry))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.ICollection<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IComparer<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IDictionary<, >))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IEnumerable<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IEnumerator<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IEqualityComparer<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IList<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IReadOnlyCollection<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IReadOnlyDictionary<, >))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.IReadOnlyList<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.ISet<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.KeyNotFoundException))] +[assembly: TypeForwardedTo(typeof(System.Collections.Generic.KeyValuePair<, >))] +[assembly: TypeForwardedTo(typeof(System.Collections.ICollection))] +[assembly: TypeForwardedTo(typeof(System.Collections.IComparer))] +[assembly: TypeForwardedTo(typeof(System.Collections.IDictionary))] +[assembly: TypeForwardedTo(typeof(System.Collections.IDictionaryEnumerator))] +[assembly: TypeForwardedTo(typeof(System.Collections.IEnumerable))] +[assembly: TypeForwardedTo(typeof(System.Collections.IEnumerator))] +[assembly: TypeForwardedTo(typeof(System.Collections.IEqualityComparer))] +[assembly: TypeForwardedTo(typeof(System.Collections.IList))] +[assembly: TypeForwardedTo(typeof(System.Collections.IStructuralComparable))] +[assembly: TypeForwardedTo(typeof(System.Collections.IStructuralEquatable))] +[assembly: TypeForwardedTo(typeof(System.Collections.ObjectModel.Collection<>))] +[assembly: TypeForwardedTo(typeof(System.Collections.ObjectModel.ReadOnlyCollection<>))] +[assembly: TypeForwardedTo(typeof(System.Comparison<>))] +[assembly: TypeForwardedTo(typeof(System.ComponentModel.DefaultValueAttribute))] +[assembly: TypeForwardedTo(typeof(System.ComponentModel.EditorBrowsableAttribute))] +[assembly: TypeForwardedTo(typeof(System.ComponentModel.EditorBrowsableState))] +[assembly: TypeForwardedTo(typeof(System.DateTime))] +[assembly: TypeForwardedTo(typeof(System.DateTimeKind))] +[assembly: TypeForwardedTo(typeof(System.DateTimeOffset))] +[assembly: TypeForwardedTo(typeof(System.DayOfWeek))] +[assembly: TypeForwardedTo(typeof(System.Decimal))] +[assembly: TypeForwardedTo(typeof(System.Delegate))] +[assembly: TypeForwardedTo(typeof(System.Diagnostics.ConditionalAttribute))] +[assembly: TypeForwardedTo(typeof(System.Diagnostics.DebuggableAttribute))] +[assembly: TypeForwardedTo(typeof(System.DivideByZeroException))] +[assembly: TypeForwardedTo(typeof(System.Double))] +[assembly: TypeForwardedTo(typeof(System.Enum))] +[assembly: TypeForwardedTo(typeof(System.EventArgs))] +[assembly: TypeForwardedTo(typeof(System.EventHandler))] +[assembly: TypeForwardedTo(typeof(System.EventHandler<>))] +[assembly: TypeForwardedTo(typeof(System.Exception))] +[assembly: TypeForwardedTo(typeof(System.FieldAccessException))] +[assembly: TypeForwardedTo(typeof(System.FlagsAttribute))] +[assembly: TypeForwardedTo(typeof(System.FormatException))] +[assembly: TypeForwardedTo(typeof(System.FormattableString))] +[assembly: TypeForwardedTo(typeof(System.Func<>))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , , , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Func<, , , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.GC))] +[assembly: TypeForwardedTo(typeof(System.GCCollectionMode))] +[assembly: TypeForwardedTo(typeof(System.Globalization.DateTimeStyles))] +[assembly: TypeForwardedTo(typeof(System.Globalization.NumberStyles))] +[assembly: TypeForwardedTo(typeof(System.Globalization.TimeSpanStyles))] +[assembly: TypeForwardedTo(typeof(System.Guid))] +[assembly: TypeForwardedTo(typeof(System.IAsyncResult))] +[assembly: TypeForwardedTo(typeof(System.IComparable))] +[assembly: TypeForwardedTo(typeof(System.IComparable<>))] +[assembly: TypeForwardedTo(typeof(System.IConvertible))] +[assembly: TypeForwardedTo(typeof(System.ICustomFormatter))] +[assembly: TypeForwardedTo(typeof(System.IDisposable))] +[assembly: TypeForwardedTo(typeof(System.IEquatable<>))] +[assembly: TypeForwardedTo(typeof(System.IFormatProvider))] +[assembly: TypeForwardedTo(typeof(System.IFormattable))] +[assembly: TypeForwardedTo(typeof(System.IndexOutOfRangeException))] +[assembly: TypeForwardedTo(typeof(System.InsufficientExecutionStackException))] +[assembly: TypeForwardedTo(typeof(System.Int16))] +[assembly: TypeForwardedTo(typeof(System.Int32))] +[assembly: TypeForwardedTo(typeof(System.Int64))] +[assembly: TypeForwardedTo(typeof(System.IntPtr))] +[assembly: TypeForwardedTo(typeof(System.InvalidCastException))] +[assembly: TypeForwardedTo(typeof(System.InvalidOperationException))] +[assembly: TypeForwardedTo(typeof(System.InvalidProgramException))] +[assembly: TypeForwardedTo(typeof(System.InvalidTimeZoneException))] +[assembly: TypeForwardedTo(typeof(System.IO.DirectoryNotFoundException))] +[assembly: TypeForwardedTo(typeof(System.IO.FileLoadException))] +[assembly: TypeForwardedTo(typeof(System.IO.FileNotFoundException))] +[assembly: TypeForwardedTo(typeof(System.IO.IOException))] +[assembly: TypeForwardedTo(typeof(System.IO.PathTooLongException))] +[assembly: TypeForwardedTo(typeof(System.IObservable<>))] +[assembly: TypeForwardedTo(typeof(System.IObserver<>))] +[assembly: TypeForwardedTo(typeof(System.IProgress<>))] +[assembly: TypeForwardedTo(typeof(System.Lazy<>))] +[assembly: TypeForwardedTo(typeof(System.Lazy<, >))] +[assembly: TypeForwardedTo(typeof(System.MemberAccessException))] +[assembly: TypeForwardedTo(typeof(System.MethodAccessException))] +[assembly: TypeForwardedTo(typeof(System.MissingFieldException))] +[assembly: TypeForwardedTo(typeof(System.MissingMemberException))] +[assembly: TypeForwardedTo(typeof(System.MissingMethodException))] +[assembly: TypeForwardedTo(typeof(System.MTAThreadAttribute))] +[assembly: TypeForwardedTo(typeof(System.MulticastDelegate))] +[assembly: TypeForwardedTo(typeof(System.NotImplementedException))] +[assembly: TypeForwardedTo(typeof(System.NotSupportedException))] +[assembly: TypeForwardedTo(typeof(System.Nullable))] +[assembly: TypeForwardedTo(typeof(System.Nullable<>))] +[assembly: TypeForwardedTo(typeof(System.NullReferenceException))] +[assembly: TypeForwardedTo(typeof(System.Object))] +[assembly: TypeForwardedTo(typeof(System.ObjectDisposedException))] +[assembly: TypeForwardedTo(typeof(System.ObsoleteAttribute))] +[assembly: TypeForwardedTo(typeof(System.OutOfMemoryException))] +[assembly: TypeForwardedTo(typeof(System.OverflowException))] +[assembly: TypeForwardedTo(typeof(System.ParamArrayAttribute))] +[assembly: TypeForwardedTo(typeof(System.PlatformNotSupportedException))] +[assembly: TypeForwardedTo(typeof(System.Predicate<>))] +[assembly: TypeForwardedTo(typeof(System.RankException))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyCompanyAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyConfigurationAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyCopyrightAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyCultureAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyDefaultAliasAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyDelaySignAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyDescriptionAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyFileVersionAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyFlagsAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyInformationalVersionAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyKeyFileAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyKeyNameAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyMetadataAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyNameFlags))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyProductAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblySignatureKeyAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyTitleAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyTrademarkAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.AssemblyVersionAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.DefaultMemberAttribute))] +[assembly: TypeForwardedTo(typeof(System.Reflection.ProcessorArchitecture))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.AccessedThroughPropertyAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.AsyncStateMachineAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.CallerFilePathAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.CallerLineNumberAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.CallerMemberNameAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.CompilationRelaxationsAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.ConditionalWeakTable<, >))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.CustomConstantAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.DateTimeConstantAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.DecimalConstantAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.DisablePrivateReflectionAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.ExtensionAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.FixedBufferAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.FormattableStringFactory))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.IndexerNameAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.InternalsVisibleToAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.IsConst))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.IStrongBox))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.IsVolatile))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.IteratorStateMachineAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.MethodImplAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.MethodImplOptions))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.ReferenceAssemblyAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.RuntimeCompatibilityAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.RuntimeHelpers))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.StateMachineAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.StrongBox<>))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.TypeForwardedFromAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.TypeForwardedToAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.CompilerServices.UnsafeValueTypeAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.ExceptionServices.ExceptionDispatchInfo))] +[assembly: TypeForwardedTo(typeof(System.Runtime.GCLargeObjectHeapCompactionMode))] +[assembly: TypeForwardedTo(typeof(System.Runtime.GCLatencyMode))] +[assembly: TypeForwardedTo(typeof(System.Runtime.GCSettings))] +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.CharSet))] +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.ComVisibleAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.FieldOffsetAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.LayoutKind))] +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.OutAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.InteropServices.StructLayoutAttribute))] +[assembly: TypeForwardedTo(typeof(System.Runtime.Versioning.TargetFrameworkAttribute))] +[assembly: TypeForwardedTo(typeof(System.RuntimeFieldHandle))] +[assembly: TypeForwardedTo(typeof(System.RuntimeMethodHandle))] +[assembly: TypeForwardedTo(typeof(System.RuntimeTypeHandle))] +[assembly: TypeForwardedTo(typeof(System.SByte))] +[assembly: TypeForwardedTo(typeof(System.Security.AllowPartiallyTrustedCallersAttribute))] +[assembly: TypeForwardedTo(typeof(System.Security.SecurityCriticalAttribute))] +[assembly: TypeForwardedTo(typeof(System.Security.SecurityException))] +[assembly: TypeForwardedTo(typeof(System.Security.SecuritySafeCriticalAttribute))] +[assembly: TypeForwardedTo(typeof(System.Security.SecurityTransparentAttribute))] +[assembly: TypeForwardedTo(typeof(System.Security.VerificationException))] +[assembly: TypeForwardedTo(typeof(System.Single))] +[assembly: TypeForwardedTo(typeof(System.STAThreadAttribute))] +[assembly: TypeForwardedTo(typeof(System.String))] +[assembly: TypeForwardedTo(typeof(System.StringComparison))] +[assembly: TypeForwardedTo(typeof(System.StringSplitOptions))] +[assembly: TypeForwardedTo(typeof(System.Text.StringBuilder))] +[assembly: TypeForwardedTo(typeof(System.Threading.LazyThreadSafetyMode))] +[assembly: TypeForwardedTo(typeof(System.Threading.Timeout))] +[assembly: TypeForwardedTo(typeof(System.Threading.WaitHandle))] +[assembly: TypeForwardedTo(typeof(System.ThreadStaticAttribute))] +[assembly: TypeForwardedTo(typeof(System.TimeoutException))] +[assembly: TypeForwardedTo(typeof(System.TimeSpan))] +[assembly: TypeForwardedTo(typeof(System.TimeZoneInfo))] +[assembly: TypeForwardedTo(typeof(System.Tuple))] +[assembly: TypeForwardedTo(typeof(System.Tuple<>))] +[assembly: TypeForwardedTo(typeof(System.Tuple<, >))] +[assembly: TypeForwardedTo(typeof(System.Tuple<, , >))] +[assembly: TypeForwardedTo(typeof(System.Tuple<, , , >))] +[assembly: TypeForwardedTo(typeof(System.Tuple<, , , , >))] +[assembly: TypeForwardedTo(typeof(System.Tuple<, , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Tuple<, , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Tuple<, , , , , , , >))] +[assembly: TypeForwardedTo(typeof(System.Type))] +[assembly: TypeForwardedTo(typeof(System.TypeAccessException))] +[assembly: TypeForwardedTo(typeof(System.TypeCode))] +[assembly: TypeForwardedTo(typeof(System.TypeInitializationException))] +[assembly: TypeForwardedTo(typeof(System.TypeLoadException))] +[assembly: TypeForwardedTo(typeof(System.UInt16))] +[assembly: TypeForwardedTo(typeof(System.UInt32))] +[assembly: TypeForwardedTo(typeof(System.UInt64))] +[assembly: TypeForwardedTo(typeof(System.UIntPtr))] +[assembly: TypeForwardedTo(typeof(System.UnauthorizedAccessException))] +[assembly: TypeForwardedTo(typeof(System.Uri))] +[assembly: TypeForwardedTo(typeof(System.UriComponents))] +[assembly: TypeForwardedTo(typeof(System.UriFormat))] +[assembly: TypeForwardedTo(typeof(System.UriFormatException))] +[assembly: TypeForwardedTo(typeof(System.UriHostNameType))] +[assembly: TypeForwardedTo(typeof(System.UriKind))] +[assembly: TypeForwardedTo(typeof(System.ValueType))] +[assembly: TypeForwardedTo(typeof(System.Version))] +[assembly: TypeForwardedTo(typeof(void))] +[assembly: TypeForwardedTo(typeof(System.WeakReference))] +[assembly: TypeForwardedTo(typeof(System.WeakReference<>))] + + + diff --git a/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.0/System.Runtime.cs b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.0/System.Runtime.cs new file mode 100644 index 0000000000..a94d1d210d --- /dev/null +++ b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.0/System.Runtime.cs @@ -0,0 +1,2665 @@ +// 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.Runtime")] +[assembly: AssemblyDescription("System.Runtime")] +[assembly: AssemblyDefaultAlias("System.Runtime")] +[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 delegate void Action(); + public delegate void Action(T obj); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate void Action(T1 arg1, T2 arg2); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public static partial class Activator + { + public static object CreateInstance(System.Type type) { throw null; } + public static object CreateInstance(System.Type type, params object[] args) { throw null; } + public static T CreateInstance() { throw null; } + } + public partial class ArgumentException : System.Exception + { + public ArgumentException() { } + public ArgumentException(string message) { } + public ArgumentException(string message, System.Exception innerException) { } + public ArgumentException(string message, string paramName) { } + public ArgumentException(string message, string paramName, System.Exception innerException) { } + public override string Message { get { throw null; } } + public virtual string ParamName { get { throw null; } } + } + public partial class ArgumentNullException : System.ArgumentException + { + public ArgumentNullException() { } + public ArgumentNullException(string paramName) { } + public ArgumentNullException(string message, System.Exception innerException) { } + public ArgumentNullException(string paramName, string message) { } + } + public partial class ArgumentOutOfRangeException : System.ArgumentException + { + public ArgumentOutOfRangeException() { } + public ArgumentOutOfRangeException(string paramName) { } + public ArgumentOutOfRangeException(string message, System.Exception innerException) { } + public ArgumentOutOfRangeException(string paramName, object actualValue, string message) { } + public ArgumentOutOfRangeException(string paramName, string message) { } + public virtual object ActualValue { get { throw null; } } + public override string Message { get { throw null; } } + } + public partial class ArithmeticException : System.Exception + { + public ArithmeticException() { } + public ArithmeticException(string message) { } + public ArithmeticException(string message, System.Exception innerException) { } + } + public abstract partial class Array : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable + { + internal Array() { } + public int Length { get { throw null; } } + public int Rank { get { throw null; } } + int System.Collections.ICollection.Count { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public static int BinarySearch(System.Array array, int index, int length, object value) { throw null; } + public static int BinarySearch(System.Array array, int index, int length, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(System.Array array, object value) { throw null; } + public static int BinarySearch(System.Array array, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, T value) { throw null; } + public static int BinarySearch(T[] array, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static void Clear(System.Array array, int index, int length) { } + public object Clone() { throw null; } + public static void ConstrainedCopy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public static void Copy(System.Array sourceArray, System.Array destinationArray, int length) { } + public static void Copy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public void CopyTo(System.Array array, int index) { } + public static System.Array CreateInstance(System.Type elementType, params int[] lengths) { throw null; } + public static System.Array CreateInstance(System.Type elementType, int[] lengths, int[] lowerBounds) { throw null; } + public static bool Exists(T[] array, System.Predicate match) { throw null; } + public static T[] FindAll(T[] array, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, System.Predicate match) { throw null; } + public static T FindLast(T[] array, System.Predicate match) { throw null; } + public static T Find(T[] array, System.Predicate match) { throw null; } + public System.Collections.IEnumerator GetEnumerator() { throw null; } + public int GetLength(int dimension) { throw null; } + public int GetLowerBound(int dimension) { throw null; } + public int GetUpperBound(int dimension) { throw null; } + public object GetValue(params int[] indices) { throw null; } + public static int IndexOf(System.Array array, object value) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int IndexOf(T[] array, T value) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public void Initialize() { } + public static int LastIndexOf(System.Array array, object value) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int LastIndexOf(T[] array, T value) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public static void Resize(ref T[] array, int newSize) { } + public static void Reverse(System.Array array) { } + public static void Reverse(System.Array array, int index, int length) { } + public void SetValue(object value, params int[] indices) { } + public static void Sort(System.Array array) { } + public static void Sort(System.Array array, System.Collections.IComparer comparer) { } + public static void Sort(System.Array array, int index, int length) { } + public static void Sort(System.Array array, int index, int length, System.Collections.IComparer comparer) { } + public static void Sort(T[] array) { } + public static void Sort(T[] array, System.Collections.Generic.IComparer comparer) { } + public static void Sort(T[] array, System.Comparison comparison) { } + public static void Sort(T[] array, int index, int length) { } + public static void Sort(T[] array, int index, int length, System.Collections.Generic.IComparer comparer) { } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + public static bool TrueForAll(T[] array, System.Predicate match) { throw null; } + } + public partial struct ArraySegment : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.IEnumerable + { + public ArraySegment(T[] array) { throw null; } + public ArraySegment(T[] array, int offset, int count) { throw null; } + public T[] Array { get { throw null; } } + public int Count { get { throw null; } } + public int Offset { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + T System.Collections.Generic.IReadOnlyList.this[int index] { get { throw null; } } + public bool Equals(System.ArraySegment obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.ArraySegment a, System.ArraySegment b) { throw null; } + public static bool operator !=(System.ArraySegment a, System.ArraySegment b) { throw null; } + void System.Collections.Generic.ICollection.Add(T item) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Contains(T item) { throw null; } + void System.Collections.Generic.ICollection.CopyTo(T[] array, int arrayIndex) { } + bool System.Collections.Generic.ICollection.Remove(T item) { throw null; } + System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.Generic.IList.IndexOf(T item) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T item) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + } + public partial class ArrayTypeMismatchException : System.Exception + { + public ArrayTypeMismatchException() { } + public ArrayTypeMismatchException(string message) { } + public ArrayTypeMismatchException(string message, System.Exception innerException) { } + } + public delegate void AsyncCallback(System.IAsyncResult ar); + public abstract partial class Attribute + { + protected Attribute() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + [System.FlagsAttribute] + public enum AttributeTargets + { + All = 32767, + Assembly = 1, + Class = 4, + Constructor = 32, + Delegate = 4096, + Enum = 16, + Event = 512, + Field = 256, + GenericParameter = 16384, + Interface = 1024, + Method = 64, + Module = 2, + Parameter = 2048, + Property = 128, + ReturnValue = 8192, + Struct = 8, + } + public sealed partial class AttributeUsageAttribute : System.Attribute + { + public AttributeUsageAttribute(System.AttributeTargets validOn) { } + public bool AllowMultiple { get { throw null; } set { } } + public bool Inherited { get { throw null; } set { } } + public System.AttributeTargets ValidOn { get { throw null; } } + } + public partial class BadImageFormatException : System.Exception + { + public BadImageFormatException() { } + public BadImageFormatException(string message) { } + public BadImageFormatException(string message, System.Exception inner) { } + public BadImageFormatException(string message, string fileName) { } + public BadImageFormatException(string message, string fileName, System.Exception inner) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial struct Boolean : System.IComparable, System.IComparable, System.IEquatable + { + public static readonly string FalseString; + public static readonly string TrueString; + public int CompareTo(System.Boolean value) { throw null; } + public System.Boolean Equals(System.Boolean obj) { throw null; } + public override System.Boolean Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Boolean Parse(string value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + public static System.Boolean TryParse(string value, out System.Boolean result) { throw null; } + } + public static partial class Buffer + { + public static void BlockCopy(System.Array src, int srcOffset, System.Array dst, int dstOffset, int count) { } + public static int ByteLength(System.Array array) { throw null; } + public static byte GetByte(System.Array array, int index) { throw null; } + public static void SetByte(System.Array array, int index, byte value) { } + } + public partial struct Byte : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const byte MaxValue = (byte)255; + public const byte MinValue = (byte)0; + public int CompareTo(System.Byte value) { throw null; } + public bool Equals(System.Byte obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Byte Parse(string s) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Byte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Byte result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Byte result) { throw null; } + } + public partial struct Char : System.IComparable, System.IComparable, System.IEquatable + { + public const char MaxValue = '\uFFFF'; + public const char MinValue = '\0'; + public int CompareTo(System.Char value) { throw null; } + public static string ConvertFromUtf32(int utf32) { throw null; } + public static int ConvertToUtf32(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static int ConvertToUtf32(string s, int index) { throw null; } + public bool Equals(System.Char obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static double GetNumericValue(System.Char c) { throw null; } + public static double GetNumericValue(string s, int index) { throw null; } + public static bool IsControl(System.Char c) { throw null; } + public static bool IsControl(string s, int index) { throw null; } + public static bool IsDigit(System.Char c) { throw null; } + public static bool IsDigit(string s, int index) { throw null; } + public static bool IsHighSurrogate(System.Char c) { throw null; } + public static bool IsHighSurrogate(string s, int index) { throw null; } + public static bool IsLetter(System.Char c) { throw null; } + public static bool IsLetter(string s, int index) { throw null; } + public static bool IsLetterOrDigit(System.Char c) { throw null; } + public static bool IsLetterOrDigit(string s, int index) { throw null; } + public static bool IsLower(System.Char c) { throw null; } + public static bool IsLower(string s, int index) { throw null; } + public static bool IsLowSurrogate(System.Char c) { throw null; } + public static bool IsLowSurrogate(string s, int index) { throw null; } + public static bool IsNumber(System.Char c) { throw null; } + public static bool IsNumber(string s, int index) { throw null; } + public static bool IsPunctuation(System.Char c) { throw null; } + public static bool IsPunctuation(string s, int index) { throw null; } + public static bool IsSeparator(System.Char c) { throw null; } + public static bool IsSeparator(string s, int index) { throw null; } + public static bool IsSurrogate(System.Char c) { throw null; } + public static bool IsSurrogate(string s, int index) { throw null; } + public static bool IsSurrogatePair(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static bool IsSurrogatePair(string s, int index) { throw null; } + public static bool IsSymbol(System.Char c) { throw null; } + public static bool IsSymbol(string s, int index) { throw null; } + public static bool IsUpper(System.Char c) { throw null; } + public static bool IsUpper(string s, int index) { throw null; } + public static bool IsWhiteSpace(System.Char c) { throw null; } + public static bool IsWhiteSpace(string s, int index) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public static System.Char ToLower(System.Char c) { throw null; } + public static System.Char ToLowerInvariant(System.Char c) { throw null; } + public override string ToString() { throw null; } + public static string ToString(System.Char c) { throw null; } + public static System.Char ToUpper(System.Char c) { throw null; } + public static System.Char ToUpperInvariant(System.Char c) { throw null; } + public static bool TryParse(string s, out System.Char result) { throw null; } + } + public sealed partial class CLSCompliantAttribute : System.Attribute + { + public CLSCompliantAttribute(bool isCompliant) { } + public bool IsCompliant { get { throw null; } } + } + public delegate int Comparison(T x, T y); + public partial struct DateTime : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.DateTime MaxValue; + public static readonly System.DateTime MinValue; + public DateTime(int year, int month, int day) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, System.DateTimeKind kind) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System.DateTimeKind kind) { throw null; } + public DateTime(long ticks) { throw null; } + public DateTime(long ticks, System.DateTimeKind kind) { throw null; } + public System.DateTime Date { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTimeKind Kind { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTime Now { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public static System.DateTime Today { get { throw null; } } + public static System.DateTime UtcNow { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTime Add(System.TimeSpan value) { throw null; } + public System.DateTime AddDays(double value) { throw null; } + public System.DateTime AddHours(double value) { throw null; } + public System.DateTime AddMilliseconds(double value) { throw null; } + public System.DateTime AddMinutes(double value) { throw null; } + public System.DateTime AddMonths(int months) { throw null; } + public System.DateTime AddSeconds(double value) { throw null; } + public System.DateTime AddTicks(long value) { throw null; } + public System.DateTime AddYears(int value) { throw null; } + public static int Compare(System.DateTime t1, System.DateTime t2) { throw null; } + public int CompareTo(System.DateTime value) { throw null; } + public static int DaysInMonth(int year, int month) { throw null; } + public bool Equals(System.DateTime value) { throw null; } + public static bool Equals(System.DateTime t1, System.DateTime t2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.DateTime FromBinary(long dateData) { throw null; } + public static System.DateTime FromFileTime(long fileTime) { throw null; } + public static System.DateTime FromFileTimeUtc(long fileTime) { throw null; } + public string[] GetDateTimeFormats() { throw null; } + public string[] GetDateTimeFormats(char format) { throw null; } + public string[] GetDateTimeFormats(char format, System.IFormatProvider provider) { throw null; } + public string[] GetDateTimeFormats(System.IFormatProvider provider) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsDaylightSavingTime() { throw null; } + public static bool IsLeapYear(int year) { throw null; } + public static System.DateTime operator +(System.DateTime d, System.TimeSpan t) { throw null; } + public static bool operator ==(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator >(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator >=(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator !=(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator <(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator <=(System.DateTime t1, System.DateTime t2) { throw null; } + public static System.TimeSpan operator -(System.DateTime d1, System.DateTime d2) { throw null; } + public static System.DateTime operator -(System.DateTime d, System.TimeSpan t) { throw null; } + public static System.DateTime Parse(string s) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime ParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime SpecifyKind(System.DateTime value, System.DateTimeKind kind) { throw null; } + public System.TimeSpan Subtract(System.DateTime value) { throw null; } + public System.DateTime Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public long ToBinary() { throw null; } + public long ToFileTime() { throw null; } + public long ToFileTimeUtc() { throw null; } + public System.DateTime ToLocalTime() { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public System.DateTime ToUniversalTime() { throw null; } + public static bool TryParse(string s, out System.DateTime result) { throw null; } + public static bool TryParse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + } + public enum DateTimeKind + { + Local = 2, + Unspecified = 0, + Utc = 1, + } + public partial struct DateTimeOffset : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.DateTimeOffset MaxValue; + public static readonly System.DateTimeOffset MinValue; + public DateTimeOffset(System.DateTime dateTime) { throw null; } + public DateTimeOffset(System.DateTime dateTime, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, System.TimeSpan offset) { throw null; } + public DateTimeOffset(long ticks, System.TimeSpan offset) { throw null; } + public System.DateTime Date { get { throw null; } } + public System.DateTime DateTime { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTime LocalDateTime { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTimeOffset Now { get { throw null; } } + public System.TimeSpan Offset { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public System.DateTime UtcDateTime { get { throw null; } } + public static System.DateTimeOffset UtcNow { get { throw null; } } + public long UtcTicks { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTimeOffset Add(System.TimeSpan timeSpan) { throw null; } + public System.DateTimeOffset AddDays(double days) { throw null; } + public System.DateTimeOffset AddHours(double hours) { throw null; } + public System.DateTimeOffset AddMilliseconds(double milliseconds) { throw null; } + public System.DateTimeOffset AddMinutes(double minutes) { throw null; } + public System.DateTimeOffset AddMonths(int months) { throw null; } + public System.DateTimeOffset AddSeconds(double seconds) { throw null; } + public System.DateTimeOffset AddTicks(long ticks) { throw null; } + public System.DateTimeOffset AddYears(int years) { throw null; } + public static int Compare(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public int CompareTo(System.DateTimeOffset other) { throw null; } + public bool Equals(System.DateTimeOffset other) { throw null; } + public static bool Equals(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool EqualsExact(System.DateTimeOffset other) { throw null; } + public static System.DateTimeOffset FromFileTime(long fileTime) { throw null; } + public override int GetHashCode() { throw null; } + public static System.DateTimeOffset operator +(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static bool operator ==(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static implicit operator System.DateTimeOffset (System.DateTime dateTime) { throw null; } + public static bool operator !=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.TimeSpan operator -(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.DateTimeOffset operator -(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static System.DateTimeOffset Parse(string input) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public System.TimeSpan Subtract(System.DateTimeOffset value) { throw null; } + public System.DateTimeOffset Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public long ToFileTime() { throw null; } + public System.DateTimeOffset ToLocalTime() { throw null; } + public System.DateTimeOffset ToOffset(System.TimeSpan offset) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider formatProvider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public System.DateTimeOffset ToUniversalTime() { throw null; } + public static bool TryParse(string input, out System.DateTimeOffset result) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + } + public enum DayOfWeek + { + Friday = 5, + Monday = 1, + Saturday = 6, + Sunday = 0, + Thursday = 4, + Tuesday = 2, + Wednesday = 3, + } + public partial struct Decimal : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MaxValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)0, (uint)0, (uint)1)] + public static readonly decimal MinusOne; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MinValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)1)] + public static readonly decimal One; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)0)] + public static readonly decimal Zero; + public Decimal(double value) { throw null; } + public Decimal(int value) { throw null; } + public Decimal(int lo, int mid, int hi, bool isNegative, byte scale) { throw null; } + public Decimal(int[] bits) { throw null; } + public Decimal(long value) { throw null; } + public Decimal(float value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(ulong value) { throw null; } + public static System.Decimal Add(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Ceiling(System.Decimal d) { throw null; } + public static int Compare(System.Decimal d1, System.Decimal d2) { throw null; } + public int CompareTo(System.Decimal value) { throw null; } + public static System.Decimal Divide(System.Decimal d1, System.Decimal d2) { throw null; } + public bool Equals(System.Decimal value) { throw null; } + public static bool Equals(System.Decimal d1, System.Decimal d2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.Decimal Floor(System.Decimal d) { throw null; } + public static int[] GetBits(System.Decimal d) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Decimal Multiply(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Negate(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator --(System.Decimal d) { throw null; } + public static System.Decimal operator /(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator ==(System.Decimal d1, System.Decimal d2) { throw null; } + public static explicit operator byte (System.Decimal value) { throw null; } + public static explicit operator char (System.Decimal value) { throw null; } + public static explicit operator double (System.Decimal value) { throw null; } + public static explicit operator short (System.Decimal value) { throw null; } + public static explicit operator int (System.Decimal value) { throw null; } + public static explicit operator long (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator sbyte (System.Decimal value) { throw null; } + public static explicit operator float (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ushort (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator uint (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ulong (System.Decimal value) { throw null; } + public static explicit operator System.Decimal (double value) { throw null; } + public static explicit operator System.Decimal (float value) { throw null; } + public static bool operator >(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator >=(System.Decimal d1, System.Decimal d2) { throw null; } + public static implicit operator System.Decimal (byte value) { throw null; } + public static implicit operator System.Decimal (char value) { throw null; } + public static implicit operator System.Decimal (short value) { throw null; } + public static implicit operator System.Decimal (int value) { throw null; } + public static implicit operator System.Decimal (long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (sbyte value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ulong value) { throw null; } + public static System.Decimal operator ++(System.Decimal d) { throw null; } + public static bool operator !=(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <=(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator %(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator *(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d) { throw null; } + public static System.Decimal Parse(string s) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Decimal Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.Decimal Remainder(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Subtract(System.Decimal d1, System.Decimal d2) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public static byte ToByte(System.Decimal value) { throw null; } + public static double ToDouble(System.Decimal d) { throw null; } + public static short ToInt16(System.Decimal value) { throw null; } + public static int ToInt32(System.Decimal d) { throw null; } + public static long ToInt64(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static sbyte ToSByte(System.Decimal value) { throw null; } + public static float ToSingle(System.Decimal d) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ushort ToUInt16(System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static uint ToUInt32(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ulong ToUInt64(System.Decimal d) { throw null; } + public static System.Decimal Truncate(System.Decimal d) { throw null; } + public static bool TryParse(string s, out System.Decimal result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Decimal result) { throw null; } + } + public abstract partial class Delegate + { + internal Delegate() { } + public object Target { get { throw null; } } + public static System.Delegate Combine(System.Delegate a, System.Delegate b) { throw null; } + public static System.Delegate Combine(params System.Delegate[] delegates) { throw null; } + public object DynamicInvoke(params object[] args) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public virtual System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.Delegate d1, System.Delegate d2) { throw null; } + public static bool operator !=(System.Delegate d1, System.Delegate d2) { throw null; } + public static System.Delegate Remove(System.Delegate source, System.Delegate value) { throw null; } + public static System.Delegate RemoveAll(System.Delegate source, System.Delegate value) { throw null; } + } + public partial class DivideByZeroException : System.ArithmeticException + { + public DivideByZeroException() { } + public DivideByZeroException(string message) { } + public DivideByZeroException(string message, System.Exception innerException) { } + } + public partial struct Double : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const double Epsilon = 4.94065645841247E-324; + public const double MaxValue = 1.7976931348623157E+308; + public const double MinValue = -1.7976931348623157E+308; + public const double NaN = 0.0 / 0.0; + public const double NegativeInfinity = -1.0 / 0.0; + public const double PositiveInfinity = 1.0 / 0.0; + public int CompareTo(System.Double value) { throw null; } + public bool Equals(System.Double obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Double d) { throw null; } + public static bool IsNaN(System.Double d) { throw null; } + public static bool IsNegativeInfinity(System.Double d) { throw null; } + public static bool IsPositiveInfinity(System.Double d) { throw null; } + public static bool operator ==(System.Double left, System.Double right) { throw null; } + public static bool operator >(System.Double left, System.Double right) { throw null; } + public static bool operator >=(System.Double left, System.Double right) { throw null; } + public static bool operator !=(System.Double left, System.Double right) { throw null; } + public static bool operator <(System.Double left, System.Double right) { throw null; } + public static bool operator <=(System.Double left, System.Double right) { throw null; } + public static System.Double Parse(string s) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Double Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Double result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Double result) { throw null; } + } + public abstract partial class Enum : System.ValueType, System.IComparable, System.IFormattable + { + protected Enum() { } + public int CompareTo(object target) { throw null; } + public override bool Equals(object obj) { throw null; } + public static string Format(System.Type enumType, object value, string format) { throw null; } + public override int GetHashCode() { throw null; } + public static string GetName(System.Type enumType, object value) { throw null; } + public static string[] GetNames(System.Type enumType) { throw null; } + public static System.Type GetUnderlyingType(System.Type enumType) { throw null; } + public static System.Array GetValues(System.Type enumType) { throw null; } + public bool HasFlag(System.Enum flag) { throw null; } + public static bool IsDefined(System.Type enumType, object value) { throw null; } + public static object Parse(System.Type enumType, string value) { throw null; } + public static object Parse(System.Type enumType, string value, bool ignoreCase) { throw null; } + [System.ObsoleteAttribute("The provider argument is not used. Please use ToString(String).")] + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public static object ToObject(System.Type enumType, object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string value, bool ignoreCase, out TEnum result) where TEnum : struct { throw null; } + public static bool TryParse(string value, out TEnum result) where TEnum : struct { throw null; } + } + public partial class EventArgs + { + public static readonly System.EventArgs Empty; + public EventArgs() { } + } + public delegate void EventHandler(object sender, System.EventArgs e); + public delegate void EventHandler(object sender, TEventArgs e); + public partial class Exception + { + public Exception() { } + public Exception(string message) { } + public Exception(string message, System.Exception innerException) { } + public virtual System.Collections.IDictionary Data { get { throw null; } } + public virtual string HelpLink { get { throw null; } set { } } + public int HResult { get { throw null; } protected set { } } + public System.Exception InnerException { get { throw null; } } + public virtual string Message { get { throw null; } } + public virtual string Source { get { throw null; } set { } } + public virtual string StackTrace { get { throw null; } } + public virtual System.Exception GetBaseException() { throw null; } + public override string ToString() { throw null; } + } + public partial class FlagsAttribute : System.Attribute + { + public FlagsAttribute() { } + } + public partial class FormatException : System.Exception + { + public FormatException() { } + public FormatException(string message) { } + public FormatException(string message, System.Exception innerException) { } + } + public delegate TResult Func(); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate TResult Func(T arg); + public delegate TResult Func(T1 arg1, T2 arg2); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public static partial class GC + { + public static int MaxGeneration { get { throw null; } } + public static void AddMemoryPressure(long bytesAllocated) { } + public static void Collect() { } + public static void Collect(int generation) { } + public static void Collect(int generation, System.GCCollectionMode mode) { } + public static void Collect(int generation, System.GCCollectionMode mode, bool blocking) { } + public static int CollectionCount(int generation) { throw null; } + public static long GetTotalMemory(bool forceFullCollection) { throw null; } + public static void KeepAlive(object obj) { } + public static void RemoveMemoryPressure(long bytesAllocated) { } + public static void ReRegisterForFinalize(object obj) { } + public static void SuppressFinalize(object obj) { } + public static void WaitForPendingFinalizers() { } + } + public enum GCCollectionMode + { + Default = 0, + Forced = 1, + Optimized = 2, + } + public partial struct Guid : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.Guid Empty; + public Guid(byte[] b) { throw null; } + public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; } + public Guid(int a, short b, short c, byte[] d) { throw null; } + public Guid(string g) { throw null; } + public int CompareTo(System.Guid value) { throw null; } + public bool Equals(System.Guid g) { throw null; } + public override bool Equals(object o) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Guid NewGuid() { throw null; } + public static bool operator ==(System.Guid a, System.Guid b) { throw null; } + public static bool operator !=(System.Guid a, System.Guid b) { throw null; } + public static System.Guid Parse(string input) { throw null; } + public static System.Guid ParseExact(string input, string format) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public byte[] ToByteArray() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string input, out System.Guid result) { throw null; } + public static bool TryParseExact(string input, string format, out System.Guid result) { throw null; } + } + public partial interface IAsyncResult + { + object AsyncState { get; } + System.Threading.WaitHandle AsyncWaitHandle { get; } + bool CompletedSynchronously { get; } + bool IsCompleted { get; } + } + public partial interface IComparable + { + int CompareTo(object obj); + } + public partial interface IComparable + { + int CompareTo(T other); + } + public partial interface ICustomFormatter + { + string Format(string format, object arg, System.IFormatProvider formatProvider); + } + public partial interface IDisposable + { + void Dispose(); + } + public partial interface IEquatable + { + bool Equals(T other); + } + public partial interface IFormatProvider + { + object GetFormat(System.Type formatType); + } + public partial interface IFormattable + { + string ToString(string format, System.IFormatProvider formatProvider); + } + public sealed partial class IndexOutOfRangeException : System.Exception + { + public IndexOutOfRangeException() { } + public IndexOutOfRangeException(string message) { } + public IndexOutOfRangeException(string message, System.Exception innerException) { } + } + public partial struct Int16 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const short MaxValue = (short)32767; + public const short MinValue = (short)-32768; + public int CompareTo(System.Int16 value) { throw null; } + public bool Equals(System.Int16 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int16 Parse(string s) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int16 result) { throw null; } + public static bool TryParse(string s, out System.Int16 result) { throw null; } + } + public partial struct Int32 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const int MaxValue = 2147483647; + public const int MinValue = -2147483648; + public System.Int32 CompareTo(System.Int32 value) { throw null; } + public bool Equals(System.Int32 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override System.Int32 GetHashCode() { throw null; } + public static System.Int32 Parse(string s) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int32 Parse(string s, System.IFormatProvider provider) { throw null; } + System.Int32 System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int32 result) { throw null; } + public static bool TryParse(string s, out System.Int32 result) { throw null; } + } + public partial struct Int64 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const long MaxValue = (long)9223372036854775807; + public const long MinValue = (long)-9223372036854775808; + public int CompareTo(System.Int64 value) { throw null; } + public bool Equals(System.Int64 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int64 Parse(string s) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int64 result) { throw null; } + public static bool TryParse(string s, out System.Int64 result) { throw null; } + } + public partial struct IntPtr + { + public static readonly System.IntPtr Zero; + public IntPtr(int value) { throw null; } + public IntPtr(long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe IntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.IntPtr Add(System.IntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.IntPtr operator +(System.IntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static explicit operator System.IntPtr (int value) { throw null; } + public static explicit operator System.IntPtr (long value) { throw null; } + public static explicit operator int (System.IntPtr value) { throw null; } + public static explicit operator long (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.IntPtr (void* value) { throw null; } + public static bool operator !=(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static System.IntPtr operator -(System.IntPtr pointer, int offset) { throw null; } + public static System.IntPtr Subtract(System.IntPtr pointer, int offset) { throw null; } + public int ToInt32() { throw null; } + public long ToInt64() { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + } + public partial class InvalidCastException : System.Exception + { + public InvalidCastException() { } + public InvalidCastException(string message) { } + public InvalidCastException(string message, System.Exception innerException) { } + public InvalidCastException(string message, int errorCode) { } + } + public partial class InvalidOperationException : System.Exception + { + public InvalidOperationException() { } + public InvalidOperationException(string message) { } + public InvalidOperationException(string message, System.Exception innerException) { } + } + public partial class InvalidTimeZoneException : System.Exception + { + public InvalidTimeZoneException() { } + public InvalidTimeZoneException(string message) { } + public InvalidTimeZoneException(string message, System.Exception innerException) { } + } + public partial interface IObservable + { + System.IDisposable Subscribe(System.IObserver observer); + } + public partial interface IObserver + { + void OnCompleted(); + void OnError(System.Exception error); + void OnNext(T value); + } + public partial interface IProgress + { + void Report(T value); + } + public partial class Lazy + { + public Lazy() { } + public Lazy(bool isThreadSafe) { } + public Lazy(System.Func valueFactory) { } + public Lazy(System.Func valueFactory, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(System.Threading.LazyThreadSafetyMode mode) { } + public bool IsValueCreated { get { throw null; } } + public T Value { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class Lazy : System.Lazy + { + public Lazy(System.Func valueFactory, TMetadata metadata) { } + public Lazy(System.Func valueFactory, TMetadata metadata, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(TMetadata metadata) { } + public Lazy(TMetadata metadata, bool isThreadSafe) { } + public Lazy(TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public TMetadata Metadata { get { throw null; } } + } + public partial class MemberAccessException : System.Exception + { + public MemberAccessException() { } + public MemberAccessException(string message) { } + public MemberAccessException(string message, System.Exception inner) { } + } + public partial class MissingMemberException : System.MemberAccessException + { + public MissingMemberException() { } + public MissingMemberException(string message) { } + public MissingMemberException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public sealed partial class MTAThreadAttribute : System.Attribute + { + public MTAThreadAttribute() { } + } + public abstract partial class MulticastDelegate : System.Delegate + { + internal MulticastDelegate() { } + public sealed override bool Equals(object obj) { throw null; } + public sealed override int GetHashCode() { throw null; } + public sealed override System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + public static bool operator !=(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + } + public partial class NotImplementedException : System.Exception + { + public NotImplementedException() { } + public NotImplementedException(string message) { } + public NotImplementedException(string message, System.Exception inner) { } + } + public partial class NotSupportedException : System.Exception + { + public NotSupportedException() { } + public NotSupportedException(string message) { } + public NotSupportedException(string message, System.Exception innerException) { } + } + public static partial class Nullable + { + public static int Compare(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static bool Equals(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static System.Type GetUnderlyingType(System.Type nullableType) { throw null; } + } + public partial struct Nullable where T : struct + { + public Nullable(T value) { throw null; } + public bool HasValue { get { throw null; } } + public T Value { get { throw null; } } + public override bool Equals(object other) { throw null; } + public override int GetHashCode() { throw null; } + public T GetValueOrDefault() { throw null; } + public T GetValueOrDefault(T defaultValue) { throw null; } + public static explicit operator T (System.Nullable value) { throw null; } + public static implicit operator System.Nullable (T value) { throw null; } + public override string ToString() { throw null; } + } + public partial class NullReferenceException : System.Exception + { + public NullReferenceException() { } + public NullReferenceException(string message) { } + public NullReferenceException(string message, System.Exception innerException) { } + } + public partial class Object + { + public Object() { } + public virtual bool Equals(System.Object obj) { throw null; } + public static bool Equals(System.Object objA, System.Object objB) { throw null; } + ~Object() { } + public virtual int GetHashCode() { throw null; } + public System.Type GetType() { throw null; } + protected System.Object MemberwiseClone() { throw null; } + public static bool ReferenceEquals(System.Object objA, System.Object objB) { throw null; } + public virtual string ToString() { throw null; } + } + public partial class ObjectDisposedException : System.InvalidOperationException + { + public ObjectDisposedException(string objectName) { } + public ObjectDisposedException(string message, System.Exception innerException) { } + public ObjectDisposedException(string objectName, string message) { } + public override string Message { get { throw null; } } + public string ObjectName { get { throw null; } } + } + public sealed partial class ObsoleteAttribute : System.Attribute + { + public ObsoleteAttribute() { } + public ObsoleteAttribute(string message) { } + public ObsoleteAttribute(string message, bool error) { } + public bool IsError { get { throw null; } } + public string Message { get { throw null; } } + } + public partial class OutOfMemoryException : System.Exception + { + public OutOfMemoryException() { } + public OutOfMemoryException(string message) { } + public OutOfMemoryException(string message, System.Exception innerException) { } + } + public partial class OverflowException : System.ArithmeticException + { + public OverflowException() { } + public OverflowException(string message) { } + public OverflowException(string message, System.Exception innerException) { } + } + public sealed partial class ParamArrayAttribute : System.Attribute + { + public ParamArrayAttribute() { } + } + public partial class PlatformNotSupportedException : System.NotSupportedException + { + public PlatformNotSupportedException() { } + public PlatformNotSupportedException(string message) { } + public PlatformNotSupportedException(string message, System.Exception inner) { } + } + public delegate bool Predicate(T obj); + public partial class RankException : System.Exception + { + public RankException() { } + public RankException(string message) { } + public RankException(string message, System.Exception innerException) { } + } + public partial struct RuntimeFieldHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeFieldHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + public static bool operator !=(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + } + public partial struct RuntimeMethodHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeMethodHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + public static bool operator !=(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + } + public partial struct RuntimeTypeHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeTypeHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator ==(System.RuntimeTypeHandle left, object right) { throw null; } + public static bool operator !=(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator !=(System.RuntimeTypeHandle left, object right) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct SByte : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const sbyte MaxValue = (sbyte)127; + public const sbyte MinValue = (sbyte)-128; + public int CompareTo(System.SByte value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.SByte obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.SByte result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.SByte result) { throw null; } + } + public partial struct Single : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const float Epsilon = 1.401298E-45f; + public const float MaxValue = 3.40282347E+38f; + public const float MinValue = -3.40282347E+38f; + public const float NaN = 0.0f / 0.0f; + public const float NegativeInfinity = -1.0f / 0.0f; + public const float PositiveInfinity = 1.0f / 0.0f; + public int CompareTo(System.Single value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Single obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Single f) { throw null; } + public static bool IsNaN(System.Single f) { throw null; } + public static bool IsNegativeInfinity(System.Single f) { throw null; } + public static bool IsPositiveInfinity(System.Single f) { throw null; } + public static bool operator ==(System.Single left, System.Single right) { throw null; } + public static bool operator >(System.Single left, System.Single right) { throw null; } + public static bool operator >=(System.Single left, System.Single right) { throw null; } + public static bool operator !=(System.Single left, System.Single right) { throw null; } + public static bool operator <(System.Single left, System.Single right) { throw null; } + public static bool operator <=(System.Single left, System.Single right) { throw null; } + public static System.Single Parse(string s) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Single Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Single result) { throw null; } + public static bool TryParse(string s, out System.Single result) { throw null; } + } + public sealed partial class STAThreadAttribute : System.Attribute + { + public STAThreadAttribute() { } + } + public sealed partial class String : System.Collections.IEnumerable, System.IComparable, System.IComparable, System.IEquatable + { + public static readonly string Empty; + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value) { } + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value, int startIndex, int length) { } + public String(char c, int count) { } + public String(char[] value) { } + public String(char[] value, int startIndex, int length) { } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } } + public int Length { get { throw null; } } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length, System.StringComparison comparisonType) { throw null; } + public static int Compare(System.String strA, System.String strB) { throw null; } + public static int Compare(System.String strA, System.String strB, System.StringComparison comparisonType) { throw null; } + public static int CompareOrdinal(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int CompareOrdinal(System.String strA, System.String strB) { throw null; } + public int CompareTo(System.String strB) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Concat(object arg0) { throw null; } + public static System.String Concat(object arg0, object arg1) { throw null; } + public static System.String Concat(object arg0, object arg1, object arg2) { throw null; } + public static System.String Concat(params object[] args) { throw null; } + public static System.String Concat(System.String str0, System.String str1) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2, System.String str3) { throw null; } + public static System.String Concat(params string[] values) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public bool Contains(System.String value) { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public bool EndsWith(System.String value) { throw null; } + public bool EndsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.String value) { throw null; } + public static bool Equals(System.String a, System.String b) { throw null; } + public static bool Equals(System.String a, System.String b, System.StringComparison comparisonType) { throw null; } + public bool Equals(System.String value, System.StringComparison comparisonType) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, params object[] args) { throw null; } + public static System.String Format(System.String format, params object[] args) { throw null; } + public override int GetHashCode() { throw null; } + public int IndexOf(char value) { throw null; } + public int IndexOf(char value, int startIndex) { throw null; } + public int IndexOf(char value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value) { throw null; } + public int IndexOf(System.String value, int startIndex) { throw null; } + public int IndexOf(System.String value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int IndexOfAny(char[] anyOf) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public System.String Insert(int startIndex, System.String value) { throw null; } + public static bool IsNullOrEmpty(System.String value) { throw null; } + public static bool IsNullOrWhiteSpace(System.String value) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Join(System.String separator, params object[] values) { throw null; } + public static System.String Join(System.String separator, params string[] value) { throw null; } + public static System.String Join(System.String separator, string[] value, int startIndex, int count) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public int LastIndexOf(char value) { throw null; } + public int LastIndexOf(char value, int startIndex) { throw null; } + public int LastIndexOf(char value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value) { throw null; } + public int LastIndexOf(System.String value, int startIndex) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int LastIndexOfAny(char[] anyOf) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public static bool operator ==(System.String a, System.String b) { throw null; } + public static bool operator !=(System.String a, System.String b) { throw null; } + public System.String PadLeft(int totalWidth) { throw null; } + public System.String PadLeft(int totalWidth, char paddingChar) { throw null; } + public System.String PadRight(int totalWidth) { throw null; } + public System.String PadRight(int totalWidth, char paddingChar) { throw null; } + public System.String Remove(int startIndex) { throw null; } + public System.String Remove(int startIndex, int count) { throw null; } + public System.String Replace(char oldChar, char newChar) { throw null; } + public System.String Replace(System.String oldValue, System.String newValue) { throw null; } + public string[] Split(params char[] separator) { throw null; } + public string[] Split(char[] separator, int count) { throw null; } + public string[] Split(char[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(char[] separator, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, System.StringSplitOptions options) { throw null; } + public bool StartsWith(System.String value) { throw null; } + public bool StartsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public System.String Substring(int startIndex) { throw null; } + public System.String Substring(int startIndex, int length) { throw null; } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public char[] ToCharArray() { throw null; } + public char[] ToCharArray(int startIndex, int length) { throw null; } + public System.String ToLower() { throw null; } + public System.String ToLowerInvariant() { throw null; } + public override System.String ToString() { throw null; } + public System.String ToUpper() { throw null; } + public System.String ToUpperInvariant() { throw null; } + public System.String Trim() { throw null; } + public System.String Trim(params char[] trimChars) { throw null; } + public System.String TrimEnd(params char[] trimChars) { throw null; } + public System.String TrimStart(params char[] trimChars) { throw null; } + } + public enum StringComparison + { + CurrentCulture = 0, + CurrentCultureIgnoreCase = 1, + Ordinal = 4, + OrdinalIgnoreCase = 5, + } + [System.FlagsAttribute] + public enum StringSplitOptions + { + None = 0, + RemoveEmptyEntries = 1, + } + public partial class ThreadStaticAttribute : System.Attribute + { + public ThreadStaticAttribute() { } + } + public partial class TimeoutException : System.Exception + { + public TimeoutException() { } + public TimeoutException(string message) { } + public TimeoutException(string message, System.Exception innerException) { } + } + public partial struct TimeSpan : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.TimeSpan MaxValue; + public static readonly System.TimeSpan MinValue; + public const long TicksPerDay = (long)864000000000; + public const long TicksPerHour = (long)36000000000; + public const long TicksPerMillisecond = (long)10000; + public const long TicksPerMinute = (long)600000000; + public const long TicksPerSecond = (long)10000000; + public static readonly System.TimeSpan Zero; + public TimeSpan(int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds) { throw null; } + public TimeSpan(long ticks) { throw null; } + public int Days { get { throw null; } } + public int Hours { get { throw null; } } + public int Milliseconds { get { throw null; } } + public int Minutes { get { throw null; } } + public int Seconds { get { throw null; } } + public long Ticks { get { throw null; } } + public double TotalDays { get { throw null; } } + public double TotalHours { get { throw null; } } + public double TotalMilliseconds { get { throw null; } } + public double TotalMinutes { get { throw null; } } + public double TotalSeconds { get { throw null; } } + public System.TimeSpan Add(System.TimeSpan ts) { throw null; } + public static int Compare(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public int CompareTo(System.TimeSpan value) { throw null; } + public System.TimeSpan Duration() { throw null; } + public override bool Equals(object value) { throw null; } + public bool Equals(System.TimeSpan obj) { throw null; } + public static bool Equals(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan FromDays(double value) { throw null; } + public static System.TimeSpan FromHours(double value) { throw null; } + public static System.TimeSpan FromMilliseconds(double value) { throw null; } + public static System.TimeSpan FromMinutes(double value) { throw null; } + public static System.TimeSpan FromSeconds(double value) { throw null; } + public static System.TimeSpan FromTicks(long value) { throw null; } + public override int GetHashCode() { throw null; } + public System.TimeSpan Negate() { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator ==(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator !=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t) { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t) { throw null; } + public static System.TimeSpan Parse(string s) { throw null; } + public static System.TimeSpan Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public System.TimeSpan Subtract(System.TimeSpan ts) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParse(string s, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + } + public sealed partial class TimeZoneInfo : System.IEquatable + { + internal TimeZoneInfo() { } + public System.TimeSpan BaseUtcOffset { get { throw null; } } + public string DaylightName { get { throw null; } } + public string DisplayName { get { throw null; } } + public static System.TimeZoneInfo Local { get { throw null; } } + public string StandardName { get { throw null; } } + public bool SupportsDaylightSavingTime { get { throw null; } } + public static System.TimeZoneInfo Utc { get { throw null; } } + public static System.DateTime ConvertTime(System.DateTime dateTime, System.TimeZoneInfo destinationTimeZone) { throw null; } + public static System.DateTimeOffset ConvertTime(System.DateTimeOffset dateTimeOffset, System.TimeZoneInfo destinationTimeZone) { throw null; } + public bool Equals(System.TimeZoneInfo other) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTime dateTime) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTimeOffset dateTimeOffset) { throw null; } + public override int GetHashCode() { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTime dateTime) { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsAmbiguousTime(System.DateTime dateTime) { throw null; } + public bool IsAmbiguousTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsDaylightSavingTime(System.DateTime dateTime) { throw null; } + public bool IsDaylightSavingTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsInvalidTime(System.DateTime dateTime) { throw null; } + public override string ToString() { throw null; } + } + public static partial class Tuple + { + public static System.Tuple Create(T1 item1) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { throw null; } + public static System.Tuple> Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8) { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1) { } + public T1 Item1 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public TRest Rest { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public abstract partial class Type + { + internal Type() { } + public static readonly object Missing; + public abstract string AssemblyQualifiedName { get; } + public abstract System.Type DeclaringType { get; } + public abstract string FullName { get; } + public abstract int GenericParameterPosition { get; } + public abstract System.Type[] GenericTypeArguments { get; } + public bool HasElementType { get { throw null; } } + public bool IsArray { get { throw null; } } + public bool IsByRef { get { throw null; } } + public abstract bool IsConstructedGenericType { get; } + public abstract bool IsGenericParameter { get; } + public bool IsNested { get { throw null; } } + public bool IsPointer { get { throw null; } } + public abstract string Name { get; } + public abstract string Namespace { get; } + public virtual System.RuntimeTypeHandle TypeHandle { get { throw null; } } + public override bool Equals(object o) { throw null; } + public bool Equals(System.Type o) { throw null; } + public abstract int GetArrayRank(); + public abstract System.Type GetElementType(); + public abstract System.Type GetGenericTypeDefinition(); + public override int GetHashCode() { throw null; } + public static System.Type GetType(string typeName) { throw null; } + public static System.Type GetType(string typeName, bool throwOnError) { throw null; } + public static System.Type GetTypeFromHandle(System.RuntimeTypeHandle handle) { throw null; } + public abstract System.Type MakeArrayType(); + public abstract System.Type MakeArrayType(int rank); + public abstract System.Type MakeByRefType(); + public abstract System.Type MakeGenericType(params System.Type[] typeArguments); + public abstract System.Type MakePointerType(); + public override string ToString() { throw null; } + } + public partial class TypeAccessException : System.TypeLoadException + { + public TypeAccessException() { } + public TypeAccessException(string message) { } + public TypeAccessException(string message, System.Exception inner) { } + } + public sealed partial class TypeInitializationException : System.Exception + { + public TypeInitializationException(string fullTypeName, System.Exception innerException) { } + public string TypeName { get { throw null; } } + } + public partial class TypeLoadException : System.Exception + { + public TypeLoadException() { } + public TypeLoadException(string message) { } + public TypeLoadException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + public string TypeName { get { throw null; } } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt16 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const ushort MaxValue = (ushort)65535; + public const ushort MinValue = (ushort)0; + public int CompareTo(System.UInt16 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt16 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt16 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt16 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt32 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const uint MaxValue = (uint)4294967295; + public const uint MinValue = (uint)0; + public int CompareTo(System.UInt32 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt32 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt32 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt32 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt64 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const ulong MaxValue = (ulong)18446744073709551615; + public const ulong MinValue = (ulong)0; + public int CompareTo(System.UInt64 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt64 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt64 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt64 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UIntPtr + { + public static readonly System.UIntPtr Zero; + public UIntPtr(uint value) { throw null; } + public UIntPtr(ulong value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe UIntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.UIntPtr Add(System.UIntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.UIntPtr operator +(System.UIntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static explicit operator System.UIntPtr (uint value) { throw null; } + public static explicit operator System.UIntPtr (ulong value) { throw null; } + public static explicit operator uint (System.UIntPtr value) { throw null; } + public static explicit operator ulong (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.UIntPtr (void* value) { throw null; } + public static bool operator !=(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static System.UIntPtr operator -(System.UIntPtr pointer, int offset) { throw null; } + public static System.UIntPtr Subtract(System.UIntPtr pointer, int offset) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public uint ToUInt32() { throw null; } + public ulong ToUInt64() { throw null; } + } + public partial class UnauthorizedAccessException : System.Exception + { + public UnauthorizedAccessException() { } + public UnauthorizedAccessException(string message) { } + public UnauthorizedAccessException(string message, System.Exception inner) { } + } + public partial class Uri + { + public Uri(string uriString) { } + public Uri(string uriString, System.UriKind uriKind) { } + public Uri(System.Uri baseUri, string relativeUri) { } + public Uri(System.Uri baseUri, System.Uri relativeUri) { } + public string AbsolutePath { get { throw null; } } + public string AbsoluteUri { get { throw null; } } + public string Authority { get { throw null; } } + public string DnsSafeHost { get { throw null; } } + public string Fragment { get { throw null; } } + public string Host { get { throw null; } } + public System.UriHostNameType HostNameType { get { throw null; } } + public bool IsAbsoluteUri { get { throw null; } } + public bool IsDefaultPort { get { throw null; } } + public bool IsFile { get { throw null; } } + public bool IsLoopback { get { throw null; } } + public bool IsUnc { get { throw null; } } + public string LocalPath { get { throw null; } } + public string OriginalString { get { throw null; } } + public string PathAndQuery { get { throw null; } } + public int Port { get { throw null; } } + public string Query { get { throw null; } } + public string Scheme { get { throw null; } } + public string[] Segments { get { throw null; } } + public bool UserEscaped { get { throw null; } } + public string UserInfo { get { throw null; } } + public static System.UriHostNameType CheckHostName(string name) { throw null; } + public static bool CheckSchemeName(string schemeName) { throw null; } + public static int Compare(System.Uri uri1, System.Uri uri2, System.UriComponents partsToCompare, System.UriFormat compareFormat, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object comparand) { throw null; } + public static string EscapeDataString(string stringToEscape) { throw null; } + public static string EscapeUriString(string stringToEscape) { throw null; } + public string GetComponents(System.UriComponents components, System.UriFormat format) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsBaseOf(System.Uri uri) { throw null; } + public bool IsWellFormedOriginalString() { throw null; } + public static bool IsWellFormedUriString(string uriString, System.UriKind uriKind) { throw null; } + public System.Uri MakeRelativeUri(System.Uri uri) { throw null; } + public static bool operator ==(System.Uri uri1, System.Uri uri2) { throw null; } + public static bool operator !=(System.Uri uri1, System.Uri uri2) { throw null; } + public override string ToString() { throw null; } + public static bool TryCreate(string uriString, System.UriKind uriKind, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, string relativeUri, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, System.Uri relativeUri, out System.Uri result) { throw null; } + public static string UnescapeDataString(string stringToUnescape) { throw null; } + } + [System.FlagsAttribute] + public enum UriComponents + { + AbsoluteUri = 127, + Fragment = 64, + Host = 4, + HostAndPort = 132, + HttpRequestUrl = 61, + KeepDelimiter = 1073741824, + NormalizedHost = 256, + Path = 16, + PathAndQuery = 48, + Port = 8, + Query = 32, + Scheme = 1, + SchemeAndServer = 13, + SerializationInfoString = -2147483648, + StrongAuthority = 134, + StrongPort = 128, + UserInfo = 2, + } + public enum UriFormat + { + SafeUnescaped = 3, + Unescaped = 2, + UriEscaped = 1, + } + public enum UriHostNameType + { + Basic = 1, + Dns = 2, + IPv4 = 3, + IPv6 = 4, + Unknown = 0, + } + public enum UriKind + { + Absolute = 1, + Relative = 2, + RelativeOrAbsolute = 0, + } + public abstract partial class ValueType + { + protected ValueType() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public override string ToString() { throw null; } + } + public sealed partial class Version : System.IComparable, System.IComparable, System.IEquatable + { + public Version(int major, int minor) { } + public Version(int major, int minor, int build) { } + public Version(int major, int minor, int build, int revision) { } + public Version(string version) { } + public int Build { get { throw null; } } + public int Major { get { throw null; } } + public short MajorRevision { get { throw null; } } + public int Minor { get { throw null; } } + public short MinorRevision { get { throw null; } } + public int Revision { get { throw null; } } + public int CompareTo(System.Version value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Version obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Version v1, System.Version v2) { throw null; } + public static bool operator >(System.Version v1, System.Version v2) { throw null; } + public static bool operator >=(System.Version v1, System.Version v2) { throw null; } + public static bool operator !=(System.Version v1, System.Version v2) { throw null; } + public static bool operator <(System.Version v1, System.Version v2) { throw null; } + public static bool operator <=(System.Version v1, System.Version v2) { throw null; } + public static System.Version Parse(string input) { throw null; } + int System.IComparable.CompareTo(object version) { throw null; } + public override string ToString() { throw null; } + public string ToString(int fieldCount) { throw null; } + public static bool TryParse(string input, out System.Version result) { throw null; } + } + public partial struct Void + { + } + public partial class WeakReference + { + public WeakReference(object target) { } + public WeakReference(object target, bool trackResurrection) { } + public virtual bool IsAlive { get { throw null; } } + public virtual object Target { get { throw null; } set { } } + public virtual bool TrackResurrection { get { throw null; } } + ~WeakReference() { } + } + public sealed partial class WeakReference where T : class + { + public WeakReference(T target) { } + public WeakReference(T target, bool trackResurrection) { } + ~WeakReference() { } + public void SetTarget(T target) { } + public bool TryGetTarget(out T target) { throw null; } + } +} +namespace System.Collections +{ + public partial struct DictionaryEntry + { + public DictionaryEntry(object key, object value) { throw null; } + public object Key { get { throw null; } set { } } + public object Value { get { throw null; } set { } } + } + public partial interface ICollection : System.Collections.IEnumerable + { + int Count { get; } + bool IsSynchronized { get; } + object SyncRoot { get; } + void CopyTo(System.Array array, int index); + } + public partial interface IComparer + { + int Compare(object x, object y); + } + public partial interface IDictionary : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[object key] { get; set; } + System.Collections.ICollection Keys { get; } + System.Collections.ICollection Values { get; } + void Add(object key, object value); + void Clear(); + bool Contains(object key); + new System.Collections.IDictionaryEnumerator GetEnumerator(); + void Remove(object key); + } + public partial interface IDictionaryEnumerator : System.Collections.IEnumerator + { + System.Collections.DictionaryEntry Entry { get; } + object Key { get; } + object Value { get; } + } + public partial interface IEnumerable + { + System.Collections.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator + { + object Current { get; } + bool MoveNext(); + void Reset(); + } + public partial interface IEqualityComparer + { + bool Equals(object x, object y); + int GetHashCode(object obj); + } + public partial interface IList : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[int index] { get; set; } + int Add(object value); + void Clear(); + bool Contains(object value); + int IndexOf(object value); + void Insert(int index, object value); + void Remove(object value); + void RemoveAt(int index); + } + public partial interface IStructuralComparable + { + int CompareTo(object other, System.Collections.IComparer comparer); + } + public partial interface IStructuralEquatable + { + bool Equals(object other, System.Collections.IEqualityComparer comparer); + int GetHashCode(System.Collections.IEqualityComparer comparer); + } +} +namespace System.Collections.Generic +{ + public partial interface ICollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + bool IsReadOnly { get; } + void Add(T item); + void Clear(); + bool Contains(T item); + void CopyTo(T[] array, int arrayIndex); + bool Remove(T item); + } + public partial interface IComparer + { + int Compare(T x, T y); + } + public partial interface IDictionary : System.Collections.Generic.ICollection>, System.Collections.Generic.IEnumerable>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; set; } + System.Collections.Generic.ICollection Keys { get; } + System.Collections.Generic.ICollection Values { get; } + void Add(TKey key, TValue value); + bool ContainsKey(TKey key); + bool Remove(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IEnumerable : System.Collections.IEnumerable + { + new System.Collections.Generic.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator : System.Collections.IEnumerator, System.IDisposable + { + new T Current { get; } + } + public partial interface IEqualityComparer + { + bool Equals(T x, T y); + int GetHashCode(T obj); + } + public partial interface IList : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + T this[int index] { get; set; } + int IndexOf(T item); + void Insert(int index, T item); + void RemoveAt(int index); + } + public partial interface IReadOnlyCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + } + public partial interface IReadOnlyDictionary : System.Collections.Generic.IEnumerable>, System.Collections.Generic.IReadOnlyCollection>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; } + System.Collections.Generic.IEnumerable Keys { get; } + System.Collections.Generic.IEnumerable Values { get; } + bool ContainsKey(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IReadOnlyList : System.Collections.Generic.IEnumerable, System.Collections.Generic.IReadOnlyCollection, System.Collections.IEnumerable + { + T this[int index] { get; } + } + public partial interface ISet : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + new bool Add(T item); + void ExceptWith(System.Collections.Generic.IEnumerable other); + void IntersectWith(System.Collections.Generic.IEnumerable other); + bool IsProperSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsProperSupersetOf(System.Collections.Generic.IEnumerable other); + bool IsSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsSupersetOf(System.Collections.Generic.IEnumerable other); + bool Overlaps(System.Collections.Generic.IEnumerable other); + bool SetEquals(System.Collections.Generic.IEnumerable other); + void SymmetricExceptWith(System.Collections.Generic.IEnumerable other); + void UnionWith(System.Collections.Generic.IEnumerable other); + } + public partial class KeyNotFoundException : System.Exception + { + public KeyNotFoundException() { } + public KeyNotFoundException(string message) { } + public KeyNotFoundException(string message, System.Exception innerException) { } + } + public partial struct KeyValuePair + { + public KeyValuePair(TKey key, TValue value) { throw null; } + public TKey Key { get { throw null; } } + public TValue Value { get { throw null; } } + public override string ToString() { throw null; } + } +} +namespace System.Collections.ObjectModel +{ + public partial class Collection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public Collection() { } + public Collection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } set { } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public void Add(T item) { } + public void Clear() { } + protected virtual void ClearItems() { } + public bool Contains(T item) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T item) { throw null; } + public void Insert(int index, T item) { } + protected virtual void InsertItem(int index, T item) { } + public bool Remove(T item) { throw null; } + public void RemoveAt(int index) { } + protected virtual void RemoveItem(int index) { } + protected virtual void SetItem(int index, T item) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + } + public partial class ReadOnlyCollection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public ReadOnlyCollection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public bool Contains(T value) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T value) { throw null; } + void System.Collections.Generic.ICollection.Add(T value) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Remove(T value) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T value) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + } +} +namespace System.ComponentModel +{ + public partial class DefaultValueAttribute : System.Attribute + { + public DefaultValueAttribute(bool value) { } + public DefaultValueAttribute(byte value) { } + public DefaultValueAttribute(char value) { } + public DefaultValueAttribute(double value) { } + public DefaultValueAttribute(short value) { } + public DefaultValueAttribute(int value) { } + public DefaultValueAttribute(long value) { } + public DefaultValueAttribute(object value) { } + public DefaultValueAttribute(float value) { } + public DefaultValueAttribute(string value) { } + public DefaultValueAttribute(System.Type type, string value) { } + public virtual object Value { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public sealed partial class EditorBrowsableAttribute : System.Attribute + { + public EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState state) { } + public System.ComponentModel.EditorBrowsableState State { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public enum EditorBrowsableState + { + Advanced = 2, + Always = 0, + Never = 1, + } +} +namespace System.Diagnostics +{ + public sealed partial class ConditionalAttribute : System.Attribute + { + public ConditionalAttribute(string conditionString) { } + public string ConditionString { get { throw null; } } + } + public sealed partial class DebuggableAttribute : System.Attribute + { + public DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes modes) { } + [System.FlagsAttribute] + public enum DebuggingModes + { + Default = 1, + DisableOptimizations = 256, + EnableEditAndContinue = 4, + IgnoreSymbolStoreSequencePoints = 2, + None = 0, + } + } +} +namespace System.Globalization +{ + [System.FlagsAttribute] + public enum DateTimeStyles + { + AdjustToUniversal = 16, + AllowInnerWhite = 4, + AllowLeadingWhite = 1, + AllowTrailingWhite = 2, + AllowWhiteSpaces = 7, + AssumeLocal = 32, + AssumeUniversal = 64, + NoCurrentDateDefault = 8, + None = 0, + RoundtripKind = 128, + } + [System.FlagsAttribute] + public enum NumberStyles + { + AllowCurrencySymbol = 256, + AllowDecimalPoint = 32, + AllowExponent = 128, + AllowHexSpecifier = 512, + AllowLeadingSign = 4, + AllowLeadingWhite = 1, + AllowParentheses = 16, + AllowThousands = 64, + AllowTrailingSign = 8, + AllowTrailingWhite = 2, + Any = 511, + Currency = 383, + Float = 167, + HexNumber = 515, + Integer = 7, + None = 0, + Number = 111, + } + [System.FlagsAttribute] + public enum TimeSpanStyles + { + AssumeNegative = 1, + None = 0, + } +} +namespace System.Reflection +{ + public sealed partial class AssemblyCompanyAttribute : System.Attribute + { + public AssemblyCompanyAttribute(string company) { } + public string Company { get { throw null; } } + } + public sealed partial class AssemblyConfigurationAttribute : System.Attribute + { + public AssemblyConfigurationAttribute(string configuration) { } + public string Configuration { get { throw null; } } + } + public sealed partial class AssemblyCopyrightAttribute : System.Attribute + { + public AssemblyCopyrightAttribute(string copyright) { } + public string Copyright { get { throw null; } } + } + public sealed partial class AssemblyCultureAttribute : System.Attribute + { + public AssemblyCultureAttribute(string culture) { } + public string Culture { get { throw null; } } + } + public sealed partial class AssemblyDefaultAliasAttribute : System.Attribute + { + public AssemblyDefaultAliasAttribute(string defaultAlias) { } + public string DefaultAlias { get { throw null; } } + } + public sealed partial class AssemblyDelaySignAttribute : System.Attribute + { + public AssemblyDelaySignAttribute(bool delaySign) { } + public bool DelaySign { get { throw null; } } + } + public sealed partial class AssemblyDescriptionAttribute : System.Attribute + { + public AssemblyDescriptionAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class AssemblyFileVersionAttribute : System.Attribute + { + public AssemblyFileVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class AssemblyFlagsAttribute : System.Attribute + { + public AssemblyFlagsAttribute(System.Reflection.AssemblyNameFlags assemblyFlags) { } + public int AssemblyFlags { get { throw null; } } + } + public sealed partial class AssemblyInformationalVersionAttribute : System.Attribute + { + public AssemblyInformationalVersionAttribute(string informationalVersion) { } + public string InformationalVersion { get { throw null; } } + } + public sealed partial class AssemblyKeyFileAttribute : System.Attribute + { + public AssemblyKeyFileAttribute(string keyFile) { } + public string KeyFile { get { throw null; } } + } + public sealed partial class AssemblyKeyNameAttribute : System.Attribute + { + public AssemblyKeyNameAttribute(string keyName) { } + public string KeyName { get { throw null; } } + } + public sealed partial class AssemblyMetadataAttribute : System.Attribute + { + public AssemblyMetadataAttribute(string key, string value) { } + public string Key { get { throw null; } } + public string Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum AssemblyNameFlags + { + None = 0, + PublicKey = 1, + Retargetable = 256, + } + public sealed partial class AssemblyProductAttribute : System.Attribute + { + public AssemblyProductAttribute(string product) { } + public string Product { get { throw null; } } + } + public sealed partial class AssemblySignatureKeyAttribute : System.Attribute + { + public AssemblySignatureKeyAttribute(string publicKey, string countersignature) { } + public string Countersignature { get { throw null; } } + public string PublicKey { get { throw null; } } + } + public sealed partial class AssemblyTitleAttribute : System.Attribute + { + public AssemblyTitleAttribute(string title) { } + public string Title { get { throw null; } } + } + public sealed partial class AssemblyTrademarkAttribute : System.Attribute + { + public AssemblyTrademarkAttribute(string trademark) { } + public string Trademark { get { throw null; } } + } + public sealed partial class AssemblyVersionAttribute : System.Attribute + { + public AssemblyVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class DefaultMemberAttribute : System.Attribute + { + public DefaultMemberAttribute(string memberName) { } + public string MemberName { get { throw null; } } + } +} +namespace System.Runtime +{ + public enum GCLatencyMode + { + Batch = 0, + Interactive = 1, + LowLatency = 2, + SustainedLowLatency = 3, + } + public static partial class GCSettings + { + public static bool IsServerGC { get { throw null; } } + public static System.Runtime.GCLatencyMode LatencyMode { get { throw null; } set { } } + } +} +namespace System.Runtime.CompilerServices +{ + public sealed partial class AccessedThroughPropertyAttribute : System.Attribute + { + public AccessedThroughPropertyAttribute(string propertyName) { } + public string PropertyName { get { throw null; } } + } + public sealed partial class AsyncStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public AsyncStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class CallerFilePathAttribute : System.Attribute + { + public CallerFilePathAttribute() { } + } + public sealed partial class CallerLineNumberAttribute : System.Attribute + { + public CallerLineNumberAttribute() { } + } + public sealed partial class CallerMemberNameAttribute : System.Attribute + { + public CallerMemberNameAttribute() { } + } + public partial class CompilationRelaxationsAttribute : System.Attribute + { + public CompilationRelaxationsAttribute(int relaxations) { } + public int CompilationRelaxations { get { throw null; } } + } + public sealed partial class CompilerGeneratedAttribute : System.Attribute + { + public CompilerGeneratedAttribute() { } + } + public abstract partial class CustomConstantAttribute : System.Attribute + { + protected CustomConstantAttribute() { } + public abstract object Value { get; } + } + public sealed partial class DateTimeConstantAttribute : System.Runtime.CompilerServices.CustomConstantAttribute + { + public DateTimeConstantAttribute(long ticks) { } + public override object Value { get { throw null; } } + } + public sealed partial class DecimalConstantAttribute : System.Attribute + { + public DecimalConstantAttribute(byte scale, byte sign, int hi, int mid, int low) { } + [System.CLSCompliantAttribute(false)] + public DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low) { } + public decimal Value { get { throw null; } } + } + public sealed partial class ExtensionAttribute : System.Attribute + { + public ExtensionAttribute() { } + } + public sealed partial class FixedBufferAttribute : System.Attribute + { + public FixedBufferAttribute(System.Type elementType, int length) { } + public System.Type ElementType { get { throw null; } } + public int Length { get { throw null; } } + } + public sealed partial class IndexerNameAttribute : System.Attribute + { + public IndexerNameAttribute(string indexerName) { } + } + public sealed partial class InternalsVisibleToAttribute : System.Attribute + { + public InternalsVisibleToAttribute(string assemblyName) { } + public string AssemblyName { get { throw null; } } + } + public partial interface IStrongBox + { + object Value { get; set; } + } + public static partial class IsVolatile + { + } + public sealed partial class IteratorStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public IteratorStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class MethodImplAttribute : System.Attribute + { + public MethodImplAttribute(System.Runtime.CompilerServices.MethodImplOptions methodImplOptions) { } + public System.Runtime.CompilerServices.MethodImplOptions Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum MethodImplOptions + { + AggressiveInlining = 256, + NoInlining = 8, + NoOptimization = 64, + PreserveSig = 128, + } + public sealed partial class ReferenceAssemblyAttribute : System.Attribute + { + public ReferenceAssemblyAttribute() { } + public ReferenceAssemblyAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class RuntimeCompatibilityAttribute : System.Attribute + { + public RuntimeCompatibilityAttribute() { } + public bool WrapNonExceptionThrows { get { throw null; } set { } } + } + public static partial class RuntimeHelpers + { + public static int OffsetToStringData { get { throw null; } } + public static int GetHashCode(object o) { throw null; } + public static object GetObjectValue(object obj) { throw null; } + public static void InitializeArray(System.Array array, System.RuntimeFieldHandle fldHandle) { } + public static void RunClassConstructor(System.RuntimeTypeHandle type) { } + } + public partial class StateMachineAttribute : System.Attribute + { + public StateMachineAttribute(System.Type stateMachineType) { } + public System.Type StateMachineType { get { throw null; } } + } + public partial class StrongBox : System.Runtime.CompilerServices.IStrongBox + { + public T Value; + public StrongBox() { } + public StrongBox(T value) { } + object System.Runtime.CompilerServices.IStrongBox.Value { get { throw null; } set { } } + } + public sealed partial class TypeForwardedFromAttribute : System.Attribute + { + public TypeForwardedFromAttribute(string assemblyFullName) { } + public string AssemblyFullName { get { throw null; } } + } + public sealed partial class TypeForwardedToAttribute : System.Attribute + { + public TypeForwardedToAttribute(System.Type destination) { } + public System.Type Destination { get { throw null; } } + } + public sealed partial class UnsafeValueTypeAttribute : System.Attribute + { + public UnsafeValueTypeAttribute() { } + } +} +namespace System.Runtime.ExceptionServices +{ + public sealed partial class ExceptionDispatchInfo + { + internal ExceptionDispatchInfo() { } + public System.Exception SourceException { get { throw null; } } + public static System.Runtime.ExceptionServices.ExceptionDispatchInfo Capture(System.Exception source) { throw null; } + public void Throw() { } + } +} +namespace System.Runtime.InteropServices +{ + public enum CharSet + { + Ansi = 2, + Unicode = 3, + } + public sealed partial class ComVisibleAttribute : System.Attribute + { + public ComVisibleAttribute(bool visibility) { } + public bool Value { get { throw null; } } + } + public sealed partial class FieldOffsetAttribute : System.Attribute + { + public FieldOffsetAttribute(int offset) { } + public int Value { get { throw null; } } + } + public enum LayoutKind + { + Auto = 3, + Explicit = 2, + Sequential = 0, + } + public sealed partial class OutAttribute : System.Attribute + { + public OutAttribute() { } + } + public sealed partial class StructLayoutAttribute : System.Attribute + { + public System.Runtime.InteropServices.CharSet CharSet; + public int Pack; + public int Size; + public StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind layoutKind) { } + public System.Runtime.InteropServices.LayoutKind Value { get { throw null; } } + } +} +namespace System.Runtime.Versioning +{ + public sealed partial class TargetFrameworkAttribute : System.Attribute + { + public TargetFrameworkAttribute(string frameworkName) { } + public string FrameworkDisplayName { get { throw null; } set { } } + public string FrameworkName { get { throw null; } } + } +} +namespace System.Security +{ + public sealed partial class AllowPartiallyTrustedCallersAttribute : System.Attribute + { + public AllowPartiallyTrustedCallersAttribute() { } + } + public sealed partial class SecurityCriticalAttribute : System.Attribute + { + public SecurityCriticalAttribute() { } + } + public partial class SecurityException : System.Exception + { + public SecurityException() { } + public SecurityException(string message) { } + public SecurityException(string message, System.Exception inner) { } + public override string ToString() { throw null; } + } + public sealed partial class SecuritySafeCriticalAttribute : System.Attribute + { + public SecuritySafeCriticalAttribute() { } + } + public sealed partial class SecurityTransparentAttribute : System.Attribute + { + public SecurityTransparentAttribute() { } + } + public partial class VerificationException : System.Exception + { + public VerificationException() { } + public VerificationException(string message) { } + public VerificationException(string message, System.Exception innerException) { } + } +} +namespace System.Text +{ + public sealed partial class StringBuilder + { + public StringBuilder() { } + public StringBuilder(int capacity) { } + public StringBuilder(int capacity, int maxCapacity) { } + public StringBuilder(string value) { } + public StringBuilder(string value, int capacity) { } + public StringBuilder(string value, int startIndex, int length, int capacity) { } + public int Capacity { get { throw null; } set { } } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } set { } } + public int Length { get { throw null; } set { } } + public int MaxCapacity { get { throw null; } } + public System.Text.StringBuilder Append(bool value) { throw null; } + public System.Text.StringBuilder Append(byte value) { throw null; } + public System.Text.StringBuilder Append(char value) { throw null; } + public System.Text.StringBuilder Append(char value, int repeatCount) { throw null; } + public System.Text.StringBuilder Append(char[] value) { throw null; } + public System.Text.StringBuilder Append(char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Append(decimal value) { throw null; } + public System.Text.StringBuilder Append(double value) { throw null; } + public System.Text.StringBuilder Append(short value) { throw null; } + public System.Text.StringBuilder Append(int value) { throw null; } + public System.Text.StringBuilder Append(long value) { throw null; } + public System.Text.StringBuilder Append(object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(sbyte value) { throw null; } + public System.Text.StringBuilder Append(float value) { throw null; } + public System.Text.StringBuilder Append(string value) { throw null; } + public System.Text.StringBuilder Append(string value, int startIndex, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ulong value) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendLine() { throw null; } + public System.Text.StringBuilder AppendLine(string value) { throw null; } + public System.Text.StringBuilder Clear() { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public int EnsureCapacity(int capacity) { throw null; } + public bool Equals(System.Text.StringBuilder sb) { throw null; } + public System.Text.StringBuilder Insert(int index, bool value) { throw null; } + public System.Text.StringBuilder Insert(int index, byte value) { throw null; } + public System.Text.StringBuilder Insert(int index, char value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Insert(int index, decimal value) { throw null; } + public System.Text.StringBuilder Insert(int index, double value) { throw null; } + public System.Text.StringBuilder Insert(int index, short value) { throw null; } + public System.Text.StringBuilder Insert(int index, int value) { throw null; } + public System.Text.StringBuilder Insert(int index, long value) { throw null; } + public System.Text.StringBuilder Insert(int index, object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, sbyte value) { throw null; } + public System.Text.StringBuilder Insert(int index, float value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ulong value) { throw null; } + public System.Text.StringBuilder Remove(int startIndex, int length) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar, int startIndex, int count) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue, int startIndex, int count) { throw null; } + public override string ToString() { throw null; } + public string ToString(int startIndex, int length) { throw null; } + } +} +namespace System.Threading +{ + public enum LazyThreadSafetyMode + { + ExecutionAndPublication = 2, + None = 0, + PublicationOnly = 1, + } + public static partial class Timeout + { + public const int Infinite = -1; + public static readonly System.TimeSpan InfiniteTimeSpan; + } + public abstract partial class WaitHandle : System.IDisposable + { + protected static readonly System.IntPtr InvalidHandle; + public const int WaitTimeout = 258; + protected WaitHandle() { } + public void Dispose() { } + protected virtual void Dispose(bool explicitDisposing) { } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public virtual bool WaitOne() { throw null; } + public virtual bool WaitOne(int millisecondsTimeout) { throw null; } + public virtual bool WaitOne(System.TimeSpan timeout) { throw null; } + } +} diff --git a/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.2/System.Runtime.cs b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.2/System.Runtime.cs new file mode 100644 index 0000000000..645aae791d --- /dev/null +++ b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.2/System.Runtime.cs @@ -0,0 +1,2672 @@ +// 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.Runtime")] +[assembly: AssemblyDescription("System.Runtime")] +[assembly: AssemblyDefaultAlias("System.Runtime")] +[assembly: AssemblyCompany("Microsoft Corporation")] +[assembly: AssemblyProduct("Microsoft® .NET Framework")] +[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: AssemblyFileVersion("4.0.40013.0")] +[assembly: AssemblyInformationalVersion("4.0.40013.0 built by: SOURCEBUILD")] +[assembly: CLSCompliant(true)] +[assembly: AssemblyMetadata("", "")] +[assembly: AssemblyVersion("4.0.10.0")] + + + + +namespace System +{ + public delegate void Action(); + public delegate void Action(T obj); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate void Action(T1 arg1, T2 arg2); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public static partial class Activator + { + public static object CreateInstance(System.Type type) { throw null; } + public static object CreateInstance(System.Type type, params object[] args) { throw null; } + public static T CreateInstance() { throw null; } + } + public partial class ArgumentException : System.Exception + { + public ArgumentException() { } + public ArgumentException(string message) { } + public ArgumentException(string message, System.Exception innerException) { } + public ArgumentException(string message, string paramName) { } + public ArgumentException(string message, string paramName, System.Exception innerException) { } + public override string Message { get { throw null; } } + public virtual string ParamName { get { throw null; } } + } + public partial class ArgumentNullException : System.ArgumentException + { + public ArgumentNullException() { } + public ArgumentNullException(string paramName) { } + public ArgumentNullException(string message, System.Exception innerException) { } + public ArgumentNullException(string paramName, string message) { } + } + public partial class ArgumentOutOfRangeException : System.ArgumentException + { + public ArgumentOutOfRangeException() { } + public ArgumentOutOfRangeException(string paramName) { } + public ArgumentOutOfRangeException(string message, System.Exception innerException) { } + public ArgumentOutOfRangeException(string paramName, object actualValue, string message) { } + public ArgumentOutOfRangeException(string paramName, string message) { } + public virtual object ActualValue { get { throw null; } } + public override string Message { get { throw null; } } + } + public partial class ArithmeticException : System.Exception + { + public ArithmeticException() { } + public ArithmeticException(string message) { } + public ArithmeticException(string message, System.Exception innerException) { } + } + public abstract partial class Array : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable + { + internal Array() { } + public int Length { get { throw null; } } + public int Rank { get { throw null; } } + int System.Collections.ICollection.Count { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public static int BinarySearch(System.Array array, int index, int length, object value) { throw null; } + public static int BinarySearch(System.Array array, int index, int length, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(System.Array array, object value) { throw null; } + public static int BinarySearch(System.Array array, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, T value) { throw null; } + public static int BinarySearch(T[] array, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static void Clear(System.Array array, int index, int length) { } + public object Clone() { throw null; } + public static void ConstrainedCopy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public static void Copy(System.Array sourceArray, System.Array destinationArray, int length) { } + public static void Copy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public void CopyTo(System.Array array, int index) { } + public static System.Array CreateInstance(System.Type elementType, params int[] lengths) { throw null; } + public static System.Array CreateInstance(System.Type elementType, int[] lengths, int[] lowerBounds) { throw null; } + public static bool Exists(T[] array, System.Predicate match) { throw null; } + public static T[] FindAll(T[] array, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, System.Predicate match) { throw null; } + public static T FindLast(T[] array, System.Predicate match) { throw null; } + public static T Find(T[] array, System.Predicate match) { throw null; } + public System.Collections.IEnumerator GetEnumerator() { throw null; } + public int GetLength(int dimension) { throw null; } + public int GetLowerBound(int dimension) { throw null; } + public int GetUpperBound(int dimension) { throw null; } + public object GetValue(params int[] indices) { throw null; } + public static int IndexOf(System.Array array, object value) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int IndexOf(T[] array, T value) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public void Initialize() { } + public static int LastIndexOf(System.Array array, object value) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int LastIndexOf(T[] array, T value) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public static void Resize(ref T[] array, int newSize) { } + public static void Reverse(System.Array array) { } + public static void Reverse(System.Array array, int index, int length) { } + public void SetValue(object value, params int[] indices) { } + public static void Sort(System.Array array) { } + public static void Sort(System.Array array, System.Collections.IComparer comparer) { } + public static void Sort(System.Array array, int index, int length) { } + public static void Sort(System.Array array, int index, int length, System.Collections.IComparer comparer) { } + public static void Sort(T[] array) { } + public static void Sort(T[] array, System.Collections.Generic.IComparer comparer) { } + public static void Sort(T[] array, System.Comparison comparison) { } + public static void Sort(T[] array, int index, int length) { } + public static void Sort(T[] array, int index, int length, System.Collections.Generic.IComparer comparer) { } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + public static bool TrueForAll(T[] array, System.Predicate match) { throw null; } + } + public partial struct ArraySegment : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.IEnumerable + { + public ArraySegment(T[] array) { throw null; } + public ArraySegment(T[] array, int offset, int count) { throw null; } + public T[] Array { get { throw null; } } + public int Count { get { throw null; } } + public int Offset { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + T System.Collections.Generic.IReadOnlyList.this[int index] { get { throw null; } } + public bool Equals(System.ArraySegment obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.ArraySegment a, System.ArraySegment b) { throw null; } + public static bool operator !=(System.ArraySegment a, System.ArraySegment b) { throw null; } + void System.Collections.Generic.ICollection.Add(T item) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Contains(T item) { throw null; } + void System.Collections.Generic.ICollection.CopyTo(T[] array, int arrayIndex) { } + bool System.Collections.Generic.ICollection.Remove(T item) { throw null; } + System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.Generic.IList.IndexOf(T item) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T item) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + } + public partial class ArrayTypeMismatchException : System.Exception + { + public ArrayTypeMismatchException() { } + public ArrayTypeMismatchException(string message) { } + public ArrayTypeMismatchException(string message, System.Exception innerException) { } + } + public delegate void AsyncCallback(System.IAsyncResult ar); + public abstract partial class Attribute + { + protected Attribute() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + [System.FlagsAttribute] + public enum AttributeTargets + { + All = 32767, + Assembly = 1, + Class = 4, + Constructor = 32, + Delegate = 4096, + Enum = 16, + Event = 512, + Field = 256, + GenericParameter = 16384, + Interface = 1024, + Method = 64, + Module = 2, + Parameter = 2048, + Property = 128, + ReturnValue = 8192, + Struct = 8, + } + public sealed partial class AttributeUsageAttribute : System.Attribute + { + public AttributeUsageAttribute(System.AttributeTargets validOn) { } + public bool AllowMultiple { get { throw null; } set { } } + public bool Inherited { get { throw null; } set { } } + public System.AttributeTargets ValidOn { get { throw null; } } + } + public partial class BadImageFormatException : System.Exception + { + public BadImageFormatException() { } + public BadImageFormatException(string message) { } + public BadImageFormatException(string message, System.Exception inner) { } + public BadImageFormatException(string message, string fileName) { } + public BadImageFormatException(string message, string fileName, System.Exception inner) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial struct Boolean : System.IComparable, System.IComparable, System.IEquatable + { + public static readonly string FalseString; + public static readonly string TrueString; + public int CompareTo(System.Boolean value) { throw null; } + public System.Boolean Equals(System.Boolean obj) { throw null; } + public override System.Boolean Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Boolean Parse(string value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + public static System.Boolean TryParse(string value, out System.Boolean result) { throw null; } + } + public static partial class Buffer + { + public static void BlockCopy(System.Array src, int srcOffset, System.Array dst, int dstOffset, int count) { } + public static int ByteLength(System.Array array) { throw null; } + public static byte GetByte(System.Array array, int index) { throw null; } + public static void SetByte(System.Array array, int index, byte value) { } + } + public partial struct Byte : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const byte MaxValue = (byte)255; + public const byte MinValue = (byte)0; + public int CompareTo(System.Byte value) { throw null; } + public bool Equals(System.Byte obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Byte Parse(string s) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Byte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Byte result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Byte result) { throw null; } + } + public partial struct Char : System.IComparable, System.IComparable, System.IEquatable + { + public const char MaxValue = '\uFFFF'; + public const char MinValue = '\0'; + public int CompareTo(System.Char value) { throw null; } + public static string ConvertFromUtf32(int utf32) { throw null; } + public static int ConvertToUtf32(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static int ConvertToUtf32(string s, int index) { throw null; } + public bool Equals(System.Char obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static double GetNumericValue(System.Char c) { throw null; } + public static double GetNumericValue(string s, int index) { throw null; } + public static bool IsControl(System.Char c) { throw null; } + public static bool IsControl(string s, int index) { throw null; } + public static bool IsDigit(System.Char c) { throw null; } + public static bool IsDigit(string s, int index) { throw null; } + public static bool IsHighSurrogate(System.Char c) { throw null; } + public static bool IsHighSurrogate(string s, int index) { throw null; } + public static bool IsLetter(System.Char c) { throw null; } + public static bool IsLetter(string s, int index) { throw null; } + public static bool IsLetterOrDigit(System.Char c) { throw null; } + public static bool IsLetterOrDigit(string s, int index) { throw null; } + public static bool IsLower(System.Char c) { throw null; } + public static bool IsLower(string s, int index) { throw null; } + public static bool IsLowSurrogate(System.Char c) { throw null; } + public static bool IsLowSurrogate(string s, int index) { throw null; } + public static bool IsNumber(System.Char c) { throw null; } + public static bool IsNumber(string s, int index) { throw null; } + public static bool IsPunctuation(System.Char c) { throw null; } + public static bool IsPunctuation(string s, int index) { throw null; } + public static bool IsSeparator(System.Char c) { throw null; } + public static bool IsSeparator(string s, int index) { throw null; } + public static bool IsSurrogate(System.Char c) { throw null; } + public static bool IsSurrogate(string s, int index) { throw null; } + public static bool IsSurrogatePair(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static bool IsSurrogatePair(string s, int index) { throw null; } + public static bool IsSymbol(System.Char c) { throw null; } + public static bool IsSymbol(string s, int index) { throw null; } + public static bool IsUpper(System.Char c) { throw null; } + public static bool IsUpper(string s, int index) { throw null; } + public static bool IsWhiteSpace(System.Char c) { throw null; } + public static bool IsWhiteSpace(string s, int index) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public static System.Char ToLower(System.Char c) { throw null; } + public static System.Char ToLowerInvariant(System.Char c) { throw null; } + public override string ToString() { throw null; } + public static string ToString(System.Char c) { throw null; } + public static System.Char ToUpper(System.Char c) { throw null; } + public static System.Char ToUpperInvariant(System.Char c) { throw null; } + public static bool TryParse(string s, out System.Char result) { throw null; } + } + public sealed partial class CLSCompliantAttribute : System.Attribute + { + public CLSCompliantAttribute(bool isCompliant) { } + public bool IsCompliant { get { throw null; } } + } + public delegate int Comparison(T x, T y); + public partial struct DateTime : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.DateTime MaxValue; + public static readonly System.DateTime MinValue; + public DateTime(int year, int month, int day) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, System.DateTimeKind kind) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System.DateTimeKind kind) { throw null; } + public DateTime(long ticks) { throw null; } + public DateTime(long ticks, System.DateTimeKind kind) { throw null; } + public System.DateTime Date { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTimeKind Kind { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTime Now { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public static System.DateTime Today { get { throw null; } } + public static System.DateTime UtcNow { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTime Add(System.TimeSpan value) { throw null; } + public System.DateTime AddDays(double value) { throw null; } + public System.DateTime AddHours(double value) { throw null; } + public System.DateTime AddMilliseconds(double value) { throw null; } + public System.DateTime AddMinutes(double value) { throw null; } + public System.DateTime AddMonths(int months) { throw null; } + public System.DateTime AddSeconds(double value) { throw null; } + public System.DateTime AddTicks(long value) { throw null; } + public System.DateTime AddYears(int value) { throw null; } + public static int Compare(System.DateTime t1, System.DateTime t2) { throw null; } + public int CompareTo(System.DateTime value) { throw null; } + public static int DaysInMonth(int year, int month) { throw null; } + public bool Equals(System.DateTime value) { throw null; } + public static bool Equals(System.DateTime t1, System.DateTime t2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.DateTime FromBinary(long dateData) { throw null; } + public static System.DateTime FromFileTime(long fileTime) { throw null; } + public static System.DateTime FromFileTimeUtc(long fileTime) { throw null; } + public string[] GetDateTimeFormats() { throw null; } + public string[] GetDateTimeFormats(char format) { throw null; } + public string[] GetDateTimeFormats(char format, System.IFormatProvider provider) { throw null; } + public string[] GetDateTimeFormats(System.IFormatProvider provider) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsDaylightSavingTime() { throw null; } + public static bool IsLeapYear(int year) { throw null; } + public static System.DateTime operator +(System.DateTime d, System.TimeSpan t) { throw null; } + public static bool operator ==(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator >(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator >=(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator !=(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator <(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator <=(System.DateTime t1, System.DateTime t2) { throw null; } + public static System.TimeSpan operator -(System.DateTime d1, System.DateTime d2) { throw null; } + public static System.DateTime operator -(System.DateTime d, System.TimeSpan t) { throw null; } + public static System.DateTime Parse(string s) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime ParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime SpecifyKind(System.DateTime value, System.DateTimeKind kind) { throw null; } + public System.TimeSpan Subtract(System.DateTime value) { throw null; } + public System.DateTime Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public long ToBinary() { throw null; } + public long ToFileTime() { throw null; } + public long ToFileTimeUtc() { throw null; } + public System.DateTime ToLocalTime() { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public System.DateTime ToUniversalTime() { throw null; } + public static bool TryParse(string s, out System.DateTime result) { throw null; } + public static bool TryParse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + } + public enum DateTimeKind + { + Local = 2, + Unspecified = 0, + Utc = 1, + } + public partial struct DateTimeOffset : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.DateTimeOffset MaxValue; + public static readonly System.DateTimeOffset MinValue; + public DateTimeOffset(System.DateTime dateTime) { throw null; } + public DateTimeOffset(System.DateTime dateTime, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, System.TimeSpan offset) { throw null; } + public DateTimeOffset(long ticks, System.TimeSpan offset) { throw null; } + public System.DateTime Date { get { throw null; } } + public System.DateTime DateTime { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTime LocalDateTime { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTimeOffset Now { get { throw null; } } + public System.TimeSpan Offset { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public System.DateTime UtcDateTime { get { throw null; } } + public static System.DateTimeOffset UtcNow { get { throw null; } } + public long UtcTicks { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTimeOffset Add(System.TimeSpan timeSpan) { throw null; } + public System.DateTimeOffset AddDays(double days) { throw null; } + public System.DateTimeOffset AddHours(double hours) { throw null; } + public System.DateTimeOffset AddMilliseconds(double milliseconds) { throw null; } + public System.DateTimeOffset AddMinutes(double minutes) { throw null; } + public System.DateTimeOffset AddMonths(int months) { throw null; } + public System.DateTimeOffset AddSeconds(double seconds) { throw null; } + public System.DateTimeOffset AddTicks(long ticks) { throw null; } + public System.DateTimeOffset AddYears(int years) { throw null; } + public static int Compare(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public int CompareTo(System.DateTimeOffset other) { throw null; } + public bool Equals(System.DateTimeOffset other) { throw null; } + public static bool Equals(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool EqualsExact(System.DateTimeOffset other) { throw null; } + public static System.DateTimeOffset FromFileTime(long fileTime) { throw null; } + public override int GetHashCode() { throw null; } + public static System.DateTimeOffset operator +(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static bool operator ==(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static implicit operator System.DateTimeOffset (System.DateTime dateTime) { throw null; } + public static bool operator !=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.TimeSpan operator -(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.DateTimeOffset operator -(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static System.DateTimeOffset Parse(string input) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public System.TimeSpan Subtract(System.DateTimeOffset value) { throw null; } + public System.DateTimeOffset Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public long ToFileTime() { throw null; } + public System.DateTimeOffset ToLocalTime() { throw null; } + public System.DateTimeOffset ToOffset(System.TimeSpan offset) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider formatProvider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public System.DateTimeOffset ToUniversalTime() { throw null; } + public static bool TryParse(string input, out System.DateTimeOffset result) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + } + public enum DayOfWeek + { + Friday = 5, + Monday = 1, + Saturday = 6, + Sunday = 0, + Thursday = 4, + Tuesday = 2, + Wednesday = 3, + } + public partial struct Decimal : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MaxValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)0, (uint)0, (uint)1)] + public static readonly decimal MinusOne; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MinValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)1)] + public static readonly decimal One; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)0)] + public static readonly decimal Zero; + public Decimal(double value) { throw null; } + public Decimal(int value) { throw null; } + public Decimal(int lo, int mid, int hi, bool isNegative, byte scale) { throw null; } + public Decimal(int[] bits) { throw null; } + public Decimal(long value) { throw null; } + public Decimal(float value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(ulong value) { throw null; } + public static System.Decimal Add(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Ceiling(System.Decimal d) { throw null; } + public static int Compare(System.Decimal d1, System.Decimal d2) { throw null; } + public int CompareTo(System.Decimal value) { throw null; } + public static System.Decimal Divide(System.Decimal d1, System.Decimal d2) { throw null; } + public bool Equals(System.Decimal value) { throw null; } + public static bool Equals(System.Decimal d1, System.Decimal d2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.Decimal Floor(System.Decimal d) { throw null; } + public static int[] GetBits(System.Decimal d) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Decimal Multiply(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Negate(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator --(System.Decimal d) { throw null; } + public static System.Decimal operator /(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator ==(System.Decimal d1, System.Decimal d2) { throw null; } + public static explicit operator byte (System.Decimal value) { throw null; } + public static explicit operator char (System.Decimal value) { throw null; } + public static explicit operator double (System.Decimal value) { throw null; } + public static explicit operator short (System.Decimal value) { throw null; } + public static explicit operator int (System.Decimal value) { throw null; } + public static explicit operator long (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator sbyte (System.Decimal value) { throw null; } + public static explicit operator float (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ushort (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator uint (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ulong (System.Decimal value) { throw null; } + public static explicit operator System.Decimal (double value) { throw null; } + public static explicit operator System.Decimal (float value) { throw null; } + public static bool operator >(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator >=(System.Decimal d1, System.Decimal d2) { throw null; } + public static implicit operator System.Decimal (byte value) { throw null; } + public static implicit operator System.Decimal (char value) { throw null; } + public static implicit operator System.Decimal (short value) { throw null; } + public static implicit operator System.Decimal (int value) { throw null; } + public static implicit operator System.Decimal (long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (sbyte value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ulong value) { throw null; } + public static System.Decimal operator ++(System.Decimal d) { throw null; } + public static bool operator !=(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <=(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator %(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator *(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d) { throw null; } + public static System.Decimal Parse(string s) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Decimal Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.Decimal Remainder(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Subtract(System.Decimal d1, System.Decimal d2) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public static byte ToByte(System.Decimal value) { throw null; } + public static double ToDouble(System.Decimal d) { throw null; } + public static short ToInt16(System.Decimal value) { throw null; } + public static int ToInt32(System.Decimal d) { throw null; } + public static long ToInt64(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static sbyte ToSByte(System.Decimal value) { throw null; } + public static float ToSingle(System.Decimal d) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ushort ToUInt16(System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static uint ToUInt32(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ulong ToUInt64(System.Decimal d) { throw null; } + public static System.Decimal Truncate(System.Decimal d) { throw null; } + public static bool TryParse(string s, out System.Decimal result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Decimal result) { throw null; } + } + public abstract partial class Delegate + { + internal Delegate() { } + public object Target { get { throw null; } } + public static System.Delegate Combine(System.Delegate a, System.Delegate b) { throw null; } + public static System.Delegate Combine(params System.Delegate[] delegates) { throw null; } + public object DynamicInvoke(params object[] args) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public virtual System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.Delegate d1, System.Delegate d2) { throw null; } + public static bool operator !=(System.Delegate d1, System.Delegate d2) { throw null; } + public static System.Delegate Remove(System.Delegate source, System.Delegate value) { throw null; } + public static System.Delegate RemoveAll(System.Delegate source, System.Delegate value) { throw null; } + } + public partial class DivideByZeroException : System.ArithmeticException + { + public DivideByZeroException() { } + public DivideByZeroException(string message) { } + public DivideByZeroException(string message, System.Exception innerException) { } + } + public partial struct Double : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const double Epsilon = 4.94065645841247E-324; + public const double MaxValue = 1.7976931348623157E+308; + public const double MinValue = -1.7976931348623157E+308; + public const double NaN = 0.0 / 0.0; + public const double NegativeInfinity = -1.0 / 0.0; + public const double PositiveInfinity = 1.0 / 0.0; + public int CompareTo(System.Double value) { throw null; } + public bool Equals(System.Double obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Double d) { throw null; } + public static bool IsNaN(System.Double d) { throw null; } + public static bool IsNegativeInfinity(System.Double d) { throw null; } + public static bool IsPositiveInfinity(System.Double d) { throw null; } + public static bool operator ==(System.Double left, System.Double right) { throw null; } + public static bool operator >(System.Double left, System.Double right) { throw null; } + public static bool operator >=(System.Double left, System.Double right) { throw null; } + public static bool operator !=(System.Double left, System.Double right) { throw null; } + public static bool operator <(System.Double left, System.Double right) { throw null; } + public static bool operator <=(System.Double left, System.Double right) { throw null; } + public static System.Double Parse(string s) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Double Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Double result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Double result) { throw null; } + } + public abstract partial class Enum : System.ValueType, System.IComparable, System.IFormattable + { + protected Enum() { } + public int CompareTo(object target) { throw null; } + public override bool Equals(object obj) { throw null; } + public static string Format(System.Type enumType, object value, string format) { throw null; } + public override int GetHashCode() { throw null; } + public static string GetName(System.Type enumType, object value) { throw null; } + public static string[] GetNames(System.Type enumType) { throw null; } + public static System.Type GetUnderlyingType(System.Type enumType) { throw null; } + public static System.Array GetValues(System.Type enumType) { throw null; } + public bool HasFlag(System.Enum flag) { throw null; } + public static bool IsDefined(System.Type enumType, object value) { throw null; } + public static object Parse(System.Type enumType, string value) { throw null; } + public static object Parse(System.Type enumType, string value, bool ignoreCase) { throw null; } + [System.ObsoleteAttribute("The provider argument is not used. Please use ToString(String).")] + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public static object ToObject(System.Type enumType, object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string value, bool ignoreCase, out TEnum result) where TEnum : struct { throw null; } + public static bool TryParse(string value, out TEnum result) where TEnum : struct { throw null; } + } + public partial class EventArgs + { + public static readonly System.EventArgs Empty; + public EventArgs() { } + } + public delegate void EventHandler(object sender, System.EventArgs e); + public delegate void EventHandler(object sender, TEventArgs e); + public partial class Exception + { + public Exception() { } + public Exception(string message) { } + public Exception(string message, System.Exception innerException) { } + public virtual System.Collections.IDictionary Data { get { throw null; } } + public virtual string HelpLink { get { throw null; } set { } } + public int HResult { get { throw null; } protected set { } } + public System.Exception InnerException { get { throw null; } } + public virtual string Message { get { throw null; } } + public virtual string Source { get { throw null; } set { } } + public virtual string StackTrace { get { throw null; } } + public virtual System.Exception GetBaseException() { throw null; } + public override string ToString() { throw null; } + } + public partial class FlagsAttribute : System.Attribute + { + public FlagsAttribute() { } + } + public partial class FormatException : System.Exception + { + public FormatException() { } + public FormatException(string message) { } + public FormatException(string message, System.Exception innerException) { } + } + public delegate TResult Func(); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate TResult Func(T arg); + public delegate TResult Func(T1 arg1, T2 arg2); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public static partial class GC + { + public static int MaxGeneration { get { throw null; } } + public static void AddMemoryPressure(long bytesAllocated) { } + public static void Collect() { } + public static void Collect(int generation) { } + public static void Collect(int generation, System.GCCollectionMode mode) { } + public static void Collect(int generation, System.GCCollectionMode mode, bool blocking) { } + public static int CollectionCount(int generation) { throw null; } + public static long GetTotalMemory(bool forceFullCollection) { throw null; } + public static void KeepAlive(object obj) { } + public static void RemoveMemoryPressure(long bytesAllocated) { } + public static void ReRegisterForFinalize(object obj) { } + public static void SuppressFinalize(object obj) { } + public static void WaitForPendingFinalizers() { } + } + public enum GCCollectionMode + { + Default = 0, + Forced = 1, + Optimized = 2, + } + public partial struct Guid : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.Guid Empty; + public Guid(byte[] b) { throw null; } + public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; } + public Guid(int a, short b, short c, byte[] d) { throw null; } + public Guid(string g) { throw null; } + public int CompareTo(System.Guid value) { throw null; } + public bool Equals(System.Guid g) { throw null; } + public override bool Equals(object o) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Guid NewGuid() { throw null; } + public static bool operator ==(System.Guid a, System.Guid b) { throw null; } + public static bool operator !=(System.Guid a, System.Guid b) { throw null; } + public static System.Guid Parse(string input) { throw null; } + public static System.Guid ParseExact(string input, string format) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public byte[] ToByteArray() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string input, out System.Guid result) { throw null; } + public static bool TryParseExact(string input, string format, out System.Guid result) { throw null; } + } + public partial interface IAsyncResult + { + object AsyncState { get; } + System.Threading.WaitHandle AsyncWaitHandle { get; } + bool CompletedSynchronously { get; } + bool IsCompleted { get; } + } + public partial interface IComparable + { + int CompareTo(object obj); + } + public partial interface IComparable + { + int CompareTo(T other); + } + public partial interface ICustomFormatter + { + string Format(string format, object arg, System.IFormatProvider formatProvider); + } + public partial interface IDisposable + { + void Dispose(); + } + public partial interface IEquatable + { + bool Equals(T other); + } + public partial interface IFormatProvider + { + object GetFormat(System.Type formatType); + } + public partial interface IFormattable + { + string ToString(string format, System.IFormatProvider formatProvider); + } + public sealed partial class IndexOutOfRangeException : System.Exception + { + public IndexOutOfRangeException() { } + public IndexOutOfRangeException(string message) { } + public IndexOutOfRangeException(string message, System.Exception innerException) { } + } + public partial struct Int16 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const short MaxValue = (short)32767; + public const short MinValue = (short)-32768; + public int CompareTo(System.Int16 value) { throw null; } + public bool Equals(System.Int16 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int16 Parse(string s) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int16 result) { throw null; } + public static bool TryParse(string s, out System.Int16 result) { throw null; } + } + public partial struct Int32 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const int MaxValue = 2147483647; + public const int MinValue = -2147483648; + public System.Int32 CompareTo(System.Int32 value) { throw null; } + public bool Equals(System.Int32 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override System.Int32 GetHashCode() { throw null; } + public static System.Int32 Parse(string s) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int32 Parse(string s, System.IFormatProvider provider) { throw null; } + System.Int32 System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int32 result) { throw null; } + public static bool TryParse(string s, out System.Int32 result) { throw null; } + } + public partial struct Int64 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const long MaxValue = (long)9223372036854775807; + public const long MinValue = (long)-9223372036854775808; + public int CompareTo(System.Int64 value) { throw null; } + public bool Equals(System.Int64 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int64 Parse(string s) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int64 result) { throw null; } + public static bool TryParse(string s, out System.Int64 result) { throw null; } + } + public partial struct IntPtr + { + public static readonly System.IntPtr Zero; + public IntPtr(int value) { throw null; } + public IntPtr(long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe IntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.IntPtr Add(System.IntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.IntPtr operator +(System.IntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static explicit operator System.IntPtr (int value) { throw null; } + public static explicit operator System.IntPtr (long value) { throw null; } + public static explicit operator int (System.IntPtr value) { throw null; } + public static explicit operator long (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.IntPtr (void* value) { throw null; } + public static bool operator !=(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static System.IntPtr operator -(System.IntPtr pointer, int offset) { throw null; } + public static System.IntPtr Subtract(System.IntPtr pointer, int offset) { throw null; } + public int ToInt32() { throw null; } + public long ToInt64() { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + } + public partial class InvalidCastException : System.Exception + { + public InvalidCastException() { } + public InvalidCastException(string message) { } + public InvalidCastException(string message, System.Exception innerException) { } + public InvalidCastException(string message, int errorCode) { } + } + public partial class InvalidOperationException : System.Exception + { + public InvalidOperationException() { } + public InvalidOperationException(string message) { } + public InvalidOperationException(string message, System.Exception innerException) { } + } + public partial class InvalidTimeZoneException : System.Exception + { + public InvalidTimeZoneException() { } + public InvalidTimeZoneException(string message) { } + public InvalidTimeZoneException(string message, System.Exception innerException) { } + } + public partial interface IObservable + { + System.IDisposable Subscribe(System.IObserver observer); + } + public partial interface IObserver + { + void OnCompleted(); + void OnError(System.Exception error); + void OnNext(T value); + } + public partial interface IProgress + { + void Report(T value); + } + public partial class Lazy + { + public Lazy() { } + public Lazy(bool isThreadSafe) { } + public Lazy(System.Func valueFactory) { } + public Lazy(System.Func valueFactory, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(System.Threading.LazyThreadSafetyMode mode) { } + public bool IsValueCreated { get { throw null; } } + public T Value { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class Lazy : System.Lazy + { + public Lazy(System.Func valueFactory, TMetadata metadata) { } + public Lazy(System.Func valueFactory, TMetadata metadata, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(TMetadata metadata) { } + public Lazy(TMetadata metadata, bool isThreadSafe) { } + public Lazy(TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public TMetadata Metadata { get { throw null; } } + } + public partial class MemberAccessException : System.Exception + { + public MemberAccessException() { } + public MemberAccessException(string message) { } + public MemberAccessException(string message, System.Exception inner) { } + } + public partial class MissingMemberException : System.MemberAccessException + { + public MissingMemberException() { } + public MissingMemberException(string message) { } + public MissingMemberException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public sealed partial class MTAThreadAttribute : System.Attribute + { + public MTAThreadAttribute() { } + } + public abstract partial class MulticastDelegate : System.Delegate + { + internal MulticastDelegate() { } + public sealed override bool Equals(object obj) { throw null; } + public sealed override int GetHashCode() { throw null; } + public sealed override System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + public static bool operator !=(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + } + public partial class NotImplementedException : System.Exception + { + public NotImplementedException() { } + public NotImplementedException(string message) { } + public NotImplementedException(string message, System.Exception inner) { } + } + public partial class NotSupportedException : System.Exception + { + public NotSupportedException() { } + public NotSupportedException(string message) { } + public NotSupportedException(string message, System.Exception innerException) { } + } + public static partial class Nullable + { + public static int Compare(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static bool Equals(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static System.Type GetUnderlyingType(System.Type nullableType) { throw null; } + } + public partial struct Nullable where T : struct + { + public Nullable(T value) { throw null; } + public bool HasValue { get { throw null; } } + public T Value { get { throw null; } } + public override bool Equals(object other) { throw null; } + public override int GetHashCode() { throw null; } + public T GetValueOrDefault() { throw null; } + public T GetValueOrDefault(T defaultValue) { throw null; } + public static explicit operator T (System.Nullable value) { throw null; } + public static implicit operator System.Nullable (T value) { throw null; } + public override string ToString() { throw null; } + } + public partial class NullReferenceException : System.Exception + { + public NullReferenceException() { } + public NullReferenceException(string message) { } + public NullReferenceException(string message, System.Exception innerException) { } + } + public partial class Object + { + public Object() { } + public virtual bool Equals(System.Object obj) { throw null; } + public static bool Equals(System.Object objA, System.Object objB) { throw null; } + ~Object() { } + public virtual int GetHashCode() { throw null; } + public System.Type GetType() { throw null; } + protected System.Object MemberwiseClone() { throw null; } + public static bool ReferenceEquals(System.Object objA, System.Object objB) { throw null; } + public virtual string ToString() { throw null; } + } + public partial class ObjectDisposedException : System.InvalidOperationException + { + public ObjectDisposedException(string objectName) { } + public ObjectDisposedException(string message, System.Exception innerException) { } + public ObjectDisposedException(string objectName, string message) { } + public override string Message { get { throw null; } } + public string ObjectName { get { throw null; } } + } + public sealed partial class ObsoleteAttribute : System.Attribute + { + public ObsoleteAttribute() { } + public ObsoleteAttribute(string message) { } + public ObsoleteAttribute(string message, bool error) { } + public bool IsError { get { throw null; } } + public string Message { get { throw null; } } + } + public partial class OutOfMemoryException : System.Exception + { + public OutOfMemoryException() { } + public OutOfMemoryException(string message) { } + public OutOfMemoryException(string message, System.Exception innerException) { } + } + public partial class OverflowException : System.ArithmeticException + { + public OverflowException() { } + public OverflowException(string message) { } + public OverflowException(string message, System.Exception innerException) { } + } + public sealed partial class ParamArrayAttribute : System.Attribute + { + public ParamArrayAttribute() { } + } + public partial class PlatformNotSupportedException : System.NotSupportedException + { + public PlatformNotSupportedException() { } + public PlatformNotSupportedException(string message) { } + public PlatformNotSupportedException(string message, System.Exception inner) { } + } + public delegate bool Predicate(T obj); + public partial class RankException : System.Exception + { + public RankException() { } + public RankException(string message) { } + public RankException(string message, System.Exception innerException) { } + } + public partial struct RuntimeFieldHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeFieldHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + public static bool operator !=(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + } + public partial struct RuntimeMethodHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeMethodHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + public static bool operator !=(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + } + public partial struct RuntimeTypeHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeTypeHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator ==(System.RuntimeTypeHandle left, object right) { throw null; } + public static bool operator !=(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator !=(System.RuntimeTypeHandle left, object right) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct SByte : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const sbyte MaxValue = (sbyte)127; + public const sbyte MinValue = (sbyte)-128; + public int CompareTo(System.SByte value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.SByte obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.SByte result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.SByte result) { throw null; } + } + public partial struct Single : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const float Epsilon = 1.401298E-45f; + public const float MaxValue = 3.40282347E+38f; + public const float MinValue = -3.40282347E+38f; + public const float NaN = 0.0f / 0.0f; + public const float NegativeInfinity = -1.0f / 0.0f; + public const float PositiveInfinity = 1.0f / 0.0f; + public int CompareTo(System.Single value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Single obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Single f) { throw null; } + public static bool IsNaN(System.Single f) { throw null; } + public static bool IsNegativeInfinity(System.Single f) { throw null; } + public static bool IsPositiveInfinity(System.Single f) { throw null; } + public static bool operator ==(System.Single left, System.Single right) { throw null; } + public static bool operator >(System.Single left, System.Single right) { throw null; } + public static bool operator >=(System.Single left, System.Single right) { throw null; } + public static bool operator !=(System.Single left, System.Single right) { throw null; } + public static bool operator <(System.Single left, System.Single right) { throw null; } + public static bool operator <=(System.Single left, System.Single right) { throw null; } + public static System.Single Parse(string s) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Single Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Single result) { throw null; } + public static bool TryParse(string s, out System.Single result) { throw null; } + } + public sealed partial class STAThreadAttribute : System.Attribute + { + public STAThreadAttribute() { } + } + public sealed partial class String : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IComparable, System.IComparable, System.IEquatable + { + public static readonly string Empty; + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value) { } + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value, int startIndex, int length) { } + public String(char c, int count) { } + public String(char[] value) { } + public String(char[] value, int startIndex, int length) { } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } } + public int Length { get { throw null; } } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length, System.StringComparison comparisonType) { throw null; } + public static int Compare(System.String strA, System.String strB) { throw null; } + public static int Compare(System.String strA, System.String strB, System.StringComparison comparisonType) { throw null; } + public static int CompareOrdinal(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int CompareOrdinal(System.String strA, System.String strB) { throw null; } + public int CompareTo(System.String strB) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Concat(object arg0) { throw null; } + public static System.String Concat(object arg0, object arg1) { throw null; } + public static System.String Concat(object arg0, object arg1, object arg2) { throw null; } + public static System.String Concat(params object[] args) { throw null; } + public static System.String Concat(System.String str0, System.String str1) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2, System.String str3) { throw null; } + public static System.String Concat(params string[] values) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public bool Contains(System.String value) { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public bool EndsWith(System.String value) { throw null; } + public bool EndsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.String value) { throw null; } + public static bool Equals(System.String a, System.String b) { throw null; } + public static bool Equals(System.String a, System.String b, System.StringComparison comparisonType) { throw null; } + public bool Equals(System.String value, System.StringComparison comparisonType) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, params object[] args) { throw null; } + public static System.String Format(System.String format, params object[] args) { throw null; } + public override int GetHashCode() { throw null; } + public int IndexOf(char value) { throw null; } + public int IndexOf(char value, int startIndex) { throw null; } + public int IndexOf(char value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value) { throw null; } + public int IndexOf(System.String value, int startIndex) { throw null; } + public int IndexOf(System.String value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int IndexOfAny(char[] anyOf) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public System.String Insert(int startIndex, System.String value) { throw null; } + public static bool IsNullOrEmpty(System.String value) { throw null; } + public static bool IsNullOrWhiteSpace(System.String value) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Join(System.String separator, params object[] values) { throw null; } + public static System.String Join(System.String separator, params string[] value) { throw null; } + public static System.String Join(System.String separator, string[] value, int startIndex, int count) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public int LastIndexOf(char value) { throw null; } + public int LastIndexOf(char value, int startIndex) { throw null; } + public int LastIndexOf(char value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value) { throw null; } + public int LastIndexOf(System.String value, int startIndex) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int LastIndexOfAny(char[] anyOf) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public static bool operator ==(System.String a, System.String b) { throw null; } + public static bool operator !=(System.String a, System.String b) { throw null; } + public System.String PadLeft(int totalWidth) { throw null; } + public System.String PadLeft(int totalWidth, char paddingChar) { throw null; } + public System.String PadRight(int totalWidth) { throw null; } + public System.String PadRight(int totalWidth, char paddingChar) { throw null; } + public System.String Remove(int startIndex) { throw null; } + public System.String Remove(int startIndex, int count) { throw null; } + public System.String Replace(char oldChar, char newChar) { throw null; } + public System.String Replace(System.String oldValue, System.String newValue) { throw null; } + public string[] Split(params char[] separator) { throw null; } + public string[] Split(char[] separator, int count) { throw null; } + public string[] Split(char[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(char[] separator, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, System.StringSplitOptions options) { throw null; } + public bool StartsWith(System.String value) { throw null; } + public bool StartsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public System.String Substring(int startIndex) { throw null; } + public System.String Substring(int startIndex, int length) { throw null; } + System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public char[] ToCharArray() { throw null; } + public char[] ToCharArray(int startIndex, int length) { throw null; } + public System.String ToLower() { throw null; } + public System.String ToLowerInvariant() { throw null; } + public override System.String ToString() { throw null; } + public System.String ToUpper() { throw null; } + public System.String ToUpperInvariant() { throw null; } + public System.String Trim() { throw null; } + public System.String Trim(params char[] trimChars) { throw null; } + public System.String TrimEnd(params char[] trimChars) { throw null; } + public System.String TrimStart(params char[] trimChars) { throw null; } + } + public enum StringComparison + { + CurrentCulture = 0, + CurrentCultureIgnoreCase = 1, + Ordinal = 4, + OrdinalIgnoreCase = 5, + } + [System.FlagsAttribute] + public enum StringSplitOptions + { + None = 0, + RemoveEmptyEntries = 1, + } + public partial class ThreadStaticAttribute : System.Attribute + { + public ThreadStaticAttribute() { } + } + public partial class TimeoutException : System.Exception + { + public TimeoutException() { } + public TimeoutException(string message) { } + public TimeoutException(string message, System.Exception innerException) { } + } + public partial struct TimeSpan : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.TimeSpan MaxValue; + public static readonly System.TimeSpan MinValue; + public const long TicksPerDay = (long)864000000000; + public const long TicksPerHour = (long)36000000000; + public const long TicksPerMillisecond = (long)10000; + public const long TicksPerMinute = (long)600000000; + public const long TicksPerSecond = (long)10000000; + public static readonly System.TimeSpan Zero; + public TimeSpan(int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds) { throw null; } + public TimeSpan(long ticks) { throw null; } + public int Days { get { throw null; } } + public int Hours { get { throw null; } } + public int Milliseconds { get { throw null; } } + public int Minutes { get { throw null; } } + public int Seconds { get { throw null; } } + public long Ticks { get { throw null; } } + public double TotalDays { get { throw null; } } + public double TotalHours { get { throw null; } } + public double TotalMilliseconds { get { throw null; } } + public double TotalMinutes { get { throw null; } } + public double TotalSeconds { get { throw null; } } + public System.TimeSpan Add(System.TimeSpan ts) { throw null; } + public static int Compare(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public int CompareTo(System.TimeSpan value) { throw null; } + public System.TimeSpan Duration() { throw null; } + public override bool Equals(object value) { throw null; } + public bool Equals(System.TimeSpan obj) { throw null; } + public static bool Equals(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan FromDays(double value) { throw null; } + public static System.TimeSpan FromHours(double value) { throw null; } + public static System.TimeSpan FromMilliseconds(double value) { throw null; } + public static System.TimeSpan FromMinutes(double value) { throw null; } + public static System.TimeSpan FromSeconds(double value) { throw null; } + public static System.TimeSpan FromTicks(long value) { throw null; } + public override int GetHashCode() { throw null; } + public System.TimeSpan Negate() { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator ==(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator !=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t) { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t) { throw null; } + public static System.TimeSpan Parse(string s) { throw null; } + public static System.TimeSpan Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public System.TimeSpan Subtract(System.TimeSpan ts) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParse(string s, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + } + public sealed partial class TimeZoneInfo : System.IEquatable + { + internal TimeZoneInfo() { } + public System.TimeSpan BaseUtcOffset { get { throw null; } } + public string DaylightName { get { throw null; } } + public string DisplayName { get { throw null; } } + public static System.TimeZoneInfo Local { get { throw null; } } + public string StandardName { get { throw null; } } + public bool SupportsDaylightSavingTime { get { throw null; } } + public static System.TimeZoneInfo Utc { get { throw null; } } + public static System.DateTime ConvertTime(System.DateTime dateTime, System.TimeZoneInfo destinationTimeZone) { throw null; } + public static System.DateTimeOffset ConvertTime(System.DateTimeOffset dateTimeOffset, System.TimeZoneInfo destinationTimeZone) { throw null; } + public bool Equals(System.TimeZoneInfo other) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTime dateTime) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTimeOffset dateTimeOffset) { throw null; } + public override int GetHashCode() { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTime dateTime) { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsAmbiguousTime(System.DateTime dateTime) { throw null; } + public bool IsAmbiguousTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsDaylightSavingTime(System.DateTime dateTime) { throw null; } + public bool IsDaylightSavingTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsInvalidTime(System.DateTime dateTime) { throw null; } + public override string ToString() { throw null; } + } + public static partial class Tuple + { + public static System.Tuple Create(T1 item1) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { throw null; } + public static System.Tuple> Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8) { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1) { } + public T1 Item1 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public TRest Rest { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public abstract partial class Type + { + internal Type() { } + public static readonly object Missing; + public abstract string AssemblyQualifiedName { get; } + public abstract System.Type DeclaringType { get; } + public abstract string FullName { get; } + public abstract int GenericParameterPosition { get; } + public abstract System.Type[] GenericTypeArguments { get; } + public bool HasElementType { get { throw null; } } + public bool IsArray { get { throw null; } } + public bool IsByRef { get { throw null; } } + public abstract bool IsConstructedGenericType { get; } + public abstract bool IsGenericParameter { get; } + public bool IsNested { get { throw null; } } + public bool IsPointer { get { throw null; } } + public abstract string Name { get; } + public abstract string Namespace { get; } + public virtual System.RuntimeTypeHandle TypeHandle { get { throw null; } } + public override bool Equals(object o) { throw null; } + public bool Equals(System.Type o) { throw null; } + public abstract int GetArrayRank(); + public abstract System.Type GetElementType(); + public abstract System.Type GetGenericTypeDefinition(); + public override int GetHashCode() { throw null; } + public static System.Type GetType(string typeName) { throw null; } + public static System.Type GetType(string typeName, bool throwOnError) { throw null; } + public static System.Type GetTypeFromHandle(System.RuntimeTypeHandle handle) { throw null; } + public abstract System.Type MakeArrayType(); + public abstract System.Type MakeArrayType(int rank); + public abstract System.Type MakeByRefType(); + public abstract System.Type MakeGenericType(params System.Type[] typeArguments); + public abstract System.Type MakePointerType(); + public override string ToString() { throw null; } + } + public partial class TypeAccessException : System.TypeLoadException + { + public TypeAccessException() { } + public TypeAccessException(string message) { } + public TypeAccessException(string message, System.Exception inner) { } + } + public sealed partial class TypeInitializationException : System.Exception + { + public TypeInitializationException(string fullTypeName, System.Exception innerException) { } + public string TypeName { get { throw null; } } + } + public partial class TypeLoadException : System.Exception + { + public TypeLoadException() { } + public TypeLoadException(string message) { } + public TypeLoadException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + public string TypeName { get { throw null; } } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt16 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const ushort MaxValue = (ushort)65535; + public const ushort MinValue = (ushort)0; + public int CompareTo(System.UInt16 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt16 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt16 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt16 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt32 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const uint MaxValue = (uint)4294967295; + public const uint MinValue = (uint)0; + public int CompareTo(System.UInt32 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt32 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt32 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt32 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt64 : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public const ulong MaxValue = (ulong)18446744073709551615; + public const ulong MinValue = (ulong)0; + public int CompareTo(System.UInt64 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt64 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt64 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt64 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UIntPtr + { + public static readonly System.UIntPtr Zero; + public UIntPtr(uint value) { throw null; } + public UIntPtr(ulong value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe UIntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.UIntPtr Add(System.UIntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.UIntPtr operator +(System.UIntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static explicit operator System.UIntPtr (uint value) { throw null; } + public static explicit operator System.UIntPtr (ulong value) { throw null; } + public static explicit operator uint (System.UIntPtr value) { throw null; } + public static explicit operator ulong (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.UIntPtr (void* value) { throw null; } + public static bool operator !=(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static System.UIntPtr operator -(System.UIntPtr pointer, int offset) { throw null; } + public static System.UIntPtr Subtract(System.UIntPtr pointer, int offset) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public uint ToUInt32() { throw null; } + public ulong ToUInt64() { throw null; } + } + public partial class UnauthorizedAccessException : System.Exception + { + public UnauthorizedAccessException() { } + public UnauthorizedAccessException(string message) { } + public UnauthorizedAccessException(string message, System.Exception inner) { } + } + public partial class Uri + { + public Uri(string uriString) { } + public Uri(string uriString, System.UriKind uriKind) { } + public Uri(System.Uri baseUri, string relativeUri) { } + public Uri(System.Uri baseUri, System.Uri relativeUri) { } + public string AbsolutePath { get { throw null; } } + public string AbsoluteUri { get { throw null; } } + public string Authority { get { throw null; } } + public string DnsSafeHost { get { throw null; } } + public string Fragment { get { throw null; } } + public string Host { get { throw null; } } + public System.UriHostNameType HostNameType { get { throw null; } } + public bool IsAbsoluteUri { get { throw null; } } + public bool IsDefaultPort { get { throw null; } } + public bool IsFile { get { throw null; } } + public bool IsLoopback { get { throw null; } } + public bool IsUnc { get { throw null; } } + public string LocalPath { get { throw null; } } + public string OriginalString { get { throw null; } } + public string PathAndQuery { get { throw null; } } + public int Port { get { throw null; } } + public string Query { get { throw null; } } + public string Scheme { get { throw null; } } + public string[] Segments { get { throw null; } } + public bool UserEscaped { get { throw null; } } + public string UserInfo { get { throw null; } } + public static System.UriHostNameType CheckHostName(string name) { throw null; } + public static bool CheckSchemeName(string schemeName) { throw null; } + public static int Compare(System.Uri uri1, System.Uri uri2, System.UriComponents partsToCompare, System.UriFormat compareFormat, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object comparand) { throw null; } + public static string EscapeDataString(string stringToEscape) { throw null; } + public static string EscapeUriString(string stringToEscape) { throw null; } + public string GetComponents(System.UriComponents components, System.UriFormat format) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsBaseOf(System.Uri uri) { throw null; } + public bool IsWellFormedOriginalString() { throw null; } + public static bool IsWellFormedUriString(string uriString, System.UriKind uriKind) { throw null; } + public System.Uri MakeRelativeUri(System.Uri uri) { throw null; } + public static bool operator ==(System.Uri uri1, System.Uri uri2) { throw null; } + public static bool operator !=(System.Uri uri1, System.Uri uri2) { throw null; } + public override string ToString() { throw null; } + public static bool TryCreate(string uriString, System.UriKind uriKind, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, string relativeUri, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, System.Uri relativeUri, out System.Uri result) { throw null; } + public static string UnescapeDataString(string stringToUnescape) { throw null; } + } + [System.FlagsAttribute] + public enum UriComponents + { + AbsoluteUri = 127, + Fragment = 64, + Host = 4, + HostAndPort = 132, + HttpRequestUrl = 61, + KeepDelimiter = 1073741824, + NormalizedHost = 256, + Path = 16, + PathAndQuery = 48, + Port = 8, + Query = 32, + Scheme = 1, + SchemeAndServer = 13, + SerializationInfoString = -2147483648, + StrongAuthority = 134, + StrongPort = 128, + UserInfo = 2, + } + public enum UriFormat + { + SafeUnescaped = 3, + Unescaped = 2, + UriEscaped = 1, + } + public enum UriHostNameType + { + Basic = 1, + Dns = 2, + IPv4 = 3, + IPv6 = 4, + Unknown = 0, + } + public enum UriKind + { + Absolute = 1, + Relative = 2, + RelativeOrAbsolute = 0, + } + public abstract partial class ValueType + { + protected ValueType() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public override string ToString() { throw null; } + } + public sealed partial class Version : System.IComparable, System.IComparable, System.IEquatable + { + public Version(int major, int minor) { } + public Version(int major, int minor, int build) { } + public Version(int major, int minor, int build, int revision) { } + public Version(string version) { } + public int Build { get { throw null; } } + public int Major { get { throw null; } } + public short MajorRevision { get { throw null; } } + public int Minor { get { throw null; } } + public short MinorRevision { get { throw null; } } + public int Revision { get { throw null; } } + public int CompareTo(System.Version value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Version obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Version v1, System.Version v2) { throw null; } + public static bool operator >(System.Version v1, System.Version v2) { throw null; } + public static bool operator >=(System.Version v1, System.Version v2) { throw null; } + public static bool operator !=(System.Version v1, System.Version v2) { throw null; } + public static bool operator <(System.Version v1, System.Version v2) { throw null; } + public static bool operator <=(System.Version v1, System.Version v2) { throw null; } + public static System.Version Parse(string input) { throw null; } + int System.IComparable.CompareTo(object version) { throw null; } + public override string ToString() { throw null; } + public string ToString(int fieldCount) { throw null; } + public static bool TryParse(string input, out System.Version result) { throw null; } + } + public partial struct Void + { + } + public partial class WeakReference + { + public WeakReference(object target) { } + public WeakReference(object target, bool trackResurrection) { } + public virtual bool IsAlive { get { throw null; } } + public virtual object Target { get { throw null; } set { } } + public virtual bool TrackResurrection { get { throw null; } } + ~WeakReference() { } + } + public sealed partial class WeakReference where T : class + { + public WeakReference(T target) { } + public WeakReference(T target, bool trackResurrection) { } + ~WeakReference() { } + public void SetTarget(T target) { } + public bool TryGetTarget(out T target) { throw null; } + } +} +namespace System.Collections +{ + public partial struct DictionaryEntry + { + public DictionaryEntry(object key, object value) { throw null; } + public object Key { get { throw null; } set { } } + public object Value { get { throw null; } set { } } + } + public partial interface ICollection : System.Collections.IEnumerable + { + int Count { get; } + bool IsSynchronized { get; } + object SyncRoot { get; } + void CopyTo(System.Array array, int index); + } + public partial interface IComparer + { + int Compare(object x, object y); + } + public partial interface IDictionary : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[object key] { get; set; } + System.Collections.ICollection Keys { get; } + System.Collections.ICollection Values { get; } + void Add(object key, object value); + void Clear(); + bool Contains(object key); + new System.Collections.IDictionaryEnumerator GetEnumerator(); + void Remove(object key); + } + public partial interface IDictionaryEnumerator : System.Collections.IEnumerator + { + System.Collections.DictionaryEntry Entry { get; } + object Key { get; } + object Value { get; } + } + public partial interface IEnumerable + { + System.Collections.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator + { + object Current { get; } + bool MoveNext(); + void Reset(); + } + public partial interface IEqualityComparer + { + bool Equals(object x, object y); + int GetHashCode(object obj); + } + public partial interface IList : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[int index] { get; set; } + int Add(object value); + void Clear(); + bool Contains(object value); + int IndexOf(object value); + void Insert(int index, object value); + void Remove(object value); + void RemoveAt(int index); + } + public partial interface IStructuralComparable + { + int CompareTo(object other, System.Collections.IComparer comparer); + } + public partial interface IStructuralEquatable + { + bool Equals(object other, System.Collections.IEqualityComparer comparer); + int GetHashCode(System.Collections.IEqualityComparer comparer); + } +} +namespace System.Collections.Generic +{ + public partial interface ICollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + bool IsReadOnly { get; } + void Add(T item); + void Clear(); + bool Contains(T item); + void CopyTo(T[] array, int arrayIndex); + bool Remove(T item); + } + public partial interface IComparer + { + int Compare(T x, T y); + } + public partial interface IDictionary : System.Collections.Generic.ICollection>, System.Collections.Generic.IEnumerable>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; set; } + System.Collections.Generic.ICollection Keys { get; } + System.Collections.Generic.ICollection Values { get; } + void Add(TKey key, TValue value); + bool ContainsKey(TKey key); + bool Remove(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IEnumerable : System.Collections.IEnumerable + { + new System.Collections.Generic.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator : System.Collections.IEnumerator, System.IDisposable + { + new T Current { get; } + } + public partial interface IEqualityComparer + { + bool Equals(T x, T y); + int GetHashCode(T obj); + } + public partial interface IList : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + T this[int index] { get; set; } + int IndexOf(T item); + void Insert(int index, T item); + void RemoveAt(int index); + } + public partial interface IReadOnlyCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + } + public partial interface IReadOnlyDictionary : System.Collections.Generic.IEnumerable>, System.Collections.Generic.IReadOnlyCollection>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; } + System.Collections.Generic.IEnumerable Keys { get; } + System.Collections.Generic.IEnumerable Values { get; } + bool ContainsKey(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IReadOnlyList : System.Collections.Generic.IEnumerable, System.Collections.Generic.IReadOnlyCollection, System.Collections.IEnumerable + { + T this[int index] { get; } + } + public partial interface ISet : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + new bool Add(T item); + void ExceptWith(System.Collections.Generic.IEnumerable other); + void IntersectWith(System.Collections.Generic.IEnumerable other); + bool IsProperSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsProperSupersetOf(System.Collections.Generic.IEnumerable other); + bool IsSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsSupersetOf(System.Collections.Generic.IEnumerable other); + bool Overlaps(System.Collections.Generic.IEnumerable other); + bool SetEquals(System.Collections.Generic.IEnumerable other); + void SymmetricExceptWith(System.Collections.Generic.IEnumerable other); + void UnionWith(System.Collections.Generic.IEnumerable other); + } + public partial class KeyNotFoundException : System.Exception + { + public KeyNotFoundException() { } + public KeyNotFoundException(string message) { } + public KeyNotFoundException(string message, System.Exception innerException) { } + } + public partial struct KeyValuePair + { + public KeyValuePair(TKey key, TValue value) { throw null; } + public TKey Key { get { throw null; } } + public TValue Value { get { throw null; } } + public override string ToString() { throw null; } + } +} +namespace System.Collections.ObjectModel +{ + public partial class Collection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public Collection() { } + public Collection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } set { } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public void Add(T item) { } + public void Clear() { } + protected virtual void ClearItems() { } + public bool Contains(T item) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T item) { throw null; } + public void Insert(int index, T item) { } + protected virtual void InsertItem(int index, T item) { } + public bool Remove(T item) { throw null; } + public void RemoveAt(int index) { } + protected virtual void RemoveItem(int index) { } + protected virtual void SetItem(int index, T item) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + } + public partial class ReadOnlyCollection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public ReadOnlyCollection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public bool Contains(T value) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T value) { throw null; } + void System.Collections.Generic.ICollection.Add(T value) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Remove(T value) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T value) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + } +} +namespace System.ComponentModel +{ + public partial class DefaultValueAttribute : System.Attribute + { + public DefaultValueAttribute(bool value) { } + public DefaultValueAttribute(byte value) { } + public DefaultValueAttribute(char value) { } + public DefaultValueAttribute(double value) { } + public DefaultValueAttribute(short value) { } + public DefaultValueAttribute(int value) { } + public DefaultValueAttribute(long value) { } + public DefaultValueAttribute(object value) { } + public DefaultValueAttribute(float value) { } + public DefaultValueAttribute(string value) { } + public DefaultValueAttribute(System.Type type, string value) { } + public virtual object Value { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public sealed partial class EditorBrowsableAttribute : System.Attribute + { + public EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState state) { } + public System.ComponentModel.EditorBrowsableState State { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public enum EditorBrowsableState + { + Advanced = 2, + Always = 0, + Never = 1, + } +} +namespace System.Diagnostics +{ + public sealed partial class ConditionalAttribute : System.Attribute + { + public ConditionalAttribute(string conditionString) { } + public string ConditionString { get { throw null; } } + } + public sealed partial class DebuggableAttribute : System.Attribute + { + public DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes modes) { } + [System.FlagsAttribute] + public enum DebuggingModes + { + Default = 1, + DisableOptimizations = 256, + EnableEditAndContinue = 4, + IgnoreSymbolStoreSequencePoints = 2, + None = 0, + } + } +} +namespace System.Globalization +{ + [System.FlagsAttribute] + public enum DateTimeStyles + { + AdjustToUniversal = 16, + AllowInnerWhite = 4, + AllowLeadingWhite = 1, + AllowTrailingWhite = 2, + AllowWhiteSpaces = 7, + AssumeLocal = 32, + AssumeUniversal = 64, + NoCurrentDateDefault = 8, + None = 0, + RoundtripKind = 128, + } + [System.FlagsAttribute] + public enum NumberStyles + { + AllowCurrencySymbol = 256, + AllowDecimalPoint = 32, + AllowExponent = 128, + AllowHexSpecifier = 512, + AllowLeadingSign = 4, + AllowLeadingWhite = 1, + AllowParentheses = 16, + AllowThousands = 64, + AllowTrailingSign = 8, + AllowTrailingWhite = 2, + Any = 511, + Currency = 383, + Float = 167, + HexNumber = 515, + Integer = 7, + None = 0, + Number = 111, + } + [System.FlagsAttribute] + public enum TimeSpanStyles + { + AssumeNegative = 1, + None = 0, + } +} +namespace System.Reflection +{ + public sealed partial class AssemblyCompanyAttribute : System.Attribute + { + public AssemblyCompanyAttribute(string company) { } + public string Company { get { throw null; } } + } + public sealed partial class AssemblyConfigurationAttribute : System.Attribute + { + public AssemblyConfigurationAttribute(string configuration) { } + public string Configuration { get { throw null; } } + } + public sealed partial class AssemblyCopyrightAttribute : System.Attribute + { + public AssemblyCopyrightAttribute(string copyright) { } + public string Copyright { get { throw null; } } + } + public sealed partial class AssemblyCultureAttribute : System.Attribute + { + public AssemblyCultureAttribute(string culture) { } + public string Culture { get { throw null; } } + } + public sealed partial class AssemblyDefaultAliasAttribute : System.Attribute + { + public AssemblyDefaultAliasAttribute(string defaultAlias) { } + public string DefaultAlias { get { throw null; } } + } + public sealed partial class AssemblyDelaySignAttribute : System.Attribute + { + public AssemblyDelaySignAttribute(bool delaySign) { } + public bool DelaySign { get { throw null; } } + } + public sealed partial class AssemblyDescriptionAttribute : System.Attribute + { + public AssemblyDescriptionAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class AssemblyFileVersionAttribute : System.Attribute + { + public AssemblyFileVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class AssemblyFlagsAttribute : System.Attribute + { + public AssemblyFlagsAttribute(System.Reflection.AssemblyNameFlags assemblyFlags) { } + public int AssemblyFlags { get { throw null; } } + } + public sealed partial class AssemblyInformationalVersionAttribute : System.Attribute + { + public AssemblyInformationalVersionAttribute(string informationalVersion) { } + public string InformationalVersion { get { throw null; } } + } + public sealed partial class AssemblyKeyFileAttribute : System.Attribute + { + public AssemblyKeyFileAttribute(string keyFile) { } + public string KeyFile { get { throw null; } } + } + public sealed partial class AssemblyKeyNameAttribute : System.Attribute + { + public AssemblyKeyNameAttribute(string keyName) { } + public string KeyName { get { throw null; } } + } + public sealed partial class AssemblyMetadataAttribute : System.Attribute + { + public AssemblyMetadataAttribute(string key, string value) { } + public string Key { get { throw null; } } + public string Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum AssemblyNameFlags + { + None = 0, + PublicKey = 1, + Retargetable = 256, + } + public sealed partial class AssemblyProductAttribute : System.Attribute + { + public AssemblyProductAttribute(string product) { } + public string Product { get { throw null; } } + } + public sealed partial class AssemblySignatureKeyAttribute : System.Attribute + { + public AssemblySignatureKeyAttribute(string publicKey, string countersignature) { } + public string Countersignature { get { throw null; } } + public string PublicKey { get { throw null; } } + } + public sealed partial class AssemblyTitleAttribute : System.Attribute + { + public AssemblyTitleAttribute(string title) { } + public string Title { get { throw null; } } + } + public sealed partial class AssemblyTrademarkAttribute : System.Attribute + { + public AssemblyTrademarkAttribute(string trademark) { } + public string Trademark { get { throw null; } } + } + public sealed partial class AssemblyVersionAttribute : System.Attribute + { + public AssemblyVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class DefaultMemberAttribute : System.Attribute + { + public DefaultMemberAttribute(string memberName) { } + public string MemberName { get { throw null; } } + } +} +namespace System.Runtime +{ + public enum GCLargeObjectHeapCompactionMode + { + CompactOnce = 2, + Default = 1, + } + public enum GCLatencyMode + { + Batch = 0, + Interactive = 1, + LowLatency = 2, + SustainedLowLatency = 3, + } + public static partial class GCSettings + { + public static bool IsServerGC { get { throw null; } } + public static System.Runtime.GCLargeObjectHeapCompactionMode LargeObjectHeapCompactionMode { get { throw null; } set { } } + public static System.Runtime.GCLatencyMode LatencyMode { get { throw null; } set { } } + } +} +namespace System.Runtime.CompilerServices +{ + public sealed partial class AccessedThroughPropertyAttribute : System.Attribute + { + public AccessedThroughPropertyAttribute(string propertyName) { } + public string PropertyName { get { throw null; } } + } + public sealed partial class AsyncStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public AsyncStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class CallerFilePathAttribute : System.Attribute + { + public CallerFilePathAttribute() { } + } + public sealed partial class CallerLineNumberAttribute : System.Attribute + { + public CallerLineNumberAttribute() { } + } + public sealed partial class CallerMemberNameAttribute : System.Attribute + { + public CallerMemberNameAttribute() { } + } + public partial class CompilationRelaxationsAttribute : System.Attribute + { + public CompilationRelaxationsAttribute(int relaxations) { } + public int CompilationRelaxations { get { throw null; } } + } + public sealed partial class CompilerGeneratedAttribute : System.Attribute + { + public CompilerGeneratedAttribute() { } + } + public abstract partial class CustomConstantAttribute : System.Attribute + { + protected CustomConstantAttribute() { } + public abstract object Value { get; } + } + public sealed partial class DateTimeConstantAttribute : System.Runtime.CompilerServices.CustomConstantAttribute + { + public DateTimeConstantAttribute(long ticks) { } + public override object Value { get { throw null; } } + } + public sealed partial class DecimalConstantAttribute : System.Attribute + { + public DecimalConstantAttribute(byte scale, byte sign, int hi, int mid, int low) { } + [System.CLSCompliantAttribute(false)] + public DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low) { } + public decimal Value { get { throw null; } } + } + public sealed partial class ExtensionAttribute : System.Attribute + { + public ExtensionAttribute() { } + } + public sealed partial class FixedBufferAttribute : System.Attribute + { + public FixedBufferAttribute(System.Type elementType, int length) { } + public System.Type ElementType { get { throw null; } } + public int Length { get { throw null; } } + } + public sealed partial class IndexerNameAttribute : System.Attribute + { + public IndexerNameAttribute(string indexerName) { } + } + public sealed partial class InternalsVisibleToAttribute : System.Attribute + { + public InternalsVisibleToAttribute(string assemblyName) { } + public string AssemblyName { get { throw null; } } + } + public partial interface IStrongBox + { + object Value { get; set; } + } + public static partial class IsVolatile + { + } + public sealed partial class IteratorStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public IteratorStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class MethodImplAttribute : System.Attribute + { + public MethodImplAttribute(System.Runtime.CompilerServices.MethodImplOptions methodImplOptions) { } + public System.Runtime.CompilerServices.MethodImplOptions Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum MethodImplOptions + { + AggressiveInlining = 256, + NoInlining = 8, + NoOptimization = 64, + PreserveSig = 128, + } + public sealed partial class ReferenceAssemblyAttribute : System.Attribute + { + public ReferenceAssemblyAttribute() { } + public ReferenceAssemblyAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class RuntimeCompatibilityAttribute : System.Attribute + { + public RuntimeCompatibilityAttribute() { } + public bool WrapNonExceptionThrows { get { throw null; } set { } } + } + public static partial class RuntimeHelpers + { + public static int OffsetToStringData { get { throw null; } } + public static int GetHashCode(object o) { throw null; } + public static object GetObjectValue(object obj) { throw null; } + public static void InitializeArray(System.Array array, System.RuntimeFieldHandle fldHandle) { } + public static void RunClassConstructor(System.RuntimeTypeHandle type) { } + } + public partial class StateMachineAttribute : System.Attribute + { + public StateMachineAttribute(System.Type stateMachineType) { } + public System.Type StateMachineType { get { throw null; } } + } + public partial class StrongBox : System.Runtime.CompilerServices.IStrongBox + { + public T Value; + public StrongBox() { } + public StrongBox(T value) { } + object System.Runtime.CompilerServices.IStrongBox.Value { get { throw null; } set { } } + } + public sealed partial class TypeForwardedFromAttribute : System.Attribute + { + public TypeForwardedFromAttribute(string assemblyFullName) { } + public string AssemblyFullName { get { throw null; } } + } + public sealed partial class TypeForwardedToAttribute : System.Attribute + { + public TypeForwardedToAttribute(System.Type destination) { } + public System.Type Destination { get { throw null; } } + } + public sealed partial class UnsafeValueTypeAttribute : System.Attribute + { + public UnsafeValueTypeAttribute() { } + } +} +namespace System.Runtime.ExceptionServices +{ + public sealed partial class ExceptionDispatchInfo + { + internal ExceptionDispatchInfo() { } + public System.Exception SourceException { get { throw null; } } + public static System.Runtime.ExceptionServices.ExceptionDispatchInfo Capture(System.Exception source) { throw null; } + public void Throw() { } + } +} +namespace System.Runtime.InteropServices +{ + public enum CharSet + { + Ansi = 2, + Unicode = 3, + } + public sealed partial class ComVisibleAttribute : System.Attribute + { + public ComVisibleAttribute(bool visibility) { } + public bool Value { get { throw null; } } + } + public sealed partial class FieldOffsetAttribute : System.Attribute + { + public FieldOffsetAttribute(int offset) { } + public int Value { get { throw null; } } + } + public enum LayoutKind + { + Auto = 3, + Explicit = 2, + Sequential = 0, + } + public sealed partial class OutAttribute : System.Attribute + { + public OutAttribute() { } + } + public sealed partial class StructLayoutAttribute : System.Attribute + { + public System.Runtime.InteropServices.CharSet CharSet; + public int Pack; + public int Size; + public StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind layoutKind) { } + public System.Runtime.InteropServices.LayoutKind Value { get { throw null; } } + } +} +namespace System.Runtime.Versioning +{ + public sealed partial class TargetFrameworkAttribute : System.Attribute + { + public TargetFrameworkAttribute(string frameworkName) { } + public string FrameworkDisplayName { get { throw null; } set { } } + public string FrameworkName { get { throw null; } } + } +} +namespace System.Security +{ + public sealed partial class AllowPartiallyTrustedCallersAttribute : System.Attribute + { + public AllowPartiallyTrustedCallersAttribute() { } + } + public sealed partial class SecurityCriticalAttribute : System.Attribute + { + public SecurityCriticalAttribute() { } + } + public partial class SecurityException : System.Exception + { + public SecurityException() { } + public SecurityException(string message) { } + public SecurityException(string message, System.Exception inner) { } + public override string ToString() { throw null; } + } + public sealed partial class SecuritySafeCriticalAttribute : System.Attribute + { + public SecuritySafeCriticalAttribute() { } + } + public sealed partial class SecurityTransparentAttribute : System.Attribute + { + public SecurityTransparentAttribute() { } + } + public partial class VerificationException : System.Exception + { + public VerificationException() { } + public VerificationException(string message) { } + public VerificationException(string message, System.Exception innerException) { } + } +} +namespace System.Text +{ + public sealed partial class StringBuilder + { + public StringBuilder() { } + public StringBuilder(int capacity) { } + public StringBuilder(int capacity, int maxCapacity) { } + public StringBuilder(string value) { } + public StringBuilder(string value, int capacity) { } + public StringBuilder(string value, int startIndex, int length, int capacity) { } + public int Capacity { get { throw null; } set { } } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } set { } } + public int Length { get { throw null; } set { } } + public int MaxCapacity { get { throw null; } } + public System.Text.StringBuilder Append(bool value) { throw null; } + public System.Text.StringBuilder Append(byte value) { throw null; } + public System.Text.StringBuilder Append(char value) { throw null; } + public System.Text.StringBuilder Append(char value, int repeatCount) { throw null; } + public System.Text.StringBuilder Append(char[] value) { throw null; } + public System.Text.StringBuilder Append(char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Append(decimal value) { throw null; } + public System.Text.StringBuilder Append(double value) { throw null; } + public System.Text.StringBuilder Append(short value) { throw null; } + public System.Text.StringBuilder Append(int value) { throw null; } + public System.Text.StringBuilder Append(long value) { throw null; } + public System.Text.StringBuilder Append(object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(sbyte value) { throw null; } + public System.Text.StringBuilder Append(float value) { throw null; } + public System.Text.StringBuilder Append(string value) { throw null; } + public System.Text.StringBuilder Append(string value, int startIndex, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ulong value) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendLine() { throw null; } + public System.Text.StringBuilder AppendLine(string value) { throw null; } + public System.Text.StringBuilder Clear() { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public int EnsureCapacity(int capacity) { throw null; } + public bool Equals(System.Text.StringBuilder sb) { throw null; } + public System.Text.StringBuilder Insert(int index, bool value) { throw null; } + public System.Text.StringBuilder Insert(int index, byte value) { throw null; } + public System.Text.StringBuilder Insert(int index, char value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Insert(int index, decimal value) { throw null; } + public System.Text.StringBuilder Insert(int index, double value) { throw null; } + public System.Text.StringBuilder Insert(int index, short value) { throw null; } + public System.Text.StringBuilder Insert(int index, int value) { throw null; } + public System.Text.StringBuilder Insert(int index, long value) { throw null; } + public System.Text.StringBuilder Insert(int index, object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, sbyte value) { throw null; } + public System.Text.StringBuilder Insert(int index, float value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ulong value) { throw null; } + public System.Text.StringBuilder Remove(int startIndex, int length) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar, int startIndex, int count) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue, int startIndex, int count) { throw null; } + public override string ToString() { throw null; } + public string ToString(int startIndex, int length) { throw null; } + } +} +namespace System.Threading +{ + public enum LazyThreadSafetyMode + { + ExecutionAndPublication = 2, + None = 0, + PublicationOnly = 1, + } + public static partial class Timeout + { + public const int Infinite = -1; + public static readonly System.TimeSpan InfiniteTimeSpan; + } + public abstract partial class WaitHandle : System.IDisposable + { + protected static readonly System.IntPtr InvalidHandle; + public const int WaitTimeout = 258; + protected WaitHandle() { } + public void Dispose() { } + protected virtual void Dispose(bool explicitDisposing) { } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public virtual bool WaitOne() { throw null; } + public virtual bool WaitOne(int millisecondsTimeout) { throw null; } + public virtual bool WaitOne(System.TimeSpan timeout) { throw null; } + } +} diff --git a/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.3/System.Runtime.cs b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.3/System.Runtime.cs new file mode 100644 index 0000000000..247b30560c --- /dev/null +++ b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.3/System.Runtime.cs @@ -0,0 +1,3152 @@ +// 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.Runtime")] +[assembly: AssemblyDescription("System.Runtime")] +[assembly: AssemblyDefaultAlias("System.Runtime")] +[assembly: AssemblyCompany("Microsoft Corporation")] +[assembly: AssemblyProduct("Microsoft® .NET Framework")] +[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")] +[assembly: AssemblyFileVersion("4.6.23123.00")] +[assembly: AssemblyInformationalVersion("4.6.23123.00 built by: SOURCEBUILD")] +[assembly: CLSCompliant(true)] +[assembly: AssemblyMetadata("", "")] +[assembly: AssemblyVersion("4.0.20.0")] + + + + +namespace System +{ + public delegate void Action(); + public delegate void Action(T obj); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate void Action(T1 arg1, T2 arg2); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public static partial class Activator + { + public static object CreateInstance(System.Type type) { throw null; } + public static object CreateInstance(System.Type type, params object[] args) { throw null; } + public static T CreateInstance() { throw null; } + } + public partial class ArgumentException : System.Exception + { + public ArgumentException() { } + public ArgumentException(string message) { } + public ArgumentException(string message, System.Exception innerException) { } + public ArgumentException(string message, string paramName) { } + public ArgumentException(string message, string paramName, System.Exception innerException) { } + public override string Message { get { throw null; } } + public virtual string ParamName { get { throw null; } } + } + public partial class ArgumentNullException : System.ArgumentException + { + public ArgumentNullException() { } + public ArgumentNullException(string paramName) { } + public ArgumentNullException(string message, System.Exception innerException) { } + public ArgumentNullException(string paramName, string message) { } + } + public partial class ArgumentOutOfRangeException : System.ArgumentException + { + public ArgumentOutOfRangeException() { } + public ArgumentOutOfRangeException(string paramName) { } + public ArgumentOutOfRangeException(string message, System.Exception innerException) { } + public ArgumentOutOfRangeException(string paramName, object actualValue, string message) { } + public ArgumentOutOfRangeException(string paramName, string message) { } + public virtual object ActualValue { get { throw null; } } + public override string Message { get { throw null; } } + } + public partial class ArithmeticException : System.Exception + { + public ArithmeticException() { } + public ArithmeticException(string message) { } + public ArithmeticException(string message, System.Exception innerException) { } + } + public abstract partial class Array : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable + { + internal Array() { } + public int Length { get { throw null; } } + public int Rank { get { throw null; } } + int System.Collections.ICollection.Count { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public static int BinarySearch(System.Array array, int index, int length, object value) { throw null; } + public static int BinarySearch(System.Array array, int index, int length, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(System.Array array, object value) { throw null; } + public static int BinarySearch(System.Array array, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, T value) { throw null; } + public static int BinarySearch(T[] array, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static void Clear(System.Array array, int index, int length) { } + public object Clone() { throw null; } + public static void ConstrainedCopy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public static void Copy(System.Array sourceArray, System.Array destinationArray, int length) { } + public static void Copy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public void CopyTo(System.Array array, int index) { } + public static System.Array CreateInstance(System.Type elementType, int length) { throw null; } + public static System.Array CreateInstance(System.Type elementType, params int[] lengths) { throw null; } + public static System.Array CreateInstance(System.Type elementType, int[] lengths, int[] lowerBounds) { throw null; } + public static T[] Empty() { throw null; } + public static bool Exists(T[] array, System.Predicate match) { throw null; } + public static T[] FindAll(T[] array, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, System.Predicate match) { throw null; } + public static T FindLast(T[] array, System.Predicate match) { throw null; } + public static T Find(T[] array, System.Predicate match) { throw null; } + public System.Collections.IEnumerator GetEnumerator() { throw null; } + public int GetLength(int dimension) { throw null; } + public int GetLowerBound(int dimension) { throw null; } + public int GetUpperBound(int dimension) { throw null; } + public object GetValue(int index) { throw null; } + public object GetValue(params int[] indices) { throw null; } + public static int IndexOf(System.Array array, object value) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int IndexOf(T[] array, T value) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public void Initialize() { } + public static int LastIndexOf(System.Array array, object value) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int LastIndexOf(T[] array, T value) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public static void Resize(ref T[] array, int newSize) { } + public static void Reverse(System.Array array) { } + public static void Reverse(System.Array array, int index, int length) { } + public void SetValue(object value, int index) { } + public void SetValue(object value, params int[] indices) { } + public static void Sort(System.Array array) { } + public static void Sort(System.Array keys, System.Array items) { } + public static void Sort(System.Array keys, System.Array items, System.Collections.IComparer comparer) { } + public static void Sort(System.Array keys, System.Array items, int index, int length) { } + public static void Sort(System.Array keys, System.Array items, int index, int length, System.Collections.IComparer comparer) { } + public static void Sort(System.Array array, System.Collections.IComparer comparer) { } + public static void Sort(System.Array array, int index, int length) { } + public static void Sort(System.Array array, int index, int length, System.Collections.IComparer comparer) { } + public static void Sort(T[] array) { } + public static void Sort(T[] array, System.Collections.Generic.IComparer comparer) { } + public static void Sort(T[] array, System.Comparison comparison) { } + public static void Sort(T[] array, int index, int length) { } + public static void Sort(T[] array, int index, int length, System.Collections.Generic.IComparer comparer) { } + public static void Sort(TKey[] keys, TValue[] items) { } + public static void Sort(TKey[] keys, TValue[] items, System.Collections.Generic.IComparer comparer) { } + public static void Sort(TKey[] keys, TValue[] items, int index, int length) { } + public static void Sort(TKey[] keys, TValue[] items, int index, int length, System.Collections.Generic.IComparer comparer) { } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + public static bool TrueForAll(T[] array, System.Predicate match) { throw null; } + } + public partial struct ArraySegment : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.IEnumerable + { + public ArraySegment(T[] array) { throw null; } + public ArraySegment(T[] array, int offset, int count) { throw null; } + public T[] Array { get { throw null; } } + public int Count { get { throw null; } } + public int Offset { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + T System.Collections.Generic.IReadOnlyList.this[int index] { get { throw null; } } + public bool Equals(System.ArraySegment obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.ArraySegment a, System.ArraySegment b) { throw null; } + public static bool operator !=(System.ArraySegment a, System.ArraySegment b) { throw null; } + void System.Collections.Generic.ICollection.Add(T item) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Contains(T item) { throw null; } + void System.Collections.Generic.ICollection.CopyTo(T[] array, int arrayIndex) { } + bool System.Collections.Generic.ICollection.Remove(T item) { throw null; } + System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.Generic.IList.IndexOf(T item) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T item) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + } + public partial class ArrayTypeMismatchException : System.Exception + { + public ArrayTypeMismatchException() { } + public ArrayTypeMismatchException(string message) { } + public ArrayTypeMismatchException(string message, System.Exception innerException) { } + } + public delegate void AsyncCallback(System.IAsyncResult ar); + public abstract partial class Attribute + { + protected Attribute() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + [System.FlagsAttribute] + public enum AttributeTargets + { + All = 32767, + Assembly = 1, + Class = 4, + Constructor = 32, + Delegate = 4096, + Enum = 16, + Event = 512, + Field = 256, + GenericParameter = 16384, + Interface = 1024, + Method = 64, + Module = 2, + Parameter = 2048, + Property = 128, + ReturnValue = 8192, + Struct = 8, + } + public sealed partial class AttributeUsageAttribute : System.Attribute + { + public AttributeUsageAttribute(System.AttributeTargets validOn) { } + public bool AllowMultiple { get { throw null; } set { } } + public bool Inherited { get { throw null; } set { } } + public System.AttributeTargets ValidOn { get { throw null; } } + } + public partial class BadImageFormatException : System.Exception + { + public BadImageFormatException() { } + public BadImageFormatException(string message) { } + public BadImageFormatException(string message, System.Exception inner) { } + public BadImageFormatException(string message, string fileName) { } + public BadImageFormatException(string message, string fileName, System.Exception inner) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial struct Boolean : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable + { + public static readonly string FalseString; + public static readonly string TrueString; + public int CompareTo(System.Boolean value) { throw null; } + public System.Boolean Equals(System.Boolean obj) { throw null; } + public override System.Boolean Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Boolean Parse(string value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + System.Boolean System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + string System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public static System.Boolean TryParse(string value, out System.Boolean result) { throw null; } + } + public static partial class Buffer + { + public static void BlockCopy(System.Array src, int srcOffset, System.Array dst, int dstOffset, int count) { } + public static int ByteLength(System.Array array) { throw null; } + public static byte GetByte(System.Array array, int index) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static void MemoryCopy(void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy) { } + [System.CLSCompliantAttribute(false)] + public unsafe static void MemoryCopy(void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy) { } + public static void SetByte(System.Array array, int index, byte value) { } + } + public partial struct Byte : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const byte MaxValue = (byte)255; + public const byte MinValue = (byte)0; + public int CompareTo(System.Byte value) { throw null; } + public bool Equals(System.Byte obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Byte Parse(string s) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Byte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + System.Byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Byte result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Byte result) { throw null; } + } + public partial struct Char : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable + { + public const char MaxValue = '\uFFFF'; + public const char MinValue = '\0'; + public int CompareTo(System.Char value) { throw null; } + public static string ConvertFromUtf32(int utf32) { throw null; } + public static int ConvertToUtf32(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static int ConvertToUtf32(string s, int index) { throw null; } + public bool Equals(System.Char obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static double GetNumericValue(System.Char c) { throw null; } + public static double GetNumericValue(string s, int index) { throw null; } + public static bool IsControl(System.Char c) { throw null; } + public static bool IsControl(string s, int index) { throw null; } + public static bool IsDigit(System.Char c) { throw null; } + public static bool IsDigit(string s, int index) { throw null; } + public static bool IsHighSurrogate(System.Char c) { throw null; } + public static bool IsHighSurrogate(string s, int index) { throw null; } + public static bool IsLetter(System.Char c) { throw null; } + public static bool IsLetter(string s, int index) { throw null; } + public static bool IsLetterOrDigit(System.Char c) { throw null; } + public static bool IsLetterOrDigit(string s, int index) { throw null; } + public static bool IsLower(System.Char c) { throw null; } + public static bool IsLower(string s, int index) { throw null; } + public static bool IsLowSurrogate(System.Char c) { throw null; } + public static bool IsLowSurrogate(string s, int index) { throw null; } + public static bool IsNumber(System.Char c) { throw null; } + public static bool IsNumber(string s, int index) { throw null; } + public static bool IsPunctuation(System.Char c) { throw null; } + public static bool IsPunctuation(string s, int index) { throw null; } + public static bool IsSeparator(System.Char c) { throw null; } + public static bool IsSeparator(string s, int index) { throw null; } + public static bool IsSurrogate(System.Char c) { throw null; } + public static bool IsSurrogate(string s, int index) { throw null; } + public static bool IsSurrogatePair(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static bool IsSurrogatePair(string s, int index) { throw null; } + public static bool IsSymbol(System.Char c) { throw null; } + public static bool IsSymbol(string s, int index) { throw null; } + public static bool IsUpper(System.Char c) { throw null; } + public static bool IsUpper(string s, int index) { throw null; } + public static bool IsWhiteSpace(System.Char c) { throw null; } + public static bool IsWhiteSpace(string s, int index) { throw null; } + public static System.Char Parse(string s) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + System.Char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + string System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public static System.Char ToLower(System.Char c) { throw null; } + public static System.Char ToLowerInvariant(System.Char c) { throw null; } + public override string ToString() { throw null; } + public static string ToString(System.Char c) { throw null; } + public static System.Char ToUpper(System.Char c) { throw null; } + public static System.Char ToUpperInvariant(System.Char c) { throw null; } + public static bool TryParse(string s, out System.Char result) { throw null; } + } + public sealed partial class CLSCompliantAttribute : System.Attribute + { + public CLSCompliantAttribute(bool isCompliant) { } + public bool IsCompliant { get { throw null; } } + } + public delegate int Comparison(T x, T y); + public partial struct DateTime : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public static readonly System.DateTime MaxValue; + public static readonly System.DateTime MinValue; + public DateTime(int year, int month, int day) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, System.DateTimeKind kind) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System.DateTimeKind kind) { throw null; } + public DateTime(long ticks) { throw null; } + public DateTime(long ticks, System.DateTimeKind kind) { throw null; } + public System.DateTime Date { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTimeKind Kind { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTime Now { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public static System.DateTime Today { get { throw null; } } + public static System.DateTime UtcNow { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTime Add(System.TimeSpan value) { throw null; } + public System.DateTime AddDays(double value) { throw null; } + public System.DateTime AddHours(double value) { throw null; } + public System.DateTime AddMilliseconds(double value) { throw null; } + public System.DateTime AddMinutes(double value) { throw null; } + public System.DateTime AddMonths(int months) { throw null; } + public System.DateTime AddSeconds(double value) { throw null; } + public System.DateTime AddTicks(long value) { throw null; } + public System.DateTime AddYears(int value) { throw null; } + public static int Compare(System.DateTime t1, System.DateTime t2) { throw null; } + public int CompareTo(System.DateTime value) { throw null; } + public static int DaysInMonth(int year, int month) { throw null; } + public bool Equals(System.DateTime value) { throw null; } + public static bool Equals(System.DateTime t1, System.DateTime t2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.DateTime FromBinary(long dateData) { throw null; } + public static System.DateTime FromFileTime(long fileTime) { throw null; } + public static System.DateTime FromFileTimeUtc(long fileTime) { throw null; } + public string[] GetDateTimeFormats() { throw null; } + public string[] GetDateTimeFormats(char format) { throw null; } + public string[] GetDateTimeFormats(char format, System.IFormatProvider provider) { throw null; } + public string[] GetDateTimeFormats(System.IFormatProvider provider) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsDaylightSavingTime() { throw null; } + public static bool IsLeapYear(int year) { throw null; } + public static System.DateTime operator +(System.DateTime d, System.TimeSpan t) { throw null; } + public static bool operator ==(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator >(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator >=(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator !=(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator <(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator <=(System.DateTime t1, System.DateTime t2) { throw null; } + public static System.TimeSpan operator -(System.DateTime d1, System.DateTime d2) { throw null; } + public static System.DateTime operator -(System.DateTime d, System.TimeSpan t) { throw null; } + public static System.DateTime Parse(string s) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime ParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime SpecifyKind(System.DateTime value, System.DateTimeKind kind) { throw null; } + public System.TimeSpan Subtract(System.DateTime value) { throw null; } + public System.DateTime Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public long ToBinary() { throw null; } + public long ToFileTime() { throw null; } + public long ToFileTimeUtc() { throw null; } + public System.DateTime ToLocalTime() { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public System.DateTime ToUniversalTime() { throw null; } + public static bool TryParse(string s, out System.DateTime result) { throw null; } + public static bool TryParse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + } + public enum DateTimeKind + { + Local = 2, + Unspecified = 0, + Utc = 1, + } + public partial struct DateTimeOffset : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.DateTimeOffset MaxValue; + public static readonly System.DateTimeOffset MinValue; + public DateTimeOffset(System.DateTime dateTime) { throw null; } + public DateTimeOffset(System.DateTime dateTime, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, System.TimeSpan offset) { throw null; } + public DateTimeOffset(long ticks, System.TimeSpan offset) { throw null; } + public System.DateTime Date { get { throw null; } } + public System.DateTime DateTime { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTime LocalDateTime { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTimeOffset Now { get { throw null; } } + public System.TimeSpan Offset { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public System.DateTime UtcDateTime { get { throw null; } } + public static System.DateTimeOffset UtcNow { get { throw null; } } + public long UtcTicks { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTimeOffset Add(System.TimeSpan timeSpan) { throw null; } + public System.DateTimeOffset AddDays(double days) { throw null; } + public System.DateTimeOffset AddHours(double hours) { throw null; } + public System.DateTimeOffset AddMilliseconds(double milliseconds) { throw null; } + public System.DateTimeOffset AddMinutes(double minutes) { throw null; } + public System.DateTimeOffset AddMonths(int months) { throw null; } + public System.DateTimeOffset AddSeconds(double seconds) { throw null; } + public System.DateTimeOffset AddTicks(long ticks) { throw null; } + public System.DateTimeOffset AddYears(int years) { throw null; } + public static int Compare(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public int CompareTo(System.DateTimeOffset other) { throw null; } + public bool Equals(System.DateTimeOffset other) { throw null; } + public static bool Equals(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool EqualsExact(System.DateTimeOffset other) { throw null; } + public static System.DateTimeOffset FromFileTime(long fileTime) { throw null; } + public static System.DateTimeOffset FromUnixTimeMilliseconds(long milliseconds) { throw null; } + public static System.DateTimeOffset FromUnixTimeSeconds(long seconds) { throw null; } + public override int GetHashCode() { throw null; } + public static System.DateTimeOffset operator +(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static bool operator ==(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static implicit operator System.DateTimeOffset (System.DateTime dateTime) { throw null; } + public static bool operator !=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.TimeSpan operator -(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.DateTimeOffset operator -(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static System.DateTimeOffset Parse(string input) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public System.TimeSpan Subtract(System.DateTimeOffset value) { throw null; } + public System.DateTimeOffset Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public long ToFileTime() { throw null; } + public System.DateTimeOffset ToLocalTime() { throw null; } + public System.DateTimeOffset ToOffset(System.TimeSpan offset) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider formatProvider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public System.DateTimeOffset ToUniversalTime() { throw null; } + public long ToUnixTimeMilliseconds() { throw null; } + public long ToUnixTimeSeconds() { throw null; } + public static bool TryParse(string input, out System.DateTimeOffset result) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + } + public enum DayOfWeek + { + Friday = 5, + Monday = 1, + Saturday = 6, + Sunday = 0, + Thursday = 4, + Tuesday = 2, + Wednesday = 3, + } + public partial struct Decimal : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MaxValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)0, (uint)0, (uint)1)] + public static readonly decimal MinusOne; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MinValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)1)] + public static readonly decimal One; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)0)] + public static readonly decimal Zero; + public Decimal(double value) { throw null; } + public Decimal(int value) { throw null; } + public Decimal(int lo, int mid, int hi, bool isNegative, byte scale) { throw null; } + public Decimal(int[] bits) { throw null; } + public Decimal(long value) { throw null; } + public Decimal(float value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(ulong value) { throw null; } + public static System.Decimal Add(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Ceiling(System.Decimal d) { throw null; } + public static int Compare(System.Decimal d1, System.Decimal d2) { throw null; } + public int CompareTo(System.Decimal value) { throw null; } + public static System.Decimal Divide(System.Decimal d1, System.Decimal d2) { throw null; } + public bool Equals(System.Decimal value) { throw null; } + public static bool Equals(System.Decimal d1, System.Decimal d2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.Decimal Floor(System.Decimal d) { throw null; } + public static int[] GetBits(System.Decimal d) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Decimal Multiply(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Negate(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator --(System.Decimal d) { throw null; } + public static System.Decimal operator /(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator ==(System.Decimal d1, System.Decimal d2) { throw null; } + public static explicit operator byte (System.Decimal value) { throw null; } + public static explicit operator char (System.Decimal value) { throw null; } + public static explicit operator double (System.Decimal value) { throw null; } + public static explicit operator short (System.Decimal value) { throw null; } + public static explicit operator int (System.Decimal value) { throw null; } + public static explicit operator long (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator sbyte (System.Decimal value) { throw null; } + public static explicit operator float (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ushort (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator uint (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ulong (System.Decimal value) { throw null; } + public static explicit operator System.Decimal (double value) { throw null; } + public static explicit operator System.Decimal (float value) { throw null; } + public static bool operator >(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator >=(System.Decimal d1, System.Decimal d2) { throw null; } + public static implicit operator System.Decimal (byte value) { throw null; } + public static implicit operator System.Decimal (char value) { throw null; } + public static implicit operator System.Decimal (short value) { throw null; } + public static implicit operator System.Decimal (int value) { throw null; } + public static implicit operator System.Decimal (long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (sbyte value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ulong value) { throw null; } + public static System.Decimal operator ++(System.Decimal d) { throw null; } + public static bool operator !=(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <=(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator %(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator *(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d) { throw null; } + public static System.Decimal Parse(string s) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Decimal Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.Decimal Remainder(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Subtract(System.Decimal d1, System.Decimal d2) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + System.Decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public static byte ToByte(System.Decimal value) { throw null; } + public static double ToDouble(System.Decimal d) { throw null; } + public static short ToInt16(System.Decimal value) { throw null; } + public static int ToInt32(System.Decimal d) { throw null; } + public static long ToInt64(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static sbyte ToSByte(System.Decimal value) { throw null; } + public static float ToSingle(System.Decimal d) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ushort ToUInt16(System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static uint ToUInt32(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ulong ToUInt64(System.Decimal d) { throw null; } + public static System.Decimal Truncate(System.Decimal d) { throw null; } + public static bool TryParse(string s, out System.Decimal result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Decimal result) { throw null; } + } + public abstract partial class Delegate + { + internal Delegate() { } + public object Target { get { throw null; } } + public static System.Delegate Combine(System.Delegate a, System.Delegate b) { throw null; } + public static System.Delegate Combine(params System.Delegate[] delegates) { throw null; } + public object DynamicInvoke(params object[] args) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public virtual System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.Delegate d1, System.Delegate d2) { throw null; } + public static bool operator !=(System.Delegate d1, System.Delegate d2) { throw null; } + public static System.Delegate Remove(System.Delegate source, System.Delegate value) { throw null; } + public static System.Delegate RemoveAll(System.Delegate source, System.Delegate value) { throw null; } + } + public partial class DivideByZeroException : System.ArithmeticException + { + public DivideByZeroException() { } + public DivideByZeroException(string message) { } + public DivideByZeroException(string message, System.Exception innerException) { } + } + public partial struct Double : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const double Epsilon = 4.94065645841247E-324; + public const double MaxValue = 1.7976931348623157E+308; + public const double MinValue = -1.7976931348623157E+308; + public const double NaN = 0.0 / 0.0; + public const double NegativeInfinity = -1.0 / 0.0; + public const double PositiveInfinity = 1.0 / 0.0; + public int CompareTo(System.Double value) { throw null; } + public bool Equals(System.Double obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Double d) { throw null; } + public static bool IsNaN(System.Double d) { throw null; } + public static bool IsNegativeInfinity(System.Double d) { throw null; } + public static bool IsPositiveInfinity(System.Double d) { throw null; } + public static bool operator ==(System.Double left, System.Double right) { throw null; } + public static bool operator >(System.Double left, System.Double right) { throw null; } + public static bool operator >=(System.Double left, System.Double right) { throw null; } + public static bool operator !=(System.Double left, System.Double right) { throw null; } + public static bool operator <(System.Double left, System.Double right) { throw null; } + public static bool operator <=(System.Double left, System.Double right) { throw null; } + public static System.Double Parse(string s) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Double Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + System.Double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Double result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Double result) { throw null; } + } + public abstract partial class Enum : System.ValueType, System.IComparable, System.IConvertible, System.IFormattable + { + protected Enum() { } + public int CompareTo(object target) { throw null; } + public override bool Equals(object obj) { throw null; } + public static string Format(System.Type enumType, object value, string format) { throw null; } + public override int GetHashCode() { throw null; } + public static string GetName(System.Type enumType, object value) { throw null; } + public static string[] GetNames(System.Type enumType) { throw null; } + public static System.Type GetUnderlyingType(System.Type enumType) { throw null; } + public static System.Array GetValues(System.Type enumType) { throw null; } + public bool HasFlag(System.Enum flag) { throw null; } + public static bool IsDefined(System.Type enumType, object value) { throw null; } + public static object Parse(System.Type enumType, string value) { throw null; } + public static object Parse(System.Type enumType, string value, bool ignoreCase) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + [System.ObsoleteAttribute("The provider argument is not used. Please use ToString().")] + string System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + [System.ObsoleteAttribute("The provider argument is not used. Please use ToString(String).")] + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public static object ToObject(System.Type enumType, object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string value, bool ignoreCase, out TEnum result) where TEnum : struct { throw null; } + public static bool TryParse(string value, out TEnum result) where TEnum : struct { throw null; } + } + public partial class EventArgs + { + public static readonly System.EventArgs Empty; + public EventArgs() { } + } + public delegate void EventHandler(object sender, System.EventArgs e); + public delegate void EventHandler(object sender, TEventArgs e); + public partial class Exception + { + public Exception() { } + public Exception(string message) { } + public Exception(string message, System.Exception innerException) { } + public virtual System.Collections.IDictionary Data { get { throw null; } } + public virtual string HelpLink { get { throw null; } set { } } + public int HResult { get { throw null; } protected set { } } + public System.Exception InnerException { get { throw null; } } + public virtual string Message { get { throw null; } } + public virtual string Source { get { throw null; } set { } } + public virtual string StackTrace { get { throw null; } } + public virtual System.Exception GetBaseException() { throw null; } + public override string ToString() { throw null; } + } + public partial class FieldAccessException : System.MemberAccessException + { + public FieldAccessException() { } + public FieldAccessException(string message) { } + public FieldAccessException(string message, System.Exception inner) { } + } + public partial class FlagsAttribute : System.Attribute + { + public FlagsAttribute() { } + } + public partial class FormatException : System.Exception + { + public FormatException() { } + public FormatException(string message) { } + public FormatException(string message, System.Exception innerException) { } + } + public abstract partial class FormattableString : System.IFormattable + { + protected FormattableString() { } + public abstract int ArgumentCount { get; } + public abstract string Format { get; } + public abstract object GetArgument(int index); + public abstract object[] GetArguments(); + public static string Invariant(System.FormattableString formattable) { throw null; } + string System.IFormattable.ToString(string ignored, System.IFormatProvider formatProvider) { throw null; } + public override string ToString() { throw null; } + public abstract string ToString(System.IFormatProvider formatProvider); + } + public delegate TResult Func(); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate TResult Func(T arg); + public delegate TResult Func(T1 arg1, T2 arg2); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public static partial class GC + { + public static int MaxGeneration { get { throw null; } } + public static void AddMemoryPressure(long bytesAllocated) { } + public static void Collect() { } + public static void Collect(int generation) { } + public static void Collect(int generation, System.GCCollectionMode mode) { } + public static void Collect(int generation, System.GCCollectionMode mode, bool blocking) { } + public static int CollectionCount(int generation) { throw null; } + public static int GetGeneration(object obj) { throw null; } + public static long GetTotalMemory(bool forceFullCollection) { throw null; } + public static void KeepAlive(object obj) { } + public static void RemoveMemoryPressure(long bytesAllocated) { } + public static void ReRegisterForFinalize(object obj) { } + public static void SuppressFinalize(object obj) { } + public static void WaitForPendingFinalizers() { } + } + public enum GCCollectionMode + { + Default = 0, + Forced = 1, + Optimized = 2, + } + public partial struct Guid : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.Guid Empty; + public Guid(byte[] b) { throw null; } + public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; } + public Guid(int a, short b, short c, byte[] d) { throw null; } + public Guid(string g) { throw null; } + [System.CLSCompliantAttribute(false)] + public Guid(uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; } + public int CompareTo(System.Guid value) { throw null; } + public bool Equals(System.Guid g) { throw null; } + public override bool Equals(object o) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Guid NewGuid() { throw null; } + public static bool operator ==(System.Guid a, System.Guid b) { throw null; } + public static bool operator !=(System.Guid a, System.Guid b) { throw null; } + public static System.Guid Parse(string input) { throw null; } + public static System.Guid ParseExact(string input, string format) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public byte[] ToByteArray() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string input, out System.Guid result) { throw null; } + public static bool TryParseExact(string input, string format, out System.Guid result) { throw null; } + } + public partial interface IAsyncResult + { + object AsyncState { get; } + System.Threading.WaitHandle AsyncWaitHandle { get; } + bool CompletedSynchronously { get; } + bool IsCompleted { get; } + } + public partial interface IComparable + { + int CompareTo(object obj); + } + public partial interface IComparable + { + int CompareTo(T other); + } + [System.CLSCompliantAttribute(false)] + public partial interface IConvertible + { + System.TypeCode GetTypeCode(); + bool ToBoolean(System.IFormatProvider provider); + byte ToByte(System.IFormatProvider provider); + char ToChar(System.IFormatProvider provider); + System.DateTime ToDateTime(System.IFormatProvider provider); + decimal ToDecimal(System.IFormatProvider provider); + double ToDouble(System.IFormatProvider provider); + short ToInt16(System.IFormatProvider provider); + int ToInt32(System.IFormatProvider provider); + long ToInt64(System.IFormatProvider provider); + sbyte ToSByte(System.IFormatProvider provider); + float ToSingle(System.IFormatProvider provider); + string ToString(System.IFormatProvider provider); + object ToType(System.Type conversionType, System.IFormatProvider provider); + ushort ToUInt16(System.IFormatProvider provider); + uint ToUInt32(System.IFormatProvider provider); + ulong ToUInt64(System.IFormatProvider provider); + } + public partial interface ICustomFormatter + { + string Format(string format, object arg, System.IFormatProvider formatProvider); + } + public partial interface IDisposable + { + void Dispose(); + } + public partial interface IEquatable + { + bool Equals(T other); + } + public partial interface IFormatProvider + { + object GetFormat(System.Type formatType); + } + public partial interface IFormattable + { + string ToString(string format, System.IFormatProvider formatProvider); + } + public sealed partial class IndexOutOfRangeException : System.Exception + { + public IndexOutOfRangeException() { } + public IndexOutOfRangeException(string message) { } + public IndexOutOfRangeException(string message, System.Exception innerException) { } + } + public sealed partial class InsufficientExecutionStackException : System.Exception + { + public InsufficientExecutionStackException() { } + public InsufficientExecutionStackException(string message) { } + public InsufficientExecutionStackException(string message, System.Exception innerException) { } + } + public partial struct Int16 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const short MaxValue = (short)32767; + public const short MinValue = (short)-32768; + public int CompareTo(System.Int16 value) { throw null; } + public bool Equals(System.Int16 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int16 Parse(string s) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + System.Int16 System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int16 result) { throw null; } + public static bool TryParse(string s, out System.Int16 result) { throw null; } + } + public partial struct Int32 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const int MaxValue = 2147483647; + public const int MinValue = -2147483648; + public System.Int32 CompareTo(System.Int32 value) { throw null; } + public bool Equals(System.Int32 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override System.Int32 GetHashCode() { throw null; } + public static System.Int32 Parse(string s) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int32 Parse(string s, System.IFormatProvider provider) { throw null; } + System.Int32 System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + System.Int32 System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int32 result) { throw null; } + public static bool TryParse(string s, out System.Int32 result) { throw null; } + } + public partial struct Int64 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const long MaxValue = (long)9223372036854775807; + public const long MinValue = (long)-9223372036854775808; + public int CompareTo(System.Int64 value) { throw null; } + public bool Equals(System.Int64 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int64 Parse(string s) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + System.Int64 System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int64 result) { throw null; } + public static bool TryParse(string s, out System.Int64 result) { throw null; } + } + public partial struct IntPtr + { + public static readonly System.IntPtr Zero; + public IntPtr(int value) { throw null; } + public IntPtr(long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe IntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.IntPtr Add(System.IntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.IntPtr operator +(System.IntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static explicit operator System.IntPtr (int value) { throw null; } + public static explicit operator System.IntPtr (long value) { throw null; } + public static explicit operator int (System.IntPtr value) { throw null; } + public static explicit operator long (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.IntPtr (void* value) { throw null; } + public static bool operator !=(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static System.IntPtr operator -(System.IntPtr pointer, int offset) { throw null; } + public static System.IntPtr Subtract(System.IntPtr pointer, int offset) { throw null; } + public int ToInt32() { throw null; } + public long ToInt64() { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + } + public partial class InvalidCastException : System.Exception + { + public InvalidCastException() { } + public InvalidCastException(string message) { } + public InvalidCastException(string message, System.Exception innerException) { } + public InvalidCastException(string message, int errorCode) { } + } + public partial class InvalidOperationException : System.Exception + { + public InvalidOperationException() { } + public InvalidOperationException(string message) { } + public InvalidOperationException(string message, System.Exception innerException) { } + } + public sealed partial class InvalidProgramException : System.Exception + { + public InvalidProgramException() { } + public InvalidProgramException(string message) { } + public InvalidProgramException(string message, System.Exception inner) { } + } + public partial class InvalidTimeZoneException : System.Exception + { + public InvalidTimeZoneException() { } + public InvalidTimeZoneException(string message) { } + public InvalidTimeZoneException(string message, System.Exception innerException) { } + } + public partial interface IObservable + { + System.IDisposable Subscribe(System.IObserver observer); + } + public partial interface IObserver + { + void OnCompleted(); + void OnError(System.Exception error); + void OnNext(T value); + } + public partial interface IProgress + { + void Report(T value); + } + public partial class Lazy + { + public Lazy() { } + public Lazy(bool isThreadSafe) { } + public Lazy(System.Func valueFactory) { } + public Lazy(System.Func valueFactory, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(System.Threading.LazyThreadSafetyMode mode) { } + public bool IsValueCreated { get { throw null; } } + public T Value { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class Lazy : System.Lazy + { + public Lazy(System.Func valueFactory, TMetadata metadata) { } + public Lazy(System.Func valueFactory, TMetadata metadata, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(TMetadata metadata) { } + public Lazy(TMetadata metadata, bool isThreadSafe) { } + public Lazy(TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public TMetadata Metadata { get { throw null; } } + } + public partial class MemberAccessException : System.Exception + { + public MemberAccessException() { } + public MemberAccessException(string message) { } + public MemberAccessException(string message, System.Exception inner) { } + } + public partial class MethodAccessException : System.MemberAccessException + { + public MethodAccessException() { } + public MethodAccessException(string message) { } + public MethodAccessException(string message, System.Exception inner) { } + } + public partial class MissingFieldException : System.MissingMemberException + { + public MissingFieldException() { } + public MissingFieldException(string message) { } + public MissingFieldException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public partial class MissingMemberException : System.MemberAccessException + { + public MissingMemberException() { } + public MissingMemberException(string message) { } + public MissingMemberException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public partial class MissingMethodException : System.MissingMemberException + { + public MissingMethodException() { } + public MissingMethodException(string message) { } + public MissingMethodException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public sealed partial class MTAThreadAttribute : System.Attribute + { + public MTAThreadAttribute() { } + } + public abstract partial class MulticastDelegate : System.Delegate + { + internal MulticastDelegate() { } + public sealed override bool Equals(object obj) { throw null; } + public sealed override int GetHashCode() { throw null; } + public sealed override System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + public static bool operator !=(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + } + public partial class NotImplementedException : System.Exception + { + public NotImplementedException() { } + public NotImplementedException(string message) { } + public NotImplementedException(string message, System.Exception inner) { } + } + public partial class NotSupportedException : System.Exception + { + public NotSupportedException() { } + public NotSupportedException(string message) { } + public NotSupportedException(string message, System.Exception innerException) { } + } + public static partial class Nullable + { + public static int Compare(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static bool Equals(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static System.Type GetUnderlyingType(System.Type nullableType) { throw null; } + } + public partial struct Nullable where T : struct + { + public Nullable(T value) { throw null; } + public bool HasValue { get { throw null; } } + public T Value { get { throw null; } } + public override bool Equals(object other) { throw null; } + public override int GetHashCode() { throw null; } + public T GetValueOrDefault() { throw null; } + public T GetValueOrDefault(T defaultValue) { throw null; } + public static explicit operator T (System.Nullable value) { throw null; } + public static implicit operator System.Nullable (T value) { throw null; } + public override string ToString() { throw null; } + } + public partial class NullReferenceException : System.Exception + { + public NullReferenceException() { } + public NullReferenceException(string message) { } + public NullReferenceException(string message, System.Exception innerException) { } + } + public partial class Object + { + public Object() { } + public virtual bool Equals(System.Object obj) { throw null; } + public static bool Equals(System.Object objA, System.Object objB) { throw null; } + ~Object() { } + public virtual int GetHashCode() { throw null; } + public System.Type GetType() { throw null; } + protected System.Object MemberwiseClone() { throw null; } + public static bool ReferenceEquals(System.Object objA, System.Object objB) { throw null; } + public virtual string ToString() { throw null; } + } + public partial class ObjectDisposedException : System.InvalidOperationException + { + public ObjectDisposedException(string objectName) { } + public ObjectDisposedException(string message, System.Exception innerException) { } + public ObjectDisposedException(string objectName, string message) { } + public override string Message { get { throw null; } } + public string ObjectName { get { throw null; } } + } + public sealed partial class ObsoleteAttribute : System.Attribute + { + public ObsoleteAttribute() { } + public ObsoleteAttribute(string message) { } + public ObsoleteAttribute(string message, bool error) { } + public bool IsError { get { throw null; } } + public string Message { get { throw null; } } + } + public partial class OutOfMemoryException : System.Exception + { + public OutOfMemoryException() { } + public OutOfMemoryException(string message) { } + public OutOfMemoryException(string message, System.Exception innerException) { } + } + public partial class OverflowException : System.ArithmeticException + { + public OverflowException() { } + public OverflowException(string message) { } + public OverflowException(string message, System.Exception innerException) { } + } + public sealed partial class ParamArrayAttribute : System.Attribute + { + public ParamArrayAttribute() { } + } + public partial class PlatformNotSupportedException : System.NotSupportedException + { + public PlatformNotSupportedException() { } + public PlatformNotSupportedException(string message) { } + public PlatformNotSupportedException(string message, System.Exception inner) { } + } + public delegate bool Predicate(T obj); + public partial class RankException : System.Exception + { + public RankException() { } + public RankException(string message) { } + public RankException(string message, System.Exception innerException) { } + } + public partial struct RuntimeFieldHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeFieldHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + public static bool operator !=(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + } + public partial struct RuntimeMethodHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeMethodHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + public static bool operator !=(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + } + public partial struct RuntimeTypeHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeTypeHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator ==(System.RuntimeTypeHandle left, object right) { throw null; } + public static bool operator !=(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator !=(System.RuntimeTypeHandle left, object right) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct SByte : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const sbyte MaxValue = (sbyte)127; + public const sbyte MinValue = (sbyte)-128; + public int CompareTo(System.SByte value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.SByte obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + System.SByte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.SByte result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.SByte result) { throw null; } + } + public partial struct Single : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const float Epsilon = 1.401298E-45f; + public const float MaxValue = 3.40282347E+38f; + public const float MinValue = -3.40282347E+38f; + public const float NaN = 0.0f / 0.0f; + public const float NegativeInfinity = -1.0f / 0.0f; + public const float PositiveInfinity = 1.0f / 0.0f; + public int CompareTo(System.Single value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Single obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Single f) { throw null; } + public static bool IsNaN(System.Single f) { throw null; } + public static bool IsNegativeInfinity(System.Single f) { throw null; } + public static bool IsPositiveInfinity(System.Single f) { throw null; } + public static bool operator ==(System.Single left, System.Single right) { throw null; } + public static bool operator >(System.Single left, System.Single right) { throw null; } + public static bool operator >=(System.Single left, System.Single right) { throw null; } + public static bool operator !=(System.Single left, System.Single right) { throw null; } + public static bool operator <(System.Single left, System.Single right) { throw null; } + public static bool operator <=(System.Single left, System.Single right) { throw null; } + public static System.Single Parse(string s) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Single Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + System.Single System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Single result) { throw null; } + public static bool TryParse(string s, out System.Single result) { throw null; } + } + public sealed partial class STAThreadAttribute : System.Attribute + { + public STAThreadAttribute() { } + } + public sealed partial class String : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IComparable, System.IComparable, System.IConvertible, System.IEquatable + { + public static readonly string Empty; + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value) { } + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value, int startIndex, int length) { } + public String(char c, int count) { } + public String(char[] value) { } + public String(char[] value, int startIndex, int length) { } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } } + public int Length { get { throw null; } } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length, System.StringComparison comparisonType) { throw null; } + public static int Compare(System.String strA, System.String strB) { throw null; } + public static int Compare(System.String strA, System.String strB, bool ignoreCase) { throw null; } + public static int Compare(System.String strA, System.String strB, System.StringComparison comparisonType) { throw null; } + public static int CompareOrdinal(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int CompareOrdinal(System.String strA, System.String strB) { throw null; } + public int CompareTo(System.String strB) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Concat(object arg0) { throw null; } + public static System.String Concat(object arg0, object arg1) { throw null; } + public static System.String Concat(object arg0, object arg1, object arg2) { throw null; } + public static System.String Concat(params object[] args) { throw null; } + public static System.String Concat(System.String str0, System.String str1) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2, System.String str3) { throw null; } + public static System.String Concat(params string[] values) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public bool Contains(System.String value) { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public bool EndsWith(System.String value) { throw null; } + public bool EndsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.String value) { throw null; } + public static bool Equals(System.String a, System.String b) { throw null; } + public static bool Equals(System.String a, System.String b, System.StringComparison comparisonType) { throw null; } + public bool Equals(System.String value, System.StringComparison comparisonType) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, object arg0) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, object arg0, object arg1) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, object arg0, object arg1, object arg2) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, params object[] args) { throw null; } + public static System.String Format(System.String format, object arg0) { throw null; } + public static System.String Format(System.String format, object arg0, object arg1) { throw null; } + public static System.String Format(System.String format, object arg0, object arg1, object arg2) { throw null; } + public static System.String Format(System.String format, params object[] args) { throw null; } + public override int GetHashCode() { throw null; } + public int IndexOf(char value) { throw null; } + public int IndexOf(char value, int startIndex) { throw null; } + public int IndexOf(char value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value) { throw null; } + public int IndexOf(System.String value, int startIndex) { throw null; } + public int IndexOf(System.String value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int IndexOfAny(char[] anyOf) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public System.String Insert(int startIndex, System.String value) { throw null; } + public static bool IsNullOrEmpty(System.String value) { throw null; } + public static bool IsNullOrWhiteSpace(System.String value) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Join(System.String separator, params object[] values) { throw null; } + public static System.String Join(System.String separator, params string[] value) { throw null; } + public static System.String Join(System.String separator, string[] value, int startIndex, int count) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public int LastIndexOf(char value) { throw null; } + public int LastIndexOf(char value, int startIndex) { throw null; } + public int LastIndexOf(char value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value) { throw null; } + public int LastIndexOf(System.String value, int startIndex) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int LastIndexOfAny(char[] anyOf) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public static bool operator ==(System.String a, System.String b) { throw null; } + public static bool operator !=(System.String a, System.String b) { throw null; } + public System.String PadLeft(int totalWidth) { throw null; } + public System.String PadLeft(int totalWidth, char paddingChar) { throw null; } + public System.String PadRight(int totalWidth) { throw null; } + public System.String PadRight(int totalWidth, char paddingChar) { throw null; } + public System.String Remove(int startIndex) { throw null; } + public System.String Remove(int startIndex, int count) { throw null; } + public System.String Replace(char oldChar, char newChar) { throw null; } + public System.String Replace(System.String oldValue, System.String newValue) { throw null; } + public string[] Split(params char[] separator) { throw null; } + public string[] Split(char[] separator, int count) { throw null; } + public string[] Split(char[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(char[] separator, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, System.StringSplitOptions options) { throw null; } + public bool StartsWith(System.String value) { throw null; } + public bool StartsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public System.String Substring(int startIndex) { throw null; } + public System.String Substring(int startIndex, int length) { throw null; } + System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + System.String System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public char[] ToCharArray() { throw null; } + public char[] ToCharArray(int startIndex, int length) { throw null; } + public System.String ToLower() { throw null; } + public System.String ToLowerInvariant() { throw null; } + public override System.String ToString() { throw null; } + public System.String ToUpper() { throw null; } + public System.String ToUpperInvariant() { throw null; } + public System.String Trim() { throw null; } + public System.String Trim(params char[] trimChars) { throw null; } + public System.String TrimEnd(params char[] trimChars) { throw null; } + public System.String TrimStart(params char[] trimChars) { throw null; } + } + public enum StringComparison + { + CurrentCulture = 0, + CurrentCultureIgnoreCase = 1, + Ordinal = 4, + OrdinalIgnoreCase = 5, + } + [System.FlagsAttribute] + public enum StringSplitOptions + { + None = 0, + RemoveEmptyEntries = 1, + } + public partial class ThreadStaticAttribute : System.Attribute + { + public ThreadStaticAttribute() { } + } + public partial class TimeoutException : System.Exception + { + public TimeoutException() { } + public TimeoutException(string message) { } + public TimeoutException(string message, System.Exception innerException) { } + } + public partial struct TimeSpan : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.TimeSpan MaxValue; + public static readonly System.TimeSpan MinValue; + public const long TicksPerDay = (long)864000000000; + public const long TicksPerHour = (long)36000000000; + public const long TicksPerMillisecond = (long)10000; + public const long TicksPerMinute = (long)600000000; + public const long TicksPerSecond = (long)10000000; + public static readonly System.TimeSpan Zero; + public TimeSpan(int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds) { throw null; } + public TimeSpan(long ticks) { throw null; } + public int Days { get { throw null; } } + public int Hours { get { throw null; } } + public int Milliseconds { get { throw null; } } + public int Minutes { get { throw null; } } + public int Seconds { get { throw null; } } + public long Ticks { get { throw null; } } + public double TotalDays { get { throw null; } } + public double TotalHours { get { throw null; } } + public double TotalMilliseconds { get { throw null; } } + public double TotalMinutes { get { throw null; } } + public double TotalSeconds { get { throw null; } } + public System.TimeSpan Add(System.TimeSpan ts) { throw null; } + public static int Compare(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public int CompareTo(System.TimeSpan value) { throw null; } + public System.TimeSpan Duration() { throw null; } + public override bool Equals(object value) { throw null; } + public bool Equals(System.TimeSpan obj) { throw null; } + public static bool Equals(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan FromDays(double value) { throw null; } + public static System.TimeSpan FromHours(double value) { throw null; } + public static System.TimeSpan FromMilliseconds(double value) { throw null; } + public static System.TimeSpan FromMinutes(double value) { throw null; } + public static System.TimeSpan FromSeconds(double value) { throw null; } + public static System.TimeSpan FromTicks(long value) { throw null; } + public override int GetHashCode() { throw null; } + public System.TimeSpan Negate() { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator ==(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator !=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t) { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t) { throw null; } + public static System.TimeSpan Parse(string s) { throw null; } + public static System.TimeSpan Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public System.TimeSpan Subtract(System.TimeSpan ts) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParse(string s, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + } + public sealed partial class TimeZoneInfo : System.IEquatable + { + internal TimeZoneInfo() { } + public System.TimeSpan BaseUtcOffset { get { throw null; } } + public string DaylightName { get { throw null; } } + public string DisplayName { get { throw null; } } + public string Id { get { throw null; } } + public static System.TimeZoneInfo Local { get { throw null; } } + public string StandardName { get { throw null; } } + public bool SupportsDaylightSavingTime { get { throw null; } } + public static System.TimeZoneInfo Utc { get { throw null; } } + public static System.DateTime ConvertTime(System.DateTime dateTime, System.TimeZoneInfo destinationTimeZone) { throw null; } + public static System.DateTime ConvertTime(System.DateTime dateTime, System.TimeZoneInfo sourceTimeZone, System.TimeZoneInfo destinationTimeZone) { throw null; } + public static System.DateTimeOffset ConvertTime(System.DateTimeOffset dateTimeOffset, System.TimeZoneInfo destinationTimeZone) { throw null; } + public bool Equals(System.TimeZoneInfo other) { throw null; } + public static System.TimeZoneInfo FindSystemTimeZoneById(string id) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTime dateTime) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTimeOffset dateTimeOffset) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Collections.ObjectModel.ReadOnlyCollection GetSystemTimeZones() { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTime dateTime) { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsAmbiguousTime(System.DateTime dateTime) { throw null; } + public bool IsAmbiguousTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsDaylightSavingTime(System.DateTime dateTime) { throw null; } + public bool IsDaylightSavingTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsInvalidTime(System.DateTime dateTime) { throw null; } + public override string ToString() { throw null; } + } + public static partial class Tuple + { + public static System.Tuple Create(T1 item1) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { throw null; } + public static System.Tuple> Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8) { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1) { } + public T1 Item1 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public TRest Rest { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public abstract partial class Type + { + internal Type() { } + public static readonly System.Type[] EmptyTypes; + public static readonly object Missing; + public abstract string AssemblyQualifiedName { get; } + public abstract System.Type DeclaringType { get; } + public abstract string FullName { get; } + public abstract int GenericParameterPosition { get; } + public abstract System.Type[] GenericTypeArguments { get; } + public bool HasElementType { get { throw null; } } + public virtual bool IsArray { get { throw null; } } + public virtual bool IsByRef { get { throw null; } } + public abstract bool IsConstructedGenericType { get; } + public abstract bool IsGenericParameter { get; } + public bool IsNested { get { throw null; } } + public virtual bool IsPointer { get { throw null; } } + public abstract string Name { get; } + public abstract string Namespace { get; } + public virtual System.RuntimeTypeHandle TypeHandle { get { throw null; } } + public override bool Equals(object o) { throw null; } + public bool Equals(System.Type o) { throw null; } + public abstract int GetArrayRank(); + public abstract System.Type GetElementType(); + public abstract System.Type GetGenericTypeDefinition(); + public override int GetHashCode() { throw null; } + public static System.Type GetType(string typeName) { throw null; } + public static System.Type GetType(string typeName, bool throwOnError) { throw null; } + public static System.Type GetType(string typeName, bool throwOnError, bool ignoreCase) { throw null; } + public static System.Type GetTypeFromHandle(System.RuntimeTypeHandle handle) { throw null; } + public abstract System.Type MakeArrayType(); + public abstract System.Type MakeArrayType(int rank); + public abstract System.Type MakeByRefType(); + public abstract System.Type MakeGenericType(params System.Type[] typeArguments); + public abstract System.Type MakePointerType(); + public override string ToString() { throw null; } + } + public partial class TypeAccessException : System.TypeLoadException + { + public TypeAccessException() { } + public TypeAccessException(string message) { } + public TypeAccessException(string message, System.Exception inner) { } + } + public enum TypeCode + { + Boolean = 3, + Byte = 6, + Char = 4, + DateTime = 16, + Decimal = 15, + Double = 14, + Empty = 0, + Int16 = 7, + Int32 = 9, + Int64 = 11, + Object = 1, + SByte = 5, + Single = 13, + String = 18, + UInt16 = 8, + UInt32 = 10, + UInt64 = 12, + } + public sealed partial class TypeInitializationException : System.Exception + { + public TypeInitializationException(string fullTypeName, System.Exception innerException) { } + public string TypeName { get { throw null; } } + } + public partial class TypeLoadException : System.Exception + { + public TypeLoadException() { } + public TypeLoadException(string message) { } + public TypeLoadException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + public string TypeName { get { throw null; } } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt16 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const ushort MaxValue = (ushort)65535; + public const ushort MinValue = (ushort)0; + public int CompareTo(System.UInt16 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt16 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + System.UInt16 System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt16 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt16 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt32 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const uint MaxValue = (uint)4294967295; + public const uint MinValue = (uint)0; + public int CompareTo(System.UInt32 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt32 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + System.UInt32 System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt32 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt32 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt64 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const ulong MaxValue = (ulong)18446744073709551615; + public const ulong MinValue = (ulong)0; + public int CompareTo(System.UInt64 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt64 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + System.UInt64 System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt64 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt64 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UIntPtr + { + public static readonly System.UIntPtr Zero; + public UIntPtr(uint value) { throw null; } + public UIntPtr(ulong value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe UIntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.UIntPtr Add(System.UIntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.UIntPtr operator +(System.UIntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static explicit operator System.UIntPtr (uint value) { throw null; } + public static explicit operator System.UIntPtr (ulong value) { throw null; } + public static explicit operator uint (System.UIntPtr value) { throw null; } + public static explicit operator ulong (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.UIntPtr (void* value) { throw null; } + public static bool operator !=(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static System.UIntPtr operator -(System.UIntPtr pointer, int offset) { throw null; } + public static System.UIntPtr Subtract(System.UIntPtr pointer, int offset) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public uint ToUInt32() { throw null; } + public ulong ToUInt64() { throw null; } + } + public partial class UnauthorizedAccessException : System.Exception + { + public UnauthorizedAccessException() { } + public UnauthorizedAccessException(string message) { } + public UnauthorizedAccessException(string message, System.Exception inner) { } + } + public partial class Uri + { + public Uri(string uriString) { } + public Uri(string uriString, System.UriKind uriKind) { } + public Uri(System.Uri baseUri, string relativeUri) { } + public Uri(System.Uri baseUri, System.Uri relativeUri) { } + public string AbsolutePath { get { throw null; } } + public string AbsoluteUri { get { throw null; } } + public string Authority { get { throw null; } } + public string DnsSafeHost { get { throw null; } } + public string Fragment { get { throw null; } } + public string Host { get { throw null; } } + public System.UriHostNameType HostNameType { get { throw null; } } + public string IdnHost { get { throw null; } } + public bool IsAbsoluteUri { get { throw null; } } + public bool IsDefaultPort { get { throw null; } } + public bool IsFile { get { throw null; } } + public bool IsLoopback { get { throw null; } } + public bool IsUnc { get { throw null; } } + public string LocalPath { get { throw null; } } + public string OriginalString { get { throw null; } } + public string PathAndQuery { get { throw null; } } + public int Port { get { throw null; } } + public string Query { get { throw null; } } + public string Scheme { get { throw null; } } + public string[] Segments { get { throw null; } } + public bool UserEscaped { get { throw null; } } + public string UserInfo { get { throw null; } } + public static System.UriHostNameType CheckHostName(string name) { throw null; } + public static bool CheckSchemeName(string schemeName) { throw null; } + public static int Compare(System.Uri uri1, System.Uri uri2, System.UriComponents partsToCompare, System.UriFormat compareFormat, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object comparand) { throw null; } + public static string EscapeDataString(string stringToEscape) { throw null; } + public static string EscapeUriString(string stringToEscape) { throw null; } + public string GetComponents(System.UriComponents components, System.UriFormat format) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsBaseOf(System.Uri uri) { throw null; } + public bool IsWellFormedOriginalString() { throw null; } + public static bool IsWellFormedUriString(string uriString, System.UriKind uriKind) { throw null; } + public System.Uri MakeRelativeUri(System.Uri uri) { throw null; } + public static bool operator ==(System.Uri uri1, System.Uri uri2) { throw null; } + public static bool operator !=(System.Uri uri1, System.Uri uri2) { throw null; } + public override string ToString() { throw null; } + public static bool TryCreate(string uriString, System.UriKind uriKind, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, string relativeUri, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, System.Uri relativeUri, out System.Uri result) { throw null; } + public static string UnescapeDataString(string stringToUnescape) { throw null; } + } + [System.FlagsAttribute] + public enum UriComponents + { + AbsoluteUri = 127, + Fragment = 64, + Host = 4, + HostAndPort = 132, + HttpRequestUrl = 61, + KeepDelimiter = 1073741824, + NormalizedHost = 256, + Path = 16, + PathAndQuery = 48, + Port = 8, + Query = 32, + Scheme = 1, + SchemeAndServer = 13, + SerializationInfoString = -2147483648, + StrongAuthority = 134, + StrongPort = 128, + UserInfo = 2, + } + public enum UriFormat + { + SafeUnescaped = 3, + Unescaped = 2, + UriEscaped = 1, + } + public partial class UriFormatException : System.FormatException + { + public UriFormatException() { } + public UriFormatException(string textString) { } + public UriFormatException(string textString, System.Exception e) { } + } + public enum UriHostNameType + { + Basic = 1, + Dns = 2, + IPv4 = 3, + IPv6 = 4, + Unknown = 0, + } + public enum UriKind + { + Absolute = 1, + Relative = 2, + RelativeOrAbsolute = 0, + } + public abstract partial class ValueType + { + protected ValueType() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public override string ToString() { throw null; } + } + public sealed partial class Version : System.IComparable, System.IComparable, System.IEquatable + { + public Version(int major, int minor) { } + public Version(int major, int minor, int build) { } + public Version(int major, int minor, int build, int revision) { } + public Version(string version) { } + public int Build { get { throw null; } } + public int Major { get { throw null; } } + public short MajorRevision { get { throw null; } } + public int Minor { get { throw null; } } + public short MinorRevision { get { throw null; } } + public int Revision { get { throw null; } } + public int CompareTo(System.Version value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Version obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Version v1, System.Version v2) { throw null; } + public static bool operator >(System.Version v1, System.Version v2) { throw null; } + public static bool operator >=(System.Version v1, System.Version v2) { throw null; } + public static bool operator !=(System.Version v1, System.Version v2) { throw null; } + public static bool operator <(System.Version v1, System.Version v2) { throw null; } + public static bool operator <=(System.Version v1, System.Version v2) { throw null; } + public static System.Version Parse(string input) { throw null; } + int System.IComparable.CompareTo(object version) { throw null; } + public override string ToString() { throw null; } + public string ToString(int fieldCount) { throw null; } + public static bool TryParse(string input, out System.Version result) { throw null; } + } + public partial struct Void + { + } + public partial class WeakReference + { + public WeakReference(object target) { } + public WeakReference(object target, bool trackResurrection) { } + public virtual bool IsAlive { get { throw null; } } + public virtual object Target { get { throw null; } set { } } + public virtual bool TrackResurrection { get { throw null; } } + ~WeakReference() { } + } + public sealed partial class WeakReference where T : class + { + public WeakReference(T target) { } + public WeakReference(T target, bool trackResurrection) { } + ~WeakReference() { } + public void SetTarget(T target) { } + public bool TryGetTarget(out T target) { throw null; } + } +} +namespace System.Collections +{ + public partial struct DictionaryEntry + { + public DictionaryEntry(object key, object value) { throw null; } + public object Key { get { throw null; } set { } } + public object Value { get { throw null; } set { } } + } + public partial interface ICollection : System.Collections.IEnumerable + { + int Count { get; } + bool IsSynchronized { get; } + object SyncRoot { get; } + void CopyTo(System.Array array, int index); + } + public partial interface IComparer + { + int Compare(object x, object y); + } + public partial interface IDictionary : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[object key] { get; set; } + System.Collections.ICollection Keys { get; } + System.Collections.ICollection Values { get; } + void Add(object key, object value); + void Clear(); + bool Contains(object key); + new System.Collections.IDictionaryEnumerator GetEnumerator(); + void Remove(object key); + } + public partial interface IDictionaryEnumerator : System.Collections.IEnumerator + { + System.Collections.DictionaryEntry Entry { get; } + object Key { get; } + object Value { get; } + } + public partial interface IEnumerable + { + System.Collections.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator + { + object Current { get; } + bool MoveNext(); + void Reset(); + } + public partial interface IEqualityComparer + { + bool Equals(object x, object y); + int GetHashCode(object obj); + } + public partial interface IList : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[int index] { get; set; } + int Add(object value); + void Clear(); + bool Contains(object value); + int IndexOf(object value); + void Insert(int index, object value); + void Remove(object value); + void RemoveAt(int index); + } + public partial interface IStructuralComparable + { + int CompareTo(object other, System.Collections.IComparer comparer); + } + public partial interface IStructuralEquatable + { + bool Equals(object other, System.Collections.IEqualityComparer comparer); + int GetHashCode(System.Collections.IEqualityComparer comparer); + } +} +namespace System.Collections.Generic +{ + public partial interface ICollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + bool IsReadOnly { get; } + void Add(T item); + void Clear(); + bool Contains(T item); + void CopyTo(T[] array, int arrayIndex); + bool Remove(T item); + } + public partial interface IComparer + { + int Compare(T x, T y); + } + public partial interface IDictionary : System.Collections.Generic.ICollection>, System.Collections.Generic.IEnumerable>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; set; } + System.Collections.Generic.ICollection Keys { get; } + System.Collections.Generic.ICollection Values { get; } + void Add(TKey key, TValue value); + bool ContainsKey(TKey key); + bool Remove(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IEnumerable : System.Collections.IEnumerable + { + new System.Collections.Generic.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator : System.Collections.IEnumerator, System.IDisposable + { + new T Current { get; } + } + public partial interface IEqualityComparer + { + bool Equals(T x, T y); + int GetHashCode(T obj); + } + public partial interface IList : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + T this[int index] { get; set; } + int IndexOf(T item); + void Insert(int index, T item); + void RemoveAt(int index); + } + public partial interface IReadOnlyCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + } + public partial interface IReadOnlyDictionary : System.Collections.Generic.IEnumerable>, System.Collections.Generic.IReadOnlyCollection>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; } + System.Collections.Generic.IEnumerable Keys { get; } + System.Collections.Generic.IEnumerable Values { get; } + bool ContainsKey(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IReadOnlyList : System.Collections.Generic.IEnumerable, System.Collections.Generic.IReadOnlyCollection, System.Collections.IEnumerable + { + T this[int index] { get; } + } + public partial interface ISet : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + new bool Add(T item); + void ExceptWith(System.Collections.Generic.IEnumerable other); + void IntersectWith(System.Collections.Generic.IEnumerable other); + bool IsProperSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsProperSupersetOf(System.Collections.Generic.IEnumerable other); + bool IsSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsSupersetOf(System.Collections.Generic.IEnumerable other); + bool Overlaps(System.Collections.Generic.IEnumerable other); + bool SetEquals(System.Collections.Generic.IEnumerable other); + void SymmetricExceptWith(System.Collections.Generic.IEnumerable other); + void UnionWith(System.Collections.Generic.IEnumerable other); + } + public partial class KeyNotFoundException : System.Exception + { + public KeyNotFoundException() { } + public KeyNotFoundException(string message) { } + public KeyNotFoundException(string message, System.Exception innerException) { } + } + public partial struct KeyValuePair + { + public KeyValuePair(TKey key, TValue value) { throw null; } + public TKey Key { get { throw null; } } + public TValue Value { get { throw null; } } + public override string ToString() { throw null; } + } +} +namespace System.Collections.ObjectModel +{ + public partial class Collection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public Collection() { } + public Collection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } set { } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public void Add(T item) { } + public void Clear() { } + protected virtual void ClearItems() { } + public bool Contains(T item) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T item) { throw null; } + public void Insert(int index, T item) { } + protected virtual void InsertItem(int index, T item) { } + public bool Remove(T item) { throw null; } + public void RemoveAt(int index) { } + protected virtual void RemoveItem(int index) { } + protected virtual void SetItem(int index, T item) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + } + public partial class ReadOnlyCollection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public ReadOnlyCollection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public bool Contains(T value) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T value) { throw null; } + void System.Collections.Generic.ICollection.Add(T value) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Remove(T value) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T value) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + } +} +namespace System.ComponentModel +{ + public partial class DefaultValueAttribute : System.Attribute + { + public DefaultValueAttribute(bool value) { } + public DefaultValueAttribute(byte value) { } + public DefaultValueAttribute(char value) { } + public DefaultValueAttribute(double value) { } + public DefaultValueAttribute(short value) { } + public DefaultValueAttribute(int value) { } + public DefaultValueAttribute(long value) { } + public DefaultValueAttribute(object value) { } + public DefaultValueAttribute(float value) { } + public DefaultValueAttribute(string value) { } + public DefaultValueAttribute(System.Type type, string value) { } + public virtual object Value { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public sealed partial class EditorBrowsableAttribute : System.Attribute + { + public EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState state) { } + public System.ComponentModel.EditorBrowsableState State { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public enum EditorBrowsableState + { + Advanced = 2, + Always = 0, + Never = 1, + } +} +namespace System.Diagnostics +{ + public sealed partial class ConditionalAttribute : System.Attribute + { + public ConditionalAttribute(string conditionString) { } + public string ConditionString { get { throw null; } } + } + public sealed partial class DebuggableAttribute : System.Attribute + { + public DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes modes) { } + [System.FlagsAttribute] + public enum DebuggingModes + { + Default = 1, + DisableOptimizations = 256, + EnableEditAndContinue = 4, + IgnoreSymbolStoreSequencePoints = 2, + None = 0, + } + } +} +namespace System.Globalization +{ + [System.FlagsAttribute] + public enum DateTimeStyles + { + AdjustToUniversal = 16, + AllowInnerWhite = 4, + AllowLeadingWhite = 1, + AllowTrailingWhite = 2, + AllowWhiteSpaces = 7, + AssumeLocal = 32, + AssumeUniversal = 64, + NoCurrentDateDefault = 8, + None = 0, + RoundtripKind = 128, + } + [System.FlagsAttribute] + public enum NumberStyles + { + AllowCurrencySymbol = 256, + AllowDecimalPoint = 32, + AllowExponent = 128, + AllowHexSpecifier = 512, + AllowLeadingSign = 4, + AllowLeadingWhite = 1, + AllowParentheses = 16, + AllowThousands = 64, + AllowTrailingSign = 8, + AllowTrailingWhite = 2, + Any = 511, + Currency = 383, + Float = 167, + HexNumber = 515, + Integer = 7, + None = 0, + Number = 111, + } + [System.FlagsAttribute] + public enum TimeSpanStyles + { + AssumeNegative = 1, + None = 0, + } +} +namespace System.IO +{ + public partial class DirectoryNotFoundException : System.IO.IOException + { + public DirectoryNotFoundException() { } + public DirectoryNotFoundException(string message) { } + public DirectoryNotFoundException(string message, System.Exception innerException) { } + } + public partial class FileLoadException : System.IO.IOException + { + public FileLoadException() { } + public FileLoadException(string message) { } + public FileLoadException(string message, System.Exception inner) { } + public FileLoadException(string message, string fileName) { } + public FileLoadException(string message, string fileName, System.Exception inner) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class FileNotFoundException : System.IO.IOException + { + public FileNotFoundException() { } + public FileNotFoundException(string message) { } + public FileNotFoundException(string message, System.Exception innerException) { } + public FileNotFoundException(string message, string fileName) { } + public FileNotFoundException(string message, string fileName, System.Exception innerException) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class IOException : System.Exception + { + public IOException() { } + public IOException(string message) { } + public IOException(string message, System.Exception innerException) { } + public IOException(string message, int hresult) { } + } + public partial class PathTooLongException : System.IO.IOException + { + public PathTooLongException() { } + public PathTooLongException(string message) { } + public PathTooLongException(string message, System.Exception innerException) { } + } +} +namespace System.Reflection +{ + public sealed partial class AssemblyCompanyAttribute : System.Attribute + { + public AssemblyCompanyAttribute(string company) { } + public string Company { get { throw null; } } + } + public sealed partial class AssemblyConfigurationAttribute : System.Attribute + { + public AssemblyConfigurationAttribute(string configuration) { } + public string Configuration { get { throw null; } } + } + public sealed partial class AssemblyCopyrightAttribute : System.Attribute + { + public AssemblyCopyrightAttribute(string copyright) { } + public string Copyright { get { throw null; } } + } + public sealed partial class AssemblyCultureAttribute : System.Attribute + { + public AssemblyCultureAttribute(string culture) { } + public string Culture { get { throw null; } } + } + public sealed partial class AssemblyDefaultAliasAttribute : System.Attribute + { + public AssemblyDefaultAliasAttribute(string defaultAlias) { } + public string DefaultAlias { get { throw null; } } + } + public sealed partial class AssemblyDelaySignAttribute : System.Attribute + { + public AssemblyDelaySignAttribute(bool delaySign) { } + public bool DelaySign { get { throw null; } } + } + public sealed partial class AssemblyDescriptionAttribute : System.Attribute + { + public AssemblyDescriptionAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class AssemblyFileVersionAttribute : System.Attribute + { + public AssemblyFileVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class AssemblyFlagsAttribute : System.Attribute + { + public AssemblyFlagsAttribute(System.Reflection.AssemblyNameFlags assemblyFlags) { } + public int AssemblyFlags { get { throw null; } } + } + public sealed partial class AssemblyInformationalVersionAttribute : System.Attribute + { + public AssemblyInformationalVersionAttribute(string informationalVersion) { } + public string InformationalVersion { get { throw null; } } + } + public sealed partial class AssemblyKeyFileAttribute : System.Attribute + { + public AssemblyKeyFileAttribute(string keyFile) { } + public string KeyFile { get { throw null; } } + } + public sealed partial class AssemblyKeyNameAttribute : System.Attribute + { + public AssemblyKeyNameAttribute(string keyName) { } + public string KeyName { get { throw null; } } + } + public sealed partial class AssemblyMetadataAttribute : System.Attribute + { + public AssemblyMetadataAttribute(string key, string value) { } + public string Key { get { throw null; } } + public string Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum AssemblyNameFlags + { + None = 0, + PublicKey = 1, + Retargetable = 256, + } + public sealed partial class AssemblyProductAttribute : System.Attribute + { + public AssemblyProductAttribute(string product) { } + public string Product { get { throw null; } } + } + public sealed partial class AssemblySignatureKeyAttribute : System.Attribute + { + public AssemblySignatureKeyAttribute(string publicKey, string countersignature) { } + public string Countersignature { get { throw null; } } + public string PublicKey { get { throw null; } } + } + public sealed partial class AssemblyTitleAttribute : System.Attribute + { + public AssemblyTitleAttribute(string title) { } + public string Title { get { throw null; } } + } + public sealed partial class AssemblyTrademarkAttribute : System.Attribute + { + public AssemblyTrademarkAttribute(string trademark) { } + public string Trademark { get { throw null; } } + } + public sealed partial class AssemblyVersionAttribute : System.Attribute + { + public AssemblyVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class DefaultMemberAttribute : System.Attribute + { + public DefaultMemberAttribute(string memberName) { } + public string MemberName { get { throw null; } } + } + public enum ProcessorArchitecture + { + Amd64 = 4, + Arm = 5, + IA64 = 3, + MSIL = 1, + None = 0, + X86 = 2, + } +} +namespace System.Runtime +{ + public enum GCLargeObjectHeapCompactionMode + { + CompactOnce = 2, + Default = 1, + } + public enum GCLatencyMode + { + Batch = 0, + Interactive = 1, + LowLatency = 2, + SustainedLowLatency = 3, + } + public static partial class GCSettings + { + public static bool IsServerGC { get { throw null; } } + public static System.Runtime.GCLargeObjectHeapCompactionMode LargeObjectHeapCompactionMode { get { throw null; } set { } } + public static System.Runtime.GCLatencyMode LatencyMode { get { throw null; } set { } } + } +} +namespace System.Runtime.CompilerServices +{ + public sealed partial class AccessedThroughPropertyAttribute : System.Attribute + { + public AccessedThroughPropertyAttribute(string propertyName) { } + public string PropertyName { get { throw null; } } + } + public sealed partial class AsyncStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public AsyncStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class CallerFilePathAttribute : System.Attribute + { + public CallerFilePathAttribute() { } + } + public sealed partial class CallerLineNumberAttribute : System.Attribute + { + public CallerLineNumberAttribute() { } + } + public sealed partial class CallerMemberNameAttribute : System.Attribute + { + public CallerMemberNameAttribute() { } + } + public partial class CompilationRelaxationsAttribute : System.Attribute + { + public CompilationRelaxationsAttribute(int relaxations) { } + public int CompilationRelaxations { get { throw null; } } + } + public sealed partial class CompilerGeneratedAttribute : System.Attribute + { + public CompilerGeneratedAttribute() { } + } + public sealed partial class ConditionalWeakTable where TKey : class where TValue : class + { + public ConditionalWeakTable() { } + public void Add(TKey key, TValue value) { } + ~ConditionalWeakTable() { } + public TValue GetOrCreateValue(TKey key) { throw null; } + public TValue GetValue(TKey key, System.Runtime.CompilerServices.ConditionalWeakTable.CreateValueCallback createValueCallback) { throw null; } + public bool Remove(TKey key) { throw null; } + public bool TryGetValue(TKey key, out TValue value) { throw null; } + public delegate TValue CreateValueCallback(TKey key); + } + public abstract partial class CustomConstantAttribute : System.Attribute + { + protected CustomConstantAttribute() { } + public abstract object Value { get; } + } + public sealed partial class DateTimeConstantAttribute : System.Runtime.CompilerServices.CustomConstantAttribute + { + public DateTimeConstantAttribute(long ticks) { } + public override object Value { get { throw null; } } + } + public sealed partial class DecimalConstantAttribute : System.Attribute + { + public DecimalConstantAttribute(byte scale, byte sign, int hi, int mid, int low) { } + [System.CLSCompliantAttribute(false)] + public DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low) { } + public decimal Value { get { throw null; } } + } + public sealed partial class DisablePrivateReflectionAttribute : System.Attribute + { + public DisablePrivateReflectionAttribute() { } + } + public sealed partial class ExtensionAttribute : System.Attribute + { + public ExtensionAttribute() { } + } + public sealed partial class FixedBufferAttribute : System.Attribute + { + public FixedBufferAttribute(System.Type elementType, int length) { } + public System.Type ElementType { get { throw null; } } + public int Length { get { throw null; } } + } + public static partial class FormattableStringFactory + { + public static System.FormattableString Create(string format, params object[] arguments) { throw null; } + } + public sealed partial class IndexerNameAttribute : System.Attribute + { + public IndexerNameAttribute(string indexerName) { } + } + public sealed partial class InternalsVisibleToAttribute : System.Attribute + { + public InternalsVisibleToAttribute(string assemblyName) { } + public string AssemblyName { get { throw null; } } + } + public static partial class IsConst + { + } + public partial interface IStrongBox + { + object Value { get; set; } + } + public static partial class IsVolatile + { + } + public sealed partial class IteratorStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public IteratorStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class MethodImplAttribute : System.Attribute + { + public MethodImplAttribute(System.Runtime.CompilerServices.MethodImplOptions methodImplOptions) { } + public System.Runtime.CompilerServices.MethodImplOptions Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum MethodImplOptions + { + AggressiveInlining = 256, + NoInlining = 8, + NoOptimization = 64, + PreserveSig = 128, + } + public sealed partial class ReferenceAssemblyAttribute : System.Attribute + { + public ReferenceAssemblyAttribute() { } + public ReferenceAssemblyAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class RuntimeCompatibilityAttribute : System.Attribute + { + public RuntimeCompatibilityAttribute() { } + public bool WrapNonExceptionThrows { get { throw null; } set { } } + } + public static partial class RuntimeHelpers + { + public static int OffsetToStringData { get { throw null; } } + public static void EnsureSufficientExecutionStack() { } + public static int GetHashCode(object o) { throw null; } + public static object GetObjectValue(object obj) { throw null; } + public static void InitializeArray(System.Array array, System.RuntimeFieldHandle fldHandle) { } + public static void RunClassConstructor(System.RuntimeTypeHandle type) { } + } + public partial class StateMachineAttribute : System.Attribute + { + public StateMachineAttribute(System.Type stateMachineType) { } + public System.Type StateMachineType { get { throw null; } } + } + public partial class StrongBox : System.Runtime.CompilerServices.IStrongBox + { + public T Value; + public StrongBox() { } + public StrongBox(T value) { } + object System.Runtime.CompilerServices.IStrongBox.Value { get { throw null; } set { } } + } + public sealed partial class TypeForwardedFromAttribute : System.Attribute + { + public TypeForwardedFromAttribute(string assemblyFullName) { } + public string AssemblyFullName { get { throw null; } } + } + public sealed partial class TypeForwardedToAttribute : System.Attribute + { + public TypeForwardedToAttribute(System.Type destination) { } + public System.Type Destination { get { throw null; } } + } + public sealed partial class UnsafeValueTypeAttribute : System.Attribute + { + public UnsafeValueTypeAttribute() { } + } +} +namespace System.Runtime.ExceptionServices +{ + public sealed partial class ExceptionDispatchInfo + { + internal ExceptionDispatchInfo() { } + public System.Exception SourceException { get { throw null; } } + public static System.Runtime.ExceptionServices.ExceptionDispatchInfo Capture(System.Exception source) { throw null; } + public void Throw() { } + } +} +namespace System.Runtime.InteropServices +{ + public enum CharSet + { + Ansi = 2, + Unicode = 3, + } + public sealed partial class ComVisibleAttribute : System.Attribute + { + public ComVisibleAttribute(bool visibility) { } + public bool Value { get { throw null; } } + } + public sealed partial class FieldOffsetAttribute : System.Attribute + { + public FieldOffsetAttribute(int offset) { } + public int Value { get { throw null; } } + } + public enum LayoutKind + { + Auto = 3, + Explicit = 2, + Sequential = 0, + } + public sealed partial class OutAttribute : System.Attribute + { + public OutAttribute() { } + } + public sealed partial class StructLayoutAttribute : System.Attribute + { + public System.Runtime.InteropServices.CharSet CharSet; + public int Pack; + public int Size; + public StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind layoutKind) { } + public System.Runtime.InteropServices.LayoutKind Value { get { throw null; } } + } +} +namespace System.Runtime.Versioning +{ + public sealed partial class TargetFrameworkAttribute : System.Attribute + { + public TargetFrameworkAttribute(string frameworkName) { } + public string FrameworkDisplayName { get { throw null; } set { } } + public string FrameworkName { get { throw null; } } + } +} +namespace System.Security +{ + public sealed partial class AllowPartiallyTrustedCallersAttribute : System.Attribute + { + public AllowPartiallyTrustedCallersAttribute() { } + } + public sealed partial class SecurityCriticalAttribute : System.Attribute + { + public SecurityCriticalAttribute() { } + } + public partial class SecurityException : System.Exception + { + public SecurityException() { } + public SecurityException(string message) { } + public SecurityException(string message, System.Exception inner) { } + public override string ToString() { throw null; } + } + public sealed partial class SecuritySafeCriticalAttribute : System.Attribute + { + public SecuritySafeCriticalAttribute() { } + } + public sealed partial class SecurityTransparentAttribute : System.Attribute + { + public SecurityTransparentAttribute() { } + } + public partial class VerificationException : System.Exception + { + public VerificationException() { } + public VerificationException(string message) { } + public VerificationException(string message, System.Exception innerException) { } + } +} +namespace System.Text +{ + public sealed partial class StringBuilder + { + public StringBuilder() { } + public StringBuilder(int capacity) { } + public StringBuilder(int capacity, int maxCapacity) { } + public StringBuilder(string value) { } + public StringBuilder(string value, int capacity) { } + public StringBuilder(string value, int startIndex, int length, int capacity) { } + public int Capacity { get { throw null; } set { } } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } set { } } + public int Length { get { throw null; } set { } } + public int MaxCapacity { get { throw null; } } + public System.Text.StringBuilder Append(bool value) { throw null; } + public System.Text.StringBuilder Append(byte value) { throw null; } + public System.Text.StringBuilder Append(char value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe System.Text.StringBuilder Append(char* value, int valueCount) { throw null; } + public System.Text.StringBuilder Append(char value, int repeatCount) { throw null; } + public System.Text.StringBuilder Append(char[] value) { throw null; } + public System.Text.StringBuilder Append(char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Append(decimal value) { throw null; } + public System.Text.StringBuilder Append(double value) { throw null; } + public System.Text.StringBuilder Append(short value) { throw null; } + public System.Text.StringBuilder Append(int value) { throw null; } + public System.Text.StringBuilder Append(long value) { throw null; } + public System.Text.StringBuilder Append(object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(sbyte value) { throw null; } + public System.Text.StringBuilder Append(float value) { throw null; } + public System.Text.StringBuilder Append(string value) { throw null; } + public System.Text.StringBuilder Append(string value, int startIndex, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ulong value) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, object arg0) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, object arg0, object arg1) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, object arg0, object arg1, object arg2) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, object arg0) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, object arg0, object arg1) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, object arg0, object arg1, object arg2) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendLine() { throw null; } + public System.Text.StringBuilder AppendLine(string value) { throw null; } + public System.Text.StringBuilder Clear() { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public int EnsureCapacity(int capacity) { throw null; } + public bool Equals(System.Text.StringBuilder sb) { throw null; } + public System.Text.StringBuilder Insert(int index, bool value) { throw null; } + public System.Text.StringBuilder Insert(int index, byte value) { throw null; } + public System.Text.StringBuilder Insert(int index, char value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Insert(int index, decimal value) { throw null; } + public System.Text.StringBuilder Insert(int index, double value) { throw null; } + public System.Text.StringBuilder Insert(int index, short value) { throw null; } + public System.Text.StringBuilder Insert(int index, int value) { throw null; } + public System.Text.StringBuilder Insert(int index, long value) { throw null; } + public System.Text.StringBuilder Insert(int index, object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, sbyte value) { throw null; } + public System.Text.StringBuilder Insert(int index, float value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ulong value) { throw null; } + public System.Text.StringBuilder Remove(int startIndex, int length) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar, int startIndex, int count) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue, int startIndex, int count) { throw null; } + public override string ToString() { throw null; } + public string ToString(int startIndex, int length) { throw null; } + } +} +namespace System.Threading +{ + public enum LazyThreadSafetyMode + { + ExecutionAndPublication = 2, + None = 0, + PublicationOnly = 1, + } + public static partial class Timeout + { + public const int Infinite = -1; + public static readonly System.TimeSpan InfiniteTimeSpan; + } + public abstract partial class WaitHandle : System.IDisposable + { + protected static readonly System.IntPtr InvalidHandle; + public const int WaitTimeout = 258; + protected WaitHandle() { } + public void Dispose() { } + protected virtual void Dispose(bool explicitDisposing) { } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public virtual bool WaitOne() { throw null; } + public virtual bool WaitOne(int millisecondsTimeout) { throw null; } + public virtual bool WaitOne(System.TimeSpan timeout) { throw null; } + } +} diff --git a/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.5/System.Runtime.cs b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.5/System.Runtime.cs new file mode 100644 index 0000000000..058f2b106a --- /dev/null +++ b/src/referencePackages/src/system.runtime/4.3.0/ref/netstandard1.5/System.Runtime.cs @@ -0,0 +1,3155 @@ +// 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.Runtime")] +[assembly: AssemblyDescription("System.Runtime")] +[assembly: AssemblyDefaultAlias("System.Runtime")] +[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.1.0.0")] + + + + +namespace System +{ + public delegate void Action(); + public delegate void Action(T obj); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate void Action(T1 arg1, T2 arg2); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public static partial class Activator + { + public static object CreateInstance(System.Type type) { throw null; } + public static object CreateInstance(System.Type type, bool nonPublic) { throw null; } + public static object CreateInstance(System.Type type, params object[] args) { throw null; } + public static T CreateInstance() { throw null; } + } + public partial class ArgumentException : System.Exception + { + public ArgumentException() { } + public ArgumentException(string message) { } + public ArgumentException(string message, System.Exception innerException) { } + public ArgumentException(string message, string paramName) { } + public ArgumentException(string message, string paramName, System.Exception innerException) { } + public override string Message { get { throw null; } } + public virtual string ParamName { get { throw null; } } + } + public partial class ArgumentNullException : System.ArgumentException + { + public ArgumentNullException() { } + public ArgumentNullException(string paramName) { } + public ArgumentNullException(string message, System.Exception innerException) { } + public ArgumentNullException(string paramName, string message) { } + } + public partial class ArgumentOutOfRangeException : System.ArgumentException + { + public ArgumentOutOfRangeException() { } + public ArgumentOutOfRangeException(string paramName) { } + public ArgumentOutOfRangeException(string message, System.Exception innerException) { } + public ArgumentOutOfRangeException(string paramName, object actualValue, string message) { } + public ArgumentOutOfRangeException(string paramName, string message) { } + public virtual object ActualValue { get { throw null; } } + public override string Message { get { throw null; } } + } + public partial class ArithmeticException : System.Exception + { + public ArithmeticException() { } + public ArithmeticException(string message) { } + public ArithmeticException(string message, System.Exception innerException) { } + } + public abstract partial class Array : System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable + { + internal Array() { } + public int Length { get { throw null; } } + public int Rank { get { throw null; } } + int System.Collections.ICollection.Count { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public static int BinarySearch(System.Array array, int index, int length, object value) { throw null; } + public static int BinarySearch(System.Array array, int index, int length, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(System.Array array, object value) { throw null; } + public static int BinarySearch(System.Array array, object value, System.Collections.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value) { throw null; } + public static int BinarySearch(T[] array, int index, int length, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static int BinarySearch(T[] array, T value) { throw null; } + public static int BinarySearch(T[] array, T value, System.Collections.Generic.IComparer comparer) { throw null; } + public static void Clear(System.Array array, int index, int length) { } + public object Clone() { throw null; } + public static void ConstrainedCopy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public static void Copy(System.Array sourceArray, System.Array destinationArray, int length) { } + public static void Copy(System.Array sourceArray, int sourceIndex, System.Array destinationArray, int destinationIndex, int length) { } + public void CopyTo(System.Array array, int index) { } + public static System.Array CreateInstance(System.Type elementType, int length) { throw null; } + public static System.Array CreateInstance(System.Type elementType, params int[] lengths) { throw null; } + public static System.Array CreateInstance(System.Type elementType, int[] lengths, int[] lowerBounds) { throw null; } + public static T[] Empty() { throw null; } + public static bool Exists(T[] array, System.Predicate match) { throw null; } + public static T[] FindAll(T[] array, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindIndex(T[] array, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, int count, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, int startIndex, System.Predicate match) { throw null; } + public static int FindLastIndex(T[] array, System.Predicate match) { throw null; } + public static T FindLast(T[] array, System.Predicate match) { throw null; } + public static T Find(T[] array, System.Predicate match) { throw null; } + public System.Collections.IEnumerator GetEnumerator() { throw null; } + public int GetLength(int dimension) { throw null; } + public int GetLowerBound(int dimension) { throw null; } + public int GetUpperBound(int dimension) { throw null; } + public object GetValue(int index) { throw null; } + public object GetValue(params int[] indices) { throw null; } + public static int IndexOf(System.Array array, object value) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int IndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int IndexOf(T[] array, T value) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex) { throw null; } + public static int IndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public void Initialize() { } + public static int LastIndexOf(System.Array array, object value) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex) { throw null; } + public static int LastIndexOf(System.Array array, object value, int startIndex, int count) { throw null; } + public static int LastIndexOf(T[] array, T value) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex) { throw null; } + public static int LastIndexOf(T[] array, T value, int startIndex, int count) { throw null; } + public static void Resize(ref T[] array, int newSize) { } + public static void Reverse(System.Array array) { } + public static void Reverse(System.Array array, int index, int length) { } + public void SetValue(object value, int index) { } + public void SetValue(object value, params int[] indices) { } + public static void Sort(System.Array array) { } + public static void Sort(System.Array keys, System.Array items) { } + public static void Sort(System.Array keys, System.Array items, System.Collections.IComparer comparer) { } + public static void Sort(System.Array keys, System.Array items, int index, int length) { } + public static void Sort(System.Array keys, System.Array items, int index, int length, System.Collections.IComparer comparer) { } + public static void Sort(System.Array array, System.Collections.IComparer comparer) { } + public static void Sort(System.Array array, int index, int length) { } + public static void Sort(System.Array array, int index, int length, System.Collections.IComparer comparer) { } + public static void Sort(T[] array) { } + public static void Sort(T[] array, System.Collections.Generic.IComparer comparer) { } + public static void Sort(T[] array, System.Comparison comparison) { } + public static void Sort(T[] array, int index, int length) { } + public static void Sort(T[] array, int index, int length, System.Collections.Generic.IComparer comparer) { } + public static void Sort(TKey[] keys, TValue[] items) { } + public static void Sort(TKey[] keys, TValue[] items, System.Collections.Generic.IComparer comparer) { } + public static void Sort(TKey[] keys, TValue[] items, int index, int length) { } + public static void Sort(TKey[] keys, TValue[] items, int index, int length, System.Collections.Generic.IComparer comparer) { } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + public static bool TrueForAll(T[] array, System.Predicate match) { throw null; } + } + public partial struct ArraySegment : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.IEnumerable + { + public ArraySegment(T[] array) { throw null; } + public ArraySegment(T[] array, int offset, int count) { throw null; } + public T[] Array { get { throw null; } } + public int Count { get { throw null; } } + public int Offset { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + T System.Collections.Generic.IReadOnlyList.this[int index] { get { throw null; } } + public bool Equals(System.ArraySegment obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.ArraySegment a, System.ArraySegment b) { throw null; } + public static bool operator !=(System.ArraySegment a, System.ArraySegment b) { throw null; } + void System.Collections.Generic.ICollection.Add(T item) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Contains(T item) { throw null; } + void System.Collections.Generic.ICollection.CopyTo(T[] array, int arrayIndex) { } + bool System.Collections.Generic.ICollection.Remove(T item) { throw null; } + System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.Generic.IList.IndexOf(T item) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T item) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + } + public partial class ArrayTypeMismatchException : System.Exception + { + public ArrayTypeMismatchException() { } + public ArrayTypeMismatchException(string message) { } + public ArrayTypeMismatchException(string message, System.Exception innerException) { } + } + public delegate void AsyncCallback(System.IAsyncResult ar); + public abstract partial class Attribute + { + protected Attribute() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + [System.FlagsAttribute] + public enum AttributeTargets + { + All = 32767, + Assembly = 1, + Class = 4, + Constructor = 32, + Delegate = 4096, + Enum = 16, + Event = 512, + Field = 256, + GenericParameter = 16384, + Interface = 1024, + Method = 64, + Module = 2, + Parameter = 2048, + Property = 128, + ReturnValue = 8192, + Struct = 8, + } + public sealed partial class AttributeUsageAttribute : System.Attribute + { + public AttributeUsageAttribute(System.AttributeTargets validOn) { } + public bool AllowMultiple { get { throw null; } set { } } + public bool Inherited { get { throw null; } set { } } + public System.AttributeTargets ValidOn { get { throw null; } } + } + public partial class BadImageFormatException : System.Exception + { + public BadImageFormatException() { } + public BadImageFormatException(string message) { } + public BadImageFormatException(string message, System.Exception inner) { } + public BadImageFormatException(string message, string fileName) { } + public BadImageFormatException(string message, string fileName, System.Exception inner) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial struct Boolean : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable + { + public static readonly string FalseString; + public static readonly string TrueString; + public int CompareTo(System.Boolean value) { throw null; } + public System.Boolean Equals(System.Boolean obj) { throw null; } + public override System.Boolean Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Boolean Parse(string value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + System.Boolean System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + string System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public static System.Boolean TryParse(string value, out System.Boolean result) { throw null; } + } + public static partial class Buffer + { + public static void BlockCopy(System.Array src, int srcOffset, System.Array dst, int dstOffset, int count) { } + public static int ByteLength(System.Array array) { throw null; } + public static byte GetByte(System.Array array, int index) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static void MemoryCopy(void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy) { } + [System.CLSCompliantAttribute(false)] + public unsafe static void MemoryCopy(void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy) { } + public static void SetByte(System.Array array, int index, byte value) { } + } + public partial struct Byte : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const byte MaxValue = (byte)255; + public const byte MinValue = (byte)0; + public int CompareTo(System.Byte value) { throw null; } + public bool Equals(System.Byte obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Byte Parse(string s) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Byte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Byte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + System.Byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Byte result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Byte result) { throw null; } + } + public partial struct Char : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable + { + public const char MaxValue = '\uFFFF'; + public const char MinValue = '\0'; + public int CompareTo(System.Char value) { throw null; } + public static string ConvertFromUtf32(int utf32) { throw null; } + public static int ConvertToUtf32(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static int ConvertToUtf32(string s, int index) { throw null; } + public bool Equals(System.Char obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static double GetNumericValue(System.Char c) { throw null; } + public static double GetNumericValue(string s, int index) { throw null; } + public static bool IsControl(System.Char c) { throw null; } + public static bool IsControl(string s, int index) { throw null; } + public static bool IsDigit(System.Char c) { throw null; } + public static bool IsDigit(string s, int index) { throw null; } + public static bool IsHighSurrogate(System.Char c) { throw null; } + public static bool IsHighSurrogate(string s, int index) { throw null; } + public static bool IsLetter(System.Char c) { throw null; } + public static bool IsLetter(string s, int index) { throw null; } + public static bool IsLetterOrDigit(System.Char c) { throw null; } + public static bool IsLetterOrDigit(string s, int index) { throw null; } + public static bool IsLower(System.Char c) { throw null; } + public static bool IsLower(string s, int index) { throw null; } + public static bool IsLowSurrogate(System.Char c) { throw null; } + public static bool IsLowSurrogate(string s, int index) { throw null; } + public static bool IsNumber(System.Char c) { throw null; } + public static bool IsNumber(string s, int index) { throw null; } + public static bool IsPunctuation(System.Char c) { throw null; } + public static bool IsPunctuation(string s, int index) { throw null; } + public static bool IsSeparator(System.Char c) { throw null; } + public static bool IsSeparator(string s, int index) { throw null; } + public static bool IsSurrogate(System.Char c) { throw null; } + public static bool IsSurrogate(string s, int index) { throw null; } + public static bool IsSurrogatePair(System.Char highSurrogate, System.Char lowSurrogate) { throw null; } + public static bool IsSurrogatePair(string s, int index) { throw null; } + public static bool IsSymbol(System.Char c) { throw null; } + public static bool IsSymbol(string s, int index) { throw null; } + public static bool IsUpper(System.Char c) { throw null; } + public static bool IsUpper(string s, int index) { throw null; } + public static bool IsWhiteSpace(System.Char c) { throw null; } + public static bool IsWhiteSpace(string s, int index) { throw null; } + public static System.Char Parse(string s) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + System.Char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + string System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public static System.Char ToLower(System.Char c) { throw null; } + public static System.Char ToLowerInvariant(System.Char c) { throw null; } + public override string ToString() { throw null; } + public static string ToString(System.Char c) { throw null; } + public static System.Char ToUpper(System.Char c) { throw null; } + public static System.Char ToUpperInvariant(System.Char c) { throw null; } + public static bool TryParse(string s, out System.Char result) { throw null; } + } + public sealed partial class CLSCompliantAttribute : System.Attribute + { + public CLSCompliantAttribute(bool isCompliant) { } + public bool IsCompliant { get { throw null; } } + } + public delegate int Comparison(T x, T y); + public partial struct DateTime : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public static readonly System.DateTime MaxValue; + public static readonly System.DateTime MinValue; + public DateTime(int year, int month, int day) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, System.DateTimeKind kind) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond) { throw null; } + public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, System.DateTimeKind kind) { throw null; } + public DateTime(long ticks) { throw null; } + public DateTime(long ticks, System.DateTimeKind kind) { throw null; } + public System.DateTime Date { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTimeKind Kind { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTime Now { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public static System.DateTime Today { get { throw null; } } + public static System.DateTime UtcNow { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTime Add(System.TimeSpan value) { throw null; } + public System.DateTime AddDays(double value) { throw null; } + public System.DateTime AddHours(double value) { throw null; } + public System.DateTime AddMilliseconds(double value) { throw null; } + public System.DateTime AddMinutes(double value) { throw null; } + public System.DateTime AddMonths(int months) { throw null; } + public System.DateTime AddSeconds(double value) { throw null; } + public System.DateTime AddTicks(long value) { throw null; } + public System.DateTime AddYears(int value) { throw null; } + public static int Compare(System.DateTime t1, System.DateTime t2) { throw null; } + public int CompareTo(System.DateTime value) { throw null; } + public static int DaysInMonth(int year, int month) { throw null; } + public bool Equals(System.DateTime value) { throw null; } + public static bool Equals(System.DateTime t1, System.DateTime t2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.DateTime FromBinary(long dateData) { throw null; } + public static System.DateTime FromFileTime(long fileTime) { throw null; } + public static System.DateTime FromFileTimeUtc(long fileTime) { throw null; } + public string[] GetDateTimeFormats() { throw null; } + public string[] GetDateTimeFormats(char format) { throw null; } + public string[] GetDateTimeFormats(char format, System.IFormatProvider provider) { throw null; } + public string[] GetDateTimeFormats(System.IFormatProvider provider) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsDaylightSavingTime() { throw null; } + public static bool IsLeapYear(int year) { throw null; } + public static System.DateTime operator +(System.DateTime d, System.TimeSpan t) { throw null; } + public static bool operator ==(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator >(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator >=(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator !=(System.DateTime d1, System.DateTime d2) { throw null; } + public static bool operator <(System.DateTime t1, System.DateTime t2) { throw null; } + public static bool operator <=(System.DateTime t1, System.DateTime t2) { throw null; } + public static System.TimeSpan operator -(System.DateTime d1, System.DateTime d2) { throw null; } + public static System.DateTime operator -(System.DateTime d, System.TimeSpan t) { throw null; } + public static System.DateTime Parse(string s) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.DateTime Parse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider) { throw null; } + public static System.DateTime ParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime ParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style) { throw null; } + public static System.DateTime SpecifyKind(System.DateTime value, System.DateTimeKind kind) { throw null; } + public System.TimeSpan Subtract(System.DateTime value) { throw null; } + public System.DateTime Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public long ToBinary() { throw null; } + public long ToFileTime() { throw null; } + public long ToFileTimeUtc() { throw null; } + public System.DateTime ToLocalTime() { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public System.DateTime ToUniversalTime() { throw null; } + public static bool TryParse(string s, out System.DateTime result) { throw null; } + public static bool TryParse(string s, System.IFormatProvider provider, System.Globalization.DateTimeStyles styles, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string format, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + public static bool TryParseExact(string s, string[] formats, System.IFormatProvider provider, System.Globalization.DateTimeStyles style, out System.DateTime result) { throw null; } + } + public enum DateTimeKind + { + Local = 2, + Unspecified = 0, + Utc = 1, + } + public partial struct DateTimeOffset : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.DateTimeOffset MaxValue; + public static readonly System.DateTimeOffset MinValue; + public DateTimeOffset(System.DateTime dateTime) { throw null; } + public DateTimeOffset(System.DateTime dateTime, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, int millisecond, System.TimeSpan offset) { throw null; } + public DateTimeOffset(int year, int month, int day, int hour, int minute, int second, System.TimeSpan offset) { throw null; } + public DateTimeOffset(long ticks, System.TimeSpan offset) { throw null; } + public System.DateTime Date { get { throw null; } } + public System.DateTime DateTime { get { throw null; } } + public int Day { get { throw null; } } + public System.DayOfWeek DayOfWeek { get { throw null; } } + public int DayOfYear { get { throw null; } } + public int Hour { get { throw null; } } + public System.DateTime LocalDateTime { get { throw null; } } + public int Millisecond { get { throw null; } } + public int Minute { get { throw null; } } + public int Month { get { throw null; } } + public static System.DateTimeOffset Now { get { throw null; } } + public System.TimeSpan Offset { get { throw null; } } + public int Second { get { throw null; } } + public long Ticks { get { throw null; } } + public System.TimeSpan TimeOfDay { get { throw null; } } + public System.DateTime UtcDateTime { get { throw null; } } + public static System.DateTimeOffset UtcNow { get { throw null; } } + public long UtcTicks { get { throw null; } } + public int Year { get { throw null; } } + public System.DateTimeOffset Add(System.TimeSpan timeSpan) { throw null; } + public System.DateTimeOffset AddDays(double days) { throw null; } + public System.DateTimeOffset AddHours(double hours) { throw null; } + public System.DateTimeOffset AddMilliseconds(double milliseconds) { throw null; } + public System.DateTimeOffset AddMinutes(double minutes) { throw null; } + public System.DateTimeOffset AddMonths(int months) { throw null; } + public System.DateTimeOffset AddSeconds(double seconds) { throw null; } + public System.DateTimeOffset AddTicks(long ticks) { throw null; } + public System.DateTimeOffset AddYears(int years) { throw null; } + public static int Compare(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public int CompareTo(System.DateTimeOffset other) { throw null; } + public bool Equals(System.DateTimeOffset other) { throw null; } + public static bool Equals(System.DateTimeOffset first, System.DateTimeOffset second) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool EqualsExact(System.DateTimeOffset other) { throw null; } + public static System.DateTimeOffset FromFileTime(long fileTime) { throw null; } + public static System.DateTimeOffset FromUnixTimeMilliseconds(long milliseconds) { throw null; } + public static System.DateTimeOffset FromUnixTimeSeconds(long seconds) { throw null; } + public override int GetHashCode() { throw null; } + public static System.DateTimeOffset operator +(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static bool operator ==(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator >=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static implicit operator System.DateTimeOffset (System.DateTime dateTime) { throw null; } + public static bool operator !=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static bool operator <=(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.TimeSpan operator -(System.DateTimeOffset left, System.DateTimeOffset right) { throw null; } + public static System.DateTimeOffset operator -(System.DateTimeOffset dateTimeOffset, System.TimeSpan timeSpan) { throw null; } + public static System.DateTimeOffset Parse(string input) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset Parse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public static System.DateTimeOffset ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles) { throw null; } + public System.TimeSpan Subtract(System.DateTimeOffset value) { throw null; } + public System.DateTimeOffset Subtract(System.TimeSpan value) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public long ToFileTime() { throw null; } + public System.DateTimeOffset ToLocalTime() { throw null; } + public System.DateTimeOffset ToOffset(System.TimeSpan offset) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider formatProvider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public System.DateTimeOffset ToUniversalTime() { throw null; } + public long ToUnixTimeMilliseconds() { throw null; } + public long ToUnixTimeSeconds() { throw null; } + public static bool TryParse(string input, out System.DateTimeOffset result) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.DateTimeStyles styles, out System.DateTimeOffset result) { throw null; } + } + public enum DayOfWeek + { + Friday = 5, + Monday = 1, + Saturday = 6, + Sunday = 0, + Thursday = 4, + Tuesday = 2, + Wednesday = 3, + } + public partial struct Decimal : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MaxValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)0, (uint)0, (uint)1)] + public static readonly decimal MinusOne; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)128, (uint)4294967295, (uint)4294967295, (uint)4294967295)] + public static readonly decimal MinValue; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)1)] + public static readonly decimal One; + [System.Runtime.CompilerServices.DecimalConstantAttribute((byte)0, (byte)0, (uint)0, (uint)0, (uint)0)] + public static readonly decimal Zero; + public Decimal(double value) { throw null; } + public Decimal(int value) { throw null; } + public Decimal(int lo, int mid, int hi, bool isNegative, byte scale) { throw null; } + public Decimal(int[] bits) { throw null; } + public Decimal(long value) { throw null; } + public Decimal(float value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public Decimal(ulong value) { throw null; } + public static System.Decimal Add(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Ceiling(System.Decimal d) { throw null; } + public static int Compare(System.Decimal d1, System.Decimal d2) { throw null; } + public int CompareTo(System.Decimal value) { throw null; } + public static System.Decimal Divide(System.Decimal d1, System.Decimal d2) { throw null; } + public bool Equals(System.Decimal value) { throw null; } + public static bool Equals(System.Decimal d1, System.Decimal d2) { throw null; } + public override bool Equals(object value) { throw null; } + public static System.Decimal Floor(System.Decimal d) { throw null; } + public static int[] GetBits(System.Decimal d) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Decimal Multiply(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Negate(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator --(System.Decimal d) { throw null; } + public static System.Decimal operator /(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator ==(System.Decimal d1, System.Decimal d2) { throw null; } + public static explicit operator byte (System.Decimal value) { throw null; } + public static explicit operator char (System.Decimal value) { throw null; } + public static explicit operator double (System.Decimal value) { throw null; } + public static explicit operator short (System.Decimal value) { throw null; } + public static explicit operator int (System.Decimal value) { throw null; } + public static explicit operator long (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator sbyte (System.Decimal value) { throw null; } + public static explicit operator float (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ushort (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator uint (System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static explicit operator ulong (System.Decimal value) { throw null; } + public static explicit operator System.Decimal (double value) { throw null; } + public static explicit operator System.Decimal (float value) { throw null; } + public static bool operator >(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator >=(System.Decimal d1, System.Decimal d2) { throw null; } + public static implicit operator System.Decimal (byte value) { throw null; } + public static implicit operator System.Decimal (char value) { throw null; } + public static implicit operator System.Decimal (short value) { throw null; } + public static implicit operator System.Decimal (int value) { throw null; } + public static implicit operator System.Decimal (long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (sbyte value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static implicit operator System.Decimal (ulong value) { throw null; } + public static System.Decimal operator ++(System.Decimal d) { throw null; } + public static bool operator !=(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <(System.Decimal d1, System.Decimal d2) { throw null; } + public static bool operator <=(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator %(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator *(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal operator -(System.Decimal d) { throw null; } + public static System.Decimal operator +(System.Decimal d) { throw null; } + public static System.Decimal Parse(string s) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Decimal Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Decimal Parse(string s, System.IFormatProvider provider) { throw null; } + public static System.Decimal Remainder(System.Decimal d1, System.Decimal d2) { throw null; } + public static System.Decimal Subtract(System.Decimal d1, System.Decimal d2) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + System.Decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public static byte ToByte(System.Decimal value) { throw null; } + public static double ToDouble(System.Decimal d) { throw null; } + public static short ToInt16(System.Decimal value) { throw null; } + public static int ToInt32(System.Decimal d) { throw null; } + public static long ToInt64(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static sbyte ToSByte(System.Decimal value) { throw null; } + public static float ToSingle(System.Decimal d) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ushort ToUInt16(System.Decimal value) { throw null; } + [System.CLSCompliantAttribute(false)] + public static uint ToUInt32(System.Decimal d) { throw null; } + [System.CLSCompliantAttribute(false)] + public static ulong ToUInt64(System.Decimal d) { throw null; } + public static System.Decimal Truncate(System.Decimal d) { throw null; } + public static bool TryParse(string s, out System.Decimal result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Decimal result) { throw null; } + } + public abstract partial class Delegate + { + internal Delegate() { } + public object Target { get { throw null; } } + public static System.Delegate Combine(System.Delegate a, System.Delegate b) { throw null; } + public static System.Delegate Combine(params System.Delegate[] delegates) { throw null; } + public object DynamicInvoke(params object[] args) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public virtual System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.Delegate d1, System.Delegate d2) { throw null; } + public static bool operator !=(System.Delegate d1, System.Delegate d2) { throw null; } + public static System.Delegate Remove(System.Delegate source, System.Delegate value) { throw null; } + public static System.Delegate RemoveAll(System.Delegate source, System.Delegate value) { throw null; } + } + public partial class DivideByZeroException : System.ArithmeticException + { + public DivideByZeroException() { } + public DivideByZeroException(string message) { } + public DivideByZeroException(string message, System.Exception innerException) { } + } + public partial struct Double : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const double Epsilon = 4.94065645841247E-324; + public const double MaxValue = 1.7976931348623157E+308; + public const double MinValue = -1.7976931348623157E+308; + public const double NaN = 0.0 / 0.0; + public const double NegativeInfinity = -1.0 / 0.0; + public const double PositiveInfinity = 1.0 / 0.0; + public int CompareTo(System.Double value) { throw null; } + public bool Equals(System.Double obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Double d) { throw null; } + public static bool IsNaN(System.Double d) { throw null; } + public static bool IsNegativeInfinity(System.Double d) { throw null; } + public static bool IsPositiveInfinity(System.Double d) { throw null; } + public static bool operator ==(System.Double left, System.Double right) { throw null; } + public static bool operator >(System.Double left, System.Double right) { throw null; } + public static bool operator >=(System.Double left, System.Double right) { throw null; } + public static bool operator !=(System.Double left, System.Double right) { throw null; } + public static bool operator <(System.Double left, System.Double right) { throw null; } + public static bool operator <=(System.Double left, System.Double right) { throw null; } + public static System.Double Parse(string s) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Double Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Double Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + System.Double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, out System.Double result) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Double result) { throw null; } + } + public abstract partial class Enum : System.ValueType, System.IComparable, System.IConvertible, System.IFormattable + { + protected Enum() { } + public int CompareTo(object target) { throw null; } + public override bool Equals(object obj) { throw null; } + public static string Format(System.Type enumType, object value, string format) { throw null; } + public override int GetHashCode() { throw null; } + public static string GetName(System.Type enumType, object value) { throw null; } + public static string[] GetNames(System.Type enumType) { throw null; } + public static System.Type GetUnderlyingType(System.Type enumType) { throw null; } + public static System.Array GetValues(System.Type enumType) { throw null; } + public bool HasFlag(System.Enum flag) { throw null; } + public static bool IsDefined(System.Type enumType, object value) { throw null; } + public static object Parse(System.Type enumType, string value) { throw null; } + public static object Parse(System.Type enumType, string value, bool ignoreCase) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + [System.ObsoleteAttribute("The provider argument is not used. Please use ToString().")] + string System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + [System.ObsoleteAttribute("The provider argument is not used. Please use ToString(String).")] + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public static object ToObject(System.Type enumType, object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string value, bool ignoreCase, out TEnum result) where TEnum : struct { throw null; } + public static bool TryParse(string value, out TEnum result) where TEnum : struct { throw null; } + } + public partial class EventArgs + { + public static readonly System.EventArgs Empty; + public EventArgs() { } + } + public delegate void EventHandler(object sender, System.EventArgs e); + public delegate void EventHandler(object sender, TEventArgs e); + public partial class Exception + { + public Exception() { } + public Exception(string message) { } + public Exception(string message, System.Exception innerException) { } + public virtual System.Collections.IDictionary Data { get { throw null; } } + public virtual string HelpLink { get { throw null; } set { } } + public int HResult { get { throw null; } protected set { } } + public System.Exception InnerException { get { throw null; } } + public virtual string Message { get { throw null; } } + public virtual string Source { get { throw null; } set { } } + public virtual string StackTrace { get { throw null; } } + public virtual System.Exception GetBaseException() { throw null; } + public override string ToString() { throw null; } + } + public partial class FieldAccessException : System.MemberAccessException + { + public FieldAccessException() { } + public FieldAccessException(string message) { } + public FieldAccessException(string message, System.Exception inner) { } + } + public partial class FlagsAttribute : System.Attribute + { + public FlagsAttribute() { } + } + public partial class FormatException : System.Exception + { + public FormatException() { } + public FormatException(string message) { } + public FormatException(string message, System.Exception innerException) { } + } + public abstract partial class FormattableString : System.IFormattable + { + protected FormattableString() { } + public abstract int ArgumentCount { get; } + public abstract string Format { get; } + public abstract object GetArgument(int index); + public abstract object[] GetArguments(); + public static string Invariant(System.FormattableString formattable) { throw null; } + string System.IFormattable.ToString(string ignored, System.IFormatProvider formatProvider) { throw null; } + public override string ToString() { throw null; } + public abstract string ToString(System.IFormatProvider formatProvider); + } + public delegate TResult Func(); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16); + public delegate TResult Func(T arg); + public delegate TResult Func(T1 arg1, T2 arg2); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); + public static partial class GC + { + public static int MaxGeneration { get { throw null; } } + public static void AddMemoryPressure(long bytesAllocated) { } + public static void Collect() { } + public static void Collect(int generation) { } + public static void Collect(int generation, System.GCCollectionMode mode) { } + public static void Collect(int generation, System.GCCollectionMode mode, bool blocking) { } + public static int CollectionCount(int generation) { throw null; } + public static int GetGeneration(object obj) { throw null; } + public static long GetTotalMemory(bool forceFullCollection) { throw null; } + public static void KeepAlive(object obj) { } + public static void RemoveMemoryPressure(long bytesAllocated) { } + public static void ReRegisterForFinalize(object obj) { } + public static void SuppressFinalize(object obj) { } + public static void WaitForPendingFinalizers() { } + } + public enum GCCollectionMode + { + Default = 0, + Forced = 1, + Optimized = 2, + } + public partial struct Guid : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.Guid Empty; + public Guid(byte[] b) { throw null; } + public Guid(int a, short b, short c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; } + public Guid(int a, short b, short c, byte[] d) { throw null; } + public Guid(string g) { throw null; } + [System.CLSCompliantAttribute(false)] + public Guid(uint a, ushort b, ushort c, byte d, byte e, byte f, byte g, byte h, byte i, byte j, byte k) { throw null; } + public int CompareTo(System.Guid value) { throw null; } + public bool Equals(System.Guid g) { throw null; } + public override bool Equals(object o) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Guid NewGuid() { throw null; } + public static bool operator ==(System.Guid a, System.Guid b) { throw null; } + public static bool operator !=(System.Guid a, System.Guid b) { throw null; } + public static System.Guid Parse(string input) { throw null; } + public static System.Guid ParseExact(string input, string format) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + string System.IFormattable.ToString(string format, System.IFormatProvider provider) { throw null; } + public byte[] ToByteArray() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public static bool TryParse(string input, out System.Guid result) { throw null; } + public static bool TryParseExact(string input, string format, out System.Guid result) { throw null; } + } + public partial interface IAsyncResult + { + object AsyncState { get; } + System.Threading.WaitHandle AsyncWaitHandle { get; } + bool CompletedSynchronously { get; } + bool IsCompleted { get; } + } + public partial interface IComparable + { + int CompareTo(object obj); + } + public partial interface IComparable + { + int CompareTo(T other); + } + [System.CLSCompliantAttribute(false)] + public partial interface IConvertible + { + System.TypeCode GetTypeCode(); + bool ToBoolean(System.IFormatProvider provider); + byte ToByte(System.IFormatProvider provider); + char ToChar(System.IFormatProvider provider); + System.DateTime ToDateTime(System.IFormatProvider provider); + decimal ToDecimal(System.IFormatProvider provider); + double ToDouble(System.IFormatProvider provider); + short ToInt16(System.IFormatProvider provider); + int ToInt32(System.IFormatProvider provider); + long ToInt64(System.IFormatProvider provider); + sbyte ToSByte(System.IFormatProvider provider); + float ToSingle(System.IFormatProvider provider); + string ToString(System.IFormatProvider provider); + object ToType(System.Type conversionType, System.IFormatProvider provider); + ushort ToUInt16(System.IFormatProvider provider); + uint ToUInt32(System.IFormatProvider provider); + ulong ToUInt64(System.IFormatProvider provider); + } + public partial interface ICustomFormatter + { + string Format(string format, object arg, System.IFormatProvider formatProvider); + } + public partial interface IDisposable + { + void Dispose(); + } + public partial interface IEquatable + { + bool Equals(T other); + } + public partial interface IFormatProvider + { + object GetFormat(System.Type formatType); + } + public partial interface IFormattable + { + string ToString(string format, System.IFormatProvider formatProvider); + } + public sealed partial class IndexOutOfRangeException : System.Exception + { + public IndexOutOfRangeException() { } + public IndexOutOfRangeException(string message) { } + public IndexOutOfRangeException(string message, System.Exception innerException) { } + } + public sealed partial class InsufficientExecutionStackException : System.Exception + { + public InsufficientExecutionStackException() { } + public InsufficientExecutionStackException(string message) { } + public InsufficientExecutionStackException(string message, System.Exception innerException) { } + } + public partial struct Int16 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const short MaxValue = (short)32767; + public const short MinValue = (short)-32768; + public int CompareTo(System.Int16 value) { throw null; } + public bool Equals(System.Int16 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int16 Parse(string s) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + System.Int16 System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int16 result) { throw null; } + public static bool TryParse(string s, out System.Int16 result) { throw null; } + } + public partial struct Int32 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const int MaxValue = 2147483647; + public const int MinValue = -2147483648; + public System.Int32 CompareTo(System.Int32 value) { throw null; } + public bool Equals(System.Int32 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override System.Int32 GetHashCode() { throw null; } + public static System.Int32 Parse(string s) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int32 Parse(string s, System.IFormatProvider provider) { throw null; } + System.Int32 System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + System.Int32 System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int32 result) { throw null; } + public static bool TryParse(string s, out System.Int32 result) { throw null; } + } + public partial struct Int64 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const long MaxValue = (long)9223372036854775807; + public const long MinValue = (long)-9223372036854775808; + public int CompareTo(System.Int64 value) { throw null; } + public bool Equals(System.Int64 obj) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Int64 Parse(string s) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Int64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Int64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + System.Int64 System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Int64 result) { throw null; } + public static bool TryParse(string s, out System.Int64 result) { throw null; } + } + public partial struct IntPtr + { + public static readonly System.IntPtr Zero; + public IntPtr(int value) { throw null; } + public IntPtr(long value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe IntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.IntPtr Add(System.IntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.IntPtr operator +(System.IntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static explicit operator System.IntPtr (int value) { throw null; } + public static explicit operator System.IntPtr (long value) { throw null; } + public static explicit operator int (System.IntPtr value) { throw null; } + public static explicit operator long (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.IntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.IntPtr (void* value) { throw null; } + public static bool operator !=(System.IntPtr value1, System.IntPtr value2) { throw null; } + public static System.IntPtr operator -(System.IntPtr pointer, int offset) { throw null; } + public static System.IntPtr Subtract(System.IntPtr pointer, int offset) { throw null; } + public int ToInt32() { throw null; } + public long ToInt64() { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + } + public partial class InvalidCastException : System.Exception + { + public InvalidCastException() { } + public InvalidCastException(string message) { } + public InvalidCastException(string message, System.Exception innerException) { } + public InvalidCastException(string message, int errorCode) { } + } + public partial class InvalidOperationException : System.Exception + { + public InvalidOperationException() { } + public InvalidOperationException(string message) { } + public InvalidOperationException(string message, System.Exception innerException) { } + } + public sealed partial class InvalidProgramException : System.Exception + { + public InvalidProgramException() { } + public InvalidProgramException(string message) { } + public InvalidProgramException(string message, System.Exception inner) { } + } + public partial class InvalidTimeZoneException : System.Exception + { + public InvalidTimeZoneException() { } + public InvalidTimeZoneException(string message) { } + public InvalidTimeZoneException(string message, System.Exception innerException) { } + } + public partial interface IObservable + { + System.IDisposable Subscribe(System.IObserver observer); + } + public partial interface IObserver + { + void OnCompleted(); + void OnError(System.Exception error); + void OnNext(T value); + } + public partial interface IProgress + { + void Report(T value); + } + public partial class Lazy + { + public Lazy() { } + public Lazy(bool isThreadSafe) { } + public Lazy(System.Func valueFactory) { } + public Lazy(System.Func valueFactory, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(System.Threading.LazyThreadSafetyMode mode) { } + public bool IsValueCreated { get { throw null; } } + public T Value { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class Lazy : System.Lazy + { + public Lazy(System.Func valueFactory, TMetadata metadata) { } + public Lazy(System.Func valueFactory, TMetadata metadata, bool isThreadSafe) { } + public Lazy(System.Func valueFactory, TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public Lazy(TMetadata metadata) { } + public Lazy(TMetadata metadata, bool isThreadSafe) { } + public Lazy(TMetadata metadata, System.Threading.LazyThreadSafetyMode mode) { } + public TMetadata Metadata { get { throw null; } } + } + public partial class MemberAccessException : System.Exception + { + public MemberAccessException() { } + public MemberAccessException(string message) { } + public MemberAccessException(string message, System.Exception inner) { } + } + public partial class MethodAccessException : System.MemberAccessException + { + public MethodAccessException() { } + public MethodAccessException(string message) { } + public MethodAccessException(string message, System.Exception inner) { } + } + public partial class MissingFieldException : System.MissingMemberException + { + public MissingFieldException() { } + public MissingFieldException(string message) { } + public MissingFieldException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public partial class MissingMemberException : System.MemberAccessException + { + public MissingMemberException() { } + public MissingMemberException(string message) { } + public MissingMemberException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public partial class MissingMethodException : System.MissingMemberException + { + public MissingMethodException() { } + public MissingMethodException(string message) { } + public MissingMethodException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + } + public sealed partial class MTAThreadAttribute : System.Attribute + { + public MTAThreadAttribute() { } + } + public abstract partial class MulticastDelegate : System.Delegate + { + internal MulticastDelegate() { } + public sealed override bool Equals(object obj) { throw null; } + public sealed override int GetHashCode() { throw null; } + public sealed override System.Delegate[] GetInvocationList() { throw null; } + public static bool operator ==(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + public static bool operator !=(System.MulticastDelegate d1, System.MulticastDelegate d2) { throw null; } + } + public partial class NotImplementedException : System.Exception + { + public NotImplementedException() { } + public NotImplementedException(string message) { } + public NotImplementedException(string message, System.Exception inner) { } + } + public partial class NotSupportedException : System.Exception + { + public NotSupportedException() { } + public NotSupportedException(string message) { } + public NotSupportedException(string message, System.Exception innerException) { } + } + public static partial class Nullable + { + public static int Compare(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static bool Equals(System.Nullable n1, System.Nullable n2) where T : struct { throw null; } + public static System.Type GetUnderlyingType(System.Type nullableType) { throw null; } + } + public partial struct Nullable where T : struct + { + public Nullable(T value) { throw null; } + public bool HasValue { get { throw null; } } + public T Value { get { throw null; } } + public override bool Equals(object other) { throw null; } + public override int GetHashCode() { throw null; } + public T GetValueOrDefault() { throw null; } + public T GetValueOrDefault(T defaultValue) { throw null; } + public static explicit operator T (System.Nullable value) { throw null; } + public static implicit operator System.Nullable (T value) { throw null; } + public override string ToString() { throw null; } + } + public partial class NullReferenceException : System.Exception + { + public NullReferenceException() { } + public NullReferenceException(string message) { } + public NullReferenceException(string message, System.Exception innerException) { } + } + public partial class Object + { + public Object() { } + public virtual bool Equals(System.Object obj) { throw null; } + public static bool Equals(System.Object objA, System.Object objB) { throw null; } + ~Object() { } + public virtual int GetHashCode() { throw null; } + public System.Type GetType() { throw null; } + protected System.Object MemberwiseClone() { throw null; } + public static bool ReferenceEquals(System.Object objA, System.Object objB) { throw null; } + public virtual string ToString() { throw null; } + } + public partial class ObjectDisposedException : System.InvalidOperationException + { + public ObjectDisposedException(string objectName) { } + public ObjectDisposedException(string message, System.Exception innerException) { } + public ObjectDisposedException(string objectName, string message) { } + public override string Message { get { throw null; } } + public string ObjectName { get { throw null; } } + } + public sealed partial class ObsoleteAttribute : System.Attribute + { + public ObsoleteAttribute() { } + public ObsoleteAttribute(string message) { } + public ObsoleteAttribute(string message, bool error) { } + public bool IsError { get { throw null; } } + public string Message { get { throw null; } } + } + public partial class OutOfMemoryException : System.Exception + { + public OutOfMemoryException() { } + public OutOfMemoryException(string message) { } + public OutOfMemoryException(string message, System.Exception innerException) { } + } + public partial class OverflowException : System.ArithmeticException + { + public OverflowException() { } + public OverflowException(string message) { } + public OverflowException(string message, System.Exception innerException) { } + } + public sealed partial class ParamArrayAttribute : System.Attribute + { + public ParamArrayAttribute() { } + } + public partial class PlatformNotSupportedException : System.NotSupportedException + { + public PlatformNotSupportedException() { } + public PlatformNotSupportedException(string message) { } + public PlatformNotSupportedException(string message, System.Exception inner) { } + } + public delegate bool Predicate(T obj); + public partial class RankException : System.Exception + { + public RankException() { } + public RankException(string message) { } + public RankException(string message, System.Exception innerException) { } + } + public partial struct RuntimeFieldHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeFieldHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + public static bool operator !=(System.RuntimeFieldHandle left, System.RuntimeFieldHandle right) { throw null; } + } + public partial struct RuntimeMethodHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeMethodHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + public static bool operator !=(System.RuntimeMethodHandle left, System.RuntimeMethodHandle right) { throw null; } + } + public partial struct RuntimeTypeHandle + { + public override bool Equals(object obj) { throw null; } + public bool Equals(System.RuntimeTypeHandle handle) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator ==(System.RuntimeTypeHandle left, object right) { throw null; } + public static bool operator !=(object left, System.RuntimeTypeHandle right) { throw null; } + public static bool operator !=(System.RuntimeTypeHandle left, object right) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct SByte : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const sbyte MaxValue = (sbyte)127; + public const sbyte MinValue = (sbyte)-128; + public int CompareTo(System.SByte value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.SByte obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.SByte Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + System.SByte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.SByte result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.SByte result) { throw null; } + } + public partial struct Single : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const float Epsilon = 1.401298E-45f; + public const float MaxValue = 3.40282347E+38f; + public const float MinValue = -3.40282347E+38f; + public const float NaN = 0.0f / 0.0f; + public const float NegativeInfinity = -1.0f / 0.0f; + public const float PositiveInfinity = 1.0f / 0.0f; + public int CompareTo(System.Single value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Single obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool IsInfinity(System.Single f) { throw null; } + public static bool IsNaN(System.Single f) { throw null; } + public static bool IsNegativeInfinity(System.Single f) { throw null; } + public static bool IsPositiveInfinity(System.Single f) { throw null; } + public static bool operator ==(System.Single left, System.Single right) { throw null; } + public static bool operator >(System.Single left, System.Single right) { throw null; } + public static bool operator >=(System.Single left, System.Single right) { throw null; } + public static bool operator !=(System.Single left, System.Single right) { throw null; } + public static bool operator <(System.Single left, System.Single right) { throw null; } + public static bool operator <=(System.Single left, System.Single right) { throw null; } + public static System.Single Parse(string s) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style) { throw null; } + public static System.Single Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + public static System.Single Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + System.Single System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.Single result) { throw null; } + public static bool TryParse(string s, out System.Single result) { throw null; } + } + public sealed partial class STAThreadAttribute : System.Attribute + { + public STAThreadAttribute() { } + } + public sealed partial class String : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IComparable, System.IComparable, System.IConvertible, System.IEquatable + { + public static readonly string Empty; + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value) { } + [System.CLSCompliantAttribute(false)] + public unsafe String(char* value, int startIndex, int length) { } + public String(char c, int count) { } + public String(char[] value) { } + public String(char[] value, int startIndex, int length) { } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } } + public int Length { get { throw null; } } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int Compare(System.String strA, int indexA, System.String strB, int indexB, int length, System.StringComparison comparisonType) { throw null; } + public static int Compare(System.String strA, System.String strB) { throw null; } + public static int Compare(System.String strA, System.String strB, bool ignoreCase) { throw null; } + public static int Compare(System.String strA, System.String strB, System.StringComparison comparisonType) { throw null; } + public static int CompareOrdinal(System.String strA, int indexA, System.String strB, int indexB, int length) { throw null; } + public static int CompareOrdinal(System.String strA, System.String strB) { throw null; } + public int CompareTo(System.String strB) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Concat(object arg0) { throw null; } + public static System.String Concat(object arg0, object arg1) { throw null; } + public static System.String Concat(object arg0, object arg1, object arg2) { throw null; } + public static System.String Concat(params object[] args) { throw null; } + public static System.String Concat(System.String str0, System.String str1) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2) { throw null; } + public static System.String Concat(System.String str0, System.String str1, System.String str2, System.String str3) { throw null; } + public static System.String Concat(params string[] values) { throw null; } + public static System.String Concat(System.Collections.Generic.IEnumerable values) { throw null; } + public bool Contains(System.String value) { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public bool EndsWith(System.String value) { throw null; } + public bool EndsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.String value) { throw null; } + public static bool Equals(System.String a, System.String b) { throw null; } + public static bool Equals(System.String a, System.String b, System.StringComparison comparisonType) { throw null; } + public bool Equals(System.String value, System.StringComparison comparisonType) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, object arg0) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, object arg0, object arg1) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, object arg0, object arg1, object arg2) { throw null; } + public static System.String Format(System.IFormatProvider provider, System.String format, params object[] args) { throw null; } + public static System.String Format(System.String format, object arg0) { throw null; } + public static System.String Format(System.String format, object arg0, object arg1) { throw null; } + public static System.String Format(System.String format, object arg0, object arg1, object arg2) { throw null; } + public static System.String Format(System.String format, params object[] args) { throw null; } + public override int GetHashCode() { throw null; } + public int IndexOf(char value) { throw null; } + public int IndexOf(char value, int startIndex) { throw null; } + public int IndexOf(char value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value) { throw null; } + public int IndexOf(System.String value, int startIndex) { throw null; } + public int IndexOf(System.String value, int startIndex, int count) { throw null; } + public int IndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int IndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int IndexOfAny(char[] anyOf) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int IndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public System.String Insert(int startIndex, System.String value) { throw null; } + public static bool IsNullOrEmpty(System.String value) { throw null; } + public static bool IsNullOrWhiteSpace(System.String value) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public static System.String Join(System.String separator, params object[] values) { throw null; } + public static System.String Join(System.String separator, params string[] value) { throw null; } + public static System.String Join(System.String separator, string[] value, int startIndex, int count) { throw null; } + public static System.String Join(System.String separator, System.Collections.Generic.IEnumerable values) { throw null; } + public int LastIndexOf(char value) { throw null; } + public int LastIndexOf(char value, int startIndex) { throw null; } + public int LastIndexOf(char value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value) { throw null; } + public int LastIndexOf(System.String value, int startIndex) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count) { throw null; } + public int LastIndexOf(System.String value, int startIndex, int count, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, int startIndex, System.StringComparison comparisonType) { throw null; } + public int LastIndexOf(System.String value, System.StringComparison comparisonType) { throw null; } + public int LastIndexOfAny(char[] anyOf) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex) { throw null; } + public int LastIndexOfAny(char[] anyOf, int startIndex, int count) { throw null; } + public static bool operator ==(System.String a, System.String b) { throw null; } + public static bool operator !=(System.String a, System.String b) { throw null; } + public System.String PadLeft(int totalWidth) { throw null; } + public System.String PadLeft(int totalWidth, char paddingChar) { throw null; } + public System.String PadRight(int totalWidth) { throw null; } + public System.String PadRight(int totalWidth, char paddingChar) { throw null; } + public System.String Remove(int startIndex) { throw null; } + public System.String Remove(int startIndex, int count) { throw null; } + public System.String Replace(char oldChar, char newChar) { throw null; } + public System.String Replace(System.String oldValue, System.String newValue) { throw null; } + public string[] Split(params char[] separator) { throw null; } + public string[] Split(char[] separator, int count) { throw null; } + public string[] Split(char[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(char[] separator, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, int count, System.StringSplitOptions options) { throw null; } + public string[] Split(string[] separator, System.StringSplitOptions options) { throw null; } + public bool StartsWith(System.String value) { throw null; } + public bool StartsWith(System.String value, System.StringComparison comparisonType) { throw null; } + public System.String Substring(int startIndex) { throw null; } + public System.String Substring(int startIndex, int length) { throw null; } + System.Collections.Generic.IEnumerator System.Collections.Generic.IEnumerable.GetEnumerator() { throw null; } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + System.String System.IConvertible.ToString(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public char[] ToCharArray() { throw null; } + public char[] ToCharArray(int startIndex, int length) { throw null; } + public System.String ToLower() { throw null; } + public System.String ToLowerInvariant() { throw null; } + public override System.String ToString() { throw null; } + public System.String ToUpper() { throw null; } + public System.String ToUpperInvariant() { throw null; } + public System.String Trim() { throw null; } + public System.String Trim(params char[] trimChars) { throw null; } + public System.String TrimEnd(params char[] trimChars) { throw null; } + public System.String TrimStart(params char[] trimChars) { throw null; } + } + public enum StringComparison + { + CurrentCulture = 0, + CurrentCultureIgnoreCase = 1, + Ordinal = 4, + OrdinalIgnoreCase = 5, + } + [System.FlagsAttribute] + public enum StringSplitOptions + { + None = 0, + RemoveEmptyEntries = 1, + } + public partial class ThreadStaticAttribute : System.Attribute + { + public ThreadStaticAttribute() { } + } + public partial class TimeoutException : System.Exception + { + public TimeoutException() { } + public TimeoutException(string message) { } + public TimeoutException(string message, System.Exception innerException) { } + } + public partial struct TimeSpan : System.IComparable, System.IComparable, System.IEquatable, System.IFormattable + { + public static readonly System.TimeSpan MaxValue; + public static readonly System.TimeSpan MinValue; + public const long TicksPerDay = (long)864000000000; + public const long TicksPerHour = (long)36000000000; + public const long TicksPerMillisecond = (long)10000; + public const long TicksPerMinute = (long)600000000; + public const long TicksPerSecond = (long)10000000; + public static readonly System.TimeSpan Zero; + public TimeSpan(int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds) { throw null; } + public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds) { throw null; } + public TimeSpan(long ticks) { throw null; } + public int Days { get { throw null; } } + public int Hours { get { throw null; } } + public int Milliseconds { get { throw null; } } + public int Minutes { get { throw null; } } + public int Seconds { get { throw null; } } + public long Ticks { get { throw null; } } + public double TotalDays { get { throw null; } } + public double TotalHours { get { throw null; } } + public double TotalMilliseconds { get { throw null; } } + public double TotalMinutes { get { throw null; } } + public double TotalSeconds { get { throw null; } } + public System.TimeSpan Add(System.TimeSpan ts) { throw null; } + public static int Compare(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public int CompareTo(System.TimeSpan value) { throw null; } + public System.TimeSpan Duration() { throw null; } + public override bool Equals(object value) { throw null; } + public bool Equals(System.TimeSpan obj) { throw null; } + public static bool Equals(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan FromDays(double value) { throw null; } + public static System.TimeSpan FromHours(double value) { throw null; } + public static System.TimeSpan FromMilliseconds(double value) { throw null; } + public static System.TimeSpan FromMinutes(double value) { throw null; } + public static System.TimeSpan FromSeconds(double value) { throw null; } + public static System.TimeSpan FromTicks(long value) { throw null; } + public override int GetHashCode() { throw null; } + public System.TimeSpan Negate() { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator ==(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator >=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator !=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static bool operator <=(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t1, System.TimeSpan t2) { throw null; } + public static System.TimeSpan operator -(System.TimeSpan t) { throw null; } + public static System.TimeSpan operator +(System.TimeSpan t) { throw null; } + public static System.TimeSpan Parse(string s) { throw null; } + public static System.TimeSpan Parse(string input, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider) { throw null; } + public static System.TimeSpan ParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles) { throw null; } + public System.TimeSpan Subtract(System.TimeSpan ts) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + public override string ToString() { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider formatProvider) { throw null; } + public static bool TryParse(string input, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParse(string s, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string format, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, System.Globalization.TimeSpanStyles styles, out System.TimeSpan result) { throw null; } + public static bool TryParseExact(string input, string[] formats, System.IFormatProvider formatProvider, out System.TimeSpan result) { throw null; } + } + public sealed partial class TimeZoneInfo : System.IEquatable + { + internal TimeZoneInfo() { } + public System.TimeSpan BaseUtcOffset { get { throw null; } } + public string DaylightName { get { throw null; } } + public string DisplayName { get { throw null; } } + public string Id { get { throw null; } } + public static System.TimeZoneInfo Local { get { throw null; } } + public string StandardName { get { throw null; } } + public bool SupportsDaylightSavingTime { get { throw null; } } + public static System.TimeZoneInfo Utc { get { throw null; } } + public static System.DateTime ConvertTime(System.DateTime dateTime, System.TimeZoneInfo destinationTimeZone) { throw null; } + public static System.DateTime ConvertTime(System.DateTime dateTime, System.TimeZoneInfo sourceTimeZone, System.TimeZoneInfo destinationTimeZone) { throw null; } + public static System.DateTimeOffset ConvertTime(System.DateTimeOffset dateTimeOffset, System.TimeZoneInfo destinationTimeZone) { throw null; } + public bool Equals(System.TimeZoneInfo other) { throw null; } + public static System.TimeZoneInfo FindSystemTimeZoneById(string id) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTime dateTime) { throw null; } + public System.TimeSpan[] GetAmbiguousTimeOffsets(System.DateTimeOffset dateTimeOffset) { throw null; } + public override int GetHashCode() { throw null; } + public static System.Collections.ObjectModel.ReadOnlyCollection GetSystemTimeZones() { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTime dateTime) { throw null; } + public System.TimeSpan GetUtcOffset(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsAmbiguousTime(System.DateTime dateTime) { throw null; } + public bool IsAmbiguousTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsDaylightSavingTime(System.DateTime dateTime) { throw null; } + public bool IsDaylightSavingTime(System.DateTimeOffset dateTimeOffset) { throw null; } + public bool IsInvalidTime(System.DateTime dateTime) { throw null; } + public override string ToString() { throw null; } + } + public static partial class Tuple + { + public static System.Tuple Create(T1 item1) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { throw null; } + public static System.Tuple Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { throw null; } + public static System.Tuple> Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8) { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1) { } + public T1 Item1 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public partial class Tuple : System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable, System.IComparable + { + public Tuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) { } + public T1 Item1 { get { throw null; } } + public T2 Item2 { get { throw null; } } + public T3 Item3 { get { throw null; } } + public T4 Item4 { get { throw null; } } + public T5 Item5 { get { throw null; } } + public T6 Item6 { get { throw null; } } + public T7 Item7 { get { throw null; } } + public TRest Rest { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + int System.Collections.IStructuralComparable.CompareTo(object other, System.Collections.IComparer comparer) { throw null; } + bool System.Collections.IStructuralEquatable.Equals(object other, System.Collections.IEqualityComparer comparer) { throw null; } + int System.Collections.IStructuralEquatable.GetHashCode(System.Collections.IEqualityComparer comparer) { throw null; } + int System.IComparable.CompareTo(object obj) { throw null; } + public override string ToString() { throw null; } + } + public abstract partial class Type + { + internal Type() { } + public static readonly char Delimiter; + public static readonly System.Type[] EmptyTypes; + public static readonly object Missing; + public abstract string AssemblyQualifiedName { get; } + public abstract System.Type DeclaringType { get; } + public abstract string FullName { get; } + public abstract int GenericParameterPosition { get; } + public abstract System.Type[] GenericTypeArguments { get; } + public bool HasElementType { get { throw null; } } + public virtual bool IsArray { get { throw null; } } + public virtual bool IsByRef { get { throw null; } } + public abstract bool IsConstructedGenericType { get; } + public abstract bool IsGenericParameter { get; } + public bool IsNested { get { throw null; } } + public virtual bool IsPointer { get { throw null; } } + public abstract string Name { get; } + public abstract string Namespace { get; } + public virtual System.RuntimeTypeHandle TypeHandle { get { throw null; } } + public override bool Equals(object o) { throw null; } + public bool Equals(System.Type o) { throw null; } + public abstract int GetArrayRank(); + public abstract System.Type GetElementType(); + public abstract System.Type GetGenericTypeDefinition(); + public override int GetHashCode() { throw null; } + public static System.Type GetType(string typeName) { throw null; } + public static System.Type GetType(string typeName, bool throwOnError) { throw null; } + public static System.Type GetType(string typeName, bool throwOnError, bool ignoreCase) { throw null; } + public static System.TypeCode GetTypeCode(System.Type type) { throw null; } + public static System.Type GetTypeFromHandle(System.RuntimeTypeHandle handle) { throw null; } + public abstract System.Type MakeArrayType(); + public abstract System.Type MakeArrayType(int rank); + public abstract System.Type MakeByRefType(); + public abstract System.Type MakeGenericType(params System.Type[] typeArguments); + public abstract System.Type MakePointerType(); + public override string ToString() { throw null; } + } + public partial class TypeAccessException : System.TypeLoadException + { + public TypeAccessException() { } + public TypeAccessException(string message) { } + public TypeAccessException(string message, System.Exception inner) { } + } + public enum TypeCode + { + Boolean = 3, + Byte = 6, + Char = 4, + DateTime = 16, + Decimal = 15, + Double = 14, + Empty = 0, + Int16 = 7, + Int32 = 9, + Int64 = 11, + Object = 1, + SByte = 5, + Single = 13, + String = 18, + UInt16 = 8, + UInt32 = 10, + UInt64 = 12, + } + public sealed partial class TypeInitializationException : System.Exception + { + public TypeInitializationException(string fullTypeName, System.Exception innerException) { } + public string TypeName { get { throw null; } } + } + public partial class TypeLoadException : System.Exception + { + public TypeLoadException() { } + public TypeLoadException(string message) { } + public TypeLoadException(string message, System.Exception inner) { } + public override string Message { get { throw null; } } + public string TypeName { get { throw null; } } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt16 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const ushort MaxValue = (ushort)65535; + public const ushort MinValue = (ushort)0; + public int CompareTo(System.UInt16 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt16 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt16 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + System.UInt16 System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt16 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt16 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt32 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const uint MaxValue = (uint)4294967295; + public const uint MinValue = (uint)0; + public int CompareTo(System.UInt32 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt32 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt32 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + System.UInt32 System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + ulong System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt32 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt32 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UInt64 : System.IComparable, System.IComparable, System.IConvertible, System.IEquatable, System.IFormattable + { + public const ulong MaxValue = (ulong)18446744073709551615; + public const ulong MinValue = (ulong)0; + public int CompareTo(System.UInt64 value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.UInt64 obj) { throw null; } + public override int GetHashCode() { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static System.UInt64 Parse(string s, System.IFormatProvider provider) { throw null; } + int System.IComparable.CompareTo(object value) { throw null; } + System.TypeCode System.IConvertible.GetTypeCode() { throw null; } + bool System.IConvertible.ToBoolean(System.IFormatProvider provider) { throw null; } + byte System.IConvertible.ToByte(System.IFormatProvider provider) { throw null; } + char System.IConvertible.ToChar(System.IFormatProvider provider) { throw null; } + System.DateTime System.IConvertible.ToDateTime(System.IFormatProvider provider) { throw null; } + decimal System.IConvertible.ToDecimal(System.IFormatProvider provider) { throw null; } + double System.IConvertible.ToDouble(System.IFormatProvider provider) { throw null; } + short System.IConvertible.ToInt16(System.IFormatProvider provider) { throw null; } + int System.IConvertible.ToInt32(System.IFormatProvider provider) { throw null; } + long System.IConvertible.ToInt64(System.IFormatProvider provider) { throw null; } + sbyte System.IConvertible.ToSByte(System.IFormatProvider provider) { throw null; } + float System.IConvertible.ToSingle(System.IFormatProvider provider) { throw null; } + object System.IConvertible.ToType(System.Type type, System.IFormatProvider provider) { throw null; } + ushort System.IConvertible.ToUInt16(System.IFormatProvider provider) { throw null; } + uint System.IConvertible.ToUInt32(System.IFormatProvider provider) { throw null; } + System.UInt64 System.IConvertible.ToUInt64(System.IFormatProvider provider) { throw null; } + public override string ToString() { throw null; } + public string ToString(System.IFormatProvider provider) { throw null; } + public string ToString(string format) { throw null; } + public string ToString(string format, System.IFormatProvider provider) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, System.Globalization.NumberStyles style, System.IFormatProvider provider, out System.UInt64 result) { throw null; } + [System.CLSCompliantAttribute(false)] + public static bool TryParse(string s, out System.UInt64 result) { throw null; } + } + [System.CLSCompliantAttribute(false)] + public partial struct UIntPtr + { + public static readonly System.UIntPtr Zero; + public UIntPtr(uint value) { throw null; } + public UIntPtr(ulong value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe UIntPtr(void* value) { throw null; } + public static int Size { get { throw null; } } + public static System.UIntPtr Add(System.UIntPtr pointer, int offset) { throw null; } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public static System.UIntPtr operator +(System.UIntPtr pointer, int offset) { throw null; } + public static bool operator ==(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static explicit operator System.UIntPtr (uint value) { throw null; } + public static explicit operator System.UIntPtr (ulong value) { throw null; } + public static explicit operator uint (System.UIntPtr value) { throw null; } + public static explicit operator ulong (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator void* (System.UIntPtr value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe static explicit operator System.UIntPtr (void* value) { throw null; } + public static bool operator !=(System.UIntPtr value1, System.UIntPtr value2) { throw null; } + public static System.UIntPtr operator -(System.UIntPtr pointer, int offset) { throw null; } + public static System.UIntPtr Subtract(System.UIntPtr pointer, int offset) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe void* ToPointer() { throw null; } + public override string ToString() { throw null; } + public uint ToUInt32() { throw null; } + public ulong ToUInt64() { throw null; } + } + public partial class UnauthorizedAccessException : System.Exception + { + public UnauthorizedAccessException() { } + public UnauthorizedAccessException(string message) { } + public UnauthorizedAccessException(string message, System.Exception inner) { } + } + public partial class Uri + { + public Uri(string uriString) { } + public Uri(string uriString, System.UriKind uriKind) { } + public Uri(System.Uri baseUri, string relativeUri) { } + public Uri(System.Uri baseUri, System.Uri relativeUri) { } + public string AbsolutePath { get { throw null; } } + public string AbsoluteUri { get { throw null; } } + public string Authority { get { throw null; } } + public string DnsSafeHost { get { throw null; } } + public string Fragment { get { throw null; } } + public string Host { get { throw null; } } + public System.UriHostNameType HostNameType { get { throw null; } } + public string IdnHost { get { throw null; } } + public bool IsAbsoluteUri { get { throw null; } } + public bool IsDefaultPort { get { throw null; } } + public bool IsFile { get { throw null; } } + public bool IsLoopback { get { throw null; } } + public bool IsUnc { get { throw null; } } + public string LocalPath { get { throw null; } } + public string OriginalString { get { throw null; } } + public string PathAndQuery { get { throw null; } } + public int Port { get { throw null; } } + public string Query { get { throw null; } } + public string Scheme { get { throw null; } } + public string[] Segments { get { throw null; } } + public bool UserEscaped { get { throw null; } } + public string UserInfo { get { throw null; } } + public static System.UriHostNameType CheckHostName(string name) { throw null; } + public static bool CheckSchemeName(string schemeName) { throw null; } + public static int Compare(System.Uri uri1, System.Uri uri2, System.UriComponents partsToCompare, System.UriFormat compareFormat, System.StringComparison comparisonType) { throw null; } + public override bool Equals(object comparand) { throw null; } + public static string EscapeDataString(string stringToEscape) { throw null; } + public static string EscapeUriString(string stringToEscape) { throw null; } + public string GetComponents(System.UriComponents components, System.UriFormat format) { throw null; } + public override int GetHashCode() { throw null; } + public bool IsBaseOf(System.Uri uri) { throw null; } + public bool IsWellFormedOriginalString() { throw null; } + public static bool IsWellFormedUriString(string uriString, System.UriKind uriKind) { throw null; } + public System.Uri MakeRelativeUri(System.Uri uri) { throw null; } + public static bool operator ==(System.Uri uri1, System.Uri uri2) { throw null; } + public static bool operator !=(System.Uri uri1, System.Uri uri2) { throw null; } + public override string ToString() { throw null; } + public static bool TryCreate(string uriString, System.UriKind uriKind, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, string relativeUri, out System.Uri result) { throw null; } + public static bool TryCreate(System.Uri baseUri, System.Uri relativeUri, out System.Uri result) { throw null; } + public static string UnescapeDataString(string stringToUnescape) { throw null; } + } + [System.FlagsAttribute] + public enum UriComponents + { + AbsoluteUri = 127, + Fragment = 64, + Host = 4, + HostAndPort = 132, + HttpRequestUrl = 61, + KeepDelimiter = 1073741824, + NormalizedHost = 256, + Path = 16, + PathAndQuery = 48, + Port = 8, + Query = 32, + Scheme = 1, + SchemeAndServer = 13, + SerializationInfoString = -2147483648, + StrongAuthority = 134, + StrongPort = 128, + UserInfo = 2, + } + public enum UriFormat + { + SafeUnescaped = 3, + Unescaped = 2, + UriEscaped = 1, + } + public partial class UriFormatException : System.FormatException + { + public UriFormatException() { } + public UriFormatException(string textString) { } + public UriFormatException(string textString, System.Exception e) { } + } + public enum UriHostNameType + { + Basic = 1, + Dns = 2, + IPv4 = 3, + IPv6 = 4, + Unknown = 0, + } + public enum UriKind + { + Absolute = 1, + Relative = 2, + RelativeOrAbsolute = 0, + } + public abstract partial class ValueType + { + protected ValueType() { } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + public override string ToString() { throw null; } + } + public sealed partial class Version : System.IComparable, System.IComparable, System.IEquatable + { + public Version(int major, int minor) { } + public Version(int major, int minor, int build) { } + public Version(int major, int minor, int build, int revision) { } + public Version(string version) { } + public int Build { get { throw null; } } + public int Major { get { throw null; } } + public short MajorRevision { get { throw null; } } + public int Minor { get { throw null; } } + public short MinorRevision { get { throw null; } } + public int Revision { get { throw null; } } + public int CompareTo(System.Version value) { throw null; } + public override bool Equals(object obj) { throw null; } + public bool Equals(System.Version obj) { throw null; } + public override int GetHashCode() { throw null; } + public static bool operator ==(System.Version v1, System.Version v2) { throw null; } + public static bool operator >(System.Version v1, System.Version v2) { throw null; } + public static bool operator >=(System.Version v1, System.Version v2) { throw null; } + public static bool operator !=(System.Version v1, System.Version v2) { throw null; } + public static bool operator <(System.Version v1, System.Version v2) { throw null; } + public static bool operator <=(System.Version v1, System.Version v2) { throw null; } + public static System.Version Parse(string input) { throw null; } + int System.IComparable.CompareTo(object version) { throw null; } + public override string ToString() { throw null; } + public string ToString(int fieldCount) { throw null; } + public static bool TryParse(string input, out System.Version result) { throw null; } + } + public partial struct Void + { + } + public partial class WeakReference + { + public WeakReference(object target) { } + public WeakReference(object target, bool trackResurrection) { } + public virtual bool IsAlive { get { throw null; } } + public virtual object Target { get { throw null; } set { } } + public virtual bool TrackResurrection { get { throw null; } } + ~WeakReference() { } + } + public sealed partial class WeakReference where T : class + { + public WeakReference(T target) { } + public WeakReference(T target, bool trackResurrection) { } + ~WeakReference() { } + public void SetTarget(T target) { } + public bool TryGetTarget(out T target) { throw null; } + } +} +namespace System.Collections +{ + public partial struct DictionaryEntry + { + public DictionaryEntry(object key, object value) { throw null; } + public object Key { get { throw null; } set { } } + public object Value { get { throw null; } set { } } + } + public partial interface ICollection : System.Collections.IEnumerable + { + int Count { get; } + bool IsSynchronized { get; } + object SyncRoot { get; } + void CopyTo(System.Array array, int index); + } + public partial interface IComparer + { + int Compare(object x, object y); + } + public partial interface IDictionary : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[object key] { get; set; } + System.Collections.ICollection Keys { get; } + System.Collections.ICollection Values { get; } + void Add(object key, object value); + void Clear(); + bool Contains(object key); + new System.Collections.IDictionaryEnumerator GetEnumerator(); + void Remove(object key); + } + public partial interface IDictionaryEnumerator : System.Collections.IEnumerator + { + System.Collections.DictionaryEntry Entry { get; } + object Key { get; } + object Value { get; } + } + public partial interface IEnumerable + { + System.Collections.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator + { + object Current { get; } + bool MoveNext(); + void Reset(); + } + public partial interface IEqualityComparer + { + bool Equals(object x, object y); + int GetHashCode(object obj); + } + public partial interface IList : System.Collections.ICollection, System.Collections.IEnumerable + { + bool IsFixedSize { get; } + bool IsReadOnly { get; } + object this[int index] { get; set; } + int Add(object value); + void Clear(); + bool Contains(object value); + int IndexOf(object value); + void Insert(int index, object value); + void Remove(object value); + void RemoveAt(int index); + } + public partial interface IStructuralComparable + { + int CompareTo(object other, System.Collections.IComparer comparer); + } + public partial interface IStructuralEquatable + { + bool Equals(object other, System.Collections.IEqualityComparer comparer); + int GetHashCode(System.Collections.IEqualityComparer comparer); + } +} +namespace System.Collections.Generic +{ + public partial interface ICollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + bool IsReadOnly { get; } + void Add(T item); + void Clear(); + bool Contains(T item); + void CopyTo(T[] array, int arrayIndex); + bool Remove(T item); + } + public partial interface IComparer + { + int Compare(T x, T y); + } + public partial interface IDictionary : System.Collections.Generic.ICollection>, System.Collections.Generic.IEnumerable>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; set; } + System.Collections.Generic.ICollection Keys { get; } + System.Collections.Generic.ICollection Values { get; } + void Add(TKey key, TValue value); + bool ContainsKey(TKey key); + bool Remove(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IEnumerable : System.Collections.IEnumerable + { + new System.Collections.Generic.IEnumerator GetEnumerator(); + } + public partial interface IEnumerator : System.Collections.IEnumerator, System.IDisposable + { + new T Current { get; } + } + public partial interface IEqualityComparer + { + bool Equals(T x, T y); + int GetHashCode(T obj); + } + public partial interface IList : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + T this[int index] { get; set; } + int IndexOf(T item); + void Insert(int index, T item); + void RemoveAt(int index); + } + public partial interface IReadOnlyCollection : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + int Count { get; } + } + public partial interface IReadOnlyDictionary : System.Collections.Generic.IEnumerable>, System.Collections.Generic.IReadOnlyCollection>, System.Collections.IEnumerable + { + TValue this[TKey key] { get; } + System.Collections.Generic.IEnumerable Keys { get; } + System.Collections.Generic.IEnumerable Values { get; } + bool ContainsKey(TKey key); + bool TryGetValue(TKey key, out TValue value); + } + public partial interface IReadOnlyList : System.Collections.Generic.IEnumerable, System.Collections.Generic.IReadOnlyCollection, System.Collections.IEnumerable + { + T this[int index] { get; } + } + public partial interface ISet : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.IEnumerable + { + new bool Add(T item); + void ExceptWith(System.Collections.Generic.IEnumerable other); + void IntersectWith(System.Collections.Generic.IEnumerable other); + bool IsProperSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsProperSupersetOf(System.Collections.Generic.IEnumerable other); + bool IsSubsetOf(System.Collections.Generic.IEnumerable other); + bool IsSupersetOf(System.Collections.Generic.IEnumerable other); + bool Overlaps(System.Collections.Generic.IEnumerable other); + bool SetEquals(System.Collections.Generic.IEnumerable other); + void SymmetricExceptWith(System.Collections.Generic.IEnumerable other); + void UnionWith(System.Collections.Generic.IEnumerable other); + } + public partial class KeyNotFoundException : System.Exception + { + public KeyNotFoundException() { } + public KeyNotFoundException(string message) { } + public KeyNotFoundException(string message, System.Exception innerException) { } + } + public partial struct KeyValuePair + { + public KeyValuePair(TKey key, TValue value) { throw null; } + public TKey Key { get { throw null; } } + public TValue Value { get { throw null; } } + public override string ToString() { throw null; } + } +} +namespace System.Collections.ObjectModel +{ + public partial class Collection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public Collection() { } + public Collection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } set { } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public void Add(T item) { } + public void Clear() { } + protected virtual void ClearItems() { } + public bool Contains(T item) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T item) { throw null; } + public void Insert(int index, T item) { } + protected virtual void InsertItem(int index, T item) { } + public bool Remove(T item) { throw null; } + public void RemoveAt(int index) { } + protected virtual void RemoveItem(int index) { } + protected virtual void SetItem(int index, T item) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + } + public partial class ReadOnlyCollection : System.Collections.Generic.ICollection, System.Collections.Generic.IEnumerable, System.Collections.Generic.IList, System.Collections.Generic.IReadOnlyCollection, System.Collections.Generic.IReadOnlyList, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList + { + public ReadOnlyCollection(System.Collections.Generic.IList list) { } + public int Count { get { throw null; } } + public T this[int index] { get { throw null; } } + protected System.Collections.Generic.IList Items { get { throw null; } } + bool System.Collections.Generic.ICollection.IsReadOnly { get { throw null; } } + T System.Collections.Generic.IList.this[int index] { get { throw null; } set { } } + bool System.Collections.ICollection.IsSynchronized { get { throw null; } } + object System.Collections.ICollection.SyncRoot { get { throw null; } } + bool System.Collections.IList.IsFixedSize { get { throw null; } } + bool System.Collections.IList.IsReadOnly { get { throw null; } } + object System.Collections.IList.this[int index] { get { throw null; } set { } } + public bool Contains(T value) { throw null; } + public void CopyTo(T[] array, int index) { } + public System.Collections.Generic.IEnumerator GetEnumerator() { throw null; } + public int IndexOf(T value) { throw null; } + void System.Collections.Generic.ICollection.Add(T value) { } + void System.Collections.Generic.ICollection.Clear() { } + bool System.Collections.Generic.ICollection.Remove(T value) { throw null; } + void System.Collections.Generic.IList.Insert(int index, T value) { } + void System.Collections.Generic.IList.RemoveAt(int index) { } + void System.Collections.ICollection.CopyTo(System.Array array, int index) { } + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } + int System.Collections.IList.Add(object value) { throw null; } + void System.Collections.IList.Clear() { } + bool System.Collections.IList.Contains(object value) { throw null; } + int System.Collections.IList.IndexOf(object value) { throw null; } + void System.Collections.IList.Insert(int index, object value) { } + void System.Collections.IList.Remove(object value) { } + void System.Collections.IList.RemoveAt(int index) { } + } +} +namespace System.ComponentModel +{ + public partial class DefaultValueAttribute : System.Attribute + { + public DefaultValueAttribute(bool value) { } + public DefaultValueAttribute(byte value) { } + public DefaultValueAttribute(char value) { } + public DefaultValueAttribute(double value) { } + public DefaultValueAttribute(short value) { } + public DefaultValueAttribute(int value) { } + public DefaultValueAttribute(long value) { } + public DefaultValueAttribute(object value) { } + public DefaultValueAttribute(float value) { } + public DefaultValueAttribute(string value) { } + public DefaultValueAttribute(System.Type type, string value) { } + public virtual object Value { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public sealed partial class EditorBrowsableAttribute : System.Attribute + { + public EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState state) { } + public System.ComponentModel.EditorBrowsableState State { get { throw null; } } + public override bool Equals(object obj) { throw null; } + public override int GetHashCode() { throw null; } + } + public enum EditorBrowsableState + { + Advanced = 2, + Always = 0, + Never = 1, + } +} +namespace System.Diagnostics +{ + public sealed partial class ConditionalAttribute : System.Attribute + { + public ConditionalAttribute(string conditionString) { } + public string ConditionString { get { throw null; } } + } + public sealed partial class DebuggableAttribute : System.Attribute + { + public DebuggableAttribute(System.Diagnostics.DebuggableAttribute.DebuggingModes modes) { } + [System.FlagsAttribute] + public enum DebuggingModes + { + Default = 1, + DisableOptimizations = 256, + EnableEditAndContinue = 4, + IgnoreSymbolStoreSequencePoints = 2, + None = 0, + } + } +} +namespace System.Globalization +{ + [System.FlagsAttribute] + public enum DateTimeStyles + { + AdjustToUniversal = 16, + AllowInnerWhite = 4, + AllowLeadingWhite = 1, + AllowTrailingWhite = 2, + AllowWhiteSpaces = 7, + AssumeLocal = 32, + AssumeUniversal = 64, + NoCurrentDateDefault = 8, + None = 0, + RoundtripKind = 128, + } + [System.FlagsAttribute] + public enum NumberStyles + { + AllowCurrencySymbol = 256, + AllowDecimalPoint = 32, + AllowExponent = 128, + AllowHexSpecifier = 512, + AllowLeadingSign = 4, + AllowLeadingWhite = 1, + AllowParentheses = 16, + AllowThousands = 64, + AllowTrailingSign = 8, + AllowTrailingWhite = 2, + Any = 511, + Currency = 383, + Float = 167, + HexNumber = 515, + Integer = 7, + None = 0, + Number = 111, + } + [System.FlagsAttribute] + public enum TimeSpanStyles + { + AssumeNegative = 1, + None = 0, + } +} +namespace System.IO +{ + public partial class DirectoryNotFoundException : System.IO.IOException + { + public DirectoryNotFoundException() { } + public DirectoryNotFoundException(string message) { } + public DirectoryNotFoundException(string message, System.Exception innerException) { } + } + public partial class FileLoadException : System.IO.IOException + { + public FileLoadException() { } + public FileLoadException(string message) { } + public FileLoadException(string message, System.Exception inner) { } + public FileLoadException(string message, string fileName) { } + public FileLoadException(string message, string fileName, System.Exception inner) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class FileNotFoundException : System.IO.IOException + { + public FileNotFoundException() { } + public FileNotFoundException(string message) { } + public FileNotFoundException(string message, System.Exception innerException) { } + public FileNotFoundException(string message, string fileName) { } + public FileNotFoundException(string message, string fileName, System.Exception innerException) { } + public string FileName { get { throw null; } } + public override string Message { get { throw null; } } + public override string ToString() { throw null; } + } + public partial class IOException : System.Exception + { + public IOException() { } + public IOException(string message) { } + public IOException(string message, System.Exception innerException) { } + public IOException(string message, int hresult) { } + } + public partial class PathTooLongException : System.IO.IOException + { + public PathTooLongException() { } + public PathTooLongException(string message) { } + public PathTooLongException(string message, System.Exception innerException) { } + } +} +namespace System.Reflection +{ + public sealed partial class AssemblyCompanyAttribute : System.Attribute + { + public AssemblyCompanyAttribute(string company) { } + public string Company { get { throw null; } } + } + public sealed partial class AssemblyConfigurationAttribute : System.Attribute + { + public AssemblyConfigurationAttribute(string configuration) { } + public string Configuration { get { throw null; } } + } + public sealed partial class AssemblyCopyrightAttribute : System.Attribute + { + public AssemblyCopyrightAttribute(string copyright) { } + public string Copyright { get { throw null; } } + } + public sealed partial class AssemblyCultureAttribute : System.Attribute + { + public AssemblyCultureAttribute(string culture) { } + public string Culture { get { throw null; } } + } + public sealed partial class AssemblyDefaultAliasAttribute : System.Attribute + { + public AssemblyDefaultAliasAttribute(string defaultAlias) { } + public string DefaultAlias { get { throw null; } } + } + public sealed partial class AssemblyDelaySignAttribute : System.Attribute + { + public AssemblyDelaySignAttribute(bool delaySign) { } + public bool DelaySign { get { throw null; } } + } + public sealed partial class AssemblyDescriptionAttribute : System.Attribute + { + public AssemblyDescriptionAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class AssemblyFileVersionAttribute : System.Attribute + { + public AssemblyFileVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class AssemblyFlagsAttribute : System.Attribute + { + public AssemblyFlagsAttribute(System.Reflection.AssemblyNameFlags assemblyFlags) { } + public int AssemblyFlags { get { throw null; } } + } + public sealed partial class AssemblyInformationalVersionAttribute : System.Attribute + { + public AssemblyInformationalVersionAttribute(string informationalVersion) { } + public string InformationalVersion { get { throw null; } } + } + public sealed partial class AssemblyKeyFileAttribute : System.Attribute + { + public AssemblyKeyFileAttribute(string keyFile) { } + public string KeyFile { get { throw null; } } + } + public sealed partial class AssemblyKeyNameAttribute : System.Attribute + { + public AssemblyKeyNameAttribute(string keyName) { } + public string KeyName { get { throw null; } } + } + public sealed partial class AssemblyMetadataAttribute : System.Attribute + { + public AssemblyMetadataAttribute(string key, string value) { } + public string Key { get { throw null; } } + public string Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum AssemblyNameFlags + { + None = 0, + PublicKey = 1, + Retargetable = 256, + } + public sealed partial class AssemblyProductAttribute : System.Attribute + { + public AssemblyProductAttribute(string product) { } + public string Product { get { throw null; } } + } + public sealed partial class AssemblySignatureKeyAttribute : System.Attribute + { + public AssemblySignatureKeyAttribute(string publicKey, string countersignature) { } + public string Countersignature { get { throw null; } } + public string PublicKey { get { throw null; } } + } + public sealed partial class AssemblyTitleAttribute : System.Attribute + { + public AssemblyTitleAttribute(string title) { } + public string Title { get { throw null; } } + } + public sealed partial class AssemblyTrademarkAttribute : System.Attribute + { + public AssemblyTrademarkAttribute(string trademark) { } + public string Trademark { get { throw null; } } + } + public sealed partial class AssemblyVersionAttribute : System.Attribute + { + public AssemblyVersionAttribute(string version) { } + public string Version { get { throw null; } } + } + public sealed partial class DefaultMemberAttribute : System.Attribute + { + public DefaultMemberAttribute(string memberName) { } + public string MemberName { get { throw null; } } + } + public enum ProcessorArchitecture + { + Amd64 = 4, + Arm = 5, + IA64 = 3, + MSIL = 1, + None = 0, + X86 = 2, + } +} +namespace System.Runtime +{ + public enum GCLargeObjectHeapCompactionMode + { + CompactOnce = 2, + Default = 1, + } + public enum GCLatencyMode + { + Batch = 0, + Interactive = 1, + LowLatency = 2, + SustainedLowLatency = 3, + } + public static partial class GCSettings + { + public static bool IsServerGC { get { throw null; } } + public static System.Runtime.GCLargeObjectHeapCompactionMode LargeObjectHeapCompactionMode { get { throw null; } set { } } + public static System.Runtime.GCLatencyMode LatencyMode { get { throw null; } set { } } + } +} +namespace System.Runtime.CompilerServices +{ + public sealed partial class AccessedThroughPropertyAttribute : System.Attribute + { + public AccessedThroughPropertyAttribute(string propertyName) { } + public string PropertyName { get { throw null; } } + } + public sealed partial class AsyncStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public AsyncStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class CallerFilePathAttribute : System.Attribute + { + public CallerFilePathAttribute() { } + } + public sealed partial class CallerLineNumberAttribute : System.Attribute + { + public CallerLineNumberAttribute() { } + } + public sealed partial class CallerMemberNameAttribute : System.Attribute + { + public CallerMemberNameAttribute() { } + } + public partial class CompilationRelaxationsAttribute : System.Attribute + { + public CompilationRelaxationsAttribute(int relaxations) { } + public int CompilationRelaxations { get { throw null; } } + } + public sealed partial class CompilerGeneratedAttribute : System.Attribute + { + public CompilerGeneratedAttribute() { } + } + public sealed partial class ConditionalWeakTable where TKey : class where TValue : class + { + public ConditionalWeakTable() { } + public void Add(TKey key, TValue value) { } + ~ConditionalWeakTable() { } + public TValue GetOrCreateValue(TKey key) { throw null; } + public TValue GetValue(TKey key, System.Runtime.CompilerServices.ConditionalWeakTable.CreateValueCallback createValueCallback) { throw null; } + public bool Remove(TKey key) { throw null; } + public bool TryGetValue(TKey key, out TValue value) { throw null; } + public delegate TValue CreateValueCallback(TKey key); + } + public abstract partial class CustomConstantAttribute : System.Attribute + { + protected CustomConstantAttribute() { } + public abstract object Value { get; } + } + public sealed partial class DateTimeConstantAttribute : System.Runtime.CompilerServices.CustomConstantAttribute + { + public DateTimeConstantAttribute(long ticks) { } + public override object Value { get { throw null; } } + } + public sealed partial class DecimalConstantAttribute : System.Attribute + { + public DecimalConstantAttribute(byte scale, byte sign, int hi, int mid, int low) { } + [System.CLSCompliantAttribute(false)] + public DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low) { } + public decimal Value { get { throw null; } } + } + public sealed partial class DisablePrivateReflectionAttribute : System.Attribute + { + public DisablePrivateReflectionAttribute() { } + } + public sealed partial class ExtensionAttribute : System.Attribute + { + public ExtensionAttribute() { } + } + public sealed partial class FixedBufferAttribute : System.Attribute + { + public FixedBufferAttribute(System.Type elementType, int length) { } + public System.Type ElementType { get { throw null; } } + public int Length { get { throw null; } } + } + public static partial class FormattableStringFactory + { + public static System.FormattableString Create(string format, params object[] arguments) { throw null; } + } + public sealed partial class IndexerNameAttribute : System.Attribute + { + public IndexerNameAttribute(string indexerName) { } + } + public sealed partial class InternalsVisibleToAttribute : System.Attribute + { + public InternalsVisibleToAttribute(string assemblyName) { } + public string AssemblyName { get { throw null; } } + } + public static partial class IsConst + { + } + public partial interface IStrongBox + { + object Value { get; set; } + } + public static partial class IsVolatile + { + } + public sealed partial class IteratorStateMachineAttribute : System.Runtime.CompilerServices.StateMachineAttribute + { + public IteratorStateMachineAttribute(System.Type stateMachineType) : base (default(System.Type)) { } + } + public sealed partial class MethodImplAttribute : System.Attribute + { + public MethodImplAttribute(System.Runtime.CompilerServices.MethodImplOptions methodImplOptions) { } + public System.Runtime.CompilerServices.MethodImplOptions Value { get { throw null; } } + } + [System.FlagsAttribute] + public enum MethodImplOptions + { + AggressiveInlining = 256, + NoInlining = 8, + NoOptimization = 64, + PreserveSig = 128, + } + public sealed partial class ReferenceAssemblyAttribute : System.Attribute + { + public ReferenceAssemblyAttribute() { } + public ReferenceAssemblyAttribute(string description) { } + public string Description { get { throw null; } } + } + public sealed partial class RuntimeCompatibilityAttribute : System.Attribute + { + public RuntimeCompatibilityAttribute() { } + public bool WrapNonExceptionThrows { get { throw null; } set { } } + } + public static partial class RuntimeHelpers + { + public static int OffsetToStringData { get { throw null; } } + public static void EnsureSufficientExecutionStack() { } + public static int GetHashCode(object o) { throw null; } + public static object GetObjectValue(object obj) { throw null; } + public static void InitializeArray(System.Array array, System.RuntimeFieldHandle fldHandle) { } + public static void RunClassConstructor(System.RuntimeTypeHandle type) { } + } + public partial class StateMachineAttribute : System.Attribute + { + public StateMachineAttribute(System.Type stateMachineType) { } + public System.Type StateMachineType { get { throw null; } } + } + public partial class StrongBox : System.Runtime.CompilerServices.IStrongBox + { + public T Value; + public StrongBox() { } + public StrongBox(T value) { } + object System.Runtime.CompilerServices.IStrongBox.Value { get { throw null; } set { } } + } + public sealed partial class TypeForwardedFromAttribute : System.Attribute + { + public TypeForwardedFromAttribute(string assemblyFullName) { } + public string AssemblyFullName { get { throw null; } } + } + public sealed partial class TypeForwardedToAttribute : System.Attribute + { + public TypeForwardedToAttribute(System.Type destination) { } + public System.Type Destination { get { throw null; } } + } + public sealed partial class UnsafeValueTypeAttribute : System.Attribute + { + public UnsafeValueTypeAttribute() { } + } +} +namespace System.Runtime.ExceptionServices +{ + public sealed partial class ExceptionDispatchInfo + { + internal ExceptionDispatchInfo() { } + public System.Exception SourceException { get { throw null; } } + public static System.Runtime.ExceptionServices.ExceptionDispatchInfo Capture(System.Exception source) { throw null; } + public void Throw() { } + } +} +namespace System.Runtime.InteropServices +{ + public enum CharSet + { + Ansi = 2, + Unicode = 3, + } + public sealed partial class ComVisibleAttribute : System.Attribute + { + public ComVisibleAttribute(bool visibility) { } + public bool Value { get { throw null; } } + } + public sealed partial class FieldOffsetAttribute : System.Attribute + { + public FieldOffsetAttribute(int offset) { } + public int Value { get { throw null; } } + } + public enum LayoutKind + { + Auto = 3, + Explicit = 2, + Sequential = 0, + } + public sealed partial class OutAttribute : System.Attribute + { + public OutAttribute() { } + } + public sealed partial class StructLayoutAttribute : System.Attribute + { + public System.Runtime.InteropServices.CharSet CharSet; + public int Pack; + public int Size; + public StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind layoutKind) { } + public System.Runtime.InteropServices.LayoutKind Value { get { throw null; } } + } +} +namespace System.Runtime.Versioning +{ + public sealed partial class TargetFrameworkAttribute : System.Attribute + { + public TargetFrameworkAttribute(string frameworkName) { } + public string FrameworkDisplayName { get { throw null; } set { } } + public string FrameworkName { get { throw null; } } + } +} +namespace System.Security +{ + public sealed partial class AllowPartiallyTrustedCallersAttribute : System.Attribute + { + public AllowPartiallyTrustedCallersAttribute() { } + } + public sealed partial class SecurityCriticalAttribute : System.Attribute + { + public SecurityCriticalAttribute() { } + } + public partial class SecurityException : System.Exception + { + public SecurityException() { } + public SecurityException(string message) { } + public SecurityException(string message, System.Exception inner) { } + public override string ToString() { throw null; } + } + public sealed partial class SecuritySafeCriticalAttribute : System.Attribute + { + public SecuritySafeCriticalAttribute() { } + } + public sealed partial class SecurityTransparentAttribute : System.Attribute + { + public SecurityTransparentAttribute() { } + } + public partial class VerificationException : System.Exception + { + public VerificationException() { } + public VerificationException(string message) { } + public VerificationException(string message, System.Exception innerException) { } + } +} +namespace System.Text +{ + public sealed partial class StringBuilder + { + public StringBuilder() { } + public StringBuilder(int capacity) { } + public StringBuilder(int capacity, int maxCapacity) { } + public StringBuilder(string value) { } + public StringBuilder(string value, int capacity) { } + public StringBuilder(string value, int startIndex, int length, int capacity) { } + public int Capacity { get { throw null; } set { } } + [System.Runtime.CompilerServices.IndexerName("Chars")] + public char this[int index] { get { throw null; } set { } } + public int Length { get { throw null; } set { } } + public int MaxCapacity { get { throw null; } } + public System.Text.StringBuilder Append(bool value) { throw null; } + public System.Text.StringBuilder Append(byte value) { throw null; } + public System.Text.StringBuilder Append(char value) { throw null; } + [System.CLSCompliantAttribute(false)] + public unsafe System.Text.StringBuilder Append(char* value, int valueCount) { throw null; } + public System.Text.StringBuilder Append(char value, int repeatCount) { throw null; } + public System.Text.StringBuilder Append(char[] value) { throw null; } + public System.Text.StringBuilder Append(char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Append(decimal value) { throw null; } + public System.Text.StringBuilder Append(double value) { throw null; } + public System.Text.StringBuilder Append(short value) { throw null; } + public System.Text.StringBuilder Append(int value) { throw null; } + public System.Text.StringBuilder Append(long value) { throw null; } + public System.Text.StringBuilder Append(object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(sbyte value) { throw null; } + public System.Text.StringBuilder Append(float value) { throw null; } + public System.Text.StringBuilder Append(string value) { throw null; } + public System.Text.StringBuilder Append(string value, int startIndex, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Append(ulong value) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, object arg0) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, object arg0, object arg1) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, object arg0, object arg1, object arg2) { throw null; } + public System.Text.StringBuilder AppendFormat(System.IFormatProvider provider, string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, object arg0) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, object arg0, object arg1) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, object arg0, object arg1, object arg2) { throw null; } + public System.Text.StringBuilder AppendFormat(string format, params object[] args) { throw null; } + public System.Text.StringBuilder AppendLine() { throw null; } + public System.Text.StringBuilder AppendLine(string value) { throw null; } + public System.Text.StringBuilder Clear() { throw null; } + public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count) { } + public int EnsureCapacity(int capacity) { throw null; } + public bool Equals(System.Text.StringBuilder sb) { throw null; } + public System.Text.StringBuilder Insert(int index, bool value) { throw null; } + public System.Text.StringBuilder Insert(int index, byte value) { throw null; } + public System.Text.StringBuilder Insert(int index, char value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value) { throw null; } + public System.Text.StringBuilder Insert(int index, char[] value, int startIndex, int charCount) { throw null; } + public System.Text.StringBuilder Insert(int index, decimal value) { throw null; } + public System.Text.StringBuilder Insert(int index, double value) { throw null; } + public System.Text.StringBuilder Insert(int index, short value) { throw null; } + public System.Text.StringBuilder Insert(int index, int value) { throw null; } + public System.Text.StringBuilder Insert(int index, long value) { throw null; } + public System.Text.StringBuilder Insert(int index, object value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, sbyte value) { throw null; } + public System.Text.StringBuilder Insert(int index, float value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value) { throw null; } + public System.Text.StringBuilder Insert(int index, string value, int count) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ushort value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, uint value) { throw null; } + [System.CLSCompliantAttribute(false)] + public System.Text.StringBuilder Insert(int index, ulong value) { throw null; } + public System.Text.StringBuilder Remove(int startIndex, int length) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar) { throw null; } + public System.Text.StringBuilder Replace(char oldChar, char newChar, int startIndex, int count) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue) { throw null; } + public System.Text.StringBuilder Replace(string oldValue, string newValue, int startIndex, int count) { throw null; } + public override string ToString() { throw null; } + public string ToString(int startIndex, int length) { throw null; } + } +} +namespace System.Threading +{ + public enum LazyThreadSafetyMode + { + ExecutionAndPublication = 2, + None = 0, + PublicationOnly = 1, + } + public static partial class Timeout + { + public const int Infinite = -1; + public static readonly System.TimeSpan InfiniteTimeSpan; + } + public abstract partial class WaitHandle : System.IDisposable + { + protected static readonly System.IntPtr InvalidHandle; + public const int WaitTimeout = 258; + protected WaitHandle() { } + public void Dispose() { } + protected virtual void Dispose(bool explicitDisposing) { } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static bool WaitAll(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout) { throw null; } + public static int WaitAny(System.Threading.WaitHandle[] waitHandles, System.TimeSpan timeout) { throw null; } + public virtual bool WaitOne() { throw null; } + public virtual bool WaitOne(int millisecondsTimeout) { throw null; } + public virtual bool WaitOne(System.TimeSpan timeout) { throw null; } + } +} diff --git a/src/referencePackages/src/system.runtime/4.3.0/system.runtime.nuspec b/src/referencePackages/src/system.runtime/4.3.0/system.runtime.nuspec new file mode 100755 index 0000000000..02fcb4d88e --- /dev/null +++ b/src/referencePackages/src/system.runtime/4.3.0/system.runtime.nuspec @@ -0,0 +1,85 @@ + + + + System.Runtime + 4.3.0 + System.Runtime + Microsoft + microsoft,dotnetframework + true + http://go.microsoft.com/fwlink/?LinkId=329770 + https://dot.net/ + http://go.microsoft.com/fwlink/?LinkID=288859 + Provides the fundamental primitives, classes and base classes that define commonly-used value and reference data types, events and event handlers, interfaces, attributes, and exceptions. This packages represents the core package, and provides the minimal set of types required to build a managed application. + +Commonly Used Types: +System.Object +System.Exception +System.Int16 +System.Int32 +System.Int64 +System.Enum +System.String +System.Char +System.Boolean +System.SByte +System.Byte +System.DateTime +System.DateTimeOffset +System.Single +System.Double +System.UInt16 +System.UInt32 +System.UInt64 +System.IDisposable +System.Uri + +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 diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.csproj b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.csproj new file mode 100644 index 0000000000..34d60cb2fd --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.csproj @@ -0,0 +1,10 @@ + + + netstandard1.3 + $(ArtifactsBinDir)microsoft.netcore.platforms/1.1.0/ + $(ArtifactsObjDir)microsoft.netcore.platforms/1.1.0/ + false + true + Microsoft.NETCore.Platforms.nuspec + + diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.nuspec b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.nuspec new file mode 100644 index 0000000000..e28f3cd101 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.nuspec @@ -0,0 +1,19 @@ + + + + Microsoft.NETCore.Platforms + 1.1.0 + Microsoft.NETCore.Platforms + Microsoft + microsoft,dotnetframework + true + http://go.microsoft.com/fwlink/?LinkId=329770 + https://dot.net/ + http://go.microsoft.com/fwlink/?LinkID=288859 + Provides runtime information required to resolve target framework, platform, and runtime specific implementations of .NETCore packages. +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 diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.pkgproj b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.pkgproj new file mode 100644 index 0000000000..03019a426a --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/Microsoft.NETCore.Platforms.pkgproj @@ -0,0 +1,28 @@ + + + netstandard1.3 + Microsoft.NETCore.Platforms.nuspec + + + true + true + false + $(ArtifactsBinDir)microsoft.netcore.platforms/4.3.0/ref/ + $(ArtifactsObjDir)microsoft.netcore.platforms/4.3.0 + + false + Release + false + + true + true + false + false + v4.0.30319 + + false + false + + + + diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/ThirdPartyNotices.txt b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/ThirdPartyNotices.txt new file mode 100644 index 0000000000..55cfb20817 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/ThirdPartyNotices.txt @@ -0,0 +1,31 @@ +This Microsoft .NET Library may incorporate components from the projects listed +below. Microsoft licenses these components under the Microsoft .NET Library +software license terms. The original copyright notices and the licenses under +which Microsoft received such components are set forth below for informational +purposes only. Microsoft reserves all rights not expressly granted herein, +whether by implication, estoppel or otherwise. + +1. .NET Core (https://github.com/dotnet/core/) + +.NET Core +Copyright (c) .NET Foundation and Contributors + +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/dotnet_library_license.txt b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/dotnet_library_license.txt new file mode 100644 index 0000000000..92b6c443d3 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/dotnet_library_license.txt @@ -0,0 +1,128 @@ + +MICROSOFT SOFTWARE LICENSE TERMS + + +MICROSOFT .NET LIBRARY + +These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft + +· updates, + +· supplements, + +· Internet-based services, and + +· support services + +for this software, unless other terms accompany those items. If so, those terms apply. + +BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE. + + +IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW. + +1. INSTALLATION AND USE RIGHTS. + +a. Installation and Use. You may install and use any number of copies of the software to design, develop and test your programs. + +b. Third Party Programs. The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only. + +2. ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS. + +a. DISTRIBUTABLE CODE. The software is comprised of Distributable Code. “Distributable Code” is code that you are permitted to distribute in programs you develop if you comply with the terms below. + +i. Right to Use and Distribute. + +· You may copy and distribute the object code form of the software. + +· Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs. + +ii. Distribution Requirements. For any Distributable Code you distribute, you must + +· add significant primary functionality to it in your programs; + +· require distributors and external end users to agree to terms that protect it at least as much as this agreement; + +· display your valid copyright notice on your programs; and + +· indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your programs. + +iii. Distribution Restrictions. You may not + +· alter any copyright, trademark or patent notice in the Distributable Code; + +· use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft; + +· include Distributable Code in malicious, deceptive or unlawful programs; or + +· modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that + +· the code be disclosed or distributed in source code form; or + +· others have the right to modify it. + +3. SCOPE OF LICENSE. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not + +· work around any technical limitations in the software; + +· reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation; + +· publish the software for others to copy; + +· rent, lease or lend the software; + +· transfer the software or this agreement to any third party; or + +· use the software for commercial software hosting services. + +4. BACKUP COPY. You may make one backup copy of the software. You may use it only to reinstall the software. + +5. DOCUMENTATION. Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes. + +6. EXPORT RESTRICTIONS. The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see www.microsoft.com/exporting. + +7. SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it. + +8. ENTIRE AGREEMENT. This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services. + +9. APPLICABLE LAW. + +a. United States. If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort. + +b. Outside the United States. If you acquired the software in any other country, the laws of that country apply. + +10. LEGAL EFFECT. This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so. + +11. DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED “AS-IS.” YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + +FOR AUSTRALIA – YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS. + +12. LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES. + +This limitation applies to + +· anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and + +· claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law. + +It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages. + +Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French. + +Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français. + +EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage particulier et d’absence de contrefaçon sont exclues. + +LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES. Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages spéciaux, indirects ou accessoires et pertes de bénéfices. + +Cette limitation concerne : + +· tout ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et + +· les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la limite autorisée par la loi en vigueur. + +Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage. Si votre pays n’autorise pas l’exclusion ou la limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre égard. + +EFFET JURIDIQUE. Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays. Le présent contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas. + + diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/lib/netstandard1.0/_._ b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/lib/netstandard1.0/_._ new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/runtime.json b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/runtime.json new file mode 100644 index 0000000000..54769f2662 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/1.1.0/runtime.json @@ -0,0 +1,406 @@ +{ + "runtimes": { + "base": { + }, + + "any": { + "#import": [ "base" ] + }, + + "win": { + "#import": [ "any" ] + }, + "win-x86": { + "#import": [ "win" ] + }, + "win-x64": { + "#import": [ "win" ] + }, + + "win7": { + "#import": [ "win" ] + }, + "win7-x86": { + "#import": [ "win7", "win-x86" ] + }, + "win7-x64": { + "#import": [ "win7", "win-x64" ] + }, + + "win8": { + "#import": [ "win7" ] + }, + "win8-x86": { + "#import": [ "win8", "win7-x86" ] + }, + "win8-x64": { + "#import": [ "win8", "win7-x64" ] + }, + "win8-arm": { + "#import": [ "win8" ] + }, + + "win81": { + "#import": [ "win8" ] + }, + "win81-x86": { + "#import": [ "win81", "win8-x86" ] + }, + "win81-x64": { + "#import": [ "win81", "win8-x64" ] + }, + "win81-arm": { + "#import": [ "win81", "win8-arm" ] + }, + + "win10": { + "#import": [ "win81" ] + }, + "win10-x86": { + "#import": [ "win10", "win81-x86" ] + }, + "win10-x64": { + "#import": [ "win10", "win81-x64" ] + }, + "win10-arm": { + "#import": [ "win10", "win81-arm" ] + }, + "win10-arm64": { + "#import": [ "win10" ] + }, + + "aot": { + "#import": [ "any" ] + }, + + "win-aot": { + "#import": [ "win", "aot" ] + }, + "win-x86-aot": { + "#import": [ "win-aot", "win-x86" ] + }, + "win-x64-aot": { + "#import": [ "win-aot", "win-x64" ] + }, + + "win7-aot": { + "#import": [ "win-aot", "win7" ] + }, + "win7-x86-aot": { + "#import": [ "win7-aot", "win7-x86" ] + }, + "win7-x64-aot": { + "#import": [ "win7-aot", "win7-x64" ] + }, + + "win8-aot": { + "#import": [ "win8", "win7-aot" ] + }, + "win8-x86-aot": { + "#import": [ "win8-aot", "win8-x86", "win7-x86-aot" ] + }, + "win8-x64-aot": { + "#import": [ "win8-aot", "win8-x64", "win7-x64-aot" ] + }, + "win8-arm-aot": { + "#import": [ "win8-aot", "win8-arm" ] + }, + + "win81-aot": { + "#import": [ "win81", "win8-aot" ] + }, + "win81-x86-aot": { + "#import": [ "win81-aot", "win81-x86", "win8-x86-aot" ] + }, + "win81-x64-aot": { + "#import": [ "win81-aot", "win81-x64", "win8-x64-aot" ] + }, + "win81-arm-aot": { + "#import": [ "win81-aot", "win81-arm", "win8-arm-aot" ] + }, + + "win10-aot": { + "#import": [ "win10", "win81-aot" ] + }, + "win10-x86-aot": { + "#import": [ "win10-aot", "win10-x86", "win81-x86-aot" ] + }, + "win10-x64-aot": { + "#import": [ "win10-aot", "win10-x64", "win81-x64-aot" ] + }, + "win10-arm-aot": { + "#import": [ "win10-aot", "win10-arm", "win81-arm-aot" ] + }, + "win10-arm64-aot": { + "#import": [ "win10-aot", "win10-arm64" ] + }, + + "unix": { + "#import": [ "any" ] + }, + "unix-x64": { + "#import": [ "unix" ] + }, + + "osx": { + "#import": [ "unix" ] + }, + "osx-x64": { + "#import": [ "osx", "unix-x64" ] + }, + + "osx.10.10": { + "#import": [ "osx" ] + }, + "osx.10.10-x64": { + "#import": [ "osx.10.10", "osx-x64" ] + }, + + "osx.10.11": { + "#import": [ "osx.10.10" ] + }, + "osx.10.11-x64": { + "#import": [ "osx.10.11", "osx.10.10-x64" ] + }, + + "osx.10.12": { + "#import": [ "osx.10.11" ] + }, + "osx.10.12-x64": { + "#import": [ "osx.10.12", "osx.10.11-x64" ] + }, + + "linux": { + "#import": [ "unix" ] + }, + "linux-x64": { + "#import": [ "linux", "unix-x64" ] + }, + + "rhel": { + "#import": [ "linux" ] + }, + "rhel-x64": { + "#import": [ "rhel", "linux-x64" ] + }, + + "rhel.7": { + "#import": [ "rhel" ] + }, + "rhel.7-x64": { + "#import": [ "rhel", "rhel-x64" ] + }, + + "rhel.7.0": { + "#import": [ "rhel.7" ] + }, + "rhel.7.0-x64": { + "#import": [ "rhel.7", "rhel.7-x64" ] + }, + + "rhel.7.1": { + "#import": [ "rhel.7.0" ] + }, + "rhel.7.1-x64": { + "#import": [ "rhel.7.0", "rhel.7.0-x64" ] + }, + + "rhel.7.2": { + "#import": [ "rhel.7.1" ] + }, + "rhel.7.2-x64": { + "#import": [ "rhel.7.1", "rhel.7.1-x64" ] + }, + + "ol": { + "#import": [ "rhel" ] + }, + "ol-x64": { + "#import": [ "ol", "rhel-x64" ] + }, + + "ol.7": { + "#import": [ "ol", "rhel.7" ] + }, + "ol.7-x64": { + "#import": [ "ol.7", "ol-x64", "rhel.7-x64" ] + }, + + "ol.7.0": { + "#import": [ "ol.7", "rhel.7.0" ] + }, + "ol.7.0-x64": { + "#import": [ "ol.7", "ol.7-x64", "rhel.7.0-x64" ] + }, + + "ol.7.1": { + "#import": [ "ol.7.0", "rhel.7.1" ] + }, + "ol.7.1-x64": { + "#import": [ "ol.7.0", "ol.7.0-x64", "rhel.7.1-x64" ] + }, + + "ol.7.2": { + "#import": [ "ol.7.1", "rhel.7.2" ] + }, + "ol.7.2-x64": { + "#import": [ "ol.7.1", "ol.7.1-x64", "rhel.7.2-x64" ] + }, + + "centos": { + "#import": [ "rhel" ] + }, + "centos-x64": { + "#import": [ "centos", "rhel-x64" ] + }, + + "centos.7": { + "#import": [ "centos", "rhel.7" ] + }, + "centos.7-x64": { + "#import": [ "centos.7", "centos-x64", "rhel.7-x64" ] + }, + + "debian": { + "#import": [ "linux" ] + }, + "debian-x64": { + "#import": [ "debian", "linux-x64" ] + }, + + "debian.8": { + "#import": [ "debian" ] + }, + "debian.8-x64": { + "#import": [ "debian.8", "debian-x64" ] + }, + + "ubuntu": { + "#import": [ "debian" ] + }, + + "ubuntu-x64": { + "#import": [ "ubuntu", "debian-x64" ] + }, + + "ubuntu.14.04": { + "#import": [ "ubuntu" ] + }, + "ubuntu.14.04-x64": { + "#import": [ "ubuntu.14.04", "ubuntu-x64" ] + }, + + "ubuntu.14.10": { + "#import": [ "ubuntu" ] + }, + "ubuntu.14.10-x64": { + "#import": [ "ubuntu.14.10", "ubuntu-x64" ] + }, + + "ubuntu.15.04": { + "#import": [ "ubuntu" ] + }, + "ubuntu.15.04-x64": { + "#import": [ "ubuntu.15.04", "ubuntu-x64" ] + }, + + "ubuntu.15.10": { + "#import": [ "ubuntu" ] + }, + "ubuntu.15.10-x64": { + "#import": [ "ubuntu.15.10", "ubuntu-x64" ] + }, + + "ubuntu.16.04": { + "#import": [ "ubuntu" ] + }, + "ubuntu.16.04-x64": { + "#import": [ "ubuntu.16.04", "ubuntu-x64" ] + }, + + "ubuntu.16.10": { + "#import": [ "ubuntu" ] + }, + "ubuntu.16.10-x64": { + "#import": [ "ubuntu.16.10", "ubuntu-x64" ] + }, + + "linuxmint.17": { + "#import": [ "ubuntu.14.04" ] + }, + "linuxmint.17-x64": { + "#import": [ "linuxmint.17", "ubuntu.14.04-x64" ] + }, + + "linuxmint.17.1": { + "#import": [ "linuxmint.17" ] + }, + "linuxmint.17.1-x64": { + "#import": [ "linuxmint.17.1", "linuxmint.17-x64" ] + }, + + "linuxmint.17.2": { + "#import": [ "linuxmint.17.1" ] + }, + "linuxmint.17.2-x64": { + "#import": [ "linuxmint.17.2", "linuxmint.17.1-x64" ] + }, + + "linuxmint.17.3": { + "#import": [ "linuxmint.17.2" ] + }, + "linuxmint.17.3-x64": { + "#import": [ "linuxmint.17.3", "linuxmint.17.2-x64" ] + }, + + "linuxmint.18": { + "#import": [ "ubuntu.16.04" ] + }, + "linuxmint.18-x64": { + "#import": [ "linuxmint.18", "ubuntu.16.04-x64" ] + }, + + "fedora": { + "#import": [ "linux" ] + }, + "fedora-x64": { + "#import": [ "fedora", "linux-x64" ] + }, + + "fedora.23": { + "#import": [ "fedora" ] + }, + "fedora.23-x64": { + "#import": [ "fedora.23", "fedora-x64" ] + }, + + "fedora.24": { + "#import": [ "fedora" ] + }, + "fedora.24-x64": { + "#import": [ "fedora.24", "fedora-x64" ] + }, + + "opensuse": { + "#import": [ "linux" ] + }, + "opensuse-x64": { + "#import": [ "opensuse", "linux-x64" ] + }, + + "opensuse.13.2": { + "#import": [ "opensuse" ] + }, + "opensuse.13.2-x64": { + "#import": [ "opensuse.13.2", "opensuse-x64" ] + }, + + "opensuse.42.1": { + "#import": [ "opensuse" ] + }, + "opensuse.42.1-x64": { + "#import": [ "opensuse.42.1", "opensuse-x64" ] + } + } + } + diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/LICENSE.TXT b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/LICENSE.TXT new file mode 100644 index 0000000000..984713a496 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/LICENSE.TXT @@ -0,0 +1,23 @@ +The MIT License (MIT) + +Copyright (c) .NET Foundation and Contributors + +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/Microsoft.NETCore.Platforms.csproj b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/Microsoft.NETCore.Platforms.csproj new file mode 100644 index 0000000000..72f276979a --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/Microsoft.NETCore.Platforms.csproj @@ -0,0 +1,10 @@ + + + netstandard1.3 + $(ArtifactsBinDir)microsoft.netcore.platforms/2.1.0/ + $(ArtifactsObjDir)microsoft.netcore.platforms/2.1.0/ + false + true + Microsoft.NETCore.Platforms.nuspec + + diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/Microsoft.NETCore.Platforms.nuspec b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/Microsoft.NETCore.Platforms.nuspec new file mode 100644 index 0000000000..7a4c416df5 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/Microsoft.NETCore.Platforms.nuspec @@ -0,0 +1,20 @@ + + + + Microsoft.NETCore.Platforms + 2.1.0 + Microsoft.NETCore.Platforms + Microsoft + microsoft,dotnetframework + false + https://github.com/dotnet/corefx/blob/master/LICENSE.TXT + https://dot.net/ + http://go.microsoft.com/fwlink/?LinkID=288859 + Provides runtime information required to resolve target framework, platform, and runtime specific implementations of .NETCore packages. +30ab651fcb4354552bd4891619a0bdd81e0ebdbf +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 diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/THIRD-PARTY-NOTICES.TXT b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/THIRD-PARTY-NOTICES.TXT new file mode 100644 index 0000000000..db542ca24f --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/THIRD-PARTY-NOTICES.TXT @@ -0,0 +1,309 @@ +.NET Core uses third-party libraries or other resources that may be +distributed under licenses different than the .NET Core software. + +In the event that we accidentally failed to list a required notice, please +bring it to our attention. Post an issue or email us: + + dotnet@microsoft.com + +The attached notices are provided for information only. + +License notice for Slicing-by-8 +------------------------------- + +http://sourceforge.net/projects/slicing-by-8/ + +Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved + + +This software program is licensed subject to the BSD License, available at +http://www.opensource.org/licenses/bsd-license.html. + + +License notice for Unicode data +------------------------------- + +http://www.unicode.org/copyright.html#License + +Copyright © 1991-2017 Unicode, Inc. All rights reserved. +Distributed under the Terms of Use in http://www.unicode.org/copyright.html. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Unicode data files and any associated documentation +(the "Data Files") or Unicode software and any associated documentation +(the "Software") to deal in the Data Files or Software +without restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, and/or sell copies of +the Data Files or Software, and to permit persons to whom the Data Files +or Software are furnished to do so, provided that either +(a) this copyright and permission notice appear with all copies +of the Data Files or Software, or +(b) this copyright and permission notice appear in associated +Documentation. + +THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT OF THIRD PARTY RIGHTS. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS +NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL +DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THE DATA FILES OR SOFTWARE. + +Except as contained in this notice, the name of a copyright holder +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in these Data Files or Software without prior +written authorization of the copyright holder. + +License notice for Zlib +----------------------- + +https://github.com/madler/zlib +http://zlib.net/zlib_license.html + +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.11, January 15th, 2017 + + Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + +*/ + +License notice for Mono +------------------------------- + +http://www.mono-project.com/docs/about-mono/ + +Copyright (c) .NET Foundation Contributors + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the Software), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +License notice for International Organization for Standardization +----------------------------------------------------------------- + +Portions (C) International Organization for Standardization 1986: + Permission to copy in any form is granted for use with + conforming SGML systems and applications as defined in + ISO 8879, provided this notice is included in all copies. + +License notice for Intel +------------------------ + +"Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +License notice for Xamarin and Novell +------------------------------------- + +Copyright (c) 2015 Xamarin, Inc (http://www.xamarin.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +Copyright (c) 2011 Novell, Inc (http://www.novell.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +Third party notice for W3C +-------------------------- + +"W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE +Status: This license takes effect 13 May, 2015. +This work is being provided by the copyright holders under the following license. +License +By obtaining and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions. +Permission to copy, modify, and distribute this work, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the work or portions thereof, including modifications: +The full text of this NOTICE in a location viewable to users of the redistributed or derivative work. +Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, the W3C Software and Document Short Notice should be included. +Notice of any changes or modifications, through a copyright statement on the new code or document such as "This software or document includes material copied from or derived from [title and URI of the W3C document]. Copyright © [YEAR] W3C® (MIT, ERCIM, Keio, Beihang)." +Disclaimers +THIS WORK IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. +COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT. +The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the work without specific, written prior permission. Title to copyright in this work will at all times remain with copyright holders." + +License notice for Bit Twiddling Hacks +-------------------------------------- + +Bit Twiddling Hacks + +By Sean Eron Anderson +seander@cs.stanford.edu + +Individually, the code snippets here are in the public domain (unless otherwise +noted) — feel free to use them however you please. The aggregate collection and +descriptions are © 1997-2005 Sean Eron Anderson. The code and descriptions are +distributed in the hope that they will be useful, but WITHOUT ANY WARRANTY and +without even the implied warranty of merchantability or fitness for a particular +purpose. + +License notice for Brotli +-------------------------------------- + +Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +compress_fragment.c: +Copyright (c) 2011, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +decode_fuzzer.c: +Copyright (c) 2015 The Chromium Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." + diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/lib/netstandard1.0/_._ b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/lib/netstandard1.0/_._ new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/runtime.json b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/runtime.json new file mode 100644 index 0000000000..30f99f8e58 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/runtime.json @@ -0,0 +1,3027 @@ +{ + "runtimes": { + "alpine": { + "#import": [ + "linux-musl" + ] + }, + "alpine-corert": { + "#import": [ + "alpine", + "linux-musl-corert" + ] + }, + "alpine-x64": { + "#import": [ + "alpine", + "linux-musl-x64" + ] + }, + "alpine-x64-corert": { + "#import": [ + "alpine-corert", + "alpine-x64", + "linux-musl-x64-corert" + ] + }, + "alpine.3.6": { + "#import": [ + "alpine" + ] + }, + "alpine.3.6-corert": { + "#import": [ + "alpine.3.6", + "alpine-corert" + ] + }, + "alpine.3.6-x64": { + "#import": [ + "alpine.3.6", + "alpine-x64" + ] + }, + "alpine.3.6-x64-corert": { + "#import": [ + "alpine.3.6-corert", + "alpine.3.6-x64", + "alpine.3.6", + "alpine-x64-corert" + ] + }, + "alpine.3.7": { + "#import": [ + "alpine.3.6" + ] + }, + "alpine.3.7-corert": { + "#import": [ + "alpine.3.7", + "alpine.3.6-corert" + ] + }, + "alpine.3.7-x64": { + "#import": [ + "alpine.3.7", + "alpine.3.6-x64" + ] + }, + "alpine.3.7-x64-corert": { + "#import": [ + "alpine.3.7-corert", + "alpine.3.7-x64", + "alpine.3.7", + "alpine.3.6-x64-corert" + ] + }, + "android": { + "#import": [ + "linux" + ] + }, + "android-arm": { + "#import": [ + "android", + "linux-arm" + ] + }, + "android-arm-corert": { + "#import": [ + "android-corert", + "android-arm", + "linux-arm-corert" + ] + }, + "android-arm64": { + "#import": [ + "android", + "linux-arm64" + ] + }, + "android-arm64-corert": { + "#import": [ + "android-corert", + "android-arm64", + "linux-arm64-corert" + ] + }, + "android-corert": { + "#import": [ + "android", + "linux-corert" + ] + }, + "android.21": { + "#import": [ + "android" + ] + }, + "android.21-arm": { + "#import": [ + "android.21", + "android-arm" + ] + }, + "android.21-arm-corert": { + "#import": [ + "android.21-corert", + "android.21-arm", + "android.21", + "android-arm-corert" + ] + }, + "android.21-arm64": { + "#import": [ + "android.21", + "android-arm64" + ] + }, + "android.21-arm64-corert": { + "#import": [ + "android.21-corert", + "android.21-arm64", + "android.21", + "android-arm64-corert" + ] + }, + "android.21-corert": { + "#import": [ + "android.21", + "android-corert" + ] + }, + "any": { + "#import": [ + "base" + ] + }, + "aot": { + "#import": [ + "any" + ] + }, + "base": { + "#import": [] + }, + "centos": { + "#import": [ + "rhel" + ] + }, + "centos-corert": { + "#import": [ + "centos", + "rhel-corert" + ] + }, + "centos-x64": { + "#import": [ + "centos", + "rhel-x64" + ] + }, + "centos-x64-corert": { + "#import": [ + "centos-corert", + "centos-x64", + "rhel-x64-corert" + ] + }, + "centos.7": { + "#import": [ + "centos", + "rhel.7" + ] + }, + "centos.7-corert": { + "#import": [ + "centos.7", + "centos-corert", + "rhel.7-corert" + ] + }, + "centos.7-x64": { + "#import": [ + "centos.7", + "centos-x64", + "rhel.7-x64" + ] + }, + "centos.7-x64-corert": { + "#import": [ + "centos.7-corert", + "centos.7-x64", + "centos.7", + "centos-x64-corert" + ] + }, + "corert": { + "#import": [ + "any" + ] + }, + "debian": { + "#import": [ + "linux" + ] + }, + "debian-arm": { + "#import": [ + "debian", + "linux-arm" + ] + }, + "debian-arm-corert": { + "#import": [ + "debian-corert", + "debian-arm", + "linux-arm-corert" + ] + }, + "debian-arm64": { + "#import": [ + "debian", + "linux-arm64" + ] + }, + "debian-arm64-corert": { + "#import": [ + "debian-corert", + "debian-arm64", + "linux-arm64-corert" + ] + }, + "debian-armel": { + "#import": [ + "debian", + "linux-armel" + ] + }, + "debian-armel-corert": { + "#import": [ + "debian-corert", + "debian-armel", + "linux-armel-corert" + ] + }, + "debian-corert": { + "#import": [ + "debian", + "linux-corert" + ] + }, + "debian-x64": { + "#import": [ + "debian", + "linux-x64" + ] + }, + "debian-x64-corert": { + "#import": [ + "debian-corert", + "debian-x64", + "linux-x64-corert" + ] + }, + "debian-x86": { + "#import": [ + "debian", + "linux-x86" + ] + }, + "debian-x86-corert": { + "#import": [ + "debian-corert", + "debian-x86", + "linux-x86-corert" + ] + }, + "debian.8": { + "#import": [ + "debian" + ] + }, + "debian.8-arm": { + "#import": [ + "debian.8", + "debian-arm" + ] + }, + "debian.8-arm-corert": { + "#import": [ + "debian.8-corert", + "debian.8-arm", + "debian.8", + "debian-arm-corert" + ] + }, + "debian.8-arm64": { + "#import": [ + "debian.8", + "debian-arm64" + ] + }, + "debian.8-arm64-corert": { + "#import": [ + "debian.8-corert", + "debian.8-arm64", + "debian.8", + "debian-arm64-corert" + ] + }, + "debian.8-armel": { + "#import": [ + "debian.8", + "debian-armel" + ] + }, + "debian.8-armel-corert": { + "#import": [ + "debian.8-corert", + "debian.8-armel", + "debian.8", + "debian-armel-corert" + ] + }, + "debian.8-corert": { + "#import": [ + "debian.8", + "debian-corert" + ] + }, + "debian.8-x64": { + "#import": [ + "debian.8", + "debian-x64" + ] + }, + "debian.8-x64-corert": { + "#import": [ + "debian.8-corert", + "debian.8-x64", + "debian.8", + "debian-x64-corert" + ] + }, + "debian.8-x86": { + "#import": [ + "debian.8", + "debian-x86" + ] + }, + "debian.8-x86-corert": { + "#import": [ + "debian.8-corert", + "debian.8-x86", + "debian.8", + "debian-x86-corert" + ] + }, + "debian.9": { + "#import": [ + "debian" + ] + }, + "debian.9-arm": { + "#import": [ + "debian.9", + "debian-arm" + ] + }, + "debian.9-arm-corert": { + "#import": [ + "debian.9-corert", + "debian.9-arm", + "debian.9", + "debian-arm-corert" + ] + }, + "debian.9-arm64": { + "#import": [ + "debian.9", + "debian-arm64" + ] + }, + "debian.9-arm64-corert": { + "#import": [ + "debian.9-corert", + "debian.9-arm64", + "debian.9", + "debian-arm64-corert" + ] + }, + "debian.9-armel": { + "#import": [ + "debian.9", + "debian-armel" + ] + }, + "debian.9-armel-corert": { + "#import": [ + "debian.9-corert", + "debian.9-armel", + "debian.9", + "debian-armel-corert" + ] + }, + "debian.9-corert": { + "#import": [ + "debian.9", + "debian-corert" + ] + }, + "debian.9-x64": { + "#import": [ + "debian.9", + "debian-x64" + ] + }, + "debian.9-x64-corert": { + "#import": [ + "debian.9-corert", + "debian.9-x64", + "debian.9", + "debian-x64-corert" + ] + }, + "debian.9-x86": { + "#import": [ + "debian.9", + "debian-x86" + ] + }, + "debian.9-x86-corert": { + "#import": [ + "debian.9-corert", + "debian.9-x86", + "debian.9", + "debian-x86-corert" + ] + }, + "fedora": { + "#import": [ + "linux" + ] + }, + "fedora-corert": { + "#import": [ + "fedora", + "linux-corert" + ] + }, + "fedora-x64": { + "#import": [ + "fedora", + "linux-x64" + ] + }, + "fedora-x64-corert": { + "#import": [ + "fedora-corert", + "fedora-x64", + "linux-x64-corert" + ] + }, + "fedora.23": { + "#import": [ + "fedora" + ] + }, + "fedora.23-corert": { + "#import": [ + "fedora.23", + "fedora-corert" + ] + }, + "fedora.23-x64": { + "#import": [ + "fedora.23", + "fedora-x64" + ] + }, + "fedora.23-x64-corert": { + "#import": [ + "fedora.23-corert", + "fedora.23-x64", + "fedora.23", + "fedora-x64-corert" + ] + }, + "fedora.24": { + "#import": [ + "fedora" + ] + }, + "fedora.24-corert": { + "#import": [ + "fedora.24", + "fedora-corert" + ] + }, + "fedora.24-x64": { + "#import": [ + "fedora.24", + "fedora-x64" + ] + }, + "fedora.24-x64-corert": { + "#import": [ + "fedora.24-corert", + "fedora.24-x64", + "fedora.24", + "fedora-x64-corert" + ] + }, + "fedora.25": { + "#import": [ + "fedora" + ] + }, + "fedora.25-corert": { + "#import": [ + "fedora.25", + "fedora-corert" + ] + }, + "fedora.25-x64": { + "#import": [ + "fedora.25", + "fedora-x64" + ] + }, + "fedora.25-x64-corert": { + "#import": [ + "fedora.25-corert", + "fedora.25-x64", + "fedora.25", + "fedora-x64-corert" + ] + }, + "fedora.26": { + "#import": [ + "fedora" + ] + }, + "fedora.26-corert": { + "#import": [ + "fedora.26", + "fedora-corert" + ] + }, + "fedora.26-x64": { + "#import": [ + "fedora.26", + "fedora-x64" + ] + }, + "fedora.26-x64-corert": { + "#import": [ + "fedora.26-corert", + "fedora.26-x64", + "fedora.26", + "fedora-x64-corert" + ] + }, + "fedora.27": { + "#import": [ + "fedora" + ] + }, + "fedora.27-corert": { + "#import": [ + "fedora.27", + "fedora-corert" + ] + }, + "fedora.27-x64": { + "#import": [ + "fedora.27", + "fedora-x64" + ] + }, + "fedora.27-x64-corert": { + "#import": [ + "fedora.27-corert", + "fedora.27-x64", + "fedora.27", + "fedora-x64-corert" + ] + }, + "fedora.28": { + "#import": [ + "fedora" + ] + }, + "fedora.28-corert": { + "#import": [ + "fedora.28", + "fedora-corert" + ] + }, + "fedora.28-x64": { + "#import": [ + "fedora.28", + "fedora-x64" + ] + }, + "fedora.28-x64-corert": { + "#import": [ + "fedora.28-corert", + "fedora.28-x64", + "fedora.28", + "fedora-x64-corert" + ] + }, + "gentoo": { + "#import": [ + "linux" + ] + }, + "gentoo-corert": { + "#import": [ + "gentoo", + "linux-corert" + ] + }, + "gentoo-x64": { + "#import": [ + "gentoo", + "linux-x64" + ] + }, + "gentoo-x64-corert": { + "#import": [ + "gentoo-corert", + "gentoo-x64", + "linux-x64-corert" + ] + }, + "linux": { + "#import": [ + "unix" + ] + }, + "linux-arm": { + "#import": [ + "linux", + "unix-arm" + ] + }, + "linux-arm-corert": { + "#import": [ + "linux-corert", + "linux-arm", + "unix-arm-corert" + ] + }, + "linux-arm64": { + "#import": [ + "linux", + "unix-arm64" + ] + }, + "linux-arm64-corert": { + "#import": [ + "linux-corert", + "linux-arm64", + "unix-arm64-corert" + ] + }, + "linux-armel": { + "#import": [ + "linux", + "unix-armel" + ] + }, + "linux-armel-corert": { + "#import": [ + "linux-corert", + "linux-armel", + "unix-armel-corert" + ] + }, + "linux-corert": { + "#import": [ + "linux", + "unix-corert" + ] + }, + "linux-musl": { + "#import": [ + "linux" + ] + }, + "linux-musl-arm": { + "#import": [ + "linux-musl", + "linux-arm" + ] + }, + "linux-musl-arm-corert": { + "#import": [ + "linux-musl-corert", + "linux-musl-arm", + "linux-arm-corert" + ] + }, + "linux-musl-arm64": { + "#import": [ + "linux-musl", + "linux-arm64" + ] + }, + "linux-musl-arm64-corert": { + "#import": [ + "linux-musl-corert", + "linux-musl-arm64", + "linux-arm64-corert" + ] + }, + "linux-musl-armel": { + "#import": [ + "linux-musl", + "linux-armel" + ] + }, + "linux-musl-armel-corert": { + "#import": [ + "linux-musl-corert", + "linux-musl-armel", + "linux-armel-corert" + ] + }, + "linux-musl-corert": { + "#import": [ + "linux-musl", + "linux-corert" + ] + }, + "linux-musl-x64": { + "#import": [ + "linux-musl", + "linux-x64" + ] + }, + "linux-musl-x64-corert": { + "#import": [ + "linux-musl-corert", + "linux-musl-x64", + "linux-x64-corert" + ] + }, + "linux-musl-x86": { + "#import": [ + "linux-musl", + "linux-x86" + ] + }, + "linux-musl-x86-corert": { + "#import": [ + "linux-musl-corert", + "linux-musl-x86", + "linux-x86-corert" + ] + }, + "linux-x64": { + "#import": [ + "linux", + "unix-x64" + ] + }, + "linux-x64-corert": { + "#import": [ + "linux-corert", + "linux-x64", + "unix-x64-corert" + ] + }, + "linux-x86": { + "#import": [ + "linux", + "unix-x86" + ] + }, + "linux-x86-corert": { + "#import": [ + "linux-corert", + "linux-x86", + "unix-x86-corert" + ] + }, + "linuxmint.17": { + "#import": [ + "ubuntu.14.04" + ] + }, + "linuxmint.17-corert": { + "#import": [ + "linuxmint.17", + "ubuntu.14.04-corert" + ] + }, + "linuxmint.17-x64": { + "#import": [ + "linuxmint.17", + "ubuntu.14.04-x64" + ] + }, + "linuxmint.17-x64-corert": { + "#import": [ + "linuxmint.17-corert", + "linuxmint.17-x64", + "ubuntu.14.04-x64-corert" + ] + }, + "linuxmint.17.1": { + "#import": [ + "linuxmint.17" + ] + }, + "linuxmint.17.1-corert": { + "#import": [ + "linuxmint.17.1", + "linuxmint.17-corert" + ] + }, + "linuxmint.17.1-x64": { + "#import": [ + "linuxmint.17.1", + "linuxmint.17-x64" + ] + }, + "linuxmint.17.1-x64-corert": { + "#import": [ + "linuxmint.17.1-corert", + "linuxmint.17.1-x64", + "linuxmint.17.1", + "linuxmint.17-x64-corert" + ] + }, + "linuxmint.17.2": { + "#import": [ + "linuxmint.17.1" + ] + }, + "linuxmint.17.2-corert": { + "#import": [ + "linuxmint.17.2", + "linuxmint.17.1-corert" + ] + }, + "linuxmint.17.2-x64": { + "#import": [ + "linuxmint.17.2", + "linuxmint.17.1-x64" + ] + }, + "linuxmint.17.2-x64-corert": { + "#import": [ + "linuxmint.17.2-corert", + "linuxmint.17.2-x64", + "linuxmint.17.2", + "linuxmint.17.1-x64-corert" + ] + }, + "linuxmint.17.3": { + "#import": [ + "linuxmint.17.2" + ] + }, + "linuxmint.17.3-corert": { + "#import": [ + "linuxmint.17.3", + "linuxmint.17.2-corert" + ] + }, + "linuxmint.17.3-x64": { + "#import": [ + "linuxmint.17.3", + "linuxmint.17.2-x64" + ] + }, + "linuxmint.17.3-x64-corert": { + "#import": [ + "linuxmint.17.3-corert", + "linuxmint.17.3-x64", + "linuxmint.17.3", + "linuxmint.17.2-x64-corert" + ] + }, + "linuxmint.18": { + "#import": [ + "ubuntu.16.04" + ] + }, + "linuxmint.18-corert": { + "#import": [ + "linuxmint.18", + "ubuntu.16.04-corert" + ] + }, + "linuxmint.18-x64": { + "#import": [ + "linuxmint.18", + "ubuntu.16.04-x64" + ] + }, + "linuxmint.18-x64-corert": { + "#import": [ + "linuxmint.18-corert", + "linuxmint.18-x64", + "ubuntu.16.04-x64-corert" + ] + }, + "linuxmint.18.1": { + "#import": [ + "linuxmint.18" + ] + }, + "linuxmint.18.1-corert": { + "#import": [ + "linuxmint.18.1", + "linuxmint.18-corert" + ] + }, + "linuxmint.18.1-x64": { + "#import": [ + "linuxmint.18.1", + "linuxmint.18-x64" + ] + }, + "linuxmint.18.1-x64-corert": { + "#import": [ + "linuxmint.18.1-corert", + "linuxmint.18.1-x64", + "linuxmint.18.1", + "linuxmint.18-x64-corert" + ] + }, + "linuxmint.18.2": { + "#import": [ + "linuxmint.18.1" + ] + }, + "linuxmint.18.2-corert": { + "#import": [ + "linuxmint.18.2", + "linuxmint.18.1-corert" + ] + }, + "linuxmint.18.2-x64": { + "#import": [ + "linuxmint.18.2", + "linuxmint.18.1-x64" + ] + }, + "linuxmint.18.2-x64-corert": { + "#import": [ + "linuxmint.18.2-corert", + "linuxmint.18.2-x64", + "linuxmint.18.2", + "linuxmint.18.1-x64-corert" + ] + }, + "linuxmint.18.3": { + "#import": [ + "linuxmint.18.2" + ] + }, + "linuxmint.18.3-corert": { + "#import": [ + "linuxmint.18.3", + "linuxmint.18.2-corert" + ] + }, + "linuxmint.18.3-x64": { + "#import": [ + "linuxmint.18.3", + "linuxmint.18.2-x64" + ] + }, + "linuxmint.18.3-x64-corert": { + "#import": [ + "linuxmint.18.3-corert", + "linuxmint.18.3-x64", + "linuxmint.18.3", + "linuxmint.18.2-x64-corert" + ] + }, + "linuxmint.19": { + "#import": [ + "ubuntu.18.04" + ] + }, + "linuxmint.19-corert": { + "#import": [ + "linuxmint.19", + "ubuntu.18.04-corert" + ] + }, + "linuxmint.19-x64": { + "#import": [ + "linuxmint.19", + "ubuntu.18.04-x64" + ] + }, + "linuxmint.19-x64-corert": { + "#import": [ + "linuxmint.19-corert", + "linuxmint.19-x64", + "ubuntu.18.04-x64-corert" + ] + }, + "ol": { + "#import": [ + "rhel" + ] + }, + "ol-corert": { + "#import": [ + "ol", + "rhel-corert" + ] + }, + "ol-x64": { + "#import": [ + "ol", + "rhel-x64" + ] + }, + "ol-x64-corert": { + "#import": [ + "ol-corert", + "ol-x64", + "rhel-x64-corert" + ] + }, + "ol.7": { + "#import": [ + "ol", + "rhel.7" + ] + }, + "ol.7-corert": { + "#import": [ + "ol.7", + "ol-corert", + "rhel.7-corert" + ] + }, + "ol.7-x64": { + "#import": [ + "ol.7", + "ol-x64", + "rhel.7-x64" + ] + }, + "ol.7-x64-corert": { + "#import": [ + "ol.7-corert", + "ol.7-x64", + "ol.7", + "ol-x64-corert" + ] + }, + "ol.7.0": { + "#import": [ + "ol.7", + "rhel.7.0" + ] + }, + "ol.7.0-corert": { + "#import": [ + "ol.7.0", + "ol.7-corert", + "rhel.7.0-corert" + ] + }, + "ol.7.0-x64": { + "#import": [ + "ol.7.0", + "ol.7-x64", + "rhel.7.0-x64" + ] + }, + "ol.7.0-x64-corert": { + "#import": [ + "ol.7.0-corert", + "ol.7.0-x64", + "ol.7.0", + "ol.7-x64-corert" + ] + }, + "ol.7.1": { + "#import": [ + "ol.7.0", + "rhel.7.1" + ] + }, + "ol.7.1-corert": { + "#import": [ + "ol.7.1", + "ol.7.0-corert", + "rhel.7.1-corert" + ] + }, + "ol.7.1-x64": { + "#import": [ + "ol.7.1", + "ol.7.0-x64", + "rhel.7.1-x64" + ] + }, + "ol.7.1-x64-corert": { + "#import": [ + "ol.7.1-corert", + "ol.7.1-x64", + "ol.7.1", + "ol.7.0-x64-corert" + ] + }, + "ol.7.2": { + "#import": [ + "ol.7.1", + "rhel.7.2" + ] + }, + "ol.7.2-corert": { + "#import": [ + "ol.7.2", + "ol.7.1-corert", + "rhel.7.2-corert" + ] + }, + "ol.7.2-x64": { + "#import": [ + "ol.7.2", + "ol.7.1-x64", + "rhel.7.2-x64" + ] + }, + "ol.7.2-x64-corert": { + "#import": [ + "ol.7.2-corert", + "ol.7.2-x64", + "ol.7.2", + "ol.7.1-x64-corert" + ] + }, + "ol.7.3": { + "#import": [ + "ol.7.2", + "rhel.7.3" + ] + }, + "ol.7.3-corert": { + "#import": [ + "ol.7.3", + "ol.7.2-corert", + "rhel.7.3-corert" + ] + }, + "ol.7.3-x64": { + "#import": [ + "ol.7.3", + "ol.7.2-x64", + "rhel.7.3-x64" + ] + }, + "ol.7.3-x64-corert": { + "#import": [ + "ol.7.3-corert", + "ol.7.3-x64", + "ol.7.3", + "ol.7.2-x64-corert" + ] + }, + "ol.7.4": { + "#import": [ + "ol.7.3", + "rhel.7.4" + ] + }, + "ol.7.4-corert": { + "#import": [ + "ol.7.4", + "ol.7.3-corert", + "rhel.7.4-corert" + ] + }, + "ol.7.4-x64": { + "#import": [ + "ol.7.4", + "ol.7.3-x64", + "rhel.7.4-x64" + ] + }, + "ol.7.4-x64-corert": { + "#import": [ + "ol.7.4-corert", + "ol.7.4-x64", + "ol.7.4", + "ol.7.3-x64-corert" + ] + }, + "opensuse": { + "#import": [ + "linux" + ] + }, + "opensuse-corert": { + "#import": [ + "opensuse", + "linux-corert" + ] + }, + "opensuse-x64": { + "#import": [ + "opensuse", + "linux-x64" + ] + }, + "opensuse-x64-corert": { + "#import": [ + "opensuse-corert", + "opensuse-x64", + "linux-x64-corert" + ] + }, + "opensuse.13.2": { + "#import": [ + "opensuse" + ] + }, + "opensuse.13.2-corert": { + "#import": [ + "opensuse.13.2", + "opensuse-corert" + ] + }, + "opensuse.13.2-x64": { + "#import": [ + "opensuse.13.2", + "opensuse-x64" + ] + }, + "opensuse.13.2-x64-corert": { + "#import": [ + "opensuse.13.2-corert", + "opensuse.13.2-x64", + "opensuse.13.2", + "opensuse-x64-corert" + ] + }, + "opensuse.42.1": { + "#import": [ + "opensuse" + ] + }, + "opensuse.42.1-corert": { + "#import": [ + "opensuse.42.1", + "opensuse-corert" + ] + }, + "opensuse.42.1-x64": { + "#import": [ + "opensuse.42.1", + "opensuse-x64" + ] + }, + "opensuse.42.1-x64-corert": { + "#import": [ + "opensuse.42.1-corert", + "opensuse.42.1-x64", + "opensuse.42.1", + "opensuse-x64-corert" + ] + }, + "opensuse.42.2": { + "#import": [ + "opensuse" + ] + }, + "opensuse.42.2-corert": { + "#import": [ + "opensuse.42.2", + "opensuse-corert" + ] + }, + "opensuse.42.2-x64": { + "#import": [ + "opensuse.42.2", + "opensuse-x64" + ] + }, + "opensuse.42.2-x64-corert": { + "#import": [ + "opensuse.42.2-corert", + "opensuse.42.2-x64", + "opensuse.42.2", + "opensuse-x64-corert" + ] + }, + "opensuse.42.3": { + "#import": [ + "opensuse" + ] + }, + "opensuse.42.3-corert": { + "#import": [ + "opensuse.42.3", + "opensuse-corert" + ] + }, + "opensuse.42.3-x64": { + "#import": [ + "opensuse.42.3", + "opensuse-x64" + ] + }, + "opensuse.42.3-x64-corert": { + "#import": [ + "opensuse.42.3-corert", + "opensuse.42.3-x64", + "opensuse.42.3", + "opensuse-x64-corert" + ] + }, + "osx": { + "#import": [ + "unix" + ] + }, + "osx-corert": { + "#import": [ + "osx", + "unix-corert" + ] + }, + "osx-x64": { + "#import": [ + "osx", + "unix-x64" + ] + }, + "osx-x64-corert": { + "#import": [ + "osx-corert", + "osx-x64", + "unix-x64-corert" + ] + }, + "osx.10.10": { + "#import": [ + "osx" + ] + }, + "osx.10.10-corert": { + "#import": [ + "osx.10.10", + "osx-corert" + ] + }, + "osx.10.10-x64": { + "#import": [ + "osx.10.10", + "osx-x64" + ] + }, + "osx.10.10-x64-corert": { + "#import": [ + "osx.10.10-corert", + "osx.10.10-x64", + "osx.10.10", + "osx-x64-corert" + ] + }, + "osx.10.11": { + "#import": [ + "osx.10.10" + ] + }, + "osx.10.11-corert": { + "#import": [ + "osx.10.11", + "osx.10.10-corert" + ] + }, + "osx.10.11-x64": { + "#import": [ + "osx.10.11", + "osx.10.10-x64" + ] + }, + "osx.10.11-x64-corert": { + "#import": [ + "osx.10.11-corert", + "osx.10.11-x64", + "osx.10.11", + "osx.10.10-x64-corert" + ] + }, + "osx.10.12": { + "#import": [ + "osx.10.11" + ] + }, + "osx.10.12-corert": { + "#import": [ + "osx.10.12", + "osx.10.11-corert" + ] + }, + "osx.10.12-x64": { + "#import": [ + "osx.10.12", + "osx.10.11-x64" + ] + }, + "osx.10.12-x64-corert": { + "#import": [ + "osx.10.12-corert", + "osx.10.12-x64", + "osx.10.12", + "osx.10.11-x64-corert" + ] + }, + "osx.10.13": { + "#import": [ + "osx.10.12" + ] + }, + "osx.10.13-corert": { + "#import": [ + "osx.10.13", + "osx.10.12-corert" + ] + }, + "osx.10.13-x64": { + "#import": [ + "osx.10.13", + "osx.10.12-x64" + ] + }, + "osx.10.13-x64-corert": { + "#import": [ + "osx.10.13-corert", + "osx.10.13-x64", + "osx.10.13", + "osx.10.12-x64-corert" + ] + }, + "rhel": { + "#import": [ + "linux" + ] + }, + "rhel-corert": { + "#import": [ + "rhel", + "linux-corert" + ] + }, + "rhel-x64": { + "#import": [ + "rhel", + "linux-x64" + ] + }, + "rhel-x64-corert": { + "#import": [ + "rhel-corert", + "rhel-x64", + "linux-x64-corert" + ] + }, + "rhel.6": { + "#import": [ + "rhel" + ] + }, + "rhel.6-corert": { + "#import": [ + "rhel.6", + "rhel-corert" + ] + }, + "rhel.6-x64": { + "#import": [ + "rhel.6", + "rhel-x64" + ] + }, + "rhel.6-x64-corert": { + "#import": [ + "rhel.6-corert", + "rhel.6-x64", + "rhel.6", + "rhel-x64-corert" + ] + }, + "rhel.7": { + "#import": [ + "rhel" + ] + }, + "rhel.7-corert": { + "#import": [ + "rhel.7", + "rhel-corert" + ] + }, + "rhel.7-x64": { + "#import": [ + "rhel.7", + "rhel-x64" + ] + }, + "rhel.7-x64-corert": { + "#import": [ + "rhel.7-corert", + "rhel.7-x64", + "rhel.7", + "rhel-x64-corert" + ] + }, + "rhel.7.0": { + "#import": [ + "rhel.7" + ] + }, + "rhel.7.0-corert": { + "#import": [ + "rhel.7.0", + "rhel.7-corert" + ] + }, + "rhel.7.0-x64": { + "#import": [ + "rhel.7.0", + "rhel.7-x64" + ] + }, + "rhel.7.0-x64-corert": { + "#import": [ + "rhel.7.0-corert", + "rhel.7.0-x64", + "rhel.7.0", + "rhel.7-x64-corert" + ] + }, + "rhel.7.1": { + "#import": [ + "rhel.7.0" + ] + }, + "rhel.7.1-corert": { + "#import": [ + "rhel.7.1", + "rhel.7.0-corert" + ] + }, + "rhel.7.1-x64": { + "#import": [ + "rhel.7.1", + "rhel.7.0-x64" + ] + }, + "rhel.7.1-x64-corert": { + "#import": [ + "rhel.7.1-corert", + "rhel.7.1-x64", + "rhel.7.1", + "rhel.7.0-x64-corert" + ] + }, + "rhel.7.2": { + "#import": [ + "rhel.7.1" + ] + }, + "rhel.7.2-corert": { + "#import": [ + "rhel.7.2", + "rhel.7.1-corert" + ] + }, + "rhel.7.2-x64": { + "#import": [ + "rhel.7.2", + "rhel.7.1-x64" + ] + }, + "rhel.7.2-x64-corert": { + "#import": [ + "rhel.7.2-corert", + "rhel.7.2-x64", + "rhel.7.2", + "rhel.7.1-x64-corert" + ] + }, + "rhel.7.3": { + "#import": [ + "rhel.7.2" + ] + }, + "rhel.7.3-corert": { + "#import": [ + "rhel.7.3", + "rhel.7.2-corert" + ] + }, + "rhel.7.3-x64": { + "#import": [ + "rhel.7.3", + "rhel.7.2-x64" + ] + }, + "rhel.7.3-x64-corert": { + "#import": [ + "rhel.7.3-corert", + "rhel.7.3-x64", + "rhel.7.3", + "rhel.7.2-x64-corert" + ] + }, + "rhel.7.4": { + "#import": [ + "rhel.7.3" + ] + }, + "rhel.7.4-corert": { + "#import": [ + "rhel.7.4", + "rhel.7.3-corert" + ] + }, + "rhel.7.4-x64": { + "#import": [ + "rhel.7.4", + "rhel.7.3-x64" + ] + }, + "rhel.7.4-x64-corert": { + "#import": [ + "rhel.7.4-corert", + "rhel.7.4-x64", + "rhel.7.4", + "rhel.7.3-x64-corert" + ] + }, + "sles": { + "#import": [ + "linux" + ] + }, + "sles-corert": { + "#import": [ + "sles", + "linux-corert" + ] + }, + "sles-x64": { + "#import": [ + "sles", + "linux-x64" + ] + }, + "sles-x64-corert": { + "#import": [ + "sles-corert", + "sles-x64", + "linux-x64-corert" + ] + }, + "sles.12": { + "#import": [ + "sles" + ] + }, + "sles.12-corert": { + "#import": [ + "sles.12", + "sles-corert" + ] + }, + "sles.12-x64": { + "#import": [ + "sles.12", + "sles-x64" + ] + }, + "sles.12-x64-corert": { + "#import": [ + "sles.12-corert", + "sles.12-x64", + "sles.12", + "sles-x64-corert" + ] + }, + "sles.12.1": { + "#import": [ + "sles.12" + ] + }, + "sles.12.1-corert": { + "#import": [ + "sles.12.1", + "sles.12-corert" + ] + }, + "sles.12.1-x64": { + "#import": [ + "sles.12.1", + "sles.12-x64" + ] + }, + "sles.12.1-x64-corert": { + "#import": [ + "sles.12.1-corert", + "sles.12.1-x64", + "sles.12.1", + "sles.12-x64-corert" + ] + }, + "sles.12.2": { + "#import": [ + "sles.12.1" + ] + }, + "sles.12.2-corert": { + "#import": [ + "sles.12.2", + "sles.12.1-corert" + ] + }, + "sles.12.2-x64": { + "#import": [ + "sles.12.2", + "sles.12.1-x64" + ] + }, + "sles.12.2-x64-corert": { + "#import": [ + "sles.12.2-corert", + "sles.12.2-x64", + "sles.12.2", + "sles.12.1-x64-corert" + ] + }, + "sles.12.3": { + "#import": [ + "sles.12.2" + ] + }, + "sles.12.3-corert": { + "#import": [ + "sles.12.3", + "sles.12.2-corert" + ] + }, + "sles.12.3-x64": { + "#import": [ + "sles.12.3", + "sles.12.2-x64" + ] + }, + "sles.12.3-x64-corert": { + "#import": [ + "sles.12.3-corert", + "sles.12.3-x64", + "sles.12.3", + "sles.12.2-x64-corert" + ] + }, + "tizen": { + "#import": [ + "linux" + ] + }, + "tizen-armel": { + "#import": [ + "tizen", + "linux-armel" + ] + }, + "tizen-armel-corert": { + "#import": [ + "tizen-corert", + "tizen-armel", + "linux-armel-corert" + ] + }, + "tizen-corert": { + "#import": [ + "tizen", + "linux-corert" + ] + }, + "tizen.4.0.0": { + "#import": [ + "tizen" + ] + }, + "tizen.4.0.0-armel": { + "#import": [ + "tizen.4.0.0", + "tizen-armel" + ] + }, + "tizen.4.0.0-armel-corert": { + "#import": [ + "tizen.4.0.0-corert", + "tizen.4.0.0-armel", + "tizen.4.0.0", + "tizen-armel-corert" + ] + }, + "tizen.4.0.0-corert": { + "#import": [ + "tizen.4.0.0", + "tizen-corert" + ] + }, + "ubuntu": { + "#import": [ + "debian" + ] + }, + "ubuntu-arm": { + "#import": [ + "ubuntu", + "debian-arm" + ] + }, + "ubuntu-arm-corert": { + "#import": [ + "ubuntu-corert", + "ubuntu-arm", + "debian-arm-corert" + ] + }, + "ubuntu-arm64": { + "#import": [ + "ubuntu", + "debian-arm64" + ] + }, + "ubuntu-arm64-corert": { + "#import": [ + "ubuntu-corert", + "ubuntu-arm64", + "debian-arm64-corert" + ] + }, + "ubuntu-corert": { + "#import": [ + "ubuntu", + "debian-corert" + ] + }, + "ubuntu-x64": { + "#import": [ + "ubuntu", + "debian-x64" + ] + }, + "ubuntu-x64-corert": { + "#import": [ + "ubuntu-corert", + "ubuntu-x64", + "debian-x64-corert" + ] + }, + "ubuntu-x86": { + "#import": [ + "ubuntu", + "debian-x86" + ] + }, + "ubuntu-x86-corert": { + "#import": [ + "ubuntu-corert", + "ubuntu-x86", + "debian-x86-corert" + ] + }, + "ubuntu.14.04": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.14.04-arm": { + "#import": [ + "ubuntu.14.04", + "ubuntu-arm" + ] + }, + "ubuntu.14.04-arm-corert": { + "#import": [ + "ubuntu.14.04-corert", + "ubuntu.14.04-arm", + "ubuntu.14.04", + "ubuntu-arm-corert" + ] + }, + "ubuntu.14.04-corert": { + "#import": [ + "ubuntu.14.04", + "ubuntu-corert" + ] + }, + "ubuntu.14.04-x64": { + "#import": [ + "ubuntu.14.04", + "ubuntu-x64" + ] + }, + "ubuntu.14.04-x64-corert": { + "#import": [ + "ubuntu.14.04-corert", + "ubuntu.14.04-x64", + "ubuntu.14.04", + "ubuntu-x64-corert" + ] + }, + "ubuntu.14.04-x86": { + "#import": [ + "ubuntu.14.04", + "ubuntu-x86" + ] + }, + "ubuntu.14.04-x86-corert": { + "#import": [ + "ubuntu.14.04-corert", + "ubuntu.14.04-x86", + "ubuntu.14.04", + "ubuntu-x86-corert" + ] + }, + "ubuntu.14.10": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.14.10-arm": { + "#import": [ + "ubuntu.14.10", + "ubuntu-arm" + ] + }, + "ubuntu.14.10-arm-corert": { + "#import": [ + "ubuntu.14.10-corert", + "ubuntu.14.10-arm", + "ubuntu.14.10", + "ubuntu-arm-corert" + ] + }, + "ubuntu.14.10-corert": { + "#import": [ + "ubuntu.14.10", + "ubuntu-corert" + ] + }, + "ubuntu.14.10-x64": { + "#import": [ + "ubuntu.14.10", + "ubuntu-x64" + ] + }, + "ubuntu.14.10-x64-corert": { + "#import": [ + "ubuntu.14.10-corert", + "ubuntu.14.10-x64", + "ubuntu.14.10", + "ubuntu-x64-corert" + ] + }, + "ubuntu.14.10-x86": { + "#import": [ + "ubuntu.14.10", + "ubuntu-x86" + ] + }, + "ubuntu.14.10-x86-corert": { + "#import": [ + "ubuntu.14.10-corert", + "ubuntu.14.10-x86", + "ubuntu.14.10", + "ubuntu-x86-corert" + ] + }, + "ubuntu.15.04": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.15.04-arm": { + "#import": [ + "ubuntu.15.04", + "ubuntu-arm" + ] + }, + "ubuntu.15.04-arm-corert": { + "#import": [ + "ubuntu.15.04-corert", + "ubuntu.15.04-arm", + "ubuntu.15.04", + "ubuntu-arm-corert" + ] + }, + "ubuntu.15.04-corert": { + "#import": [ + "ubuntu.15.04", + "ubuntu-corert" + ] + }, + "ubuntu.15.04-x64": { + "#import": [ + "ubuntu.15.04", + "ubuntu-x64" + ] + }, + "ubuntu.15.04-x64-corert": { + "#import": [ + "ubuntu.15.04-corert", + "ubuntu.15.04-x64", + "ubuntu.15.04", + "ubuntu-x64-corert" + ] + }, + "ubuntu.15.04-x86": { + "#import": [ + "ubuntu.15.04", + "ubuntu-x86" + ] + }, + "ubuntu.15.04-x86-corert": { + "#import": [ + "ubuntu.15.04-corert", + "ubuntu.15.04-x86", + "ubuntu.15.04", + "ubuntu-x86-corert" + ] + }, + "ubuntu.15.10": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.15.10-arm": { + "#import": [ + "ubuntu.15.10", + "ubuntu-arm" + ] + }, + "ubuntu.15.10-arm-corert": { + "#import": [ + "ubuntu.15.10-corert", + "ubuntu.15.10-arm", + "ubuntu.15.10", + "ubuntu-arm-corert" + ] + }, + "ubuntu.15.10-corert": { + "#import": [ + "ubuntu.15.10", + "ubuntu-corert" + ] + }, + "ubuntu.15.10-x64": { + "#import": [ + "ubuntu.15.10", + "ubuntu-x64" + ] + }, + "ubuntu.15.10-x64-corert": { + "#import": [ + "ubuntu.15.10-corert", + "ubuntu.15.10-x64", + "ubuntu.15.10", + "ubuntu-x64-corert" + ] + }, + "ubuntu.15.10-x86": { + "#import": [ + "ubuntu.15.10", + "ubuntu-x86" + ] + }, + "ubuntu.15.10-x86-corert": { + "#import": [ + "ubuntu.15.10-corert", + "ubuntu.15.10-x86", + "ubuntu.15.10", + "ubuntu-x86-corert" + ] + }, + "ubuntu.16.04": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.16.04-arm": { + "#import": [ + "ubuntu.16.04", + "ubuntu-arm" + ] + }, + "ubuntu.16.04-arm-corert": { + "#import": [ + "ubuntu.16.04-corert", + "ubuntu.16.04-arm", + "ubuntu.16.04", + "ubuntu-arm-corert" + ] + }, + "ubuntu.16.04-arm64": { + "#import": [ + "ubuntu.16.04", + "ubuntu-arm64" + ] + }, + "ubuntu.16.04-arm64-corert": { + "#import": [ + "ubuntu.16.04-corert", + "ubuntu.16.04-arm64", + "ubuntu.16.04", + "ubuntu-arm64-corert" + ] + }, + "ubuntu.16.04-corert": { + "#import": [ + "ubuntu.16.04", + "ubuntu-corert" + ] + }, + "ubuntu.16.04-x64": { + "#import": [ + "ubuntu.16.04", + "ubuntu-x64" + ] + }, + "ubuntu.16.04-x64-corert": { + "#import": [ + "ubuntu.16.04-corert", + "ubuntu.16.04-x64", + "ubuntu.16.04", + "ubuntu-x64-corert" + ] + }, + "ubuntu.16.04-x86": { + "#import": [ + "ubuntu.16.04", + "ubuntu-x86" + ] + }, + "ubuntu.16.04-x86-corert": { + "#import": [ + "ubuntu.16.04-corert", + "ubuntu.16.04-x86", + "ubuntu.16.04", + "ubuntu-x86-corert" + ] + }, + "ubuntu.16.10": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.16.10-arm": { + "#import": [ + "ubuntu.16.10", + "ubuntu-arm" + ] + }, + "ubuntu.16.10-arm-corert": { + "#import": [ + "ubuntu.16.10-corert", + "ubuntu.16.10-arm", + "ubuntu.16.10", + "ubuntu-arm-corert" + ] + }, + "ubuntu.16.10-arm64": { + "#import": [ + "ubuntu.16.10", + "ubuntu-arm64" + ] + }, + "ubuntu.16.10-arm64-corert": { + "#import": [ + "ubuntu.16.10-corert", + "ubuntu.16.10-arm64", + "ubuntu.16.10", + "ubuntu-arm64-corert" + ] + }, + "ubuntu.16.10-corert": { + "#import": [ + "ubuntu.16.10", + "ubuntu-corert" + ] + }, + "ubuntu.16.10-x64": { + "#import": [ + "ubuntu.16.10", + "ubuntu-x64" + ] + }, + "ubuntu.16.10-x64-corert": { + "#import": [ + "ubuntu.16.10-corert", + "ubuntu.16.10-x64", + "ubuntu.16.10", + "ubuntu-x64-corert" + ] + }, + "ubuntu.16.10-x86": { + "#import": [ + "ubuntu.16.10", + "ubuntu-x86" + ] + }, + "ubuntu.16.10-x86-corert": { + "#import": [ + "ubuntu.16.10-corert", + "ubuntu.16.10-x86", + "ubuntu.16.10", + "ubuntu-x86-corert" + ] + }, + "ubuntu.17.04": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.17.04-arm": { + "#import": [ + "ubuntu.17.04", + "ubuntu-arm" + ] + }, + "ubuntu.17.04-arm-corert": { + "#import": [ + "ubuntu.17.04-corert", + "ubuntu.17.04-arm", + "ubuntu.17.04", + "ubuntu-arm-corert" + ] + }, + "ubuntu.17.04-arm64": { + "#import": [ + "ubuntu.17.04", + "ubuntu-arm64" + ] + }, + "ubuntu.17.04-arm64-corert": { + "#import": [ + "ubuntu.17.04-corert", + "ubuntu.17.04-arm64", + "ubuntu.17.04", + "ubuntu-arm64-corert" + ] + }, + "ubuntu.17.04-corert": { + "#import": [ + "ubuntu.17.04", + "ubuntu-corert" + ] + }, + "ubuntu.17.04-x64": { + "#import": [ + "ubuntu.17.04", + "ubuntu-x64" + ] + }, + "ubuntu.17.04-x64-corert": { + "#import": [ + "ubuntu.17.04-corert", + "ubuntu.17.04-x64", + "ubuntu.17.04", + "ubuntu-x64-corert" + ] + }, + "ubuntu.17.04-x86": { + "#import": [ + "ubuntu.17.04", + "ubuntu-x86" + ] + }, + "ubuntu.17.04-x86-corert": { + "#import": [ + "ubuntu.17.04-corert", + "ubuntu.17.04-x86", + "ubuntu.17.04", + "ubuntu-x86-corert" + ] + }, + "ubuntu.17.10": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.17.10-arm": { + "#import": [ + "ubuntu.17.10", + "ubuntu-arm" + ] + }, + "ubuntu.17.10-arm-corert": { + "#import": [ + "ubuntu.17.10-corert", + "ubuntu.17.10-arm", + "ubuntu.17.10", + "ubuntu-arm-corert" + ] + }, + "ubuntu.17.10-arm64": { + "#import": [ + "ubuntu.17.10", + "ubuntu-arm64" + ] + }, + "ubuntu.17.10-arm64-corert": { + "#import": [ + "ubuntu.17.10-corert", + "ubuntu.17.10-arm64", + "ubuntu.17.10", + "ubuntu-arm64-corert" + ] + }, + "ubuntu.17.10-corert": { + "#import": [ + "ubuntu.17.10", + "ubuntu-corert" + ] + }, + "ubuntu.17.10-x64": { + "#import": [ + "ubuntu.17.10", + "ubuntu-x64" + ] + }, + "ubuntu.17.10-x64-corert": { + "#import": [ + "ubuntu.17.10-corert", + "ubuntu.17.10-x64", + "ubuntu.17.10", + "ubuntu-x64-corert" + ] + }, + "ubuntu.17.10-x86": { + "#import": [ + "ubuntu.17.10", + "ubuntu-x86" + ] + }, + "ubuntu.17.10-x86-corert": { + "#import": [ + "ubuntu.17.10-corert", + "ubuntu.17.10-x86", + "ubuntu.17.10", + "ubuntu-x86-corert" + ] + }, + "ubuntu.18.04": { + "#import": [ + "ubuntu" + ] + }, + "ubuntu.18.04-arm": { + "#import": [ + "ubuntu.18.04", + "ubuntu-arm" + ] + }, + "ubuntu.18.04-arm-corert": { + "#import": [ + "ubuntu.18.04-corert", + "ubuntu.18.04-arm", + "ubuntu.18.04", + "ubuntu-arm-corert" + ] + }, + "ubuntu.18.04-arm64": { + "#import": [ + "ubuntu.18.04", + "ubuntu-arm64" + ] + }, + "ubuntu.18.04-arm64-corert": { + "#import": [ + "ubuntu.18.04-corert", + "ubuntu.18.04-arm64", + "ubuntu.18.04", + "ubuntu-arm64-corert" + ] + }, + "ubuntu.18.04-corert": { + "#import": [ + "ubuntu.18.04", + "ubuntu-corert" + ] + }, + "ubuntu.18.04-x64": { + "#import": [ + "ubuntu.18.04", + "ubuntu-x64" + ] + }, + "ubuntu.18.04-x64-corert": { + "#import": [ + "ubuntu.18.04-corert", + "ubuntu.18.04-x64", + "ubuntu.18.04", + "ubuntu-x64-corert" + ] + }, + "ubuntu.18.04-x86": { + "#import": [ + "ubuntu.18.04", + "ubuntu-x86" + ] + }, + "ubuntu.18.04-x86-corert": { + "#import": [ + "ubuntu.18.04-corert", + "ubuntu.18.04-x86", + "ubuntu.18.04", + "ubuntu-x86-corert" + ] + }, + "unix": { + "#import": [ + "any" + ] + }, + "unix-arm": { + "#import": [ + "unix" + ] + }, + "unix-arm-corert": { + "#import": [ + "unix-corert", + "unix-arm" + ] + }, + "unix-arm64": { + "#import": [ + "unix" + ] + }, + "unix-arm64-corert": { + "#import": [ + "unix-corert", + "unix-arm64" + ] + }, + "unix-armel": { + "#import": [ + "unix" + ] + }, + "unix-armel-corert": { + "#import": [ + "unix-corert", + "unix-armel" + ] + }, + "unix-corert": { + "#import": [ + "unix", + "corert" + ] + }, + "unix-x64": { + "#import": [ + "unix" + ] + }, + "unix-x64-corert": { + "#import": [ + "unix-corert", + "unix-x64" + ] + }, + "unix-x86": { + "#import": [ + "unix" + ] + }, + "unix-x86-corert": { + "#import": [ + "unix-corert", + "unix-x86" + ] + }, + "win": { + "#import": [ + "any" + ] + }, + "win-aot": { + "#import": [ + "win", + "aot" + ] + }, + "win-arm": { + "#import": [ + "win" + ] + }, + "win-arm-aot": { + "#import": [ + "win-aot", + "win-arm" + ] + }, + "win-arm-corert": { + "#import": [ + "win-corert", + "win-arm" + ] + }, + "win-arm64": { + "#import": [ + "win" + ] + }, + "win-arm64-aot": { + "#import": [ + "win-aot", + "win-arm64" + ] + }, + "win-arm64-corert": { + "#import": [ + "win-corert", + "win-arm64" + ] + }, + "win-corert": { + "#import": [ + "win", + "corert" + ] + }, + "win-x64": { + "#import": [ + "win" + ] + }, + "win-x64-aot": { + "#import": [ + "win-aot", + "win-x64" + ] + }, + "win-x64-corert": { + "#import": [ + "win-corert", + "win-x64" + ] + }, + "win-x86": { + "#import": [ + "win" + ] + }, + "win-x86-aot": { + "#import": [ + "win-aot", + "win-x86" + ] + }, + "win-x86-corert": { + "#import": [ + "win-corert", + "win-x86" + ] + }, + "win10": { + "#import": [ + "win81" + ] + }, + "win10-aot": { + "#import": [ + "win10", + "win81-aot" + ] + }, + "win10-arm": { + "#import": [ + "win10", + "win81-arm" + ] + }, + "win10-arm-aot": { + "#import": [ + "win10-aot", + "win10-arm", + "win10", + "win81-arm-aot" + ] + }, + "win10-arm-corert": { + "#import": [ + "win10-corert", + "win10-arm", + "win10", + "win81-arm-corert" + ] + }, + "win10-arm64": { + "#import": [ + "win10", + "win81-arm64" + ] + }, + "win10-arm64-aot": { + "#import": [ + "win10-aot", + "win10-arm64", + "win10", + "win81-arm64-aot" + ] + }, + "win10-arm64-corert": { + "#import": [ + "win10-corert", + "win10-arm64", + "win10", + "win81-arm64-corert" + ] + }, + "win10-corert": { + "#import": [ + "win10", + "win81-corert" + ] + }, + "win10-x64": { + "#import": [ + "win10", + "win81-x64" + ] + }, + "win10-x64-aot": { + "#import": [ + "win10-aot", + "win10-x64", + "win10", + "win81-x64-aot" + ] + }, + "win10-x64-corert": { + "#import": [ + "win10-corert", + "win10-x64", + "win10", + "win81-x64-corert" + ] + }, + "win10-x86": { + "#import": [ + "win10", + "win81-x86" + ] + }, + "win10-x86-aot": { + "#import": [ + "win10-aot", + "win10-x86", + "win10", + "win81-x86-aot" + ] + }, + "win10-x86-corert": { + "#import": [ + "win10-corert", + "win10-x86", + "win10", + "win81-x86-corert" + ] + }, + "win7": { + "#import": [ + "win" + ] + }, + "win7-aot": { + "#import": [ + "win7", + "win-aot" + ] + }, + "win7-arm": { + "#import": [ + "win7", + "win-arm" + ] + }, + "win7-arm-aot": { + "#import": [ + "win7-aot", + "win7-arm", + "win7", + "win-arm-aot" + ] + }, + "win7-arm-corert": { + "#import": [ + "win7-corert", + "win7-arm", + "win7", + "win-arm-corert" + ] + }, + "win7-arm64": { + "#import": [ + "win7", + "win-arm64" + ] + }, + "win7-arm64-aot": { + "#import": [ + "win7-aot", + "win7-arm64", + "win7", + "win-arm64-aot" + ] + }, + "win7-arm64-corert": { + "#import": [ + "win7-corert", + "win7-arm64", + "win7", + "win-arm64-corert" + ] + }, + "win7-corert": { + "#import": [ + "win7", + "win-corert" + ] + }, + "win7-x64": { + "#import": [ + "win7", + "win-x64" + ] + }, + "win7-x64-aot": { + "#import": [ + "win7-aot", + "win7-x64", + "win7", + "win-x64-aot" + ] + }, + "win7-x64-corert": { + "#import": [ + "win7-corert", + "win7-x64", + "win7", + "win-x64-corert" + ] + }, + "win7-x86": { + "#import": [ + "win7", + "win-x86" + ] + }, + "win7-x86-aot": { + "#import": [ + "win7-aot", + "win7-x86", + "win7", + "win-x86-aot" + ] + }, + "win7-x86-corert": { + "#import": [ + "win7-corert", + "win7-x86", + "win7", + "win-x86-corert" + ] + }, + "win8": { + "#import": [ + "win7" + ] + }, + "win8-aot": { + "#import": [ + "win8", + "win7-aot" + ] + }, + "win8-arm": { + "#import": [ + "win8", + "win7-arm" + ] + }, + "win8-arm-aot": { + "#import": [ + "win8-aot", + "win8-arm", + "win8", + "win7-arm-aot" + ] + }, + "win8-arm-corert": { + "#import": [ + "win8-corert", + "win8-arm", + "win8", + "win7-arm-corert" + ] + }, + "win8-arm64": { + "#import": [ + "win8", + "win7-arm64" + ] + }, + "win8-arm64-aot": { + "#import": [ + "win8-aot", + "win8-arm64", + "win8", + "win7-arm64-aot" + ] + }, + "win8-arm64-corert": { + "#import": [ + "win8-corert", + "win8-arm64", + "win8", + "win7-arm64-corert" + ] + }, + "win8-corert": { + "#import": [ + "win8", + "win7-corert" + ] + }, + "win8-x64": { + "#import": [ + "win8", + "win7-x64" + ] + }, + "win8-x64-aot": { + "#import": [ + "win8-aot", + "win8-x64", + "win8", + "win7-x64-aot" + ] + }, + "win8-x64-corert": { + "#import": [ + "win8-corert", + "win8-x64", + "win8", + "win7-x64-corert" + ] + }, + "win8-x86": { + "#import": [ + "win8", + "win7-x86" + ] + }, + "win8-x86-aot": { + "#import": [ + "win8-aot", + "win8-x86", + "win8", + "win7-x86-aot" + ] + }, + "win8-x86-corert": { + "#import": [ + "win8-corert", + "win8-x86", + "win8", + "win7-x86-corert" + ] + }, + "win81": { + "#import": [ + "win8" + ] + }, + "win81-aot": { + "#import": [ + "win81", + "win8-aot" + ] + }, + "win81-arm": { + "#import": [ + "win81", + "win8-arm" + ] + }, + "win81-arm-aot": { + "#import": [ + "win81-aot", + "win81-arm", + "win81", + "win8-arm-aot" + ] + }, + "win81-arm-corert": { + "#import": [ + "win81-corert", + "win81-arm", + "win81", + "win8-arm-corert" + ] + }, + "win81-arm64": { + "#import": [ + "win81", + "win8-arm64" + ] + }, + "win81-arm64-aot": { + "#import": [ + "win81-aot", + "win81-arm64", + "win81", + "win8-arm64-aot" + ] + }, + "win81-arm64-corert": { + "#import": [ + "win81-corert", + "win81-arm64", + "win81", + "win8-arm64-corert" + ] + }, + "win81-corert": { + "#import": [ + "win81", + "win8-corert" + ] + }, + "win81-x64": { + "#import": [ + "win81", + "win8-x64" + ] + }, + "win81-x64-aot": { + "#import": [ + "win81-aot", + "win81-x64", + "win81", + "win8-x64-aot" + ] + }, + "win81-x64-corert": { + "#import": [ + "win81-corert", + "win81-x64", + "win81", + "win8-x64-corert" + ] + }, + "win81-x86": { + "#import": [ + "win81", + "win8-x86" + ] + }, + "win81-x86-aot": { + "#import": [ + "win81-aot", + "win81-x86", + "win81", + "win8-x86-aot" + ] + }, + "win81-x86-corert": { + "#import": [ + "win81-corert", + "win81-x86", + "win81", + "win8-x86-corert" + ] + } + } +} \ No newline at end of file diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/useSharedDesignerContext.txt b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/useSharedDesignerContext.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/version.txt b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/version.txt new file mode 100644 index 0000000000..47004a02b3 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.platforms/2.1.0/version.txt @@ -0,0 +1 @@ +30ab651fcb4354552bd4891619a0bdd81e0ebdbf diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/Microsoft.NETCore.Targets.csproj b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/Microsoft.NETCore.Targets.csproj new file mode 100644 index 0000000000..47ee0dc74a --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/Microsoft.NETCore.Targets.csproj @@ -0,0 +1,10 @@ + + + netstandard1.3 + $(ArtifactsBinDir)microsoft.netcore.targets/1.1.0/ + $(ArtifactsObjDir)microsoft.netcore.targets/1.1.0/ + false + true + Microsoft.NETCore.Targets.nuspec + + diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/Microsoft.NETCore.Targets.nuspec b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/Microsoft.NETCore.Targets.nuspec new file mode 100644 index 0000000000..a9acb49653 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/Microsoft.NETCore.Targets.nuspec @@ -0,0 +1,19 @@ + + + + Microsoft.NETCore.Targets + 1.1.0 + Microsoft.NETCore.Targets + Microsoft + microsoft,dotnetframework + true + http://go.microsoft.com/fwlink/?LinkId=329770 + https://dot.net/ + http://go.microsoft.com/fwlink/?LinkID=288859 + Provides supporting infrastructure for portable projects: support identifiers that define framework and runtime for support targets and packages that reference the minimum supported package versions when targeting these. +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 diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/ThirdPartyNotices.txt b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/ThirdPartyNotices.txt new file mode 100644 index 0000000000..55cfb20817 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/ThirdPartyNotices.txt @@ -0,0 +1,31 @@ +This Microsoft .NET Library may incorporate components from the projects listed +below. Microsoft licenses these components under the Microsoft .NET Library +software license terms. The original copyright notices and the licenses under +which Microsoft received such components are set forth below for informational +purposes only. Microsoft reserves all rights not expressly granted herein, +whether by implication, estoppel or otherwise. + +1. .NET Core (https://github.com/dotnet/core/) + +.NET Core +Copyright (c) .NET Foundation and Contributors + +The MIT License (MIT) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/dotnet_library_license.txt b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/dotnet_library_license.txt new file mode 100644 index 0000000000..92b6c443d3 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/dotnet_library_license.txt @@ -0,0 +1,128 @@ + +MICROSOFT SOFTWARE LICENSE TERMS + + +MICROSOFT .NET LIBRARY + +These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft + +· updates, + +· supplements, + +· Internet-based services, and + +· support services + +for this software, unless other terms accompany those items. If so, those terms apply. + +BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS. IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE. + + +IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE PERPETUAL RIGHTS BELOW. + +1. INSTALLATION AND USE RIGHTS. + +a. Installation and Use. You may install and use any number of copies of the software to design, develop and test your programs. + +b. Third Party Programs. The software may include third party programs that Microsoft, not the third party, licenses to you under this agreement. Notices, if any, for the third party program are included for your information only. + +2. ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS. + +a. DISTRIBUTABLE CODE. The software is comprised of Distributable Code. “Distributable Code” is code that you are permitted to distribute in programs you develop if you comply with the terms below. + +i. Right to Use and Distribute. + +· You may copy and distribute the object code form of the software. + +· Third Party Distribution. You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs. + +ii. Distribution Requirements. For any Distributable Code you distribute, you must + +· add significant primary functionality to it in your programs; + +· require distributors and external end users to agree to terms that protect it at least as much as this agreement; + +· display your valid copyright notice on your programs; and + +· indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your programs. + +iii. Distribution Restrictions. You may not + +· alter any copyright, trademark or patent notice in the Distributable Code; + +· use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft; + +· include Distributable Code in malicious, deceptive or unlawful programs; or + +· modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires, as a condition of use, modification or distribution, that + +· the code be disclosed or distributed in source code form; or + +· others have the right to modify it. + +3. SCOPE OF LICENSE. The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not + +· work around any technical limitations in the software; + +· reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation; + +· publish the software for others to copy; + +· rent, lease or lend the software; + +· transfer the software or this agreement to any third party; or + +· use the software for commercial software hosting services. + +4. BACKUP COPY. You may make one backup copy of the software. You may use it only to reinstall the software. + +5. DOCUMENTATION. Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes. + +6. EXPORT RESTRICTIONS. The software is subject to United States export laws and regulations. You must comply with all domestic and international export laws and regulations that apply to the software. These laws include restrictions on destinations, end users and end use. For additional information, see www.microsoft.com/exporting. + +7. SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it. + +8. ENTIRE AGREEMENT. This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services. + +9. APPLICABLE LAW. + +a. United States. If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles. The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort. + +b. Outside the United States. If you acquired the software in any other country, the laws of that country apply. + +10. LEGAL EFFECT. This agreement describes certain legal rights. You may have other rights under the laws of your country. You may also have rights with respect to the party from whom you acquired the software. This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so. + +11. DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED “AS-IS.” YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS OR STATUTORY GUARANTEES UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + +FOR AUSTRALIA – YOU HAVE STATUTORY GUARANTEES UNDER THE AUSTRALIAN CONSUMER LAW AND NOTHING IN THESE TERMS IS INTENDED TO AFFECT THOSE RIGHTS. + +12. LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES. + +This limitation applies to + +· anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and + +· claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law. + +It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages. + +Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French. + +Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français. + +EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage particulier et d’absence de contrefaçon sont exclues. + +LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES. Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages spéciaux, indirects ou accessoires et pertes de bénéfices. + +Cette limitation concerne : + +· tout ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et + +· les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la limite autorisée par la loi en vigueur. + +Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage. Si votre pays n’autorise pas l’exclusion ou la limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre égard. + +EFFET JURIDIQUE. Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays. Le présent contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas. + + diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/lib/netstandard1.0/_._ b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/lib/netstandard1.0/_._ new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/runtime.json b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/runtime.json new file mode 100644 index 0000000000..1585ef6283 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/1.1.0/runtime.json @@ -0,0 +1,438 @@ +{ + "runtimes": { + "win": { + "Microsoft.Win32.Primitives": { + "runtime.win.Microsoft.Win32.Primitives": "4.3.0" + }, + "System.Console": { + "runtime.win.System.Console": "4.3.0" + }, + "System.Diagnostics.Debug": { + "runtime.win.System.Diagnostics.Debug": "4.3.0" + }, + "System.IO.FileSystem": { + "runtime.win.System.IO.FileSystem": "4.3.0" + }, + "System.Net.Primitives": { + "runtime.win.System.Net.Primitives": "4.3.0" + }, + "System.Net.Sockets": { + "runtime.win.System.Net.Sockets": "4.3.0" + }, + "System.Runtime.Extensions": { + "runtime.win.System.Runtime.Extensions": "4.3.0" + } + }, + "unix": { + "Microsoft.Win32.Primitives": { + "runtime.unix.Microsoft.Win32.Primitives": "4.3.0" + }, + "System.Console": { + "runtime.unix.System.Console": "4.3.0" + }, + "System.Diagnostics.Debug": { + "runtime.unix.System.Diagnostics.Debug": "4.3.0" + }, + "System.IO.FileSystem": { + "runtime.unix.System.IO.FileSystem": "4.3.0" + }, + "System.Net.Primitives": { + "runtime.unix.System.Net.Primitives": "4.3.0" + }, + "System.Net.Sockets": { + "runtime.unix.System.Net.Sockets": "4.3.0" + }, + "System.Runtime.Extensions": { + "runtime.unix.System.Runtime.Extensions": "4.3.0" + }, + "System.Private.Uri": { + "runtime.unix.System.Private.Uri": "4.3.0" + } + }, + "any": { + "System.Collections": { + "runtime.any.System.Collections": "4.3.0" + }, + "System.Diagnostics.Tools": { + "runtime.any.System.Diagnostics.Tools": "4.3.0" + }, + "System.Diagnostics.Tracing": { + "runtime.any.System.Diagnostics.Tracing": "4.3.0" + }, + "System.Globalization": { + "runtime.any.System.Globalization": "4.3.0" + }, + "System.Globalization.Calendars": { + "runtime.any.System.Globalization.Calendars": "4.3.0" + }, + "System.IO": { + "runtime.any.System.IO": "4.3.0" + }, + "System.Reflection": { + "runtime.any.System.Reflection": "4.3.0" + }, + "System.Reflection.Extensions": { + "runtime.any.System.Reflection.Extensions": "4.3.0" + }, + "System.Reflection.Primitives": { + "runtime.any.System.Reflection.Primitives": "4.3.0" + }, + "System.Resources.ResourceManager": { + "runtime.any.System.Resources.ResourceManager": "4.3.0" + }, + "System.Runtime": { + "runtime.any.System.Runtime": "4.3.0" + }, + "System.Runtime.Handles": { + "runtime.any.System.Runtime.Handles": "4.3.0" + }, + "System.Runtime.InteropServices": { + "runtime.any.System.Runtime.InteropServices": "4.3.0" + }, + "System.Text.Encoding": { + "runtime.any.System.Text.Encoding": "4.3.0" + }, + "System.Text.Encoding.Extensions": { + "runtime.any.System.Text.Encoding.Extensions": "4.3.0" + }, + "System.Threading.Tasks": { + "runtime.any.System.Threading.Tasks": "4.3.0" + }, + "System.Threading.Timer": { + "runtime.any.System.Threading.Timer": "4.3.0" + } + }, + "aot": { + "System.Collections": { + "runtime.aot.System.Collections": "4.3.0" + }, + "System.Diagnostics.Tools": { + "runtime.aot.System.Diagnostics.Tools": "4.3.0" + }, + "System.Diagnostics.Tracing": { + "runtime.aot.System.Diagnostics.Tracing": "4.3.0" + }, + "System.Globalization": { + "runtime.aot.System.Globalization": "4.3.0" + }, + "System.Globalization.Calendars": { + "runtime.aot.System.Globalization.Calendars": "4.3.0" + }, + "System.IO": { + "runtime.aot.System.IO": "4.3.0" + }, + "System.Reflection": { + "runtime.aot.System.Reflection": "4.3.0" + }, + "System.Reflection.Extensions": { + "runtime.aot.System.Reflection.Extensions": "4.3.0" + }, + "System.Reflection.Primitives": { + "runtime.aot.System.Reflection.Primitives": "4.3.0" + }, + "System.Resources.ResourceManager": { + "runtime.aot.System.Resources.ResourceManager": "4.3.0" + }, + "System.Runtime": { + "runtime.aot.System.Runtime": "4.3.0" + }, + "System.Runtime.Handles": { + "runtime.aot.System.Runtime.Handles": "4.3.0" + }, + "System.Runtime.InteropServices": { + "runtime.aot.System.Runtime.InteropServices": "4.3.0" + }, + "System.Text.Encoding": { + "runtime.aot.System.Text.Encoding": "4.3.0" + }, + "System.Text.Encoding.Extensions": { + "runtime.aot.System.Text.Encoding.Extensions": "4.3.0" + }, + "System.Threading.Tasks": { + "runtime.aot.System.Threading.Tasks": "4.3.0" + }, + "System.Threading.Timer": { + "runtime.aot.System.Threading.Timer": "4.3.0" + } + }, + "win7": { + "System.Private.Uri": { + "runtime.win7.System.Private.Uri": "4.3.0" + } + }, + "win10-x64-aot": { + "runtime.native.System.IO.Compression": { + "runtime.win10-x64-aot.runtime.native.System.IO.Compression": "4.0.1" + } + }, + "win10-arm-aot": { + "runtime.native.System.IO.Compression": { + "runtime.win10-arm-aot.runtime.native.System.IO.Compression": "4.0.1" + } + }, + "win10-x86-aot": { + "runtime.native.System.IO.Compression": { + "runtime.win10-x86-aot.runtime.native.System.IO.Compression": "4.0.1" + } + }, + "rhel.7-x64": { + "runtime.native.System.IO.Compression": { + "runtime.rhel.7-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.rhel.7-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.rhel.7-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.rhel.7-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "debian.8-x64": { + "runtime.native.System.IO.Compression": { + "runtime.debian.8-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.debian.8-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.debian.8-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.debian.8-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "fedora.23-x64": { + "runtime.native.System.IO.Compression": { + "runtime.fedora.23-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.fedora.23-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.fedora.23-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.fedora.23-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "fedora.24-x64": { + "runtime.native.System.IO.Compression": { + "runtime.fedora.24-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.fedora.24-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.fedora.24-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.fedora.24-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "osx.10.10-x64": { + "runtime.native.System.IO.Compression": { + "runtime.osx.10.10-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.osx.10.10-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.osx.10.10-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.osx.10.10-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "opensuse.13.2-x64": { + "runtime.native.System.IO.Compression": { + "runtime.opensuse.13.2-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.opensuse.13.2-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.opensuse.13.2-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.opensuse.13.2-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "opensuse.42.1-x64": { + "runtime.native.System.IO.Compression": { + "runtime.opensuse.42.1-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.opensuse.42.1-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.opensuse.42.1-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.opensuse.42.1-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "ubuntu.14.04-x64": { + "runtime.native.System.IO.Compression": { + "runtime.ubuntu.14.04-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.ubuntu.14.04-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.ubuntu.14.04-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "ubuntu.16.04-x64": { + "runtime.native.System.IO.Compression": { + "runtime.ubuntu.16.04-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.ubuntu.16.04-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.ubuntu.16.04-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "ubuntu.16.10-x64": { + "runtime.native.System.IO.Compression": { + "runtime.ubuntu.16.10-x64.runtime.native.System.IO.Compression": "4.3.0" + }, + "runtime.native.System": { + "runtime.ubuntu.16.10-x64.runtime.native.System": "4.3.0" + }, + "runtime.native.System.Net.Http": { + "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Http": "4.3.0" + }, + "runtime.native.System.Net.Security": { + "runtime.ubuntu.16.10-x64.runtime.native.System.Net.Security": "4.3.0" + } + }, + "win7-x86": { + "runtime.native.System.IO.Compression": { + "runtime.win7-x86.runtime.native.System.IO.Compression": "4.3.0" + } + }, + "win7-x64": { + "runtime.native.System.IO.Compression": { + "runtime.win7-x64.runtime.native.System.IO.Compression": "4.3.0" + } + }, + "win8-arm": { + "runtime.native.System.IO.Compression": { + "runtime.win8-arm.runtime.native.System.IO.Compression": "4.3.0" + } + }, + "win10-arm64": { + "runtime.native.System.IO.Compression": { + "runtime.win10-arm64.runtime.native.System.IO.Compression": "4.3.0" + } + } + }, + "supports": { + "uwp.10.0.app": { + "uap10.0": [ + "win10-x86", + "win10-x86-aot", + "win10-x64", + "win10-x64-aot", + "win10-arm", + "win10-arm-aot" + ] + }, + "net45.app": { + "net45": [ + "", + "win-x86", + "win-x64" + ] + }, + "net451.app": { + "net451": [ + "", + "win-x86", + "win-x64" + ] + }, + "net452.app": { + "net452": [ + "", + "win-x86", + "win-x64" + ] + }, + "net46.app": { + "net46": [ + "", + "win-x86", + "win-x64" + ] + }, + "net461.app": { + "net461": [ + "", + "win-x86", + "win-x64" + ] + }, + "net462.app": { + "net462": [ + "", + "win-x86", + "win-x64" + ] + }, + "netcoreapp1.0.app": { + "netcoreapp1.0": [ + "win7-x86", + "win7-x64", + "osx.10.11-x64", + "centos.7-x64", + "debian.8-x64", + "linuxmint.17-x64", + "opensuse.13.2-x64", + "rhel.7.2-x64", + "ubuntu.14.04-x64", + "ubuntu.16.04-x64" + ] + }, + "win8.app": { + "win8": [ + "" + ] + }, + "win81.app": { + "win81": [ + "" + ] + }, + "wp8.app": { + "wp8": [ + "" + ] + }, + "wp81.app": { + "wp81": [ + "" + ] + }, + "wpa81.app": { + "wpa81": [ + "" + ] + }, + "dnxcore50.app": { + "dnxcore50": [ + "win7-x86", + "win7-x64" + ] + } + } +} \ No newline at end of file diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/LICENSE.TXT b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/LICENSE.TXT new file mode 100644 index 0000000000..984713a496 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/LICENSE.TXT @@ -0,0 +1,23 @@ +The MIT License (MIT) + +Copyright (c) .NET Foundation and Contributors + +All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/Microsoft.NETCore.Targets.csproj b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/Microsoft.NETCore.Targets.csproj new file mode 100644 index 0000000000..77d25764b5 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/Microsoft.NETCore.Targets.csproj @@ -0,0 +1,10 @@ + + + netstandard1.3 + $(ArtifactsBinDir)microsoft.netcore.targets/2.1.0/ + $(ArtifactsObjDir)microsoft.netcore.targets/2.1.0/ + false + true + Microsoft.NETCore.Targets.nuspec + + diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/Microsoft.NETCore.Targets.nuspec b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/Microsoft.NETCore.Targets.nuspec new file mode 100644 index 0000000000..90588267e5 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/Microsoft.NETCore.Targets.nuspec @@ -0,0 +1,20 @@ + + + + Microsoft.NETCore.Targets + 2.1.0 + Microsoft.NETCore.Targets + Microsoft + microsoft,dotnetframework + false + https://github.com/dotnet/corefx/blob/master/LICENSE.TXT + https://dot.net/ + http://go.microsoft.com/fwlink/?LinkID=288859 + Provides supporting infrastructure for portable projects: support identifiers that define framework and runtime for support targets and packages that reference the minimum supported package versions when targeting these. +30ab651fcb4354552bd4891619a0bdd81e0ebdbf +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 diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/THIRD-PARTY-NOTICES.TXT b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/THIRD-PARTY-NOTICES.TXT new file mode 100644 index 0000000000..db542ca24f --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/THIRD-PARTY-NOTICES.TXT @@ -0,0 +1,309 @@ +.NET Core uses third-party libraries or other resources that may be +distributed under licenses different than the .NET Core software. + +In the event that we accidentally failed to list a required notice, please +bring it to our attention. Post an issue or email us: + + dotnet@microsoft.com + +The attached notices are provided for information only. + +License notice for Slicing-by-8 +------------------------------- + +http://sourceforge.net/projects/slicing-by-8/ + +Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved + + +This software program is licensed subject to the BSD License, available at +http://www.opensource.org/licenses/bsd-license.html. + + +License notice for Unicode data +------------------------------- + +http://www.unicode.org/copyright.html#License + +Copyright © 1991-2017 Unicode, Inc. All rights reserved. +Distributed under the Terms of Use in http://www.unicode.org/copyright.html. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Unicode data files and any associated documentation +(the "Data Files") or Unicode software and any associated documentation +(the "Software") to deal in the Data Files or Software +without restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, and/or sell copies of +the Data Files or Software, and to permit persons to whom the Data Files +or Software are furnished to do so, provided that either +(a) this copyright and permission notice appear with all copies +of the Data Files or Software, or +(b) this copyright and permission notice appear in associated +Documentation. + +THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT OF THIRD PARTY RIGHTS. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS +NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL +DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THE DATA FILES OR SOFTWARE. + +Except as contained in this notice, the name of a copyright holder +shall not be used in advertising or otherwise to promote the sale, +use or other dealings in these Data Files or Software without prior +written authorization of the copyright holder. + +License notice for Zlib +----------------------- + +https://github.com/madler/zlib +http://zlib.net/zlib_license.html + +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.11, January 15th, 2017 + + Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + +*/ + +License notice for Mono +------------------------------- + +http://www.mono-project.com/docs/about-mono/ + +Copyright (c) .NET Foundation Contributors + +MIT License + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the Software), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +License notice for International Organization for Standardization +----------------------------------------------------------------- + +Portions (C) International Organization for Standardization 1986: + Permission to copy in any form is granted for use with + conforming SGML systems and applications as defined in + ISO 8879, provided this notice is included in all copies. + +License notice for Intel +------------------------ + +"Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this +list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +License notice for Xamarin and Novell +------------------------------------- + +Copyright (c) 2015 Xamarin, Inc (http://www.xamarin.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +Copyright (c) 2011 Novell, Inc (http://www.novell.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +Third party notice for W3C +-------------------------- + +"W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE +Status: This license takes effect 13 May, 2015. +This work is being provided by the copyright holders under the following license. +License +By obtaining and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions. +Permission to copy, modify, and distribute this work, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the work or portions thereof, including modifications: +The full text of this NOTICE in a location viewable to users of the redistributed or derivative work. +Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, the W3C Software and Document Short Notice should be included. +Notice of any changes or modifications, through a copyright statement on the new code or document such as "This software or document includes material copied from or derived from [title and URI of the W3C document]. Copyright © [YEAR] W3C® (MIT, ERCIM, Keio, Beihang)." +Disclaimers +THIS WORK IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. +COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT. +The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the work without specific, written prior permission. Title to copyright in this work will at all times remain with copyright holders." + +License notice for Bit Twiddling Hacks +-------------------------------------- + +Bit Twiddling Hacks + +By Sean Eron Anderson +seander@cs.stanford.edu + +Individually, the code snippets here are in the public domain (unless otherwise +noted) — feel free to use them however you please. The aggregate collection and +descriptions are © 1997-2005 Sean Eron Anderson. The code and descriptions are +distributed in the hope that they will be useful, but WITHOUT ANY WARRANTY and +without even the implied warranty of merchantability or fitness for a particular +purpose. + +License notice for Brotli +-------------------------------------- + +Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + +compress_fragment.c: +Copyright (c) 2011, Google Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +decode_fuzzer.c: +Copyright (c) 2015 The Chromium Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." + diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/lib/netstandard1.0/_._ b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/lib/netstandard1.0/_._ new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/runtime.json b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/runtime.json new file mode 100644 index 0000000000..925514c361 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/runtime.json @@ -0,0 +1,92 @@ +{ + "supports": { + "uwp.10.0.app": { + "uap10.0": [ + "win10-x86", + "win10-x86-aot", + "win10-x64", + "win10-x64-aot", + "win10-arm", + "win10-arm-aot" + ] + }, + "net45.app": { + "net45": [ + "", + "win-x86", + "win-x64" + ] + }, + "net451.app": { + "net451": [ + "", + "win-x86", + "win-x64" + ] + }, + "net452.app": { + "net452": [ + "", + "win-x86", + "win-x64" + ] + }, + "net46.app": { + "net46": [ + "", + "win-x86", + "win-x64" + ] + }, + "net461.app": { + "net461": [ + "", + "win-x86", + "win-x64" + ] + }, + "net462.app": { + "net462": [ + "", + "win-x86", + "win-x64" + ] + }, + "netcoreapp1.0.app": { + "netcoreapp1.0": [ + "win7-x86", + "win7-x64", + "osx.10.11-x64", + "centos.7-x64", + "debian.8-x64", + "linuxmint.17-x64", + "opensuse.13.2-x64", + "rhel.7.2-x64", + "ubuntu.14.04-x64", + "ubuntu.16.04-x64" + ] + }, + "win8.app": { + "win8": "" + }, + "win81.app": { + "win81": "" + }, + "wp8.app": { + "wp8": "" + }, + "wp81.app": { + "wp81": "" + }, + "wpa81.app": { + "wpa81": "" + }, + "dnxcore50.app": { + "dnxcore50": [ + "win7-x86", + "win7-x64" + ] + } + } + } + diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/useSharedDesignerContext.txt b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/useSharedDesignerContext.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/version.txt b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/version.txt new file mode 100644 index 0000000000..47004a02b3 --- /dev/null +++ b/src/textOnlyPackages/src/microsoft.netcore.targets/2.1.0/version.txt @@ -0,0 +1 @@ +30ab651fcb4354552bd4891619a0bdd81e0ebdbf