From aa7239356c74af942d00a4e16343c0c0d3585166 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 24 Sep 2013 11:31:45 -0500 Subject: [PATCH 1/6] Update to SimpleRESTServices 1.2.0.0 --- src/console/console.csproj | 4 +- src/console/packages.config | 2 +- src/corelib/corelib.csproj | 4 +- src/corelib/packages.config | 2 +- .../lib/net40/SimpleRESTServices.dll | Bin 39760 -> 0 bytes .../SimpleRESTServices.1.2.0.0.nuspec} | 11 +- .../lib/net35/SimpleRESTServices.dll | Bin 0 -> 24400 bytes .../lib/net35/SimpleRESTServices.xml | 1965 +++++++++++++++++ .../lib/net40/SimpleRESTServices.dll | Bin 0 -> 39760 bytes .../lib/net40/SimpleRESTServices.xml | 24 +- src/testing/integration/integration.csproj | 4 +- src/testing/integration/packages.config | 2 +- src/testing/unit/packages.config | 2 +- src/testing/unit/unit.csproj | 4 +- 14 files changed, 1993 insertions(+), 31 deletions(-) delete mode 100644 src/packages/SimpleRESTServices.1.1.3.0/lib/net40/SimpleRESTServices.dll rename src/packages/{SimpleRESTServices.1.1.3.0/SimpleRESTServices.1.1.3.0.nuspec => SimpleRESTServices.1.2.0.0/SimpleRESTServices.1.2.0.0.nuspec} (74%) create mode 100644 src/packages/SimpleRESTServices.1.2.0.0/lib/net35/SimpleRESTServices.dll create mode 100644 src/packages/SimpleRESTServices.1.2.0.0/lib/net35/SimpleRESTServices.xml create mode 100644 src/packages/SimpleRESTServices.1.2.0.0/lib/net40/SimpleRESTServices.dll rename src/packages/{SimpleRESTServices.1.1.3.0 => SimpleRESTServices.1.2.0.0}/lib/net40/SimpleRESTServices.xml (99%) diff --git a/src/console/console.csproj b/src/console/console.csproj index a8ab467cf..e112bacbb 100644 --- a/src/console/console.csproj +++ b/src/console/console.csproj @@ -39,9 +39,9 @@ False ..\packages\Newtonsoft.Json.5.0.6\lib\net40\Newtonsoft.Json.dll - + False - ..\packages\SimpleRESTServices.1.1.3.0\lib\net40\SimpleRESTServices.dll + ..\packages\SimpleRESTServices.1.2.0.0\lib\net40\SimpleRESTServices.dll diff --git a/src/console/packages.config b/src/console/packages.config index 4467c0394..a1bad3480 100644 --- a/src/console/packages.config +++ b/src/console/packages.config @@ -1,5 +1,5 @@  - + \ No newline at end of file diff --git a/src/corelib/corelib.csproj b/src/corelib/corelib.csproj index 0872d9725..d09aeeb4c 100644 --- a/src/corelib/corelib.csproj +++ b/src/corelib/corelib.csproj @@ -38,9 +38,9 @@ False ..\packages\Newtonsoft.Json.5.0.6\lib\net40\Newtonsoft.Json.dll - + False - ..\packages\SimpleRESTServices.1.1.3.0\lib\net40\SimpleRESTServices.dll + ..\packages\SimpleRESTServices.1.2.0.0\lib\net40\SimpleRESTServices.dll diff --git a/src/corelib/packages.config b/src/corelib/packages.config index 4467c0394..a1bad3480 100644 --- a/src/corelib/packages.config +++ b/src/corelib/packages.config @@ -1,5 +1,5 @@  - + \ No newline at end of file diff --git a/src/packages/SimpleRESTServices.1.1.3.0/lib/net40/SimpleRESTServices.dll b/src/packages/SimpleRESTServices.1.1.3.0/lib/net40/SimpleRESTServices.dll deleted file mode 100644 index 9c02484ccc0c8a4ae8940ee0f86c32d06418e82f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 39760 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 diff --git a/src/packages/SimpleRESTServices.1.1.3.0/SimpleRESTServices.1.1.3.0.nuspec b/src/packages/SimpleRESTServices.1.2.0.0/SimpleRESTServices.1.2.0.0.nuspec similarity index 74% rename from src/packages/SimpleRESTServices.1.1.3.0/SimpleRESTServices.1.1.3.0.nuspec rename to src/packages/SimpleRESTServices.1.2.0.0/SimpleRESTServices.1.2.0.0.nuspec index aca1d4910..464cc88c9 100644 --- a/src/packages/SimpleRESTServices.1.1.3.0/SimpleRESTServices.1.1.3.0.nuspec +++ b/src/packages/SimpleRESTServices.1.2.0.0/SimpleRESTServices.1.2.0.0.nuspec @@ -2,19 +2,16 @@ SimpleRESTServices - 1.1.3.0 + 1.2.0.0 SimpleRESTServices - Alan Quillin - Alan Quillin + Alan Quillin, Sam Harwell + Alan Quillin, Sam Harwell https://github.com/JSIStudios/SimpleRestServices/wiki/License https://github.com/JSIStudios/SimpleRestServices true A simple set of client side and server side REST helpers - https://github.com/JSIStudios/SimpleRestServices/wiki/v1.1.3.0 + https://github.com/JSIStudios/SimpleRestServices/wiki/v1.2.0.0 Copyright © JSI Studios 2013 REST REST_client - - - \ No newline at end of file diff --git a/src/packages/SimpleRESTServices.1.2.0.0/lib/net35/SimpleRESTServices.dll b/src/packages/SimpleRESTServices.1.2.0.0/lib/net35/SimpleRESTServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..074c6688d3f0f9ab2bff25ab715b9d6ec6875478 GIT binary patch literal 24400 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 literal 0 HcmV?d00001 diff --git a/src/packages/SimpleRESTServices.1.2.0.0/lib/net35/SimpleRESTServices.xml b/src/packages/SimpleRESTServices.1.2.0.0/lib/net35/SimpleRESTServices.xml new file mode 100644 index 000000000..9f1642706 --- /dev/null +++ b/src/packages/SimpleRESTServices.1.2.0.0/lib/net35/SimpleRESTServices.xml @@ -0,0 +1,1965 @@ + + + + SimpleRESTServices + + + + + Represents a single header included with an HTTP response. + + + + + Initializes a new instance of the class using the specified + key and value. + + The HTTP header key. + The HTTP header value. + + If is null. + -or-If is null. + If is empty. + + + + Gets the HTTP header key. + + + + + Gets the HTTP header value. + + + + + Represents the types of HTTP protocol methods that can be used with a REST request. + + + + + Represents an HTTP GET protocol method. + + + + + Represents an HTTP POST protocol method that is used to post a new entity + as an addition to a URI. + + + + + Represents an HTTP PUT protocol method that is used to replace an entity + identified by a URI. + + + + + Represents an HTTP DELETE protocol method. + + + + + Represents an HTTP HEAD protocol method. The method is identical to + except that the server only returns message-headers in the response, + without a message-body. + + + + + Represents an HTTP PATCH protocol method. + + + + + Represents an HTTP OPTIONS protocol method. + + + + + Represents an HTTP TRACE protocol method. + + + + + Represents the HTTP CONNECT protocol method that is used with a proxy that + can dynamically switch to tunneling, as in the case of SSL tunneling. + + + + + Represents an HTTP COPY protocol method. + + + + + Represents an HTTP MOVE protocol method. + + + + + Represents a service for executing generic REST requests. + + + + + Executes a REST request with a string and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + + The body of the request. This parameter is optional. If the value is null, + the request is sent without a body. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not a valid base URI. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a string and basic result (text or no content). + + The base URI. + The HTTP method to use for the request. + + The body of the request. This parameter is optional. If the value is null, + the request is sent without a body. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + If is null. + If is not a valid base URI. + If is not supported by the service. + + + + Executes a REST request with a strongly-typed and basic result (text or no content). + + The base URI. + The HTTP method to use for the request. + + The strongly-typed data to include in the body of the request. If the value is null, + the behavior is implementation-defined. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data included in the body of the REST request. + Returns a object containing the HTTP status code, headers, + and body from the REST response. + If is null. + If is not a valid base URI. + If is not supported by the service. + + + + Executes a REST request with a strongly-typed and result. + + The base URI. + The HTTP method to use for the request. + + The strongly-typed data to include in the body of the request. If the value is null, + the behavior is implementation-defined. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + The type of the data included in the body of the REST request. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not a valid base URI. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a string and user-defined + callback function for constructing the resulting object. + + The base URI. + The HTTP method to use for the request. + A user-specified function used to construct the resulting + object from the and a Boolean value specifying whether or not a + was thrown during the request. If this value is null, this method is equivalent to calling + . + The body of the request. If the value is null, the request is sent without a body. + + A collection of custom HTTP headers to include with the request. If the value is + null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + If the value is null, no parameters are added to the query string. + + + The settings to use for the request. If the value is null, an implementation-specific + set of default settings will be used for the request. + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + If is null. + If is not supported by the service. + + + + Executes a REST request with a string and basic result (text or no content). + + The base URI. + The HTTP method to use for the request. + + The body of the request. This parameter is optional. If the value is null, + the request is sent without a body. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + If is null. + If is not supported by the service. + + + + Executes a REST request with a string and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + + The body of the request. This parameter is optional. If the value is null, + the request is sent without a body. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a strongly-typed and basic result (text or no content). + + The base URI. + The HTTP method to use for the request. + + The strongly-typed data to include in the body of the request. If the value is null, + the behavior is implementation-defined. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data included in the body of the REST request. + Returns a object containing the HTTP status code, headers, + and body from the REST response. + If is null. + If is not supported by the service. + + + + Executes a REST request with a strongly-typed and result. + + The base URI. + The HTTP method to use for the request. + + The strongly-typed data to include in the body of the request. If the value is null, + the behavior is implementation-defined. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + The type of the data included in the body of the REST request. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + A stream providing the body of the request. + + The size of the buffer used for copying data from to the + HTTP request stream. + + + The maximum number of bytes to send with the request. This parameter is optional. + If the value is 0, the request will include all data from . + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + + A user-defined callback function for reporting progress of the send operation. + This parameter is optional. If the value is null, the method does not report + progress updates to the caller. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + + If is null. + -or-If is null. + + If is less than or equal to zero. + -or-If is less than zero. + If is not a valid base URI. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a and basic result (text or no content). + + The base URI. + The HTTP method to use for the request. + A stream providing the body of the request. + + The size of the buffer used for copying data from to the + HTTP request stream. + + + The maximum number of bytes to send with the request. This parameter is optional. + If the value is 0, the request will include all data from . + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + + A user-defined callback function for reporting progress of the send operation. + This parameter is optional. If the value is null, the method does not report + progress updates to the caller. + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + + If is null. + -or-If is null. + + If is less than or equal to zero. + -or-If is less than zero. + If is not a valid base URI. + If is not supported by the service. + + + + Executes a REST request with a and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + A stream providing the body of the request. + + The size of the buffer used for copying data from to the + HTTP request stream. + + + The maximum number of bytes to send with the request. This parameter is optional. + If the value is 0, the request will include all data from . + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + + A user-defined callback function for reporting progress of the send operation. + This parameter is optional. If the value is null, the method does not report + progress updates to the caller. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + + If is null. + -or-If is null. + + If is less than or equal to zero. + -or-If is less than zero. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a and basic result (text or no content). + + The base URI. + The HTTP method to use for the request. + A stream providing the body of the request. + + The size of the buffer used for copying data from to the + HTTP request stream. + + + The maximum number of bytes to send with the request. This parameter is optional. + If the value is 0, the request will include all data from . + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + + A user-defined callback function for reporting progress of the send operation. + This parameter is optional. If the value is null, the method does not report + progress updates to the caller. + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + + If is null. + -or-If is null. + + If is less than or equal to zero. + -or-If is less than zero. + If is not supported by the service. + + + + This interface provides simple support for serializing and deserializing generic objects to and from strings. + + + + + Deserializes an object from a string. + + The serialized representation of the object. + The type of the object to deserialize. + An instance of which describes. + If could not be deserialized to an object of type . + + + + Serializes an object to a string. + + The object to serialize + The type of the object to serialize. + A serialized string representation of . + If could not be serialized to a string. + + + + Provides a simple default implementation of + for HTTP REST requests. + + + + + + + JSIStudios.SimpleRESTServices.Client.RequestRetryLogic + + + + + + + Executes a user-defined operation with the specified "success" values, number of + retry attempts if a failure occurs, and delay time between retry attempts. + + The user-defined operation to execute. + A collection of values which are generally considered failures, but should be treated as success values for this call. + The number of times to retry a failed operation. This parameter is optional. The default value is 1. + The delay between retry operations. This parameter is optional. If the value is null, the default is (no delay). + + + + param + callback + M:JSIStudios.SimpleRESTServices.Client.RequestRetryLogic.Execute(System.Func{JSIStudios.SimpleRESTServices.Client.Response},System.Collections.Generic.IEnumerable{System.Net.HttpStatusCode},System.Int32,System.Nullable{System.TimeSpan}) + + + + + + + param + non200SuccessCodes + M:JSIStudios.SimpleRESTServices.Client.RequestRetryLogic.Execute(System.Func{JSIStudios.SimpleRESTServices.Client.Response},System.Collections.Generic.IEnumerable{System.Net.HttpStatusCode},System.Int32,System.Nullable{System.TimeSpan}) + + + + Returns the result of a successful execution of . If + failed and the maximum number of retries has been reached, + the method returns the last (unsuccessful) result returned by . + If is null. + + If is less than zero. + -or-If is less than . + + + + Executes a user-defined operation with the specified number of retry attempts + if a failure occurs and delay time between retry attempts. + + The user-defined operation to execute. + The number of times to retry a failed operation. This parameter is optional. The default value is 1. + The delay between retry operations. This parameter is optional. If the value is null, the default is (no delay). + + + + param + callback + M:JSIStudios.SimpleRESTServices.Client.RequestRetryLogic.Execute(System.Func{JSIStudios.SimpleRESTServices.Client.Response},System.Int32,System.Nullable{System.TimeSpan}) + + + + Returns the result of a successful execution of . If + failed and the maximum number of retries has been reached, + the method returns the last (unsuccessful) result returned by . + If is null. + + If is less than zero. + -or-If is less than . + + + + Specifies the settings for an HTTP REST request. + + + + + Initializes a new instance of the class with the default values. + + + + + Gets or sets the HTTP Accept header, which specifies the MIME types that are + acceptable for the response. If this value is null, the Accept header + is omitted from the request. + + + + + Gets or sets a value indicating whether or not 0 is a valid value for the Content-Length HTTP header + for this request. + + + + + Gets or sets a value indicating whether to send data in segments to the + Internet resource. + + + + + Gets or sets the maximum number of connections allowed on the object + used for the request. If the value is null, the connection limit value for the + object is not altered. + + + + + Gets or sets the value of the Content-Length HTTP header. + + + + + Gets or sets the value of the Content-Type HTTP header. If this value is + null, the Content-Type header is omitted from the request. + + + + + Gets or sets the credentials to use for this request. This value can be + null if credentials are not specified. + + + + + Gets or sets a user-defined collection to pass as the final argument to the + callback method. + + + + + Gets or sets the set of HTTP status codes greater than or equal to 300 which + should be considered a successful result for this request. A value of + null is allowed, and should be treated as an empty collection. + + + + + Gets or sets a map of user-defined actions to execute in response to specific + HTTP status codes. A value of null is allowed, and should be treated as + an empty collection. + + + + + Gets or sets the number of times this request should be retried if it fails. + + + + + Gets or sets the delay before retrying a failed request. + + + + + Gets or sets the request timeout. + + + + + Gets or sets the value of the User-Agent HTTP header. If this value is null, + the User-Agent header is omitted from the request. + + + + + Represents the basic response of an HTTP REST request, where the body of the response + is stored as a text string. + + + + + Initializes a new instance of the class with the given HTTP status code, + headers, and raw body. + + The HTTP status code. + A collection of all HTTP headers included with this response. + + The raw body of this HTTP response as a text string. When included in the response, this + value should be loaded with the encoding specified in the Content-Encoding and/or + Content-Type HTTP headers. + + + + + Initializes a new instance of the class with the given HTTP status code, + status, headers, and raw body. + + The HTTP status code. + A string representation of the HTTP status code. + A collection of all HTTP headers included with this response. + + The raw body of this HTTP response as a text string. When included in the response, this + value should be loaded with the encoding specified in the Content-Encoding and/or + Content-Type HTTP headers. + + + + + Gets a collection of all HTTP headers included with this response. + + + + + Gets the raw body of this HTTP response as a text string. + + + + + Gets a string representation of the HTTP status code for this response. + + + + + Gets the HTTP status code for this response. + + + + + Extends to include a strongly-typed return value + from the response. + + The type of the data included with the response. + + + + Initializes a new instance of the class by adding a strongly-typed + data value to a base response. + + The base response. + The strongly-typed data representation of the value returned with this response. + + + + Initializes a new instance of the class with the given HTTP status code, + status, strongly-type data, headers, and raw body. + + The HTTP status code. + A string representation of the HTTP status code. + The strongly-typed data representation of the value returned with this response. + A collection of all HTTP headers included with this response. + + The raw body of this HTTP response as a text string. When included in the response, this + value should be loaded with the encoding specified in the Content-Encoding and/or + Content-Type HTTP headers. + + + + + Initializes a new instance of the class with the given HTTP status code, + strongly-type data, headers, and raw body. + + The HTTP status code. + The strongly-typed data representation of the value returned with this response. + A collection of all HTTP headers included with this response. + + The raw body of this HTTP response as a text string. When included in the response, this + value should be loaded with the encoding specified in the Content-Encoding and/or + Content-Type HTTP headers. + + + + + Gets the strongly-typed representation of the value included with this response. + + + + + Implements basic support for in terms of an implementation + of , , + , and . + + + + + Initializes a new instance of the class with the specified string serializer + and the default retry logic and URL builder. + + The string serializer to use for requests from this service. + If is null. + + + + Initializes a new instance of the class with the specified string serializer + and logger, and the default retry logic and URL builder. + + The string serializer to use for requests from this service. + The logger to use for requests. Specify null if requests do not need to be logged. + If is null. + + + + Initializes a new instance of the class with the specified string serializer, + logger, retry logic, and URI builder. + + The string serializer to use for requests from this service. + The logger to use for requests. Specify null if requests do not need to be logged. + The retry logic to use for REST operations. + The URL builder to use for constructing URLs with query parameters. + + If is null. + -or-If is null.-or-If is null. + + + + Gets the default to use for requests sent from this service. + + + + + Executes a REST request with a string and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + + The body of the request. This parameter is optional. If the value is null, + the request is sent without a body. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not a valid base URI. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + + + summary + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + url + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + method + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + body + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + headers + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + queryStringParameters + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + settings + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + returns + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + + + summary + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + url + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + method + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + body + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + headers + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + queryStringParameters + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + settings + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + typeparam + TBody + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + returns + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + Executes a REST request with a strongly-typed and result. + + The base URI. + The HTTP method to use for the request. + + The strongly-typed data to include in the body of the request. If the value is null, + the behavior is implementation-defined. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + The type of the data included in the body of the REST request. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not a valid base URI. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a string and user-defined + callback function for constructing the resulting object. + + The base URI. + The HTTP method to use for the request. + A user-specified function used to construct the resulting + object from the and a Boolean value specifying whether or not a + was thrown during the request. If this value is null, this method is equivalent to calling + . + The body of the request. If the value is null, the request is sent without a body. + + A collection of custom HTTP headers to include with the request. If the value is + null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + If the value is null, no parameters are added to the query string. + + + The settings to use for the request. If the value is null, an implementation-specific + set of default settings will be used for the request. + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + If is null. + If is not supported by the service. + + + + Executes a REST request with a string and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + + The body of the request. This parameter is optional. If the value is null, + the request is sent without a body. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + + + summary + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + url + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + method + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + body + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + headers + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + queryStringParameters + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + settings + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + returns + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + Executes a REST request with a strongly-typed and result. + + The base URI. + The HTTP method to use for the request. + + The strongly-typed data to include in the body of the request. If the value is null, + the behavior is implementation-defined. + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + The type of the data returned in the REST response. + The type of the data included in the body of the REST request. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + If is null. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + + + summary + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + url + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + method + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + body + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + headers + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + queryStringParameters + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + param + settings + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + typeparam + TBody + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + returns + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Execute``1(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,``0,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings) + + + + + + + Executes a REST request indirectly via a callback function , + and using a user-defined callback function for + constructing the resulting object. + + The base URI. + The HTTP method to use for the request. + A user-specified function used to construct the resulting + object from the and a Boolean value specifying whether or not a + was thrown during the request. If this value is null, a default method is used to construct + the resulting object. + + A collection of custom HTTP headers to include with the request. If the value is + null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + If the value is null, no parameters are added to the query string. + + + The settings to use for the request. If the value is null, the default settings returned + by will be used for the request. + + + + + param + executeCallback + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.ExecuteRequest(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.Func{System.Net.HttpWebResponse,System.Boolean,JSIStudios.SimpleRESTServices.Client.Response},System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Func{System.Net.HttpWebRequest,System.String}) + + + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + + If is null. + -or-If is null. + If is not supported by the service. + + + + + + summary + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + url + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + method + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + content + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + bufferSize + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + maxReadLength + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + headers + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + queryStringParameters + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + settings + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + progressUpdated + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + returns + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.String,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + Executes a REST request with a and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + A stream providing the body of the request. + + The size of the buffer used for copying data from to the + HTTP request stream. + + + The maximum number of bytes to send with the request. This parameter is optional. + If the value is 0, the request will include all data from . + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + + A user-defined callback function for reporting progress of the send operation. + This parameter is optional. If the value is null, the method does not report + progress updates to the caller. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + + If is null. + -or-If is null. + + If is less than or equal to zero. + -or-If is less than zero. + If is not a valid base URI. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + Executes a REST request with a + and user-defined callback function for constructing the resulting + object. + + The base URI. + The HTTP method to use for the request. + A user-specified function used to construct the resulting + object from the and a Boolean value specifying whether or not a + was thrown during the request. If this value is null, this method is equivalent to calling + . + A stream providing the body of the request. + + The size of the buffer used for copying data from to the + HTTP request stream. + + + The maximum number of bytes to send with the request. This parameter is optional. + If the value is 0, the request will include all data from . + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + + A user-defined callback function for reporting progress of the send operation. + This parameter is optional. If the value is null, the method does not report + progress updates to the caller. + + Returns a object containing the HTTP status code, headers, + and body from the REST response. + + If is null. + -or-If is null. + + If is less than or equal to zero. + -or-If is less than zero. + If is not supported by the service. + + + + Executes a REST request with a and strongly-typed result. + + The base URI. + The HTTP method to use for the request. + A stream providing the body of the request. + + The size of the buffer used for copying data from to the + HTTP request stream. + + + The maximum number of bytes to send with the request. This parameter is optional. + If the value is 0, the request will include all data from . + + + A collection of custom HTTP headers to include with the request. This parameter is + optional. If the value is null, no custom headers are added to the HTTP request. + + + A collection of parameters to add to the query string portion of the request URI. + This parameter is optional. If the value is null, no parameters are added + to the query string. + + + The settings to use for the request. This parameters is optional. If the value is + null, an implementation-specific set of default settings will be used for the request. + + + A user-defined callback function for reporting progress of the send operation. + This parameter is optional. If the value is null, the method does not report + progress updates to the caller. + + The type of the data returned in the REST response. + Returns a object containing the HTTP status code, headers, body, + and strongly-typed data from the REST response. + + If is null. + -or-If is null. + + If is less than or equal to zero. + -or-If is less than zero. + If is not supported by the service. + + If the body of the response could not be deserialized to an object of type . + + + + + + + summary + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + url + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + method + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + content + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + bufferSize + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + maxReadLength + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + headers + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + queryStringParameters + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + settings + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + param + progressUpdated + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + returns + M:JSIStudios.SimpleRESTServices.Client.RestServiceBase.Stream(System.Uri,JSIStudios.SimpleRESTServices.Client.HttpMethod,System.IO.Stream,System.Int32,System.Int64,System.Collections.Generic.Dictionary{System.String,System.String},System.Collections.Generic.Dictionary{System.String,System.String},JSIStudios.SimpleRESTServices.Client.RequestSettings,System.Action{System.Int64}) + + + + + + + A simple, default implementation of a URI builder. + + + + + + + JSIStudios.SimpleRESTServices.Client.UrlBuilder + + + + + + + Constructs a complete URI for an HTTP request using a base URI and a + collection of query string parameters. + + The base URI. + A collection of parameters to place in the URI query string, + or null if there are no parameters. + A constructed from and the specified + . + If is null. + + + + Constructs a complete URI for an HTTP request using a base URI and a + collection of query string parameters. + + The base URI. + A collection of parameters to place in the URI query string, + or null if there are no parameters. + A constructed from and the specified + . + If is null. + + + + Extends by setting the default + and values to application/json. + + + + + Initializes a new instance of the class with the default value + application/json for and . + + + + + The content type (MIME type) for a JSON request or response. + + + + + An implementation of that uses JSON notation for + the serialized representation of objects. + + + + + Initializes a new instance of the class with the default + JSON string serializer, retry logic, and URL builder. + + + + + Initializes a new instance of the class with the specified + request logger and the default JSON string serializer and URL builder. + + The logger to use for requests. Specify null if requests do not need to be logged. + + + + Initializes a new instance of the class with the specified + logger, retry logic, URI builder, and string serializer. + + The logger to use for requests. Specify null if requests do not need to be logged. + The retry logic to use for REST operations. + The URL builder to use for constructing URLs with query parameters. + The string serializer to use for requests from this service. + + If is null. + -or-If is null.-or-If is null. + + + + Gets the default to use for requests sent from this service. + + + + + Provides a default implementation of using JSON for + the underlying serialized notation. + + + + + + + JSIStudios.SimpleRESTServices.Client.Json.JsonStringSerializer + + + + + + + Deserializes an object from a string. + + The serialized representation of the object. + The type of the object to deserialize. + An instance of which describes. + If could not be deserialized to an object of type . + + + + Serializes an object to a string. + + The object to serialize + The type of the object to serialize. + A serialized string representation of . + If could not be serialized to a string. + + + + The exception thrown when string serialization or deserialization fails. + + + + + Initializes a new instance of the class + with a reference to the inner exception that is the cause of this exception. + + The exception that is the cause of the current exception. + If the parameter is not a null reference, the current + exception is raised in a catch block that handles the inner exception. + + + + Represents custom logging behavior for a REST request. + + + + + Logs a REST request along with its response. + + The used for the request. + The complete URI, including the query string (if any). + The set of custom headers sent with the request. This may be null if no custom headers were specified. + The body of the request. This is null or empty if the request did not include a body. + The response. + The request start time. + The request end time. + The user-defined extended data specified in . + + + + Provides the behavior for executing a callback method with configurable success + values, number of retries, and the retry delay. + + The operation return type + The type of the value used to represent the operation's success or failure + + + + Executes a user-defined operation with the specified "success" values, number of + retry attempts if a failure occurs, and delay time between retry attempts. + + The user-defined operation to execute. + A collection of values which are generally considered failures, but should be treated as success values for this call. + The number of times to retry a failed operation. This parameter is optional. The default value is 1. + The delay between retry operations. This parameter is optional. If the value is null, the default is (no delay). + Returns the result of a successful execution of . If + failed and the maximum number of retries has been reached, + the method returns the last (unsuccessful) result returned by . + If is null. + + If is less than zero. + -or-If is less than . + + + + Executes a user-defined operation with the specified number of retry attempts + if a failure occurs and delay time between retry attempts. + + The user-defined operation to execute. + The number of times to retry a failed operation. This parameter is optional. The default value is 1. + The delay between retry operations. This parameter is optional. If the value is null, the default is (no delay). + Returns the result of a successful execution of . If + failed and the maximum number of retries has been reached, + the method returns the last (unsuccessful) result returned by . + If is null. + + If is less than zero. + -or-If is less than . + + + + Represents a builder which can construct a complete URI for a GET or HEAD request + from a base URI and a collection of query parameters. + + + + + Constructs a complete URI for an HTTP request using a base URI and a + collection of query string parameters. + + The base URI. + A collection of parameters to place in the URI query string, + or null if there are no parameters. + A constructed from and the specified + . + If is null. + + + \ No newline at end of file diff --git a/src/packages/SimpleRESTServices.1.2.0.0/lib/net40/SimpleRESTServices.dll b/src/packages/SimpleRESTServices.1.2.0.0/lib/net40/SimpleRESTServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..0f705afc1038e46f70ff9bd3e5af5568ab7065f6 GIT binary patch literal 39760 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 QJ8v&JKWAp;1$)K+1CnXHL;wH) literal 0 HcmV?d00001 diff --git a/src/packages/SimpleRESTServices.1.1.3.0/lib/net40/SimpleRESTServices.xml b/src/packages/SimpleRESTServices.1.2.0.0/lib/net40/SimpleRESTServices.xml similarity index 99% rename from src/packages/SimpleRESTServices.1.1.3.0/lib/net40/SimpleRESTServices.xml rename to src/packages/SimpleRESTServices.1.2.0.0/lib/net40/SimpleRESTServices.xml index 9f8fea793..a44037ca9 100644 --- a/src/packages/SimpleRESTServices.1.1.3.0/lib/net40/SimpleRESTServices.xml +++ b/src/packages/SimpleRESTServices.1.2.0.0/lib/net40/SimpleRESTServices.xml @@ -130,7 +130,7 @@ If is null. If is not a valid base URI. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -223,7 +223,7 @@ If is null. If is not a valid base URI. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -312,7 +312,7 @@ and strongly-typed data from the REST response. If is null. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -374,7 +374,7 @@ and strongly-typed data from the REST response. If is null. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -422,7 +422,7 @@ -or-If is less than zero. If is not a valid base URI. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -513,7 +513,7 @@ If is less than or equal to zero. -or-If is less than zero. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -925,7 +925,7 @@ If is null. If is not a valid base URI. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -1112,7 +1112,7 @@ If is null. If is not a valid base URI. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -1173,7 +1173,7 @@ and strongly-typed data from the REST response. If is null. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -1278,7 +1278,7 @@ and strongly-typed data from the REST response. If is null. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -1546,7 +1546,7 @@ -or-If is less than zero. If is not a valid base URI. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . @@ -1642,7 +1642,7 @@ If is less than or equal to zero. -or-If is less than zero. If is not supported by the service. - + If the body of the response could not be deserialized to an object of type . diff --git a/src/testing/integration/integration.csproj b/src/testing/integration/integration.csproj index 4b5262f30..e6ff1bf25 100644 --- a/src/testing/integration/integration.csproj +++ b/src/testing/integration/integration.csproj @@ -45,9 +45,9 @@ False ..\..\packages\SSH.NET.2013.4.7\lib\net40\Renci.SshNet.dll - + False - ..\..\packages\SimpleRESTServices.1.1.3.0\lib\net40\SimpleRESTServices.dll + ..\..\packages\SimpleRESTServices.1.2.0.0\lib\net40\SimpleRESTServices.dll diff --git a/src/testing/integration/packages.config b/src/testing/integration/packages.config index a3ad86567..d1de4805a 100644 --- a/src/testing/integration/packages.config +++ b/src/testing/integration/packages.config @@ -2,6 +2,6 @@ - + \ No newline at end of file diff --git a/src/testing/unit/packages.config b/src/testing/unit/packages.config index c32627076..c7acc9b12 100644 --- a/src/testing/unit/packages.config +++ b/src/testing/unit/packages.config @@ -2,5 +2,5 @@ - + \ No newline at end of file diff --git a/src/testing/unit/unit.csproj b/src/testing/unit/unit.csproj index d9243e3d9..9e9209f5e 100644 --- a/src/testing/unit/unit.csproj +++ b/src/testing/unit/unit.csproj @@ -41,9 +41,9 @@ False ..\..\packages\Newtonsoft.Json.5.0.6\lib\net40\Newtonsoft.Json.dll - + False - ..\..\packages\SimpleRESTServices.1.1.3.0\lib\net40\SimpleRESTServices.dll + ..\..\packages\SimpleRESTServices.1.2.0.0\lib\net40\SimpleRESTServices.dll From fa97c9f8eb2a0f5af6aaa128281ea2afe8baf639 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Sun, 22 Sep 2013 09:04:01 -0500 Subject: [PATCH 2/6] Add project for .NET 3.5 output --- src/Documentation/Documentation.shfbproj | 6 +- src/console/console.csproj | 4 +- src/corelib/corelib.v3.5.csproj | 269 ++++++++++++++++++ .../{corelib.csproj => corelib.v4.0.csproj} | 10 +- src/openstack.net.sln | 14 +- src/openstack.net_2012.sln | 14 +- src/testing/integration/integration.csproj | 4 +- src/testing/unit/unit.csproj | 4 +- 8 files changed, 309 insertions(+), 16 deletions(-) create mode 100644 src/corelib/corelib.v3.5.csproj rename src/corelib/{corelib.csproj => corelib.v4.0.csproj} (98%) diff --git a/src/Documentation/Documentation.shfbproj b/src/Documentation/Documentation.shfbproj index 1b29a9b77..8a04b31f6 100644 --- a/src/Documentation/Documentation.shfbproj +++ b/src/Documentation/Documentation.shfbproj @@ -20,7 +20,7 @@ API Reference Documentation en-US - + OnlyWarningsAndErrors HtmlHelp1, MSHelpViewer, Website @@ -94,8 +94,8 @@ - - corelib + + corelib.v4.0 {7dba11eb-dba7-4d3a-8d42-b5312e74b9c0} True diff --git a/src/console/console.csproj b/src/console/console.csproj index e112bacbb..f5e20b38d 100644 --- a/src/console/console.csproj +++ b/src/console/console.csproj @@ -65,9 +65,9 @@ - + {7DBA11EB-DBA7-4D3A-8D42-B5312E74B9C0} - corelib + corelib.v4.0 diff --git a/src/corelib/corelib.v3.5.csproj b/src/corelib/corelib.v3.5.csproj new file mode 100644 index 000000000..3e1295221 --- /dev/null +++ b/src/corelib/corelib.v3.5.csproj @@ -0,0 +1,269 @@ + + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318} + Library + Properties + net.openstack + openstacknet + v4.0 + 512 + obj\v3.5\ + + + true + full + false + bin\v3.5\Debug\ + DEBUG;TRACE + prompt + 4 + bin\v3.5\Debug\openstacknet.xml + + + pdbonly + true + bin\v3.5\Release\ + TRACE + prompt + 4 + bin\v3.5\Release\openstacknet.xml + + + + False + ..\packages\Newtonsoft.Json.5.0.6\lib\net40\Newtonsoft.Json.dll + + + False + ..\packages\SimpleRESTServices.1.2.0.0\lib\net40\SimpleRESTServices.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/corelib/corelib.csproj b/src/corelib/corelib.v4.0.csproj similarity index 98% rename from src/corelib/corelib.csproj rename to src/corelib/corelib.v4.0.csproj index d09aeeb4c..487a78915 100644 --- a/src/corelib/corelib.csproj +++ b/src/corelib/corelib.v4.0.csproj @@ -12,26 +12,26 @@ openstacknet v4.0 512 - - + obj\v4.0\ true full false - bin\Debug\ + bin\v4.0\Debug\ DEBUG;TRACE prompt 4 - bin\Debug\openstacknet.XML + bin\v4.0\Debug\openstacknet.xml pdbonly true - bin\Release\ + bin\v4.0\Release\ TRACE prompt 4 + bin\v4.0\Release\openstacknet.xml diff --git a/src/openstack.net.sln b/src/openstack.net.sln index 0cb6e64a7..9a39ace12 100644 --- a/src/openstack.net.sln +++ b/src/openstack.net.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 11.00 # Visual Studio 2010 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib", "corelib\corelib.csproj", "{7DBA11EB-DBA7-4D3A-8D42-B5312E74B9C0}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib.v4.0", "corelib\corelib.v4.0.csproj", "{7DBA11EB-DBA7-4D3A-8D42-B5312E74B9C0}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "integration", "testing\integration\integration.csproj", "{C1D0D0D8-9EF2-4557-B85F-34FDB0F466C4}" EndProject @@ -19,6 +19,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "console", "console\console. EndProject Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation", "Documentation\Documentation.shfbproj", "{EA57BD15-3742-45B8-BDE2-263F7236BAFD}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib.v3.5", "corelib\corelib.v3.5.csproj", "{E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}" +EndProject Global GlobalSection(TestCaseManagementSettings) = postSolution CategoryFile = openstack.net.vsmdi @@ -80,6 +82,16 @@ Global {EA57BD15-3742-45B8-BDE2-263F7236BAFD}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {EA57BD15-3742-45B8-BDE2-263F7236BAFD}.Release|Mixed Platforms.Build.0 = Release|Any CPU {EA57BD15-3742-45B8-BDE2-263F7236BAFD}.Release|x86.ActiveCfg = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|x86.ActiveCfg = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Any CPU.Build.0 = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/openstack.net_2012.sln b/src/openstack.net_2012.sln index 9d47a60ef..81da882b2 100644 --- a/src/openstack.net_2012.sln +++ b/src/openstack.net_2012.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 2012 -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib", "corelib\corelib.csproj", "{7DBA11EB-DBA7-4D3A-8D42-B5312E74B9C0}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib.v4.0", "corelib\corelib.v4.0.csproj", "{7DBA11EB-DBA7-4D3A-8D42-B5312E74B9C0}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "integration", "testing\integration\integration.csproj", "{C1D0D0D8-9EF2-4557-B85F-34FDB0F466C4}" EndProject @@ -19,6 +19,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "console", "console\console. EndProject Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation", "Documentation\Documentation.shfbproj", "{EA57BD15-3742-45B8-BDE2-263F7236BAFD}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib.v3.5", "corelib\corelib.v3.5.csproj", "{E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}" +EndProject Global GlobalSection(TestCaseManagementSettings) = postSolution CategoryFile = openstack.net.vsmdi @@ -80,6 +82,16 @@ Global {EA57BD15-3742-45B8-BDE2-263F7236BAFD}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {EA57BD15-3742-45B8-BDE2-263F7236BAFD}.Release|Mixed Platforms.Build.0 = Release|Any CPU {EA57BD15-3742-45B8-BDE2-263F7236BAFD}.Release|x86.ActiveCfg = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Debug|x86.ActiveCfg = Debug|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Any CPU.Build.0 = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/testing/integration/integration.csproj b/src/testing/integration/integration.csproj index e6ff1bf25..e78e88af8 100644 --- a/src/testing/integration/integration.csproj +++ b/src/testing/integration/integration.csproj @@ -78,9 +78,9 @@ - + {7DBA11EB-DBA7-4D3A-8D42-B5312E74B9C0} - corelib + corelib.v4.0 diff --git a/src/testing/unit/unit.csproj b/src/testing/unit/unit.csproj index 9e9209f5e..e9e517034 100644 --- a/src/testing/unit/unit.csproj +++ b/src/testing/unit/unit.csproj @@ -71,9 +71,9 @@ - + {7DBA11EB-DBA7-4D3A-8D42-B5312E74B9C0} - corelib + corelib.v4.0 From ce898840c313d7c86a9a8f41fe3d36a1cc41d83c Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 24 Sep 2013 11:54:47 -0500 Subject: [PATCH 3/6] Added documentation projects for the .NET 3.5 build --- src/Documentation/Documentation.v3.5.shfbproj | 116 ++++++++++++++++++ ...n.shfbproj => Documentation.v4.0.shfbproj} | 6 +- src/openstack.net.sln | 12 +- src/openstack.net_2012.sln | 12 +- 4 files changed, 141 insertions(+), 5 deletions(-) create mode 100644 src/Documentation/Documentation.v3.5.shfbproj rename src/Documentation/{Documentation.shfbproj => Documentation.v4.0.shfbproj} (97%) diff --git a/src/Documentation/Documentation.v3.5.shfbproj b/src/Documentation/Documentation.v3.5.shfbproj new file mode 100644 index 000000000..30a9e13b5 --- /dev/null +++ b/src/Documentation/Documentation.v3.5.shfbproj @@ -0,0 +1,116 @@ + + + + + Debug + AnyCPU + 2.0 + {60b1668c-4331-4e3d-86f6-954ffce0cd36} + 1.9.5.0 + + Documentation + Documentation + Documentation.v3.5 + + .NET Framework 4.0 + ..\..\docs\html\v3.5 + API Reference Documentation + en-US + + + + OnlyWarningsAndErrors + HtmlHelp1, MSHelpViewer, Website + True + True + False + False + True + CSharp, VisualBasic, CPlusPlus, FSharp + Blank + True + VS2010 + True + MemberName + openstack.net API Reference Documentation + AboveNamespaces + API Reference + Msdn + Msdn + True + True + Attributes, ExplicitInterfaceImplementations, InheritedMembers, InheritedFrameworkMembers, Protected, ProtectedInternalAsProtected, SealedProtected + openstack.net%40lists.rackspace.com + + + + + + + + + + + + + + + + + + + + VisualStudio11 + -1 + 100 + 100 + -1 + openstack.net SDK + openstacknet + Id + 100 + VS + + + + + + + + + + + + + + + + + + + + + corelib.v3.5 + {e49d9dc3-79d5-4c5e-8c38-fd5060b4e318} + True + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/Documentation/Documentation.shfbproj b/src/Documentation/Documentation.v4.0.shfbproj similarity index 97% rename from src/Documentation/Documentation.shfbproj rename to src/Documentation/Documentation.v4.0.shfbproj index 8a04b31f6..a3d891a85 100644 --- a/src/Documentation/Documentation.shfbproj +++ b/src/Documentation/Documentation.v4.0.shfbproj @@ -13,10 +13,10 @@ Studio adds them anyway --> Documentation Documentation - Documentation + Documentation.v4.0 .NET Framework 4.0 - ..\..\docs\html\ + ..\..\docs\html\v4.0 API Reference Documentation en-US @@ -59,7 +59,7 @@ - + diff --git a/src/openstack.net.sln b/src/openstack.net.sln index 9a39ace12..4039d6fe9 100644 --- a/src/openstack.net.sln +++ b/src/openstack.net.sln @@ -17,10 +17,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "unit", "testing\unit\unit.c EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "console", "console\console.csproj", "{1C279666-B88A-4765-8A51-B352C85EFC28}" EndProject -Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation", "Documentation\Documentation.shfbproj", "{EA57BD15-3742-45B8-BDE2-263F7236BAFD}" +Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation.v4.0", "Documentation\Documentation.v4.0.shfbproj", "{EA57BD15-3742-45B8-BDE2-263F7236BAFD}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib.v3.5", "corelib\corelib.v3.5.csproj", "{E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}" EndProject +Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation.v3.5", "Documentation\Documentation.v3.5.shfbproj", "{60B1668C-4331-4E3D-86F6-954FFCE0CD36}" +EndProject Global GlobalSection(TestCaseManagementSettings) = postSolution CategoryFile = openstack.net.vsmdi @@ -92,6 +94,14 @@ Global {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.Build.0 = Release|Any CPU {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|x86.ActiveCfg = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Debug|x86.ActiveCfg = Debug|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Any CPU.ActiveCfg = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Any CPU.Build.0 = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/openstack.net_2012.sln b/src/openstack.net_2012.sln index 81da882b2..cdf30e808 100644 --- a/src/openstack.net_2012.sln +++ b/src/openstack.net_2012.sln @@ -17,10 +17,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "unit", "testing\unit\unit.c EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "console", "console\console.csproj", "{1C279666-B88A-4765-8A51-B352C85EFC28}" EndProject -Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation", "Documentation\Documentation.shfbproj", "{EA57BD15-3742-45B8-BDE2-263F7236BAFD}" +Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation.v4.0", "Documentation\Documentation.v4.0.shfbproj", "{EA57BD15-3742-45B8-BDE2-263F7236BAFD}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corelib.v3.5", "corelib\corelib.v3.5.csproj", "{E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}" EndProject +Project("{7CF6DF6D-3B04-46F8-A40B-537D21BCA0B4}") = "Documentation.v3.5", "Documentation\Documentation.v3.5.shfbproj", "{60B1668C-4331-4E3D-86F6-954FFCE0CD36}" +EndProject Global GlobalSection(TestCaseManagementSettings) = postSolution CategoryFile = openstack.net.vsmdi @@ -92,6 +94,14 @@ Global {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|Mixed Platforms.Build.0 = Release|Any CPU {E49D9DC3-79D5-4C5E-8C38-FD5060B4E318}.Release|x86.ActiveCfg = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Debug|x86.ActiveCfg = Debug|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Any CPU.ActiveCfg = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Any CPU.Build.0 = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {60B1668C-4331-4E3D-86F6-954FFCE0CD36}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE From 2dc5ddd55cca359adc29025a7c0a61fe736f2851 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 24 Sep 2013 12:06:28 -0500 Subject: [PATCH 4/6] Updated NuGet package specification to include .NET 3.5 output --- src/corelib/corelib.nuspec | 18 +++++++++++++++--- src/corelib/corelib.v3.5.csproj | 1 + src/corelib/corelib.v4.0.csproj | 1 + 3 files changed, 17 insertions(+), 3 deletions(-) diff --git a/src/corelib/corelib.nuspec b/src/corelib/corelib.nuspec index a84a49aa2..b4ba9cd3b 100644 --- a/src/corelib/corelib.nuspec +++ b/src/corelib/corelib.nuspec @@ -2,9 +2,9 @@ openstack.net - $version$ + 0.0.0 openstack.net - alanquillin, kravi, ejwebb, jasonmitschke, bretmc + alanquillin, kravi, ejwebb, jasonmitschke, bretmc, sharwell alanquillin https://github.com/openstacknetsdk/openstack.net/wiki/Copyright https://github.com/openstacknetsdk/openstack.net @@ -15,6 +15,18 @@ openstack - + + + + + + + + + + + + + diff --git a/src/corelib/corelib.v3.5.csproj b/src/corelib/corelib.v3.5.csproj index 3e1295221..d402d6e37 100644 --- a/src/corelib/corelib.v3.5.csproj +++ b/src/corelib/corelib.v3.5.csproj @@ -253,6 +253,7 @@ + diff --git a/src/corelib/corelib.v4.0.csproj b/src/corelib/corelib.v4.0.csproj index 487a78915..4437073ef 100644 --- a/src/corelib/corelib.v4.0.csproj +++ b/src/corelib/corelib.v4.0.csproj @@ -253,6 +253,7 @@ + From de8931283f70c59cfa7e17b684ba9798c41bd6e3 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 24 Sep 2013 12:28:48 -0500 Subject: [PATCH 5/6] Proper support for .NET 3.5 --- src/Documentation/Documentation.v3.5.shfbproj | 2 +- src/corelib/Core/Compat/Funcs.cs | 53 + .../Core/Compat/ISafeSerializationData.cs | 17 + .../Core/Compat/IStructuralComparable.cs | 72 + .../Core/Compat/IStructuralEquatable.cs | 57 + src/corelib/Core/Compat/Tuple.cs | 222 + src/corelib/Core/Compat/Tuples.cs | 1280 + .../ImageEnteredErrorStateException.cs | 2 + .../Exceptions/Response/ResponseException.cs | 2 + .../ServerEnteredErrorStateException.cs | 2 + .../SnapshotEnteredErrorStateException.cs | 2 + .../VolumeEnteredErrorStateException.cs | 2 + .../Providers/Rackspace/CloudFilesProvider.cs | 4 +- .../Rackspace/CloudIdentityProvider.cs | 2 +- .../Exceptions/BulkDeletionException.cs | 2 + .../Exceptions/InvalidVolumeSizeException.cs | 2 + src/corelib/corelib.v3.5.csproj | 20 +- src/corelib/packages.config | 1 + .../TaskParallelLibrary.1.0.2856.0.nuspec | 24 + .../lib/Net35/System.Threading.dll | Bin 0 -> 387408 bytes .../lib/Net35/System.Threading.xml | 19811 ++++++++++++++++ .../lib/Net35/redist.txt | 11 + 22 files changed, 21581 insertions(+), 9 deletions(-) create mode 100644 src/corelib/Core/Compat/Funcs.cs create mode 100644 src/corelib/Core/Compat/ISafeSerializationData.cs create mode 100644 src/corelib/Core/Compat/IStructuralComparable.cs create mode 100644 src/corelib/Core/Compat/IStructuralEquatable.cs create mode 100644 src/corelib/Core/Compat/Tuple.cs create mode 100644 src/corelib/Core/Compat/Tuples.cs create mode 100644 src/packages/TaskParallelLibrary.1.0.2856.0/TaskParallelLibrary.1.0.2856.0.nuspec create mode 100644 src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/System.Threading.dll create mode 100644 src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/System.Threading.xml create mode 100644 src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/redist.txt diff --git a/src/Documentation/Documentation.v3.5.shfbproj b/src/Documentation/Documentation.v3.5.shfbproj index 30a9e13b5..cabc9d5e6 100644 --- a/src/Documentation/Documentation.v3.5.shfbproj +++ b/src/Documentation/Documentation.v3.5.shfbproj @@ -15,7 +15,7 @@ Documentation Documentation.v3.5 - .NET Framework 4.0 + .NET Framework 3.5 ..\..\docs\html\v3.5 API Reference Documentation en-US diff --git a/src/corelib/Core/Compat/Funcs.cs b/src/corelib/Core/Compat/Funcs.cs new file mode 100644 index 000000000..6d38079e5 --- /dev/null +++ b/src/corelib/Core/Compat/Funcs.cs @@ -0,0 +1,53 @@ +// +// System.Func.cs +// +// Authors: +// Alejandro Serrano "Serras" (trupill@yahoo.es) +// Marek Safar (marek.safar@gmail.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 TArg 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 +// + +using System.Runtime.CompilerServices; + +namespace net.openstack.Core { + +#if NET35 + /// + /// Encapsulates a method that has six parameters and returns a value of the type specified by the parameter. + /// + /// The type of the first parameter of the method that this delegate encapsulates. + /// The type of the second parameter of the method that this delegate encapsulates. + /// The type of the third parameter of the method that this delegate encapsulates. + /// The type of the fourth parameter of the method that this delegate encapsulates. + /// The type of the fifth parameter of the method that this delegate encapsulates. + /// The type of the sixth parameter of the method that this delegate encapsulates. + /// The type of the return value of the method that this delegate encapsulates. + /// The first parameter of the method that this delegate encapsulates. + /// The second parameter of the method that this delegate encapsulates. + /// The third parameter of the method that this delegate encapsulates. + /// The fourth parameter of the method that this delegate encapsulates. + /// The fifth parameter of the method that this delegate encapsulates. + /// The sixth parameter of the method that this delegate encapsulates. + /// The return value of the method that this delegate encapsulates. + public delegate TResult Func(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); +#endif + +} diff --git a/src/corelib/Core/Compat/ISafeSerializationData.cs b/src/corelib/Core/Compat/ISafeSerializationData.cs new file mode 100644 index 000000000..45e8c601d --- /dev/null +++ b/src/corelib/Core/Compat/ISafeSerializationData.cs @@ -0,0 +1,17 @@ +#if NET35 + +namespace System.Runtime.Serialization +{ + /// + /// For internal compatibility use only. + /// + internal interface ISafeSerializationData + { + /// + /// For internal compatibility use only. + /// + void CompleteDeserialization(object deserialized); + } +} + +#endif diff --git a/src/corelib/Core/Compat/IStructuralComparable.cs b/src/corelib/Core/Compat/IStructuralComparable.cs new file mode 100644 index 000000000..2101ecf41 --- /dev/null +++ b/src/corelib/Core/Compat/IStructuralComparable.cs @@ -0,0 +1,72 @@ +// +// IStructuralComparable.cs +// +// Authors: +// Zoltan Varga (vargaz@gmail.com) +// +// Copyright (C) 2009 Novell +// +// 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. +// + +#if NET35 + +using System; +using System.Collections; + +namespace net.openstack.Core +{ + /// + /// Supports the structural comparison of collection objects. + /// + public interface IStructuralComparable { + /// + /// Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order. + /// + /// The object to compare with the current instance. + /// An object that compares members of the current collection object with the corresponding members of . + /// + /// An integer that indicates the relationship of the current collection object to other, as shown in the following table. + /// + /// + /// + /// Return value + /// Description + /// + /// + /// -1 + /// The current instance precedes . + /// + /// + /// 0 + /// The current instance and are equal. + /// + /// + /// 1 + /// The current instance follows . + /// + /// + /// + /// This instance and are not the same type. + int CompareTo (object other, IComparer comparer); + } +} + +#endif diff --git a/src/corelib/Core/Compat/IStructuralEquatable.cs b/src/corelib/Core/Compat/IStructuralEquatable.cs new file mode 100644 index 000000000..b92ae4496 --- /dev/null +++ b/src/corelib/Core/Compat/IStructuralEquatable.cs @@ -0,0 +1,57 @@ +// +// IStructuralEquatable.cs +// +// Authors: +// Zoltan Varga (vargaz@gmail.com) +// +// Copyright (C) 2009 Novell +// +// 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. +// + +#if NET35 + +using System; +using System.Collections; + +namespace net.openstack.Core +{ + /// + /// Defines methods to support the comparison of objects for structural equality. + /// + public interface IStructuralEquatable { + /// + /// Determines whether an object is structurally equal to the current instance. + /// + /// The object to compare with the current instance. + /// An object that determines whether the current instance and are equal. + /// true if the two objects are equal; otherwise, false. + bool Equals (object other, IEqualityComparer comparer); + + /// + /// Returns a hash code for the current instance. + /// + /// An object that computes the hash code of the current object. + /// The hash code for the current instance. + int GetHashCode (IEqualityComparer comparer); + } +} + +#endif diff --git a/src/corelib/Core/Compat/Tuple.cs b/src/corelib/Core/Compat/Tuple.cs new file mode 100644 index 000000000..913cb5fe9 --- /dev/null +++ b/src/corelib/Core/Compat/Tuple.cs @@ -0,0 +1,222 @@ +// +// Tuple.cs +// +// Authors: +// Zoltan Varga (vargaz@gmail.com) +// +// Copyright (C) 2009 Novell +// +// 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. +// + +#if NET35 + +using System; + +namespace net.openstack.Core +{ + /// + /// Provides static methods for creating tuple objects. + /// + public static class Tuple + { + /// + /// Creates a new 8-tuple, or octuple. + /// + /// The type of the first component of the tuple. + /// The type of the second component of the tuple. + /// The type of the third component of the tuple. + /// The type of the fourth component of the tuple. + /// The type of the fifth component of the tuple. + /// The type of the sixth component of the tuple. + /// The type of the seventh component of the tuple. + /// The type of the eighth component of the tuple. + /// The value of the first component of the tuple. + /// The value of the second component of the tuple. + /// The value of the third component of the tuple. + /// The value of the fourth component of the tuple. + /// The value of the fifth component of the tuple. + /// The value of the sixth component of the tuple. + /// The value of the seventh component of the tuple. + /// The value of the eighth component of the tuple. + /// An 8-tuple (octuple) whose value is (, , , , , , , ). + public static Tuple> Create + ( + T1 item1, + T2 item2, + T3 item3, + T4 item4, + T5 item5, + T6 item6, + T7 item7, + T8 item8) { + return new Tuple> (item1, item2, item3, item4, item5, item6, item7, new Tuple (item8)); + } + + /// + /// Creates a new 7-tuple, or septuple. + /// + /// The type of the first component of the tuple. + /// The type of the second component of the tuple. + /// The type of the third component of the tuple. + /// The type of the fourth component of the tuple. + /// The type of the fifth component of the tuple. + /// The type of the sixth component of the tuple. + /// The type of the seventh component of the tuple. + /// The value of the first component of the tuple. + /// The value of the second component of the tuple. + /// The value of the third component of the tuple. + /// The value of the fourth component of the tuple. + /// The value of the fifth component of the tuple. + /// The value of the sixth component of the tuple. + /// The value of the seventh component of the tuple. + /// A 7-tuple (septuple) whose value is (, , , , , , ). + public static Tuple Create + ( + T1 item1, + T2 item2, + T3 item3, + T4 item4, + T5 item5, + T6 item6, + T7 item7) { + return new Tuple (item1, item2, item3, item4, item5, item6, item7); + } + + /// + /// Creates a new 6-tuple, or sextuple. + /// + /// The type of the first component of the tuple. + /// The type of the second component of the tuple. + /// The type of the third component of the tuple. + /// The type of the fourth component of the tuple. + /// The type of the fifth component of the tuple. + /// The type of the sixth component of the tuple. + /// The value of the first component of the tuple. + /// The value of the second component of the tuple. + /// The value of the third component of the tuple. + /// The value of the fourth component of the tuple. + /// The value of the fifth component of the tuple. + /// The value of the sixth component of the tuple. + /// A 6-tuple (sextuple) whose value is (, , , , , ). + public static Tuple Create + ( + T1 item1, + T2 item2, + T3 item3, + T4 item4, + T5 item5, + T6 item6) { + return new Tuple (item1, item2, item3, item4, item5, item6); + } + + /// + /// Creates a new 5-tuple, or quintuple. + /// + /// The type of the first component of the tuple. + /// The type of the second component of the tuple. + /// The type of the third component of the tuple. + /// The type of the fourth component of the tuple. + /// The type of the fifth component of the tuple. + /// The value of the first component of the tuple. + /// The value of the second component of the tuple. + /// The value of the third component of the tuple. + /// The value of the fourth component of the tuple. + /// The value of the fifth component of the tuple. + /// A 5-tuple (quintuple) whose value is (, , , , ). + public static Tuple Create + ( + T1 item1, + T2 item2, + T3 item3, + T4 item4, + T5 item5) { + return new Tuple (item1, item2, item3, item4, item5); + } + + /// + /// Creates a new 4-tuple, or quadruple. + /// + /// The type of the first component of the tuple. + /// The type of the second component of the tuple. + /// The type of the third component of the tuple. + /// The type of the fourth component of the tuple. + /// The value of the first component of the tuple. + /// The value of the second component of the tuple. + /// The value of the third component of the tuple. + /// The value of the fourth component of the tuple. + /// A 4-tuple (quadruple) whose value is (, , , ). + public static Tuple Create + ( + T1 item1, + T2 item2, + T3 item3, + T4 item4) { + return new Tuple (item1, item2, item3, item4); + } + + /// + /// Creates a new 3-tuple, or triple. + /// + /// The type of the first component of the tuple. + /// The type of the second component of the tuple. + /// The type of the third component of the tuple. + /// The value of the first component of the tuple. + /// The value of the second component of the tuple. + /// The value of the third component of the tuple. + /// A 3-tuple (triple) whose value is (, , ). + public static Tuple Create + ( + T1 item1, + T2 item2, + T3 item3) { + return new Tuple (item1, item2, item3); + } + + /// + /// Creates a new 2-tuple, or pair. + /// + /// The type of the first component of the tuple. + /// The type of the second component of the tuple. + /// The value of the first component of the tuple. + /// The value of the second component of the tuple. + /// A 2-tuple (pair) whose value is (, ). + public static Tuple Create + ( + T1 item1, + T2 item2) { + return new Tuple (item1, item2); + } + + /// + /// Creates a new 1-tuple, or singleton. + /// + /// The type of the only component of the tuple. + /// The value of the only component of the tuple. + /// A 1-tuple (singleton) whose value is (). + public static Tuple Create + ( + T1 item1) { + return new Tuple (item1); + } + } +} + +#endif diff --git a/src/corelib/Core/Compat/Tuples.cs b/src/corelib/Core/Compat/Tuples.cs new file mode 100644 index 000000000..dc0592876 --- /dev/null +++ b/src/corelib/Core/Compat/Tuples.cs @@ -0,0 +1,1280 @@ +// +// Tuples.cs +// +// Authors: +// Zoltan Varga (vargaz@gmail.com) +// Marek Safar (marek.safar@gmail.com) +// +// Copyright (C) 2009 Novell +// +// 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. +// + +#if NET35 + +using System; +using System.Collections; +using System.Collections.Generic; + +namespace net.openstack.Core +{ + public partial class Tuple + { + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's first component. + /// The value of the tuple's second component. + /// The value of the tuple's third component. + /// The value of the tuple's fourth component. + /// The value of the tuple's fifth component. + /// The value of the tuple's sixth component. + /// The value of the tuple's seventh component. + /// Any generic Tuple object that contains the values of the tuple's remaining components. + /// is not a generic Tuple object. + public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest) + { + this.item1 = item1; + this.item2 = item2; + this.item3 = item3; + this.item4 = item4; + this.item5 = item5; + this.item6 = item6; + this.item7 = item7; + this.rest = rest; + + bool ok = true; + if (!typeof (TRest).IsGenericType) + ok = false; + if (ok) { + Type t = typeof (TRest).GetGenericTypeDefinition (); + if (!(t == typeof (Tuple<>) || t == typeof (Tuple<,>) || t == typeof (Tuple<,,>) || t == typeof (Tuple<,,,>) || t == typeof (Tuple<,,,,>) || t == typeof (Tuple <,,,,,>) || t == typeof (Tuple<,,,,,,>) || t == typeof (Tuple<,,,,,,,>))) + ok = false; + } + if (!ok) + throw new ArgumentException ("rest", "The last element of an eight element tuple must be a Tuple."); + } + } + + /* The rest is generated by the script at the bottom */ + + /// + /// Represents a 1-tuple, or singleton. + /// + /// The type of the tuple's only component. + [Serializable] + public class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's only component. + public Tuple (T1 item1) + { + this.item1 = item1; + } + + /// + /// Gets the value of the current object's only component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + return comparer.Compare (item1, t.item1); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + return comparer.GetHashCode (item1); + } + + /// + public override string ToString () + { + return String.Format ("({0})", item1); + } + } + + /// + /// Represents a 2-tuple, or pair. + /// + /// The type of the tuple's first component. + /// The type of the tuple's second component. + [Serializable] + public class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + T2 item2; + + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's first component. + /// The value of the tuple's second component. + public Tuple (T1 item1, T2 item2) + { + this.item1 = item1; + this.item2 = item2; + } + + /// + /// Gets the value of the current object's first component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + /// Gets the value of the current object's second component. + /// + public T2 Item2 { + get { return item2; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + int res = comparer.Compare (item1, t.item1); + if (res != 0) return res; + return comparer.Compare (item2, t.item2); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1) && + comparer.Equals (item2, t.item2); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + int h = comparer.GetHashCode (item1); + h = (h << 5) - h + comparer.GetHashCode (item2); + return h; + } + + /// + public override string ToString () + { + return String.Format ("({0}, {1})", item1, item2); + } + } + + /// + /// Represents a 3-tuple, or triple. + /// + /// The type of the tuple's first component. + /// The type of the tuple's second component. + /// The type of the tuple's third component. + [Serializable] + public class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + T2 item2; + T3 item3; + + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's first component. + /// The value of the tuple's second component. + /// The value of the tuple's third component. + public Tuple (T1 item1, T2 item2, T3 item3) + { + this.item1 = item1; + this.item2 = item2; + this.item3 = item3; + } + + /// + /// Gets the value of the current object's first component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + /// Gets the value of the current object's second component. + /// + public T2 Item2 { + get { return item2; } + } + + /// + /// Gets the value of the current object's third component. + /// + public T3 Item3 { + get { return item3; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + int res = comparer.Compare (item1, t.item1); + if (res != 0) return res; + res = comparer.Compare (item2, t.item2); + if (res != 0) return res; + return comparer.Compare (item3, t.item3); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1) && + comparer.Equals (item2, t.item2) && + comparer.Equals (item3, t.item3); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + int h = comparer.GetHashCode (item1); + h = (h << 5) - h + comparer.GetHashCode (item2); + h = (h << 5) - h + comparer.GetHashCode (item3); + return h; + } + + /// + public override string ToString () + { + return String.Format ("({0}, {1}, {2})", item1, item2, item3); + } + } + + /// + /// Represents a 4-tuple, or quadruple. + /// + /// The type of the tuple's first component. + /// The type of the tuple's second component. + /// The type of the tuple's third component. + /// The type of the tuple's fourth component. + [Serializable] + public class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + T2 item2; + T3 item3; + T4 item4; + + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's first component. + /// The value of the tuple's second component. + /// The value of the tuple's third component. + /// The value of the tuple's fourth component. + public Tuple (T1 item1, T2 item2, T3 item3, T4 item4) + { + this.item1 = item1; + this.item2 = item2; + this.item3 = item3; + this.item4 = item4; + } + + /// + /// Gets the value of the current object's first component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + /// Gets the value of the current object's second component. + /// + public T2 Item2 { + get { return item2; } + } + + /// + /// Gets the value of the current object's third component. + /// + public T3 Item3 { + get { return item3; } + } + + /// + /// Gets the value of the current object's fourth component. + /// + public T4 Item4 { + get { return item4; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + int res = comparer.Compare (item1, t.item1); + if (res != 0) return res; + res = comparer.Compare (item2, t.item2); + if (res != 0) return res; + res = comparer.Compare (item3, t.item3); + if (res != 0) return res; + return comparer.Compare (item4, t.item4); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1) && + comparer.Equals (item2, t.item2) && + comparer.Equals (item3, t.item3) && + comparer.Equals (item4, t.item4); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + int h = comparer.GetHashCode (item1); + h = (h << 5) - h + comparer.GetHashCode (item2); + h = (h << 5) - h + comparer.GetHashCode (item3); + h = (h << 5) - h + comparer.GetHashCode (item4); + return h; + } + + /// + public override string ToString () + { + return String.Format ("({0}, {1}, {2}, {3})", item1, item2, item3, item4); + } + } + + /// + /// Represents a 5-tuple, or quintuple. + /// + /// The type of the tuple's first component. + /// The type of the tuple's second component. + /// The type of the tuple's third component. + /// The type of the tuple's fourth component. + /// The type of the tuple's fifth component. + [Serializable] + public class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + T2 item2; + T3 item3; + T4 item4; + T5 item5; + + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's first component. + /// The value of the tuple's second component. + /// The value of the tuple's third component. + /// The value of the tuple's fourth component. + /// The value of the tuple's fifth component. + public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5) + { + this.item1 = item1; + this.item2 = item2; + this.item3 = item3; + this.item4 = item4; + this.item5 = item5; + } + + /// + /// Gets the value of the current object's first component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + /// Gets the value of the current object's second component. + /// + public T2 Item2 { + get { return item2; } + } + + /// + /// Gets the value of the current object's third component. + /// + public T3 Item3 { + get { return item3; } + } + + /// + /// Gets the value of the current object's fourth component. + /// + public T4 Item4 { + get { return item4; } + } + + /// + /// Gets the value of the current object's fifth component. + /// + public T5 Item5 { + get { return item5; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + int res = comparer.Compare (item1, t.item1); + if (res != 0) return res; + res = comparer.Compare (item2, t.item2); + if (res != 0) return res; + res = comparer.Compare (item3, t.item3); + if (res != 0) return res; + res = comparer.Compare (item4, t.item4); + if (res != 0) return res; + return comparer.Compare (item5, t.item5); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1) && + comparer.Equals (item2, t.item2) && + comparer.Equals (item3, t.item3) && + comparer.Equals (item4, t.item4) && + comparer.Equals (item5, t.item5); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + int h = comparer.GetHashCode (item1); + h = (h << 5) - h + comparer.GetHashCode (item2); + h = (h << 5) - h + comparer.GetHashCode (item3); + h = (h << 5) - h + comparer.GetHashCode (item4); + h = (h << 5) - h + comparer.GetHashCode (item5); + return h; + } + + /// + public override string ToString () + { + return String.Format ("({0}, {1}, {2}, {3}, {4})", item1, item2, item3, item4, item5); + } + } + + /// + /// Represents a 6-tuple, or sextuple. + /// + /// The type of the tuple's first component. + /// The type of the tuple's second component. + /// The type of the tuple's third component. + /// The type of the tuple's fourth component. + /// The type of the tuple's fifth component. + /// The type of the tuple's sixth component. + [Serializable] + public class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + T2 item2; + T3 item3; + T4 item4; + T5 item5; + T6 item6; + + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's first component. + /// The value of the tuple's second component. + /// The value of the tuple's third component. + /// The value of the tuple's fourth component. + /// The value of the tuple's fifth component. + /// The value of the tuple's sixth component. + public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6) + { + this.item1 = item1; + this.item2 = item2; + this.item3 = item3; + this.item4 = item4; + this.item5 = item5; + this.item6 = item6; + } + + /// + /// Gets the value of the current object's first component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + /// Gets the value of the current object's second component. + /// + public T2 Item2 { + get { return item2; } + } + + /// + /// Gets the value of the current object's third component. + /// + public T3 Item3 { + get { return item3; } + } + + /// + /// Gets the value of the current object's fourth component. + /// + public T4 Item4 { + get { return item4; } + } + + /// + /// Gets the value of the current object's fifth component. + /// + public T5 Item5 { + get { return item5; } + } + + /// + /// Gets the value of the current object's sixth component. + /// + public T6 Item6 { + get { return item6; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + int res = comparer.Compare (item1, t.item1); + if (res != 0) return res; + res = comparer.Compare (item2, t.item2); + if (res != 0) return res; + res = comparer.Compare (item3, t.item3); + if (res != 0) return res; + res = comparer.Compare (item4, t.item4); + if (res != 0) return res; + res = comparer.Compare (item5, t.item5); + if (res != 0) return res; + return comparer.Compare (item6, t.item6); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1) && + comparer.Equals (item2, t.item2) && + comparer.Equals (item3, t.item3) && + comparer.Equals (item4, t.item4) && + comparer.Equals (item5, t.item5) && + comparer.Equals (item6, t.item6); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + int h = comparer.GetHashCode (item1); + h = (h << 5) - h + comparer.GetHashCode (item2); + h = (h << 5) - h + comparer.GetHashCode (item3); + h = (h << 5) - h + comparer.GetHashCode (item4); + h = (h << 5) - h + comparer.GetHashCode (item5); + h = (h << 5) - h + comparer.GetHashCode (item6); + return h; + } + + /// + public override string ToString () + { + return String.Format ("({0}, {1}, {2}, {3}, {4}, {5})", item1, item2, item3, item4, item5, item6); + } + } + + /// + /// Represents a 7-tuple, or septuple. + /// + /// The type of the tuple's first component. + /// The type of the tuple's second component. + /// The type of the tuple's third component. + /// The type of the tuple's fourth component. + /// The type of the tuple's fifth component. + /// The type of the tuple's sixth component. + /// The type of the tuple's seventh component. + [Serializable] + public class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + T2 item2; + T3 item3; + T4 item4; + T5 item5; + T6 item6; + T7 item7; + + /// + /// Initializes a new instance of the class. + /// + /// The value of the tuple's first component. + /// The value of the tuple's second component. + /// The value of the tuple's third component. + /// The value of the tuple's fourth component. + /// The value of the tuple's fifth component. + /// The value of the tuple's sixth component. + /// The value of the tuple's seventh component. + public Tuple (T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7) + { + this.item1 = item1; + this.item2 = item2; + this.item3 = item3; + this.item4 = item4; + this.item5 = item5; + this.item6 = item6; + this.item7 = item7; + } + + /// + /// Gets the value of the current object's first component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + /// Gets the value of the current object's second component. + /// + public T2 Item2 { + get { return item2; } + } + + /// + /// Gets the value of the current object's third component. + /// + public T3 Item3 { + get { return item3; } + } + + /// + /// Gets the value of the current object's fourth component. + /// + public T4 Item4 { + get { return item4; } + } + + /// + /// Gets the value of the current object's fifth component. + /// + public T5 Item5 { + get { return item5; } + } + + /// + /// Gets the value of the current object's sixth component. + /// + public T6 Item6 { + get { return item6; } + } + + /// + /// Gets the value of the current object's seventh component. + /// + public T7 Item7 { + get { return item7; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + int res = comparer.Compare (item1, t.item1); + if (res != 0) return res; + res = comparer.Compare (item2, t.item2); + if (res != 0) return res; + res = comparer.Compare (item3, t.item3); + if (res != 0) return res; + res = comparer.Compare (item4, t.item4); + if (res != 0) return res; + res = comparer.Compare (item5, t.item5); + if (res != 0) return res; + res = comparer.Compare (item6, t.item6); + if (res != 0) return res; + return comparer.Compare (item7, t.item7); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1) && + comparer.Equals (item2, t.item2) && + comparer.Equals (item3, t.item3) && + comparer.Equals (item4, t.item4) && + comparer.Equals (item5, t.item5) && + comparer.Equals (item6, t.item6) && + comparer.Equals (item7, t.item7); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + int h = comparer.GetHashCode (item1); + h = (h << 5) - h + comparer.GetHashCode (item2); + h = (h << 5) - h + comparer.GetHashCode (item3); + h = (h << 5) - h + comparer.GetHashCode (item4); + h = (h << 5) - h + comparer.GetHashCode (item5); + h = (h << 5) - h + comparer.GetHashCode (item6); + h = (h << 5) - h + comparer.GetHashCode (item7); + return h; + } + + /// + public override string ToString () + { + return String.Format ("({0}, {1}, {2}, {3}, {4}, {5}, {6})", item1, item2, item3, item4, item5, item6, item7); + } + } + + /// + /// Represents an n-tuple, where n is 8 or greater. + /// + /// The type of the tuple's first component. + /// The type of the tuple's second component. + /// The type of the tuple's third component. + /// The type of the tuple's fourth component. + /// The type of the tuple's fifth component. + /// The type of the tuple's sixth component. + /// The type of the tuple's seventh component. + /// Any generic Tuple object that defines the types of the tuple's remaining components. + [Serializable] + public partial class Tuple : IStructuralEquatable, IStructuralComparable, IComparable + { + T1 item1; + T2 item2; + T3 item3; + T4 item4; + T5 item5; + T6 item6; + T7 item7; + TRest rest; + + /// + /// Gets the value of the current object's first component. + /// + public T1 Item1 { + get { return item1; } + } + + /// + /// Gets the value of the current object's second component. + /// + public T2 Item2 { + get { return item2; } + } + + /// + /// Gets the value of the current object's third component. + /// + public T3 Item3 { + get { return item3; } + } + + /// + /// Gets the value of the current object's fourth component. + /// + public T4 Item4 { + get { return item4; } + } + + /// + /// Gets the value of the current object's fifth component. + /// + public T5 Item5 { + get { return item5; } + } + + /// + /// Gets the value of the current object's sixth component. + /// + public T6 Item6 { + get { return item6; } + } + + /// + /// Gets the value of the current object's seventh component. + /// + public T7 Item7 { + get { return item7; } + } + + /// + /// Gets the current object's remaining components. + /// + public TRest Rest { + get { return rest; } + } + + /// + int IComparable.CompareTo (object obj) + { + return ((IStructuralComparable) this).CompareTo (obj, Comparer.Default); + } + + /// + int IStructuralComparable.CompareTo (object other, IComparer comparer) + { + var t = other as Tuple; + if (t == null) { + if (other == null) return 1; + throw new ArgumentException ("other"); + } + + int res = comparer.Compare (item1, t.item1); + if (res != 0) return res; + res = comparer.Compare (item2, t.item2); + if (res != 0) return res; + res = comparer.Compare (item3, t.item3); + if (res != 0) return res; + res = comparer.Compare (item4, t.item4); + if (res != 0) return res; + res = comparer.Compare (item5, t.item5); + if (res != 0) return res; + res = comparer.Compare (item6, t.item6); + if (res != 0) return res; + res = comparer.Compare (item7, t.item7); + if (res != 0) return res; + return comparer.Compare (rest, t.rest); + } + + /// + public override bool Equals (object obj) + { + return ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default); + } + + /// + bool IStructuralEquatable.Equals (object other, IEqualityComparer comparer) + { + var t = other as Tuple; + if (t == null) + return false; + + return comparer.Equals (item1, t.item1) && + comparer.Equals (item2, t.item2) && + comparer.Equals (item3, t.item3) && + comparer.Equals (item4, t.item4) && + comparer.Equals (item5, t.item5) && + comparer.Equals (item6, t.item6) && + comparer.Equals (item7, t.item7) && + comparer.Equals (rest, t.rest); + } + + /// + public override int GetHashCode () + { + return ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default); + } + + /// + int IStructuralEquatable.GetHashCode (IEqualityComparer comparer) + { + int h = comparer.GetHashCode (item1); + h = (h << 5) - h + comparer.GetHashCode (item2); + h = (h << 5) - h + comparer.GetHashCode (item3); + h = (h << 5) - h + comparer.GetHashCode (item4); + h = (h << 5) - h + comparer.GetHashCode (item5); + h = (h << 5) - h + comparer.GetHashCode (item6); + h = (h << 5) - h + comparer.GetHashCode (item7); + h = (h << 5) - h + comparer.GetHashCode (rest); + return h; + } + + /// + public override string ToString () + { + return String.Format ("({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", item1, item2, item3, item4, item5, item6, item7, rest); + } + } + +} + +#endif + +#if FALSE + +// +// generator script +// + +using System; +using System.Text; + +public class TupleGen +{ + public static void Main () { + for (int arity = 1; arity < 9; ++arity) { + string type_name = GetTypeName (arity); + + Console.WriteLine ("\t[Serializable]"); + Console.Write ("\tpublic {0}class ", arity < 8 ? null : "partial "); + Console.Write (type_name); + Console.WriteLine (" : IStructuralEquatable, IStructuralComparable, IComparable"); + Console.WriteLine ("\t{"); + for (int i = 1; i <= arity; ++i) + Console.WriteLine ("\t\t{0} {1};", GetItemTypeName (i), GetItemName (i)); + + if (arity < 8) { + Console.WriteLine (); + Console.Write ("\t\tpublic Tuple ("); + for (int i = 1; i <= arity; ++i) { + Console.Write ("{0} {1}", GetItemTypeName (i), GetItemName (i)); + if (i < arity) + Console.Write (", "); + } + Console.WriteLine (")"); + Console.WriteLine ("\t\t{"); + for (int i = 1; i <= arity; ++i) + Console.WriteLine ("\t\t\t this.{0} = {0};", GetItemName (i)); + Console.WriteLine ("\t\t}"); + } + + for (int i = 1; i <= arity; ++i) { + Console.WriteLine (); + Console.WriteLine ("\t\tpublic {0} {1} {{", GetItemTypeName (i), + System.Globalization.CultureInfo.InvariantCulture.TextInfo.ToTitleCase (GetItemName (i))); + Console.Write ("\t\t\tget { "); + Console.WriteLine ("return {0}; }}", GetItemName (i)); + Console.WriteLine ("\t\t}"); + } + + Console.WriteLine (); + Console.WriteLine ("\t\tint IComparable.CompareTo (object obj)"); + Console.WriteLine ("\t\t{"); + Console.WriteLine ("\t\t\treturn ((IStructuralComparable) this).CompareTo (obj, Comparer.Default);"); + Console.WriteLine ("\t\t}"); + + Console.WriteLine (); + Console.WriteLine ("\t\tint IStructuralComparable.CompareTo (object other, IComparer comparer)"); + Console.WriteLine ("\t\t{"); + Console.WriteLine ("\t\t\tvar t = other as {0};", type_name); + Console.WriteLine ("\t\t\tif (t == null) {"); + Console.WriteLine ("\t\t\t\tif (other == null) return 1;"); + Console.WriteLine ("\t\t\t\tthrow new ArgumentException ("other");"); + Console.WriteLine ("\t\t\t}"); + Console.WriteLine (); + + for (int i = 1; i < arity; ++i) { + Console.Write ("\t\t\t"); + if (i == 1) + Console.Write ("int "); + + Console.WriteLine ("res = comparer.Compare ({0}, t.{0});", GetItemName (i)); + Console.WriteLine ("\t\t\tif (res != 0) return res;"); + } + Console.WriteLine ("\t\t\treturn comparer.Compare ({0}, t.{0});", GetItemName (arity)); + Console.WriteLine ("\t\t}"); + + Console.WriteLine (); + Console.WriteLine ("\t\tpublic override bool Equals (object obj)"); + Console.WriteLine ("\t\t{"); + Console.WriteLine ("\t\t\treturn ((IStructuralEquatable) this).Equals (obj, EqualityComparer.Default);"); + Console.WriteLine ("\t\t}"); + + Console.WriteLine (); + Console.WriteLine ("\t\tbool IStructuralEquatable.Equals (object other, IEqualityComparer comparer)"); + Console.WriteLine ("\t\t{"); + Console.WriteLine ("\t\t\tvar t = other as {0};", type_name); + Console.WriteLine ("\t\t\tif (t == null)"); + Console.WriteLine ("\t\t\t\treturn false;"); + Console.WriteLine (); + Console.Write ("\t\t\treturn"); + + for (int i = 1; i <= arity; ++i) { + if (i == 1) + Console.Write (" "); + else + Console.Write ("\t\t\t\t"); + + Console.Write ("comparer.Equals ({0}, t.{0})", GetItemName (i)); + if (i != arity) + Console.WriteLine (" &&"); + else + Console.WriteLine (";"); + } + Console.WriteLine ("\t\t}"); + + Console.WriteLine (); + Console.WriteLine ("\t\tpublic override int GetHashCode ()"); + Console.WriteLine ("\t\t{"); + Console.WriteLine ("\t\t\treturn ((IStructuralEquatable) this).GetHashCode (EqualityComparer.Default);"); + Console.WriteLine ("\t\t}"); + + Console.WriteLine (); + Console.WriteLine ("\t\tint IStructuralEquatable.GetHashCode (IEqualityComparer comparer)"); + Console.WriteLine ("\t\t{"); + if (arity == 1) { + Console.WriteLine ("\t\t\treturn comparer.GetHashCode ({0});", GetItemName (arity)); + } else { + Console.WriteLine ("\t\t\tint h = comparer.GetHashCode ({0});", GetItemName (1)); + for (int i = 2; i <= arity; ++i) + Console.WriteLine ("\t\t\th = (h << 5) - h + comparer.GetHashCode ({0});", GetItemName (i)); + Console.WriteLine ("\t\t\treturn h;"); + } + + Console.WriteLine ("\t\t}"); + + Console.WriteLine (); + Console.WriteLine ("\t\tpublic override string ToString ()"); + Console.WriteLine ("\t\t{"); + Console.Write ("\t\t\treturn String.Format (\"("); + for (int i = 1; i <= arity; ++i) { + Console.Write ("{" + (i - 1) + "}"); + if (i < arity) + Console.Write (", "); + } + Console.Write (")\", "); + for (int i = 1; i <= arity; ++i) { + Console.Write (GetItemName (i)); + if (i < arity) + Console.Write (", "); + } + Console.WriteLine (");"); + Console.WriteLine ("\t\t}"); + + Console.WriteLine ("\t}\n"); + } + } + + static string GetTypeName (int arity) + { + StringBuilder sb = new StringBuilder (); + sb.Append ("Tuple<"); + for (int i = 1; i <= arity; ++i) { + sb.Append (GetItemTypeName (i)); + if (i < arity) + sb.Append (", "); + } + sb.Append (">"); + + return sb.ToString (); + } + + static string GetItemName (int arity) + { + return arity < 8 ? "item" + arity.ToString () : "rest"; + } + + static string GetItemTypeName (int arity) + { + return arity < 8 ? "T" + arity.ToString () : "TRest"; + } +} + +#endif diff --git a/src/corelib/Core/Exceptions/ImageEnteredErrorStateException.cs b/src/corelib/Core/Exceptions/ImageEnteredErrorStateException.cs index 21df5bfd2..6f9f32d50 100644 --- a/src/corelib/Core/Exceptions/ImageEnteredErrorStateException.cs +++ b/src/corelib/Core/Exceptions/ImageEnteredErrorStateException.cs @@ -40,7 +40,9 @@ public ImageEnteredErrorStateException(ImageState status) throw new ArgumentNullException("status"); _state.Status = status.Name; +#if !NET35 SerializeObjectState += (ex, args) => args.AddSerializedState(_state); +#endif } [Serializable] diff --git a/src/corelib/Core/Exceptions/Response/ResponseException.cs b/src/corelib/Core/Exceptions/Response/ResponseException.cs index 05b55d9c1..79f977fe7 100644 --- a/src/corelib/Core/Exceptions/Response/ResponseException.cs +++ b/src/corelib/Core/Exceptions/Response/ResponseException.cs @@ -40,7 +40,9 @@ public ResponseException(string message, RestResponse response) : base(message) { _state.Response = response; +#if !NET35 SerializeObjectState += (ex, args) => args.AddSerializedState(_state); +#endif } /// diff --git a/src/corelib/Core/Exceptions/ServerEnteredErrorStateException.cs b/src/corelib/Core/Exceptions/ServerEnteredErrorStateException.cs index e10e10501..c72fc1114 100644 --- a/src/corelib/Core/Exceptions/ServerEnteredErrorStateException.cs +++ b/src/corelib/Core/Exceptions/ServerEnteredErrorStateException.cs @@ -40,7 +40,9 @@ public ServerEnteredErrorStateException(ServerState status) throw new ArgumentNullException("status"); _state.Status = status.Name; +#if !NET35 SerializeObjectState += (ex, args) => args.AddSerializedState(_state); +#endif } [Serializable] diff --git a/src/corelib/Core/Exceptions/SnapshotEnteredErrorStateException.cs b/src/corelib/Core/Exceptions/SnapshotEnteredErrorStateException.cs index 202497c3d..49111fa9d 100644 --- a/src/corelib/Core/Exceptions/SnapshotEnteredErrorStateException.cs +++ b/src/corelib/Core/Exceptions/SnapshotEnteredErrorStateException.cs @@ -40,7 +40,9 @@ public SnapshotEnteredErrorStateException(SnapshotState status) throw new ArgumentNullException("status"); _state.Status = status.Name; +#if !NET35 SerializeObjectState += (ex, args) => args.AddSerializedState(_state); +#endif } [Serializable] diff --git a/src/corelib/Core/Exceptions/VolumeEnteredErrorStateException.cs b/src/corelib/Core/Exceptions/VolumeEnteredErrorStateException.cs index 8a5cda454..0c40cec8b 100644 --- a/src/corelib/Core/Exceptions/VolumeEnteredErrorStateException.cs +++ b/src/corelib/Core/Exceptions/VolumeEnteredErrorStateException.cs @@ -40,7 +40,9 @@ public VolumeEnteredErrorStateException(VolumeState status) throw new ArgumentNullException("status"); _state.Status = status.Name; +#if !NET35 SerializeObjectState += (ex, args) => args.AddSerializedState(_state); +#endif } [Serializable] diff --git a/src/corelib/Providers/Rackspace/CloudFilesProvider.cs b/src/corelib/Providers/Rackspace/CloudFilesProvider.cs index ffe407746..710ce333b 100644 --- a/src/corelib/Providers/Rackspace/CloudFilesProvider.cs +++ b/src/corelib/Providers/Rackspace/CloudFilesProvider.cs @@ -1247,7 +1247,7 @@ public void BulkDelete(IEnumerable> items, Dictiona return string.Format("/{0}/{1}", _encodeDecodeProvider.UrlEncode(pair.Key), _encodeDecodeProvider.UrlEncode(pair.Value)); }); - var body = string.Join("\n", encoded); + var body = string.Join("\n", encoded.ToArray()); var response = ExecuteRESTRequest(identity, urlPath, HttpMethod.DELETE, body: body, headers: headers, settings: new JsonRequestSettings { ContentType = "text/plain" }); @@ -1287,7 +1287,7 @@ public void PurgeObjectFromCDN(string container, string objectName, IEnumerable< _cloudFilesValidator.ValidateObjectName(objectName); VerifyContainerIsCDNEnabled(container, region, identity); - string email = emails != null ? string.Join(",", emails) : null; + string email = emails != null ? string.Join(",", emails.ToArray()) : null; var headers = new Dictionary(StringComparer.OrdinalIgnoreCase); if (!string.IsNullOrEmpty(email)) { diff --git a/src/corelib/Providers/Rackspace/CloudIdentityProvider.cs b/src/corelib/Providers/Rackspace/CloudIdentityProvider.cs index 034027bc8..a94898635 100644 --- a/src/corelib/Providers/Rackspace/CloudIdentityProvider.cs +++ b/src/corelib/Providers/Rackspace/CloudIdentityProvider.cs @@ -364,7 +364,7 @@ public IEnumerable ListUserCredentials(string userId, CloudIdent var urlPath = string.Format("v2.0/users/{0}/OS-KSADM/credentials", userId); var response = ExecuteRESTRequest(identity, new Uri(_urlBase, urlPath), HttpMethod.GET); - if (response == null || string.IsNullOrWhiteSpace(response.RawBody)) + if (response == null || string.IsNullOrEmpty(response.RawBody)) return null; var jObject = JObject.Parse(response.RawBody); diff --git a/src/corelib/Providers/Rackspace/Exceptions/BulkDeletionException.cs b/src/corelib/Providers/Rackspace/Exceptions/BulkDeletionException.cs index 0c8ce0cb9..52692ce3f 100644 --- a/src/corelib/Providers/Rackspace/Exceptions/BulkDeletionException.cs +++ b/src/corelib/Providers/Rackspace/Exceptions/BulkDeletionException.cs @@ -51,7 +51,9 @@ public BulkDeletionException(string status, BulkDeletionResults results) throw new ArgumentException("status cannot be empty"); _state.Results = results; +#if !NET35 SerializeObjectState += (ex, args) => args.AddSerializedState(_state); +#endif } [Serializable] diff --git a/src/corelib/Providers/Rackspace/Exceptions/InvalidVolumeSizeException.cs b/src/corelib/Providers/Rackspace/Exceptions/InvalidVolumeSizeException.cs index a4429d5e7..c92e632a3 100644 --- a/src/corelib/Providers/Rackspace/Exceptions/InvalidVolumeSizeException.cs +++ b/src/corelib/Providers/Rackspace/Exceptions/InvalidVolumeSizeException.cs @@ -35,7 +35,9 @@ public InvalidVolumeSizeException(int size) : base(string.Format("The volume size value must be between 100 and 1000. The size requested was: {0}", size)) { _state.Size = size; +#if !NET35 SerializeObjectState += (ex, args) => args.AddSerializedState(_state); +#endif } [Serializable] diff --git a/src/corelib/corelib.v3.5.csproj b/src/corelib/corelib.v3.5.csproj index d402d6e37..61a1d9ca3 100644 --- a/src/corelib/corelib.v3.5.csproj +++ b/src/corelib/corelib.v3.5.csproj @@ -10,16 +10,17 @@ Properties net.openstack openstacknet - v4.0 + v3.5 512 obj\v3.5\ + true full false bin\v3.5\Debug\ - DEBUG;TRACE + DEBUG;TRACE;NET35 prompt 4 bin\v3.5\Debug\openstacknet.xml @@ -28,7 +29,7 @@ pdbonly true bin\v3.5\Release\ - TRACE + TRACE;NET35 prompt 4 bin\v3.5\Release\openstacknet.xml @@ -36,20 +37,29 @@ False - ..\packages\Newtonsoft.Json.5.0.6\lib\net40\Newtonsoft.Json.dll + ..\packages\Newtonsoft.Json.5.0.6\lib\net35\Newtonsoft.Json.dll False - ..\packages\SimpleRESTServices.1.2.0.0\lib\net40\SimpleRESTServices.dll + ..\packages\SimpleRESTServices.1.2.0.0\lib\net35\SimpleRESTServices.dll + + ..\packages\TaskParallelLibrary.1.0.2856.0\lib\Net35\System.Threading.dll + + + + + + + diff --git a/src/corelib/packages.config b/src/corelib/packages.config index a1bad3480..c91666b9c 100644 --- a/src/corelib/packages.config +++ b/src/corelib/packages.config @@ -2,4 +2,5 @@ + \ No newline at end of file diff --git a/src/packages/TaskParallelLibrary.1.0.2856.0/TaskParallelLibrary.1.0.2856.0.nuspec b/src/packages/TaskParallelLibrary.1.0.2856.0/TaskParallelLibrary.1.0.2856.0.nuspec new file mode 100644 index 000000000..9cfb2ace4 --- /dev/null +++ b/src/packages/TaskParallelLibrary.1.0.2856.0/TaskParallelLibrary.1.0.2856.0.nuspec @@ -0,0 +1,24 @@ + + + + TaskParallelLibrary + 1.0.2856.0 + Task Parallel Library for .NET 3.5 + Microsoft Corporation + Microsoft Corporation + http://go.microsoft.com/fwlink/?LinkID=186234 + http://msdn.microsoft.com/en-us/library/dd460717.aspx + http://i.msdn.microsoft.com/ee402630.NET_lg.png + true + The package includes: +* Task<T> for executing asynchronous operations. +* Concurrent Collections such as ConcurrentStack, ConcurentQueue ad ConcurrentDictionary. +* PLINQ for writing parallel queries. +* additional Threading operations such as Barrier,SpinLock and SpinWait. + A complete and official Microsoft backport of the Task Parallel Library (TPL) for .NET 3.5. + This backport was shipped with the Reactive Extensions (Rx) library up until v1.0.2856.0. It can be downloaded from http://www.microsoft.com/download/en/details.aspx?id=24940 . + + + tpl plinq pfx task parallel extensions .net35 backport + + \ No newline at end of file diff --git a/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/System.Threading.dll b/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/System.Threading.dll new file mode 100644 index 0000000000000000000000000000000000000000..0230d71d42a504487751bf617fcc122817b0b0de GIT binary patch literal 387408 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

1AadFG61|4_*Zh$_QIia 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�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

4ylqx z!CM?^$K;P`SqT<0m;rjF-aE9kSIAOCI3c$Inc##R$cJDkc6~k!Lku;vN7BmnNV@9g zd`RZSi6{Tod{~AgF?SrAH&upa$TE`MQW>5pfugIX0eRIlu(_==REsbj**hx3HRUMc zyaE1qIvQuHW5VQ4ugtMmI^=v%cwT5^K9nIm)$+WW&D}+2ksDsEmnTYz(z^21T}y@2D5D$&?*I4VPM`sNrAV zp#`wW7OUq2UqIpd;f>Z-kZ6W zmQ25LQ{pG-DQf#8(`!T7Er|sx2@(verZM;vOShK`gI^2(M&4?UQRft-I z<7nTr3QhBz1^mtQxgxp$X7_r{Ot8Rl^>?EJW;CC$iN_6Y9+>+!7-DovKV9Y|G&2t8os4xH{g{TpH+Az0b!{|V?vt4O9Ry5Cr^yZc ze7))B6yufx29kHa(8M6h15mgeUVeLXuH9{F0v^B}C~0-3zZoXDcdrc>#Q>~BB)TEW z-(pS&J5&OKT0#`x5ZNM(L&X8QV>HHF?EG?W2R|4U8wNMJ2emf5$w?_qq)1i}poVE2 z3ogHXz0)*hu;$PJB6hi&MGYv%&o=Da79{vOFN27QR*e-ZIyV8AGt zBRNl$6X3O5^FkCU5YS5xe=INCF&*%?@2I;~kb4=6>JNP=l^>M!Rq_Dp<2$-smyf{i zOBIqEMz~8&mj|tTjeLN-dq=m6_7RBFS?P}8QkB+5L3g`?UPE3$%k#s7)dSbOreZN2 z>BFD`zi$&ujKpdbW2{r`@)b|8laAh>4u3K1pLDc2lJ;AUX2)M%#5{)k+JEXk?oB zQ*u*aOm&N5%B)Gu^<~af9?e@z?5apjQA>R3IUTvJ=GY2!N1R!H;JC$yREnxAbq!f; ziWYHeDS{Qs}%Q$zEZcmBrU(96ILi$yp3$N>89y*z z+y`1Yw7iCbRj3O7UO%szk9X-+z5l=Z`Ny!W1uP8je$38)`kn57`W@DrK}d$sO0T?V zzHUpPiJ6O6pFbSG-CEPvo--DZS-buxKrVmL9qHQ1#BKvQY&r0uXrmTcL_FRaO-QCEnQ#ooS2jfS$$iO|(tb*^wM#zC6e4pq;?ky4 zj>bUNT__;%Te5X2Mm4ez{d&jhWAawW8ejTetRqjX_iKa4AmCyi0plOe*dn}vLjBgn z*V|$)U02T25Y$*>AOhZE^_Nj=OQs2_Q6N48UdFUbm%3pOZC3D>$d6^2-H&Cj+RL{r z@w;*dFvH#wdv_12y*ev{K%J5yt8=v_Z=#DrY{(OXR-?MsUQ~nl#CO)}p?#XROhY-1 zEEP9&wIijze$&cLx(A`f{7C1*;u*iuaH4y{;&r;iKMF9)Nsp7nDc(<<`3XM7m(OX9 za)!!J^eLy{dr94BuAHNpZqD)3OJ}m}oQl!;wXg72JwcM69NNQ)BYmpJPlE|-eX2*d zxar(X6{1e1R8RCR0Ka^Cbvq|b%BQ9LM5))c9jH1tI%@Y7JRfS)O-7@%LicBR?lajv z#HhV$nK06`(<#Pn_W7VzIQiqZr0EQu=%v#+ey5pWs8;U}-Ta~xb2((4yw#^)6z6B} z+k46(d{ioL*JeX;;^P?Y8V+pPDMo0Wb)Xnw8D(#*Jjy>-S@d$Rm+{RImgD++J;rK5g!-0BtBM_yO?FI%`c-S*Ld5Y%#-erwJ0#8@ zG1I8u+$rUcnJzR)lBK8$3eZ$&q;^ZEBr7#iyS={)t3t)fRRV=^Rk!6pA4ZyA$b@E8*ashn%^$ziZv9Sqx(rpDq!16>|e4 zY%q!~ixm`$Y((i{huR3xhOPMS7-V&&vsEyq$M=}dR#Pv6eawbpontdz(;I1?y&2Lx zWLttr<7^gSdqbLsl-5fcN3}@n3uzuwS|2kUjsYrhU}DH?3}Gb`*WQN4EmC$u$jYe? zjfE^q`73Q|#{89ds#qnhCK#{89d-VwGG? z@i_J)7X%3cCUIP7=}0Y+GbS}ak(Wssgi)@SBR2u18S-%0a0~Ah>^ON z*TGBQqK-l~6?CLJ)veMx8xE{Ev$;#WE%bekd6In7JoVfa{%)zLxaqf@St$>E89 zfp{46o1nFk?w3%oUYFUOC>e#DxHi}3oFSsa} z>e~q*n)Y3iUw%8M`Cl>30NkXigiUTkO3ilS_9 zi@&*>g~O9NslB3O{G0>C*OdZt+Niw^mWJ-NGZy!1Ybj%fbAvkHhzII^O2`AD;!J8d zEnw{zInUy-@FWsKK|8v2xl!Xxr-*AuJ1MAh3059VF6hjm_IS~f5W;nE={0j>U3yLD zxdvD4%$&|;yvzAk&J3}U?9yv7fk_^_+Lqq6cIherPHtJLJwU$EmT2vU08XLO>6+(V z`j#E+Sh+}sTl?)ofN%0jMJf(kdA_vaMyIqEJcq z5{t&l;x`mrC#+x{>s^lHSbu#7Fn$ckGkH-C;f$iw{epz>uWKd(^C2i5A zDuoHbh7ki!nrH;)LGi4z*>HKOcUvK+F|4I&MA zN6m(cGl-GH2{=^W6eu`UH_}C#u&tTPGAXu&EV> zx7t_!j<{i~eJ^jGz`;rlc>k4btuwIcp)j@y)XgDnC1e_{?51gshM7exyX&mNmm>tj zy4<7%0X!tQ8!oBx6^8X$dBpLD+)svsRRxn=uoTJ-#AWL?g>ANaoGA zkjvkfSUJ+h@K7BuKZaE-r{rL$#2}NvIXAe{hh4a454P$}Q-h0~Rnoir zqV;ASAYzJ9JX-A_+Gs=v*AS7a?{T925o5gf)gheW4P8^ajb$%o_Yv$bHlq@ejdg4_ z#Y(9P^%Do>d9j;b$iv1c0L1=Nav`zYkv={I*dW+F9t7CnDHIe>(HN_KHJY08>iU?E z=a4B@9xxy3QtpB@!U|$rrl96@pvg$FtW%4bC_4fuxr;AvW2c0|>AIbPOIOTDG9tyC zbon53pkssJCKuGNMw!I8EJNtt$Oy&!6#z&G;Rx(40P^$O;hv799`18WlMl2vh|tU~C0saKIN3e!?N0O*>?% zd5jJ#ac9`z_|3Kl2TGwr6ODv9?*Xw0j!mEH zqQf|wWRH1U>iuL4sP)mdJ`iIEmAB0h<5I8ysL#=|S;^sgpNMRoZtsFe?**j#nmXyA z_VzWfeH>h01&|+>10g^eK1Qj&h)yr)^j-y>-V!>!1$1~9IuV859EIM9LMWV2P!W|e z6nfiH4*4T)jWUfmz!+%MC?SOrmuSR$nMTb-qehM(aGc))poE}`t9-mxB4Xj&06=pA?8pewz!;!STWmMC+QQHH+5~^|hBvgA>Z)zxCY)i2pp>;l z$?~~A+t>)|WGGsjIj~n1-*B)tlsVe(Rzjn_!t4!3o`9 z;7O)IgCFDV2ZC4v*&*xV)@abuKQ^;9!0vody6r7PZ@0}9!%cULdX=={&x_64E`A4$ zY$I4Z(hDY1a(0GPIK9i9RuMqw+ z(97ewp%1rU0GM7l$Y3;~O3KT!94S&JM&^WZw})syq;2|DI@2XI(T~Ok8o_>Eyn(|C z(mG;-;1z1$z6jYim1G{PS>D!MteW#L*sa1<&}eQxOBkxjur8UwL$%v;p;`stBm+#a zYQQz=i-foM!TG?Ec8n(HbPxX^u9-b|UM?8%Yw=5kf-wFupc7#W8bi=&F$49!9n zW+Tl{EOpfAFh8ncM}-Kc6+mDVTgg?#~U-`k9+aS}`Z|`5txIjPQCO zwncV;8z=$J%kJk=k*0?CLO?^TJ+?@^B)*j5N)0Z)s~r zZ-R4kwJ~`TcPpAp?9#A2bX{_yAqQ-hEx;WxpvCPNs9RRW05KKj%atBUZ~`SNO&UT~ zY)$iU>zCSQQvlUiyJc}N%L+EP!(R^XLCr7> z-mW5Rat`ssiI6Q7qNEDVqjs zs#;W*++i&?afC~?AoA1;5hL0hG1?=M1wJlfs<9e8)&bV~npI#e_3$UE;=!XM?xhe^ ztalR5CMM91K>{T0$Z%#2&0A{rf(ZnR)inRo@uBVwPjgXTIvf(Wlqi+TKns*V zF5ECT)5bIHoRPiLHof#%QgMQvm#RFL5X#+v6E6HgA+r2&i$C zp$3rLzFE*3dWA?SLl9Zf0~5`XG?Ky0Z>80XlZ9(_{k~U4sXR-9)+sqZ(@Nc6;Ulg= z%atY9YnPV5q7#QJzMaEkth@OOq*I3(i`VOSMekHeoyOFnVl9lwq#-pTyB}uFbbY2f z0%g8|@1@tUKL_o6?Y7ZoYL8Zc>-y8i`NFCyXD2?WZ_74liI}$AK=6#^d|NG}I>zpi zwlzR2;_JB~`sR!yzX^~q^<*j$b~3ivEs^KZPBdQ~)}>P)bWGFcMbd`YNs(Zy9C5}c z5-?&UHNC*TzTzxKdSI0dikFkARM2-d`*sxlLf2{(t=MdvP&^m>V(8Gej3$nge3K=^ zj!H1b&vS4nh8)`CW8`KbPEt(kard#W&EibHssu^&2yZ^f9U5C`fT@i%;I_N1jP0Yl zdLg!Au!Q9QHe`~I3do~Ig^UlbOx)Vg((=Hi_idbNVj$a>qb@vcY04ZOexGw=Ba6l; zOX(zYPRfX3#Y#ig-Zc2_P2ycQf}4p&ZW*9{b9$JiAj5T4H0|@~c&l~HrPXPM61lYK zrt6wbPh#T-b1c0uJ0!0f1M-?Xv$KE(T}EAMtx?V3vgNI8Nr3;PwOJ9oesHDN7NvLP z14m7QvB(LDT$9HF+76S7++?f7m-~$h)@>pOC8gTAd&sKrJBV~$h$O8=!5x1FN&xS} z;A(Jba*e9+Siwu1w%Q%Bo4VPu(b!;n;Lp+RxP31V>t|Fycj#xEe(vF-Dkl2+ZR(n` zMsKfv`}#zIf%E*)?zFOC%MFkn+S#kwCz9i~>aQ0z5?tQH91LNC$aqc98*Fn?xc7mF z#gAm{GO|rszW_UOXAd+Vy+?;-`QAuP@B~;amUZvBUrA51*d;k2n2~uy}ZWZqch7TU?xEzVEO+%tOk+=-d#$}t|K$Cj-1*>ryIVUR zc<`?J(fV~q&d*Mso}ZhY{_P1htah|MF#h~vYkqcO=IH79*2L8G?5WxYZnxVH1-REv zhx#-$bW-~d;4<5NWp8XO^+~Lf$#YYWrUHTJ#Wc8@JKce_!yt9_)EbaoWpr@#1%L+N zwb34_JI|&Gxxd9HpDWnh)6JNR5%K9zYTJACoeAJ+T*kE3o_qiy)8%=8!U*iq1;01; ztm8LvO?tV$M_Z%L@LBp17UB;xX;MhqA=z261? z1%LIsFeW4;+YQZ`|#@5*4#zckAXs9RjXD!q2>D?B;AvLO7-y*1Q9lpM2eW}sJ zZXNzu&xQgTTiZK=TYY<2-lEq`80x8;{BMSWA*#@KmK3szixjTqS*62bD=n$Fhtq(8 zPL07HB%sqQKATW1L`~JQ;~j?TzPVXO*nDetal5A$#&Mo@oZ&WgZn8B`)WW$lddAV7 z59pnU1;1FIhb)(d`s*{i48V!fjC!{TN461MJ!$#rtuk3XNxveYk;)_2A#|3X9_Yb* zDCTj8=JHP{(6f2Kp1>q$D1};KhY4pZ`H}$FRC4L;)2tILKfRvL;L+EEiDI=_q;7ad zclss$H}o*~)XJxj^%c;)gcwdSs7SEXV*~K~jXm6KN9D3<{WWBrS~k%jWDGGk_VgH@ ziVabN%YVhkI7E}sa;1qZLJK~)>=4BMdL!Wg4?d^DXQhH*!F5b{tQaQS(`4JCww4kY zaB7iE%rEln6OOkTrvL?UGx#7hwGRz!a0VipykAEJiYdPpp5F-1S9o?e`616~9$0k^ zRO`~u2A2Ou-st5Q_#Ig0vnrZ%{ES@sFaRYC>S=$>@VME;hYL!oEFdLRb!ERlbOqK~ z@@vQX4*>5ipR5SSN}D|8{`$N_c)JJip8Hj#_qW(s%o3QIg}&Pqxmw z(v12~z;t6jjL(h!3h8P`T0G{DEqXBSx%a$F8Aj{Fo1m)v%$vA7{%1WsGQ*c%g&N2` zuKRBWzM_EQbf)>$k)8-R#*m~68der}{^0U|#st{3A?w;Sxcv8+YwLTuHZ`^mKTyl= z+rO}HVs^4MGh=G;sn%D{wXgxEq{UZBLa%Eevmgt1E&V|7mwsfwKiSyBZEru~W>a0( z4>nv*gx$uy_Jd1r317P@e``-S!5CeA8oD)fW&L9e(olA_=N*izRkGyu8k%peYl6fN z?fr*NI&dTt;)a(^J?!k^V+J9p4E7a)jZMw_{JkkT;IBK;ShOJ}#rX6LNC8q{`G=h> z@kI}V#@`R$)#Eq}jwcwYPJs9q1qPOWOeZ1P+Y(mBXO)rJ> z44<9A3@u~`VKP|xy0n;QC3N2yx5x&Wx1O; z!EJ>~4{zzv9r=@`2=>Rk@>-yR(*+N2G-Jnd8A0jH7bBDV0rqJ?on$la`-m zJjtF#8*r=17xk@2wilyfx|@tAO~moRGobh#IIjV%sL#~0Pq#C}+38uj{@J@dCFhDG zAtA9umfcXx2KFyJ-kJ$2MsJJ?A=1!Lmkno92@~(UDkaDWH-m4TgvxpC9U54gne|=zi5h^=K#=QvCyuXLbtzR0jOAztxyb%l!lsIbMD))=7 zVr#rj0df0OBnau#6#;R*M#N>jI^s=7T#1f&%vQj%iNy$(OJFJEkGh{mNL>p*MY zFYB6!wqclFZpki=?19D@IZ^p`eoyaYwq>rrM*o4AF~Yxth`cv#t>*FCJyuIKs1miE8smZBTh+>(=N)f28#r8hpt50-Zf{xwKg>*S^j%f^~ z0q|N0x96KlpXsiBNwFF0(tgE=CsDB zt;Lt{6_yTw6A*o6K`0Kdt-{k*AsuW78}wAlJw3hfD~=La0Ippu%!`7dZZita zdl2s6eL7;Rn?rW>Y!VyW*Q#s)K4@TdgvIkE)<`d)b{pfkPe#c2AUQRv%^`Mr?%d4O z`18|?!N$QmG;fx&WbBbuQ>Et-5)!2AICtIO#Axx4g9d3NrsfuPSF(JJ!DNfR%7CG$ znT|>iEPu0!Ms8yM^sL{w5pQXu;G|1ZcKgwZg=ZJ48rdR`>$f0$pQvT~_q*Vo!caM~ zII(zc!CGQ(L>+7`o}RNDR_s)3K3FcE@Mvpca(>!oIW!R+MHjsy%k`(YUB9cB^hJV! zmA$gLE!OXg$6lpZWVQ0K1Ll$|V|rhyS+)-lsv`bMH**{^xX4!Ccg@ay)pWs|4YT9l zC4dp=DepFAFfLnJ1NELP#O3#>+U8G8tTYcE4;DA~>7&*RQ>-kCE`OH*Gby=`{ppsz zMadCUN%cts*+7Y<0&r54-ECOJ@a zp{)?OeAeV1b4%SUEJ3>nPfBQ&qRdxd?sOa~UK;lGYn3T6f*FMke#QSq>Inggw39iwj$hOLJb{+`~um z$i>L9>^x&Z13L}OFEc0kS}ptPuWV@EGx}6(f$52cc4ZuULU|lZ z7QIHlyPd2zmU1@983U>K0)t!4iYG>M3T>jK<)N6^=Ig|&i&G?2N^BO=O_OpA+ADJf zuw)8AO0Yu$C;uZ9E2K61%PQgg_y%BXc{^~Q;HvgdaM_s0UBXwWXd6wEgu+q<;0+XZ^_OWy}$L1k7ninXa* zRk)^vDlWgAjD{HUG`>n+xt$h2zvHYTo(Tz{@hl-hud1)(z3zxkF#+6SwEAXfe@s^6 zLO;@2A6)et`&IGFDrYO2Vmr5};^n7URHo9uWpq=sJEh>H)Hr47r3zZ*_$Xk) zlU(YlZvz&7ramGZY7BAOwa1{v2zwfyDplfI!s07oExY3tL$b)d!d?!TQkIbnUlxuY zBE`avgy#`81O*!$KibMO?f@SgzZGR6&!7I;bNQF%oEjW=gnk;&7osdF=}`RY7Bw>49iq}x~oetCQCcLLasYry$>Fy6s`nI+%>)_Z%8&CcW7 zW-%MLT@9*W9n{%l;+`~q-EgrhSXsS*1?;u@)Cq8OqB)K{2dlFKe{uOM4k3#Fqd9+E#*o`2yyse>WwefvLlBl<`<_Yr_WBX zns4r-ysAvbyfBWxr_Jij!ACe~i62 zvzCSO$9G>^^ zL=#?m+SIe&M(quqcwsRp-(}WimV1w$ZjCOqCg*0SMyDngCq@_M&dpD@M(0kBPK=(I zo@JNM=-gSkJm%&{&zxIW96e!)iy9(D;>6oQQGgtnZu!n=$QHvcM~PO|$Z>GCu51(_~>;022B=`I5XjdtF0$R0+6sqGkt za$f#&bHz}+ zgurX#)QIq7%o-{-&v-x0Ga`od5{8t4l9%64v@78VopT%sTqo1HkXc24k!tXe;~(?> zA_4B{uc@8ld!`I}qmA5FqBo{pf}BDcL%O5R6rVOZs2d@xQL4ta07)#0@jqv-wRZ3R z;|LrM+1SHXk|bhyji-u;NBUa#U(k*UaJg_148n#G6C3VQ1%nF`7BL4qA?2ZNY|yX! zzVy~iVNdT(;a3Eifdiq|U@(wYFF zSfTMkEM6=P6)x?eMK~N4?c>nMe(~po#QEA@#5lE)D-o!PGF)Qm#ubY41O;6Y8spb> z8(>TeBVO~yOS>Zwds`KVvWlTJT*V0&HJj7(3Qx1`?M;FMc^BR-hwanv(taX|6bt#D zj6acI5=(@=(Z*XFg3YieJU_z|>z^Iq*mL+{>?Wlc9?E`GEk_3BG4ZVwogxDuYkQ28 z@lpY+B@#hCNA3FjV=NY)Zc=_gV#sr2sWt$HjMm!A%6M}-l$Z$uUj93>U;r0d5>w;T zK`9@fG|Fo*WmCK*F{p|hQ{xi|Z*7*(1es?K5@aKXc=3VVj;QAsseuA3N6BEjc@e_0 z6n+1vPSId$%N>G*(t0Sim797?JYik!4+}?aELko;ax-F82*V9SU3~Dkmwt)leyzlT zjPVBG>pkqEkRN%lXQNMhf>)VbLd`d&=}pI497%b|taToImEa9Mz=gML!;TxOW>$xC z&Ya&SV}xmAY{ea7Ze9y2mT-ReVelCEArzH!w;Ra&ff%ALeb$MMhc-V)Y z1{SJ!<+WhPunTyDRV5-SAv&RO&~dIKC0&1gIc#Ss2I1;bu14e5p7q*STmU4qD?x4O z@&I*45%zuBVU@DLJH^t$`fY4DoP74@0aqk5yD9=IJe zK{pfTL&uh6G~D1&r~UJd+9tB}k5 zxKeaB)4L!k1Zo$)&hs|OaX+DVp_?!jT71xp452+ey+Pv%{X$l%{{|%>UMRyG|Hz!{ zRjRS87v=7iUus3tf=DJZj>9&dwiJZ$6QG!I`5y?nP}iF_1Iwto&})L@u7I_M4&0-q z*YI?8ZlU`$(PLN^M1g0_KvgqQ3 z&>Lp1Z`CH3FgqHGje45z_jX9~hK%=Y1UY50BV0Drh$!v$ChYD)+W?WE8!3F+;G$7F zPMF@qvrnFtFD^*H(n<$|B)iD5bJ2bw(fSt&?M;v7uYpO=TO=Vxsh+)e| zywyTTrK9~I+)xXO5ks|G7%3?~iY2`>Xkrrtd*JeJU~jfbMmi@K4i+kP2dQx7Ga5fS zrL*#aA+_1wss(O}992!YUY_V`s}((WBgGPmud0$qCbU-D2L! z$YjcyKs5H)H(20`B5yFn-SYrf=ml?p$&oNkvCOay?(gK%D07fjc?}guWT;!=;#H6I zd54=BgV6)(o1CyzYleeb8d;1~n8^Di2{>pr)XhIKO5VB7AY5Wr-E=Y6qX|n16$2%x z4H2zeai~947r7xKCP``|hlny%N8F_B7sHU!Mmit4PnX_Y$@n(A-{9z0sLijS2@Qn{ ziwvi67mwXH8LX5z3vN(%WQBkadfns6l>!s`V^=1@ZQ^_kQ3PCy zfFf{r*@ay@EFdZaqVxr;@Q(R=QhDeHR4b&@xuT~kjwH+&i-=s45Ol9!d z%1}BHI4Vw=x1v~}N`YcQBrGH9Rp38c2r^y8*!S2}_tZ!a@gOFd_fC1rhU1hPss@6T z&`3}GmJNTaBqmHhRJno!{M| zMR&*qvSGrF*l;5z9D)eShzcNrGm$6}O1du_HxsCMHf{Joto*htoD2% zFM^y}ECkz|1&gy*JbuUEuUr5cDYu-y8E49oXpLHjkK8VHuAR6|LF0Gd!u zUr9B6HL59cBH8`r1B(~P;t<%3YLFXCwXehcf@&lxb_V%jEZ8s=)vy=}&VX-y*p#hm zze*uU=*vEcWpD5>+a*mzk@NB~l?DG5+q0(^L> zkpLw%Ljt}U37AtWB=+BUAPzY!4mr(80J*U&^L3bNB)}>M6v+d@PGiANQ;`6Rp;Y*#0+K^5B+ zBo?3u5N9-$C}h!RIr}b#H!~FBlHL=}`@qDw2N)~D!MP4}oc#ROnG z7wmDc%5HFD3}qCU2jCVmn3P~%>)E`vk~hvlz}O#2g1kVS2zwKx01)gfQAej6tU0l< z)ZXkBJ?v{Jban(lQ*b(_5?NWX1z4xJ>LC65EUzWhsP3y*4=)S;Rm;gqI5{RCtIPQ7q(R5(Y>u3*;;T zf*I72FIWavlpmmcSu#`y5+yII2qejjIfjgFAdpl44$STbn_UCE?QkOm3m<}T{zh_Ds}UT4 z!aNQ~s+js7L@~h;KH>(uC7B%Hi51ZZXsfI6kxyA~GR4h*%1$jAZ6H(#qX}UNg$8#~ zAqI*ScK;ID^^^aBq+-HgT%rtvv0nkD&|Z@}IaOwOtrV=NiVg%-f@+?xLglD{jjNUg zMohjWOf6p=a~7ypEbIsyt0N6G9E!}=6aLj_=?46?8!8!1$=ncIBit)gXV-hggp;3Dgb2(f#9**C8mJyWigmG5e*!42#9hQXdL*)dDm9~f*fV8?N#ro0SW*_Oc{8D z61ePy7)k*{TsOlZ27)F>ic?rahUqRK#b5`LhUt5h$QHcCwIZfBU>O(O*epU6 z5+C*gGnqm_djgC}!~kWO9fGjif&k@MiU}ZE@&bRBEy!pJWD(FAWgv;J4hA|uC@zuU zu#tk?vkN3>DuW4afI_5RaAk?PUl`&k$wovp6VLHWAf!IOfMWR-PGTY=K?B)B;2}3$ zA_A(yPyo0Kr7IxLE`h>*oodu0n|{^INJAJAu}oUF>To@(O#!aykk*Hl0~L>Xjv#rG zgJ%q#z@J2pC6O7kwO<0uj;i3-_K19N0HG!aza5z)L9u(|I zBRl7VQ*G?VHXooJMo^8W8Qz};k&T)Ss*x8|ZC2S-b^2>J4PXX-3|xi=z+OzR{g-b< z6k9b}TtK_P=rNbUT&2 z7Xj7PxEa0)=b^VTnmTI*+ETI*0vBp%!%1Z{N=KR(JHG`Vm{G#UHvl?SAAsU6(>4Xg zI4OZcU#us&WVg_W0EJwqvR@ddpcwvx9~%m@5=aJAV&eb}aWfE@kk;151E)D)L;#j$ zh@BUNWTJpsfHN_a=&%b<2^4~n$?y;;!G&>Ry0*%6M-*S+*CaCI#K;zkCYn0^a=IrbSKIr8e*Z-52O z8H)vV$uwo0y8&vr!vJW7n+5KXFIZ~Ru_P?XxWT{#>Bkx&K19bCAqb8#7=n;52zpA= zLq7{ky%?9VmfeQfx`Yv|%8RiYjqMTIpStO7BH);0M0E@bDi#X4L5T?=ruvz@&@zEq z95m_8#6g;i2|5gknQtuaTjGoK0C7*|7Cd<4ItVE=F~v;?1YHKqdchXA(wa6JYJ`@M zr|+b#j~j*A_66-1laiq$r-}J(LTUjVIfYxh(8LR-CA(SFjcmj64b(c;0qA>RcPz8( zw~w|B@&ZUBOQ>}cAB}LsK0acMn@B4BM2Ur%vti1p#GmAk_I{zeFyK%+fxclOL7s9S z)+8Suhep%g#3UB(80Ueh6h1!m@nJwtIg=yw#L!A9m`?$5Nls)d-mP;F;@Q%vQmhF$ z?Mxm(PQ?jr){PAaTP@5&Rgs8wQ#EjGTmZ>LC(RNLSA)SOlAS6oNLO_S!-aVG0IkYE zdXV!R%7{Jvr93D~QRW=VG$1i1JvAdW9?!a_r=>FHeJEm8EhsJuj9rh56QHSRa@Z^b zBgF~)6Qk4NY#c>(;ZP3p)U*lAX|t-I1T8`nh-e|4HZ|l>d?DDd7D*-UE;L2u!qL{; z(7+@(KoK!n8u%2N?tO?MbqxIh2H(KZ+@$_|fle@`;a)}S^?cwVyl=;%&De?6dd&y<)fQn2g zlDYZNGO@2rB$s0hk(=1p4FGw23B@u`Ur!&IuRAUFlzD=`r-z7klZa*BB5$#$w?ys@ z#gzhvA|F~Vbo20%`v~Q3QYe~C0>$u<`*{0GAiV_ONkqOfIqmN0C82%go}RRuyGZEn zDU*0ZQef!Z5kTA_X-M4Rv2o)vfxsF6rSShv3WHTi5ESsUf+MR`2-j?IdQ{qg)D)#5 zTxe*i<1;upE5QnUKHKJ zDKj!CE-5Z5BQ7!|E;%hy>MnHmi1(0sNTlL8u_#6)k$Sj^W#VY}=r~zSWOGU6k`@~c zFzp(^3JCk_iQfW+tLd9oi$_tzK_q!6B?SN~6fv707v~b2lthwz?nnuGH%24NtJrKt)mM04I@3qT&E%3KdVK zl5jhcDg;8Kz&8WJqo_=XmkKWCx0S~OT*3AP_@_fi3YE|Tq#KYi2THB@C#Is229!T# z2L5t@mrSLRJSISiqQDhLzy|=t7=W7!d8Yzanb5E>b~?nyr#d$NRBM2xD1|pb$RKGG zA+9>k!PEo@$%OD^%7qG{Mgp8TfE3GOj~PoTJvCT^AUqw?sLCyblr;Q_Af|+JCoW9q zPnkkGq#(jihj$dvOjV-4%G(97NP>U(%cL9tmOsErAW*Q}X@EOYIRUWFgg9UN38)2+3@p<~P+ z9F;K=?D1r#rU;GbR_Lj1tQ`~=n+zsMgjTc#`tXfgo|Fk~X=@DEFg918X2r${f)f+a z`j8+{?nzsHV*nE%514nr+(<|d0jE$%E1h)ilz#*_16mJp(=+A;3=9lX6h-4JMWORJ zHtICvXi^$^97Cve4xgLH;ZU`cbFw|(&)gBPq?7#Wowq^PBfJ*xb8EN!NyQ&^2d~_F zwrhXnP5$;ON%7={7iXnq&keoO%YIpQs)OCNK?eC5wP#}9d~;$;Vro=?f6l;~@fP34 z)|}zJFtIPM^y=j%-+I|TJZwQl^7Lp!?LiUe+7xfotu=FcH|u)TpnFX0MTO zdd+8X-X>@Ni`>RXsk>JTt402MUVj`O9Wm_L>)3g}7L4y>@w&{ZkF%af$iST)c(W@S zM>v$dn7nghiT}KHGsm1iDv9c|_mFA-tDD?x_G`6U)PIIm3iWWmRpQmKaBB^x?)&c; zYkm_iDJyg~e|AZHkdtHnVX5zml+wF?S0oQS;1)fKvnG$jrE@>i#z0xijy!#uucZUb zt_fN@4cZbtTk*_zCJm{>k57LWy#Hz1V6DInRTB(04O&Kc%hHg;`3xfqu67RH0i)aU z+R|n@CWC!4ErxD=T_e}LF)PG*j;QRD-y*s%M(DuvqI=Uli@O(hEtHPT%uMU*>Kc=t zqCcCDMPDEc11ZO%Hi$+;6Y$N7x1S86liidJWsk8-9zD~xrIU& z>iF^FTY?JaYnp+}ROb_DTfiqAYLVyA9+6I^Co4PqxO#DimCUv9&vei|sTVRS&CxTx zTdC>Z)4ZU;TgGQ5>xB-U>S5H^>inIvRWS>9d@OZwem}gvUASrfrCmGk2dxgeW;>v-`|Y*f4U-)&iE($6>0?^1gIbN%OEeQKCL@wYQapZjN} zeBApv-iZH3W2otaVMY47zb~2NQX$wEb>~>Brb+AHvj6nb*{AW$esDs-obZ{I-oN^s ziRS4$(;8vJ8vS0TtTz$zK8jaY@|?L>yO!t<+Z?rRPTIk&P}`XGtHQ^xzP!8r7)Of_ zE;o5|DxQe<_gm8ER&0=2_xJm5+`D0-Z)79R%d-MObQ}cHc7-6~mA@i_$eibZ84&Tu|b{C??uxAaCoc7OJ02dF+DUI!mzv<5 zrH2e|?JM&+AiRF3aOR}xoS7C`Vbbka7xar*X?bD!(WgfO>JB*c(_Y9M!<}Z3cIR#9 zyRD*b74<)Tbz{g*k3Wz4ek`@v`*};__Qg3@Di?gLv{}ERV|ZH6$ZQMGPM(o2kfhWlGo>H8 zHXO3sknZ1x=lbmIcjLNMpBm$!m;6DRP*!ad?Ueofp>dnas_p%M+ER3NhIHtuxYAsg zpPmfj`tR1+A9uuRrnPfQ+4HfnJFb|Iu6x$;cGcY+Z`oN_{)EY#&ShBCq(YISz@FCre{#ttHdOJ>jy)C}_ zK+uu>J-gj__e19FJ2v` zakNXjoBQf-RWJG0HgNOFt8E9^89qK;cG`b)CM{_FQ2SiSkEVSWw)dLDq>GTJegWPOt6oo15L#70+KLSakW2eRrDWgS!LPlpL}RK0f=s&nexyVO#39 zdhu4jTbHyT;ez88-{7r6EE2!s!+7C!b$je$RUG zYztGtgoE)^nXYMLLs$ZY@)()NG*Dr23qm|ol^}GDC)_qKL^H$|Q3eEb&S!x-m zQ$QKfzK?cYv-RC`#5rWu7ON~z;rQBR*Sk$wP!h$hur%2A;mxw`oRc>FLq5OLJX|Hv zQwW}oAb84XLlhjwIQY?|HQ=QtiCPpiICQl%#E}xGkT%lNWoHzo9Q2{++#(FO<>k($ zb7$w6wAz$6qW2(&#kV^ef9QOZAN*r@LupA&Y1BW?o_R(SHk+07D_*4d85Z$s7}rtZ%&W)a;F7D~^{yYhXG_>pi<_35!cBX!p3kgn?8bRqzkd#2vu3tm z{nKF6s{=RAZ@4>q)VZ8PcNRX^axKufKd-Z$P1>KYKQv@5aWQzKU7xnM?SK_OjOM5R zSXm-lp5R>lZL0^-k-f}{W(s=MYnzMS)e8HK6ZUXQ*Qm=41ZytTDhgEWiyr+7@5B*tW4Br`J7b)|er_a+AH~q`={&Q*37a!7Qb(WL!5?_F2+atSpXeav{xN9YQ2VQ`zM=n71A z9LT^{|6l0}V0lm^5xI%rKMr6$7^fRL|II1>Uv>twuNQdC+NL!q-hIGX{zG@$c~)CC z&JMeO6UHNuLjvN`b^|7f*_4}Sn+(x%cOn*61bNKBg9lb9|+Rd1I#qo!^`cKZy zjoN(eO4~H&DaTT`6m)reb@y)i$_HO-pOe->Xgk6 z+YU+R9PaL#d}zlx(dG#qExZcrR}{P){73t6S7-bAovO<(6s%b}V#vZf*~_zs<%#Fk+({uGtPHJU3aoQ&FuLqNg^7|e0o-oq!y3G`W${Ah!qUt}jW;+9}EuF{h z(1JWyO`Thu39I!6N5AY!{@WR#0^FAQW!XqxPrikK(+4Nj? zzVPk6ovV(|Jl}1sUdgtzLi~ly%yKZ^Ehj_?e3;C4?In# zj6ZX1pyu#3CP4=lmAdvE6k#;>WbomWnjwih;*Qy^HN4re(tLNoZSL+stAXW3`j$U( zAKQd)w)ssnQ;+A9%?rPA(XjlX|JxB)tFl&}{$u;u$Qo291 zVV$(i8o!qoq2J9AoSyV)-sOdJT&uE2uZt}hxaM{jai^hr2VVUubv+_DGD!G3@npeU z{=CMz^FRM0)zp8OGSGjyMyCy{KeR3Gq;C)zImmYK9~O%YYV6$)dH;6%=AG2(cjw$M zs>nE#b?ea@PWQ~)!}cbN`#kP-I*4jx}r-!DWu%GP85s9k=KA9xw`wVU_D zE}qNc)P}o0d*%du9C7JFc-6(6^CQIByGj-aKIK+!SR1K(e}=(+$AHNf?ioIc%Q`I_ zzB~T%b+5a6wOsAl*FOui*7(HjC>PCknO7gM<+s%xdk_={f7esi&C z{nG-jPI#$cT^Bv`=RsPJ5^u-0ZGU6U#%sqXnncMf<6gP12{m>~=n~ML_7~>yjzT9? z16@sSRZ8#T+!u5^rNUWPL#VH&^5%gOS)~%!6Skt&Lrp=?q0p-9@`Rv0 zJoaQ=_ffjH>gq=&PFTcEXrD&Mtfh13tHID0=1!q=bBZH#hCqW%0^RvoSb`F;i%|(= z2`L$te4;?Jj*Fj(pjXGGA6!<81r56ZmNjv)Ed{1OW6Zk2m4+0-6hJ}EeK?zH>$rg5G1to^pGF5fo7!gFH1^<6E?ii^KATH5c5Fbope zd5K~Q!{eNEUkq7x>u39M%Oh44&VKXYwxhM_OQVP%o{0^UdMkv(U`h^Yi9OZC#&hVT?SWf*;VfU zTFok@2DY0ZnSH7H#qS-LU3(cIJ+r*N(JbD@uD5)D$b-Q6N2f~ixR%hzsquoAFptXz zFD=5m1^?QF6*yO=lhkIHYl?@`ZB^W-A=Fbkv^l`FO1{(-8se%2Z1s`}r6Qr&eaIJF z8{!vMePVjtg>Z|EhZ$?C^!A2M?V!#epeRNL2@=af4U=S_*0~-}y1e#S{S)6&p4~ft zaQykkf^!DHRR)=P+JAe^RH}0&_r#M}v(|d^rbZn)`12z1pQo0rF&P!Pe|+Bkl3K1s zcej<+eSdwr?^LZ@gU!P|Pow8c91>28?hP(}*fq`kLUh}uk#FZcpBz5M)FR9L@tvc! zi7PD5UGQ(H+q|=3*-L}$TT6xncF6MnVEN7Yoia|;j;d#U1X1>{7L=y%>ac~Le(|=> zDADvZ&i=sr6L+&^qvMx&>=1~xKM`PoeZ%RHpx~FDzzUB8z vhXY*~nVfb#zU}%6TlvD+cZ;pYrc_^k^eBJd^MT%abw{V3Oh4KNHZA-QL;i)G literal 0 HcmV?d00001 diff --git a/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/System.Threading.xml b/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/System.Threading.xml new file mode 100644 index 000000000..8fc7b65a7 --- /dev/null +++ b/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/System.Threading.xml @@ -0,0 +1,19811 @@ + + + + System.Threading + + + +

+ A stub version of .NET 4.0 contracts. + + + + + A dummy class that implements GetResourceString. Environment.GetResourceString(string) is an internal + method in mscorlib.dll. + + + + + An interface similar to the one added in .NET 4.0. + + + + + .NET 4.0 Monitor class supports new overloads that return a boolean value + representing whether the lock was successfully taken or not. The return value + is meant to be accurate even in the presence of thread aborts. + + Monitor2 implements these methods as simple wrappers over the .NET 3.5 methods, + but without making the guarantees related to thread aborts. + + + + + This internal class from mscorlib.dll is used by ConcurrentDictionary. + + + + + OperationCanceledException is changing from .NET 3.5 to .NET 4.0. To make Parallel Extensions work, + we include the new version as OperationCanceledException2. + + + + + A convenience class for common platform-related logic. + + + + + Gets the number of available processors available to this process on the current machine. + + + + + A dummy replacement for the .NET 4.0 SecuritySafeCriticalAttribute. The dummy attribute makes the + code compile, but we are likely losing the ability to be called from a partial trust environment. + + + + + A dummy replacement for the .NET internal class StackCrawlMark. + + + + + Represents a thread-safe collection of keys and values. + + The type of the keys in the dictionary. + The type of the values in the dictionary. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Initializes a new instance of the + class that is empty, has the default concurrency level, has the default initial capacity, and + uses the default comparer for the key type. + + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the default + comparer for the key type. + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + is + less than 1. + is less than + 0. + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency + level, has the default initial capacity, and uses the default comparer for the key type. + + The whose elements are copied to + the new + . + is a null reference + (Nothing in Visual Basic). + contains one or more + duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level and capacity, and uses the specified + . + + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). + + + + Initializes a new instance of the + class that contains elements copied from the specified , has the default concurrency level, has the default + initial capacity, and uses the specified + . + + The whose elements are copied to + the new + . + The + implementation to use when comparing keys. + is a null reference + (Nothing in Visual Basic). -or- + is a null reference (Nothing in Visual Basic). + + + + + Initializes a new instance of the + class that contains elements copied from the specified , + has the specified concurrency level, has the specified initial capacity, and uses the specified + . + + The estimated number of threads that will update the + concurrently. + The whose elements are copied to the new + . + The implementation to use + when comparing keys. + + is a null reference (Nothing in Visual Basic). + -or- + is a null reference (Nothing in Visual Basic). + + + is less than 1. + + contains one or more duplicate keys. + + + + Initializes a new instance of the + class that is empty, has the specified concurrency level, has the specified initial capacity, and + uses the specified . + + The estimated number of threads that will update the + concurrently. + The initial number of elements that the + can contain. + The + implementation to use when comparing keys. + + is less than 1. -or- + is less than 0. + + is a null reference + (Nothing in Visual Basic). + + + + Attempts to add the specified key and value to the . + + The key of the element to add. + The value of the element to add. The value can be a null reference (Nothing + in Visual Basic) for reference types. + true if the key/value pair was added to the + successfully; otherwise, false. + is null reference + (Nothing in Visual Basic). + The + contains too many elements. + + + + Determines whether the contains the specified + key. + + The key to locate in the . + true if the contains an element with + the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Attempts to remove and return the the value with the specified key from the + . + + The key of the element to remove and return. + When this method returns, contains the object removed from the + or the default value of + if the operation failed. + true if an object was removed successfully; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Removes the specified key from the dictionary if it exists and returns its associated value. + If matchValue flag is set, the key will be removed only if is associated with a particular + value. + + The key to search for and remove if it exists. + The variable into which the removed value, if found, is stored. + Whether removal of the key is conditional on its value. + The conditional value to compare against if is true + + + + + Attempts to get the value associated with the specified key from the . + + The key of the value to get. + When this method returns, contains the object from + the + with the spedified key or the default value of + , if the operation failed. + true if the key was found in the ; + otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + + Compares the existing value for the specified key with a specified value, and if they’re equal, + updates the key with a third value. + + The key whose value is compared with and + possibly replaced. + The value that replaces the value of the element with if the comparison results in equality. + The value that is compared to the value of the element with + . + true if the value with was equal to and replaced with ; otherwise, + false. + is a null + reference. + + + + Removes all keys and values from the . + + + + + Copies the elements of the to an array of + type , starting at the + specified array index. + + The one-dimensional array of type + that is the destination of the elements copied from the . The array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Copies the key and value pairs stored in the to a + new array. + + A new array containing a snapshot of key and value pairs copied from the . + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToPairs. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToEntries. + + + + + Copy dictionary contents to an array - shared implementation between ToArray and CopyTo. + + Important: the caller must hold all locks in m_locks before calling CopyToObjects. + + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Shared internal implementation for inserts and updates. + If key exists, we always return false; and if updateIfExists == true we force update with value; + If key doesn't exist, we always add value and return true; + + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + The function used to generate a value for the key + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value for the key as returned by valueFactory + if the key was not in the dictionary. + + + + Adds a key/value pair to the + if the key does not already exist. + + The key of the element to add. + the value to be added, if the key does not already exist + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The value for the key. This will be either the existing value for the key if the + key is already in the dictionary, or the new value if the key was not in the dictionary. + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The function used to generate a value for an absent key + The function used to generate a new value for an existing key + based on the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds a key/value pair to the if the key does not already + exist, or updates a key/value pair in the if the key + already exists. + + The key to be added or whose value should be updated + The value to be added for an absent key + The function used to generate a new value for an existing key based on + the key's existing value + is a null reference + (Nothing in Visual Basic). + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + The new value for the key. This will be either be the result of addValueFactory (if the key was + absent) or the result of updateValueFactory (if the key was present). + + + + Adds the specified key and value to the . + + The object to use as the key of the element to add. + The object to use as the value of the element to add. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + An element with the same key already exists in the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + true if the element is successfully remove; otherwise false. This method also returns + false if + was not found in the original . + + is a null reference + (Nothing in Visual Basic). + + + + Adds the specified value to the + with the specified key. + + The + structure representing the key and value to add to the . + The of is null. + The + contains too many elements. + An element with the same key already exists in the + + + + + Determines whether the + contains a specific key and value. + + The + structure to locate in the . + true if the is found in the ; otherwise, false. + + + + Removes a key and value from the dictionary. + + The + structure representing the key and value to remove from the . + true if the key and value represented by is successfully + found and removed; otherwise, false. + The Key property of is a null reference (Nothing in Visual Basic). + + + Returns an enumerator that iterates through the . + An enumerator for the . + + The enumerator returned from the dictionary is safe to use concurrently with + reads and writes to the dictionary, however it does not represent a moment-in-time snapshot + of the dictionary. The contents exposed through the enumerator may contain modifications + made to the dictionary after was called. + + + + + Adds the specified key and value to the dictionary. + + The object to use as the key. + The object to use as the value. + is a null reference + (Nothing in Visual Basic). + The dictionary contains too many + elements. + + is of a type that is not assignable to the key type of the . -or- + is of a type that is not assignable to , + the type of values in the . + -or- A value with the same key already exists in the . + + + + + Gets whether the contains an + element with the specified key. + + The key to locate in the . + true if the contains + an element with the specified key; otherwise, false. + is a null reference + (Nothing in Visual Basic). + + + Provides an for the + . + An for the . + + + + Removes the element with the specified key from the . + + The key of the element to remove. + is a null reference + (Nothing in Visual Basic). + + + + Copies the elements of the to an array, starting + at the specified array index. + + The one-dimensional array that is the destination of the elements copied from + the . The array must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference + (Nothing in Visual Basic). + is less than + 0. + is equal to or greater than + the length of the . -or- The number of elements in the source + is greater than the available space from to the end of the destination + . + + + + Replaces the internal table with a larger one. To prevent multiple threads from resizing the + table as a result of races, the table of buckets that was deemed too small is passed in as + an argument to GrowTable(). GrowTable() obtains a lock, and then checks whether the bucket + table has been replaced in the meantime or not. + + Reference to the bucket table that was deemed too small. + + + + Computes the bucket and lock number for a particular key. + + + + + Acquires all locks for this hash table, and increments locksAcquired by the number + of locks that were successfully acquired. The locks are acquired in an increasing + order. + + + + + Acquires a contiguous range of locks for this hash table, and increments locksAcquired + by the number of locks that were successfully acquired. The locks are acquired in an + increasing order. + + + + + Releases a contiguous range of locks. + + + + + Gets a collection containing the keys in the dictionary. + + + + + Gets a collection containing the values in the dictionary. + + + + + A helper method for asserts. + + + + + A helper function to obtain the string for a particular resource key. + + + + + + + Get the data array to be serialized + + + + + Construct the dictionary from a previously seiralized one + + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key. If the specified key is not found, a get + operation throws a + , and a set operation creates a new + element with the specified key. + is a null reference + (Nothing in Visual Basic). + The property is retrieved and + + does not exist in the collection. + + + + Gets the number of key/value pairs contained in the . + + The dictionary contains too many + elements. + The number of key/value paris contained in the . + Count has snapshot semantics and represents the number of items in the + at the moment when Count was accessed. + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, + false. + + + + Gets a collection containing the keys in the . + + An containing the keys in the + . + + + + Gets a collection containing the values in the . + + An containing the values in + the + . + + + + Gets a value indicating whether the dictionary is read-only. + + true if the is + read-only; otherwise, false. For , this property always returns + false. + + + + Gets a value indicating whether the has a fixed size. + + true if the has a + fixed size; otherwise, false. For , this property always + returns false. + + + + Gets a value indicating whether the is read-only. + + true if the is + read-only; otherwise, false. For , this property always + returns false. + + + + Gets an containing the keys of the . + + An containing the keys of the . + + + + Gets an containing the values in the . + + An containing the values in the . + + + + Gets or sets the value associated with the specified key. + + The key of the value to get or set. + The value associated with the specified key, or a null reference (Nothing in Visual Basic) + if is not in the dictionary or is of a type that is + not assignable to the key type of the . + is a null reference + (Nothing in Visual Basic). + + A value is being assigned, and is of a type that is not assignable to the + key type of the . -or- A value is being + assigned, and is of a type that is not assignable to the value type + of the + + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + (thread safe); otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + The number of concurrent writes for which to optimize by default. + + + + + A node in a singly-linked list representing a particular hash table bucket. + + + + + A private class to represent enumeration over the dictionary that implements the + IDictionaryEnumerator interface. + + + + + Represents a thread-safe first-in, first-out collection of objects. + + Specifies the type of elements in the queue. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Defines methods to manipulate thread-safe collections intended for producer/consumer usage. + + Specifies the type of elements in the collection. + + All implementations of this interface must enable all members of this interface + to be used concurrently from multiple threads. + + + + + Copies the elements of the to + an + , starting at a specified index. + + The one-dimensional that is the destination of + the elements copied from the . + The array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference (Nothing in + Visual Basic). + is less than + zero. + is equal to or greater than the + length of the + -or- The number of elements in the source is greater than the + available space from to the end of the destination . + + + + + Attempts to add an object to the . + + The object to add to the . + true if the object was added successfully; otherwise, false. + The was invalid for this collection. + + + + Attempts to remove and return an object from the . + + + When this method returns, if the object was removed and returned successfully, contains the removed object. If no object was available to be removed, the value is + unspecified. + + true if an object was removed and returned successfully; otherwise, false. + + + + Copies the elements contained in the to a new array. + + A new array containing the elements copied from the . + + + + Initializes a new instance of the class. + + + + + Initializes the contents of the queue from an existing collection. + + A collection from which to copy elements. + + + + Initializes a new instance of the + class that contains elements copied from the specified collection + + The collection whose elements are copied to the new . + The argument is + null. + + + + Get the data array to be serialized + + + + + Construct the queue from a previously seiralized one + + + + + Copies the elements of the to an , starting at a particular + index. + + The one-dimensional Array that is the + destination of the elements copied from the + . The Array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference (Nothing in + Visual Basic). + is less than + zero. + + is multidimensional. -or- + does not have zero-based indexing. -or- + is equal to or greater than the length of the + -or- The number of elements in the source is + greater than the available space from to the end of the destination + . -or- The type of the source cannot be cast automatically to the type of the + destination . + + + + + Returns an enumerator that iterates through a collection. + + An that can be used to iterate through the collection. + + + + Attempts to add an object to the . + + The object to add to the . The value can be a null + reference (Nothing in Visual Basic) for reference types. + + true if the object was added successfully; otherwise, false. + For , this operation will always add the object to the + end of the + and return true. + + + + Attempts to remove and return an object from the . + + + When this method returns, if the operation was successful, contains the + object removed. If no object was available to be removed, the value is unspecified. + + true if an element was removed and returned succesfully; otherwise, false. + For , this operation will attempt to remove the object + from the beginning of the . + + + + + Copies the elements stored in the to a new array. + + A new array containing a snapshot of elements copied from the . + + + + Copies the elements to a new . + + A new containing a snapshot of + elements copied from the . + + + + Store the position of the current head and tail positions. + + return the head segment + return the tail segment + return the head offset + return the tail offset + + + + Copies the elements to an existing one-dimensional Array, starting at the specified array index. + + The one-dimensional Array that is the + destination of the elements copied from the + . The Array must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference (Nothing in + Visual Basic). + is less than + zero. + is equal to or greater than the + length of the + -or- The number of elements in the source is greater than the + available space from to the end of the destination . + + + + + Returns an enumerator that iterates through the . + + An enumerator for the contents of the . + + The enumeration represents a moment-in-time snapshot of the contents + of the queue. It does not reflect any updates to the collection after + was called. The enumerator is safe to use + concurrently with reads from and writes to the queue. + + + + + Adds an object to the end of the . + + The object to add to the end of the . The value can be a null reference + (Nothing in Visual Basic) for reference types. + + + + + Attempts to remove and return the object at the beginning of the . + + + When this method returns, if the operation was successful, contains the + object removed. If no object was available to be removed, the value is unspecified. + + true if an element was removed and returned from the beggining of the + succesfully; otherwise, false. + + + + Attempts to return an object from the beginning of the + without removing it. + + When this method returns, contains an object from + the beginning of the or an + unspecified value if the operation failed. + true if and object was returned successfully; otherwise, false. + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + with the SyncRoot; otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, false. + + For determining whether the collection contains any items, use of this property is recommended + rather than retrieving the number of items from the property and comparing it + to 0. However, as this collection is intended to be accessed concurrently, it may be the case + that another thread will modify the collection after returns, thus invalidating + the result. + + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + For determining whether the collection contains any items, use of the + property is recommended rather than retrieving the number of items from the + property and comparing it to 0. + + + + + private class for ConcurrentQueue. + a queue is a linked list of small arrays, each node is called a segment. + A segment contains an array, a pointer to the next segment, and m_low, m_high indices recording + the first and last valid elements of the array. + + + + + Create and initialize a segment with the specified index. + + + + + Add an element to the tail of the current segment + exclusively called by ConcurrentQueue.InitializedFromCollection + InitializeFromCollection is responsible to guaratee that there is no index overflow, + and there is no contention + + + + + + Create a new segment and append to the current one + Does not update the m_tail pointer + exclusively called by ConcurrentQueue.InitializedFromCollection + InitializeFromCollection is responsible to guaratee that there is no index overflow, + and there is no contention + + the reference to the new Segment + + + + Create a new segment and append to the current one + Update the m_tail pointer + This method is called when there is no contention + + + + + Try to append an element at the end of this segment. + + the element to append + The tail. + true if the element is appended, false if the current segment is full + if appending the specified element succeeds, and after which the segment is full, + then grow the segment + + + + try to remove an element from the head of current segment + + The result. + The head. + return false only if the current segment is empty + + + + try to peek the current segment + + holds the return value of the element at the head position, + value set to default(T) if there is no such an element + true if there are elements in the current segment, false otherwise + + + + Convert part or all of the current segment into a List + + the start position + the end position + the result list + + + + return the next segment + + + + + return true if the current segment is empty (doesn't have any element available to dequeue, + false otherwise + + + + + return the position of the head of the current segment + + + + + return the logical position of the tail of the current segment + + + + + Represents a thread-safe last-in, first-out collection of objects. + + Specifies the type of elements in the stack. + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + Initializes a new instance of the + class. + + + + + Initializes a new instance of the + class that contains elements copied from the specified collection + + The collection whose elements are copied to the new . + The argument is + null. + + + + Initializes the contents of the stack from an existing collection. + + A collection from which to copy elements. + + + + Get the data array to be serialized + + + + + Construct the stack from a previously seiralized one + + + + + Removes all objects from the . + + + + + Copies the elements of the to an , starting at a particular + index. + + The one-dimensional that is the destination of + the elements copied from the + . The must + have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference (Nothing in + Visual Basic). + is less than + zero. + + is multidimensional. -or- + does not have zero-based indexing. -or- + is equal to or greater than the length of the + -or- The number of elements in the source is + greater than the available space from to the end of the destination + . -or- The type of the source cannot be cast automatically to the type of the + destination . + + + + + Copies the elements to an existing one-dimensional , starting at the specified array index. + + The one-dimensional that is the destination of + the elements copied from the + . The must have zero-based + indexing. + The zero-based index in at which copying + begins. + is a null reference (Nothing in + Visual Basic). + is less than + zero. + is equal to or greater than the + length of the + -or- The number of elements in the source is greater than the + available space from to the end of the destination . + + + + + Inserts an object at the top of the . + + The object to push onto the . The value can be + a null reference (Nothing in Visual Basic) for reference types. + + + + + Inserts multiple objects at the top of the atomically. + + The objects to push onto the . + is a null reference + (Nothing in Visual Basic). + + When adding multiple items to the stack, using PushRange is a more efficient + mechanism than using one item at a time. Additionally, PushRange + guarantees that all of the elements will be added atomically, meaning that no other threads will + be able to inject elements between the elements being pushed. Items at lower indices in + the array will be pushed before items at higher indices. + + + + + Inserts multiple objects at the top of the atomically. + + The objects to push onto the . + The zero-based offset in at which to begin + inserting elements onto the top of the . + The number of elements to be inserted onto the top of the . + is a null reference + (Nothing in Visual Basic). + or is negative. Or is greater than or equal to the length + of . + + is + greater than the length of . + + When adding multiple items to the stack, using PushRange is a more efficient + mechanism than using one item at a time. Additionally, PushRange + guarantees that all of the elements will be added atomically, meaning that no other threads will + be able to inject elements between the elements being pushed. Items at lower indices in the + array will be pushed before items at higher indices. + + + + + Push one or many nodes into the stack, if head and tails are equal then push one node to the stack other wise push the list between head + and tail to the stack + + The head pointer to the new list + The tail pointer to the new list + + + + Local helper function to validate the Pop Push range methods input + + + + + Attempts to add an object to the . + + The object to add to the . The value can be a null + reference (Nothing in Visual Basic) for reference types. + + true if the object was added successfully; otherwise, false. + For , this operation + will always insert the object onto the top of the + and return true. + + + + Attempts to return an object from the top of the + without removing it. + + When this method returns, contains an object from + the top of the or an + unspecified value if the operation failed. + true if and object was returned successfully; otherwise, false. + + + + Attempts to pop and return the object at the top of the . + + + When this method returns, if the operation was successful, contains the + object removed. If no object was available to be removed, the value is unspecified. + + true if an element was removed and returned from the top of the + succesfully; otherwise, false. + + + + Attempts to pop and return multiple objects from the top of the + atomically. + + + The to which objects popped from the top of the will be added. + + The number of objects successfully popped from the top of the and inserted in + . + is a null argument (Nothing + in Visual Basic). + + When popping multiple items, if there is little contention on the stack, using + TryPopRange can be more efficient than using + once per item to be removed. Nodes fill the + with the first node to be popped at the startIndex, the second node to be popped + at startIndex + 1, and so on. + + + + + Attempts to pop and return multiple objects from the top of the + atomically. + + + The to which objects popped from the top of the will be added. + + The zero-based offset in at which to begin + inserting elements from the top of the . + The number of elements to be popped from top of the and inserted into . + is a null reference + (Nothing in Visual Basic). + or is negative. Or is greater than or equal to the length + of . + + is + greater than the length of . + + When popping multiple items, if there is little contention on the stack, using + TryPopRange can be more efficient than using + once per item to be removed. Nodes fill the + with the first node to be popped at the startIndex, the second node to be popped + at startIndex + 1, and so on. + + + + + Local helper function to Pop an item from the stack, slow path + + The popped item + True if succeeded, false otherwise + + + + Slow path helper for TryPop. This method assumes an initial attempt to pop an element + has already occurred and failed, so it begins spinning right away. + + The number of items to pop. + + When this method returns, if the pop succeeded, contains the removed object. If no object was + available to be removed, the value is unspecified. This parameter is passed uninitialized. + + True if an element was removed and returned; otherwise, false. + + + + Local helper function to copy the poped elements into a given collection + + The head of the list to be copied + The collection to place the popped items in + the beginning of index of where to place the popped items + The number of nodes. + + + + Attempts to remove and return an object from the . + + + When this method returns, if the operation was successful, contains the + object removed. If no object was available to be removed, the value is unspecified. + + true if an element was removed and returned succesfully; otherwise, false. + For , this operation will attempt to pope the object at + the top of the . + + + + + Copies the items stored in the to a new array. + + A new array containing a snapshot of elements copied from the . + + + + Returns an array containing a snapshot of the list's contents, using + the target list node as the head of a region in the list. + + An array of the list's contents. + + + + Returns an enumerator that iterates through the . + + An enumerator for the . + + The enumeration represents a moment-in-time snapshot of the contents + of the stack. It does not reflect any updates to the collection after + was called. The enumerator is safe to use + concurrently with reads from and writes to the stack. + + + + + Returns an enumerator that iterates through a collection. + + An that can be used to iterate through + the collection. + + The enumeration represents a moment-in-time snapshot of the contents of the stack. It does not + reflect any updates to the collection after + was called. The enumerator is safe to use concurrently with reads + from and writes to the stack. + + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, false. + + For determining whether the collection contains any items, use of this property is recommended + rather than retrieving the number of items from the property and comparing it + to 0. However, as this collection is intended to be accessed concurrently, it may be the case + that another thread will modify the collection after returns, thus invalidating + the result. + + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + For determining whether the collection contains any items, use of the + property is recommended rather than retrieving the number of items from the + property and comparing it to 0. + + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + with the SyncRoot; otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported + + + + A simple (internal) node type used to store elements of concurrent stacks and queues. + + + + + Constructs a new node with the specified value and no next node. + + The value of the node. + + + + A debugger view of the IProducerConsumerCollection that makes it simple to browse the + collection's contents at a point in time. + + The type of elements stored within. + + + + Constructs a new debugger view object for the provided collection object. + + A collection to browse in the debugger. + + + + Returns a snapshot of the underlying collection's elements. + + + + + Represents a particular manner of splitting an orderable data source into multiple partitions. + + Type of the elements in the collection. + + + Each element in each partition has an integer index associated with it, which determines the relative + order of that element against elements in other partitions. + + + Inheritors of must adhere to the following rules: +
    +
  1. All indices must be unique, such that there may not be duplicate indices. If all indices are not + unique, the output ordering may be scrambled.
    2. +
  2. All indices must be non-negative. If any indices are negative, consumers of the implementation + may throw exceptions.
    3. +
  3. and should throw a + if the requested partition count is less than or + equal to zero.
    4. +
  4. and should always return a number + of enumerables equal to the requested partition count. If the partitioner runs out of data and cannot + create as many partitions as requested, an empty enumerator should be returned for each of the + remaining partitions. If this rule is not followed, consumers of the implementation may throw a .
    5. +
  5. , , + , and + should never return null. If null is returned, a consumer of the implementation may throw a + .
    6. +
  6. , , + , and + should always return partitions that can fully and uniquely enumerate the input data source. All of + the data and only the data contained in the input source should be enumerated, with no duplication + that was not already in the input, unless specifically required by the particular partitioner's + design. If this is not followed, the output ordering may be scrambled.
    7. +
  7. If returns true, each partition must return elements + with increasing key indices.
    8. +
  8. If returns true, all the keys in partition numbered N + must be larger than all the keys in partition numbered N-1.
    9. +
  9. If returns true, all indices must be monotonically increasing from + 0, though not necessarily within a single partition.
    10. +
+ + + + + + Represents a particular manner of splitting a data source into multiple partitions. + + Type of the elements in the collection. + + + Inheritors of must adhere to the following rules: +
    +
  1. should throw a + if the requested partition count is less than or + equal to zero.
    2. +
  2. should always return a number of enumerables equal to the requested + partition count. If the partitioner runs out of data and cannot create as many partitions as + requested, an empty enumerator should be returned for each of the remaining partitions. If this rule + is not followed, consumers of the implementation may throw a .
    3. +
  3. and + should never return null. If null is returned, a consumer of the implementation may throw a + .
    4. +
  4. and should always return + partitions that can fully and uniquely enumerate the input data source. All of the data and only the + data contained in the input source should be enumerated, with no duplication that was not already in + the input, unless specifically required by the particular partitioner's design. If this is not + followed, the output ordering may be scrambled.
    5. +
+ + + + + + Partitions the underlying collection into the given number of partitions. + + The number of partitions to create. + A list containing enumerators. + + + + Creates an object that can partition the underlying collection into a variable number of + partitions. + + + + The returned object implements the interface. Calling GetEnumerator on the + object creates another partition over the sequence. + + + The method is only supported if the + property returns true. + + + An object that can create partitions over the underlying data source. + Dynamic partitioning is not supported by this + partitioner. + + + + Gets whether additional partitions can be created dynamically. + + + true if the can create partitions dynamically as they are + requested; false if the can only allocate + partitions statically. + + + + If a derived class does not override and implement , + should return false. The value of should not vary over the lifetime of this instance. + + + + + + Initializes a new instance of the class with the + specified constraints on the index keys. + + + Indicates whether the elements in each partition are yielded in the order of + increasing keys. + + + Indicates whether elements in an earlier partition always come before + elements in a later partition. If true, each element in partition 0 has a smaller order key than + any element in partition 1, each element in partition 1 has a smaller order key than any element + in partition 2, and so on. + + + Indicates whether keys are normalized. If true, all order keys are distinct + integers in the range [0 .. numberOfElements-1]. If false, order keys must still be dictinct, but + only their relative order is considered, not their absolute values. + + + + + Partitions the underlying collection into the specified number of orderable partitions. + + + Each partition is represented as an enumerator over key-value pairs. + The value of the pair is the element itself, and the key is an integer which determines + the relative ordering of this element against other elements in the data source. + + The number of partitions to create. + A list containing enumerators. + + + + Creates an object that can partition the underlying collection into a variable number of + partitions. + + + + The returned object implements the interface. Calling GetEnumerator on the + object creates another partition over the sequence. + + + Each partition is represented as an enumerator over key-value pairs. The value in the pair is the element + itself, and the key is an integer which determines the relative ordering of this element against + other elements. + + + The method is only supported if the SupportsDynamicPartitions + property returns true. + + + An object that can create partitions over the underlying data source. + Dynamic partitioning is not supported by this + partitioner. + + + + Partitions the underlying collection into the given number of ordered partitions. + + + The default implementation provides the same behavior as except + that the returned set of partitions does not provide the keys for the elements. + + The number of partitions to create. + A list containing enumerators. + + + + Creates an object that can partition the underlying collection into a variable number of + partitions. + + + + The returned object implements the interface. Calling GetEnumerator on the + object creates another partition over the sequence. + + + The default implementation provides the same behavior as except + that the returned set of partitions does not provide the keys for the elements. + + + The method is only supported if the + property returns true. + + + An object that can create partitions over the underlying data source. + Dynamic partitioning is not supported by this + partitioner. + + + + Gets whether elements in each partition are yielded in the order of increasing keys. + + + + + Gets whether elements in an earlier partition always come before elements in a later partition. + + + If returns true, each element in partition 0 has a + smaller order key than any element in partition 1, each element in partition 1 has a smaller + order key than any element in partition 2, and so on. + + + + + Gets whether order keys are normalized. + + + If returns true, all order keys are distinct integers in the range + [0 .. numberOfElements-1]. If the property returns false, order keys must still be dictinct, but + only their relative order is considered, not their absolute values. + + + + + Converts an enumerable over key-value pairs to an enumerable over values. + + + + + Provides common partitioning strategies for arrays, lists, and enumerables. + + + + The static methods on are all thread-safe and may be used concurrently + from multiple threads. However, while a created partitioner is in use, the underlying data source + should not be modified, whether from the same thread that's using a partitioner or from a separate + thread. + + + + + + Creates an orderable partitioner from an + instance. + + Type of the elements in source list. + The list to be partitioned. + + A Boolean value that indicates whether the created partitioner should dynamically + load balance between partitions rather than statically partition. + + + An orderable partitioner based on the input list. + + + + + Creates an orderable partitioner from a instance. + + Type of the elements in source array. + The array to be partitioned. + + A Boolean value that indicates whether the created partitioner should dynamically load balance + between partitions rather than statically partition. + + + An orderable partitioner based on the input array. + + + + + Creates an orderable partitioner from a instance. + + Type of the elements in source enumerable. + The enumerable to be partitioned. + + An orderable partitioner based on the input array. + + + The ordering used in the created partitioner is determined by the natural order of the elements + as retrieved from the source enumerable. + + + + + DynamicPartitionEnumerator_Abstract defines the enumerator for each partition for the dynamic load-balance + partitioning algorithm. + - Partition is an enumerator of KeyValuePairs, each corresponding to an item in the data source: + the key is the index in the source collection; the value is the item itself. + - a set of such partitions share a reader over data source. The type of the reader is specified by + TSourceReader. + - each partition requests a contiguous chunk of elements at a time from the source data. The chunk + size is initially 1, and doubles every time until it reaches the maximum chunk size. + The implementation for GrabNextChunk() method has two versions: one for data source of IndexRange + types (IList and the array), one for data source of IEnumerable. + - The method "Reset" is not supported for any partitioning algorithm. + - The implementation for MoveNext() method is same for all dynanmic partitioners, so we provide it + in this abstract class. + + Type of the elements in the data source + Type of the reader on the data source + + + + Abstract method to request a contiguous chunk of elements from the source collection + + specified number of elements requested + + true if we successfully reserved at least one element (up to #=requestedChunkSize) + false if all elements in the source collection have been reserved. + + + + + Dispose is abstract, and depends on the type of the source data: + - For source data type IList and Array, the type of the shared reader is just the dataitself. + We don't do anything in Dispose method for IList and Array. + - For source data type IEnumerable, the type of the shared reader is an enumerator we created. + Thus we need to dispose this shared reader enumerator, when there is no more active partitions + left. + + + + + Reset on partitions is not supported + + + + + Moves to the next element if any. + Try current chunk first, if the current chunk do not have any elements left, then we + attempt to grab a chunk from the source collection. + + + true if successfully moving to the next position; + false otherwise, if and only if there is no more elements left in the current chunk + AND the source collection is exhausted. + + + + + Abstract property, returns whether or not the shared reader has already read the last + element of the source data + + + + + Get the current element in the current partition. Property required by IEnumerator interface + This property is abstract because the implementation is different depending on the type + of the source data: IList, Array or IEnumerable + + + + + Get the current element in the current partition. Property required by IEnumerator interface + + + + + Inherits from DynamicPartitioners + Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance + of EnumerableOfPartitionsForIEnumerator defined internally + + Type of elements in the source data + + + + Overrides OrderablePartitioner.GetOrderablePartitions. + Partitions the underlying collection into the given number of orderable partitions. + + number of partitions requested + A list containing enumerators. + + + + Overrides OrderablePartitioner.GetOrderableDyanmicPartitions + + a enumerable collection of orderable partitions + + + + Whether additional partitions can be created dynamically. + + + + + Provides customized implementation for source data of IEnumerable + Different from the counterpart for IList/Array, this enumerable maintains several additional fields + shared by the partitions it owns, including a boolean "m_hasNoElementsLef", a shared lock, and a + shared count "m_activePartitionCount" + + + + + Inherits from DynamicPartitionEnumerator_Abstract directly + Provides customized implementation for: GrabNextChunk, HasNoElementsLeft, Current, Dispose + + + + + Reserves a contiguous range of elements from source data + + specified number of elements requested + + true if we successfully reserved at least one element (up to #=requestedChunkSize) + false if all elements in the source collection have been reserved. + + + + + If the current partition is to be disposed, we decrement the number of active partitions + for the shared reader. + If the number of active partitions becomes 0, we need to dispose the shared reader we created + + + + + Returns whether or not the shared reader has already read the last + element of the source data + + + We cannot call m_sharedReader.MoveNext(), to see if it hits the last element + or not, because we can't undo MoveNext(). Thus we need to maintain a shared + boolean value m_hasNoElementsLeft across all partitions + + + + + Dynamic load-balance partitioner. This class is abstract and to be derived from by + the customized partitioner classes for IList, Array, and IEnumerable + + Type of the elements in the source data + Type of the source data collection + + + + Constructs a new orderable partitioner + + source data collection + + + + Partition the source data and create an enumerable over the resulting partitions. + + the source data collection + an enumerable of partitions of + + + + Overrides OrderablePartitioner.GetOrderablePartitions. + Partitions the underlying collection into the given number of orderable partitions. + + number of partitions requested + A list containing enumerators. + + + + Overrides OrderablePartitioner.GetOrderableDyanmicPartitions + + a enumerable collection of orderable partitions + + + + Whether additional partitions can be created dynamically. + + + + + Defines dynamic partition for source data of IList and Array. + This class inherits DynamicPartitionEnumerator_Abstract + - implements GrabNextChunk, HasNoElementsLeft, and Dispose methods for IList and Array + - Current property still remains abstract, implementation is different for IList and Array + - introduces another abstract method SourceCount, which returns the number of elements in + the source data. Implementation differs for IList and Array + + Type of the elements in the data source + Type of the reader on the source data + + + + Reserves a contiguous range of elements from source data + + specified number of elements requested + + true if we successfully reserved at least one element (up to #=requestedChunkSize) + false if all elements in the source collection have been reserved. + + + + + For source data type IList and Array, the type of the shared reader is just the data itself. + We don't do anything in Dispose method for IList and Array. + + + + + Get the number of elements from the source reader. + It calls IList.Count or Array.Length + + + + + Returns whether or not the shared reader has already read the last + element of the source data + + + + + Inherits from DynamicPartitioners + Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance + of EnumerableOfPartitionsForIList defined internally + + Type of elements in the source data + + + + Inherits from PartitionList_Abstract + Provides customized implementation for source data of IList + + + + + Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract + Provides customized implementation of SourceCount property and Current property for IList + + + + + return a KeyValuePair of the current element and its key + + + + + Inherits from DynamicPartitioners + Provides customized implementation of GetOrderableDynamicPartitions_Factory method, to return an instance + of EnumerableOfPartitionsForArray defined internally + + Type of elements in the source data + + + + Inherits from PartitionList_Abstract + Provides customized implementation for source data of Array + + + + + Inherits from DynamicPartitionEnumeratorForIndexRange_Abstract + Provides customized implementation of SourceCount property and Current property for Array + + + + + Static partitioning over IList. + - dynamic and load-balance + - Keys are ordered within each partition + - Keys are ordered across partitions + - Keys are normalized + - Number of partitions is fixed once specified, and the elements of the source data are + distributed to each partition as evenly as possible. + + type of the elements + Type of the source data collection + + + + Abstract method to create a partition that covers a range over source data, + starting from "startIndex", ending at "endIndex" + + start index of the current partition on the source data + end index of the current partition on the source data + a partition enumerator over the specified range + + + + Overrides OrderablePartitioner.GetOrderablePartitions + Return a list of partitions, each of which enumerate a fixed part of the source data + The elements of the source data are distributed to each partition as evenly as possible. + Specifically, if the total number of elements is N, and number of partitions is x, and N = a*x +b, + where a is the quotient, and b is the remainder. Then the first b partitions each has a + 1 elements, + and the last x-b partitions each has a elements. + For example, if N=10, x =3, then + partition 0 ranges [0,3], + partition 1 ranges [4,6], + partition 2 ranges [7,9]. + This also takes care of the situation of (x>N), the last x-N partitions are empty enumerators. + An empty enumerator is indicated by + (m_startIndex == list.Count && m_endIndex == list.Count -1) + + specified number of partitions + a list of partitions + + + + Abstract method to return the number of elements in the source data + + + + + Static Partition for IList/Array. + This class implements all methods required by IEnumerator interface, except for the Current property. + Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster element + retrieval. + + + + + Constructs an instance of StaticIndexRangePartition + + the start index in the source collection for the current partition + the end index in the source collection for the current partition + + + + We don't dispose the source for IList and array + + + + + Moves to the next item + Before the first MoveNext is called: m_offset == m_startIndex-1; + + true if successful, false if there is no item left + + + + Current Property is different for IList and Array. Arrays calls 'ldelem' instructions for faster + element retrieval. + + + + + Inherits from StaticIndexRangePartitioner + Provides customized implementation of SourceCount and CreatePartition + + + + + + Inherits from StaticIndexRangePartition + Provides customized implementation of Current property + + + + + + Inherits from StaticIndexRangePartitioner + Provides customized implementation of SourceCount and CreatePartition for Array + + + + + Inherits from StaticIndexRangePartitioner + Provides customized implementation of SourceCount and CreatePartition + + + + + A very simple primitive that allows us to share a value across multiple threads. + + + + + Represents one or more errors that occur during application execution. + + is used to consolidate multiple failures into a single, throwable + exception object. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with + a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the class with a specified error + message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + The argument + is null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with + references to the inner exceptions that are the cause of this exception. + + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with a specified error + message and references to the inner exceptions that are the cause of this exception. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Allocates a new aggregate exception with the specified message and list of inner exceptions. + + The error message that explains the reason for the exception. + The exceptions that are the cause of the current exception. + The argument + is null. + An element of is + null. + + + + Initializes a new instance of the class with serialized data. + + The that holds + the serialized object data about the exception being thrown. + The that + contains contextual information about the source or destination. + The argument is null. + The exception could not be deserialized correctly. + + + + Sets the with information about + the exception. + + The that holds + the serialized object data about the exception being thrown. + The that + contains contextual information about the source or destination. + The argument is null. + + + + Returns the that is the root cause of this exception. + + + + + Invokes a handler on each contained by this . + + The predicate to execute for each exception. The predicate accepts as an + argument the to be processed and returns a Boolean to indicate + whether the exception was handled. + + Each invocation of the returns true or false to indicate whether the + was handled. After all invocations, if any exceptions went + unhandled, all unhandled exceptions will be put into a new + which will be thrown. Otherwise, the method simply returns. If any + invocations of the throws an exception, it will halt the processing + of any more exceptions and immediately propagate the thrown exception as-is. + + An exception contained by this was not handled. + The argument is + null. + + + + Flattens an instances into a single, new instance. + + A new, flattened . + + If any inner exceptions are themselves instances of + , this method will recursively flatten all of them. The + inner exceptions returned in the new + will be the union of all of the the inner exceptions from exception tree rooted at the provided + instance. + + + + + Creates and returns a string representation of the current . + + A string representation of the current exception. + + + + Gets a read-only collection of the instances that caused the + current exception. + + + + + Encapsulates a method that has five parameters and returns a value of the type specified by the TResult parameter. + + + + + Propogates notification that operations should be canceled. + + + + A may be created directly in an unchangeable canceled or non-canceled state + using the CancellationToken's constructors. However, to have a CancellationToken that can change + from a non-canceled to a canceled state, + CancellationTokenSource must be used. + CancellationTokenSource exposes the associated CancellationToken that may be canceled by the source through its + Token property. + + + Once canceled, a token may not transition to a non-canceled state, and a token whose + is false will never change to one that can be canceled. + + + All members of this struct are thread-safe and may be used concurrently from multiple threads. + + + + + + Internal constructor only a CancellationTokenSource should create a CancellationToken + + + + + Initializes the CancellationToken. + + + The canceled state for the token. + + + Tokens created with this constructor will remain in the canceled state specified + by the parameter. If is false, + both and will be false. + If is true, + both and will be true. + + + + + Registers a delegate that will be called when this CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The current ExecutionContext, if one exists, will be captured + along with the delegate and will be used when executing it. + + + The delegate to be executed when the CancellationToken is canceled. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The current ExecutionContext, if one exists, will be captured + along with the delegate and will be used when executing it. + + + The delegate to be executed when the CancellationToken is canceled. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The current ExecutionContext, if one exists, will be captured + along with the delegate and will be used when executing it. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Registers a delegate that will be called when this + CancellationToken is canceled. + + + + If this token is already in the canceled state, the + delegate will be run immediately and synchronously. Any exception the delegate generates will be + propogated out of this method call. + + + The current ExecutionContext, if one exists, + will be captured along with the delegate and will be used when executing it. + + + The delegate to be executed when the CancellationToken is canceled. + The state to pass to the when the delegate is invoked. This may be null. + A Boolean value that indicates whether to capture + the current SynchronizationContext and use it + when invoking the . + The instance that can + be used to deregister the callback. + is null. + The associated CancellationTokenSource has been disposed. + + + + Determines whether the current CancellationToken instance is equal to the + specified token. + + The other CancellationToken to which to compare this + instance. + True if the instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other object to which to compare this instance. + True if is a CancellationToken + and if the two instances are equal; otherwise, false. Two tokens are equal if they are associated + with the same CancellationTokenSource or if they were both constructed + from public CancellationToken constructors and their values are equal. + An associated CancellationTokenSource has been disposed. + + + + Serves as a hash function for a CancellationToken. + + A hash code for the current CancellationToken instance. + + + + Determines whether two CancellationToken instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Determines whether two CancellationToken instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + An associated CancellationTokenSource has been disposed. + + + + Throws a OperationCanceledException if + this token has had cancellation requested. + + + This method provides functionality equivalent to: + + if (token.IsCancellationRequested) + throw new OperationCanceledException(token); + + + The token has had cancellation requested. + The associated CancellationTokenSource has been disposed. + + + + Returns an empty CancellationToken value. + + + The value returned by this property will be non-cancelable by default. + + + + + Gets whether cancellation has been requested for this token. + + Whether cancellation has been requested for this token. + + + This property indicates whether cancellation has been requested for this token, + either through the token initially being construted in a canceled state, or through + calling Cancel + on the token's associated . + + + If this property is true, it only guarantees that cancellation has been requested. + It does not guarantee that every registered handler + has finished executing, nor that cancellation requests have finished propagating + to all registered handlers. Additional synchronization may be required, + particularly in situations where related objects are being canceled concurrently. + + + + + + Gets whether this token is capable of being in the canceled state. + + + If CanBeCanceled returns false, it is guaranteed that the token will never transition + into a canceled state, meaning that will never + return true. + + + + + Gets a that is signaled when the token is canceled. + + Accessing this property causes a WaitHandle + to be instantiated. It is preferable to only use this property when necessary, and to then + dispose the associated instance at the earliest opportunity (disposing + the source will dispose of this allocated handle). The handle should not be closed or disposed directly. + + The associated CancellationTokenSource has been disposed. + + + + Represents a callback delegate that has been registered with a CancellationToken. + + + To unregister a callback, dispose the corresponding Registration instance. + + + + + Attempts to deregister the item. If it's already being run, this may fail. + Entails a full memory fence. + + True if the callback was found and deregistered, false otherwise. + + + + Disposes of the registration and unregisters the target callback from the associated + CancellationToken. + If the target callback is currently executing this method will wait until it completes, except + in the degenerate cases where a callback method deregisters itself. + + + + + Determines whether two CancellationTokenRegistration + instances are equal. + + The first instance. + The second instance. + True if the instances are equal; otherwise, false. + + + + Determines whether two CancellationTokenRegistration instances are not equal. + + The first instance. + The second instance. + True if the instances are not equal; otherwise, false. + + + + Determines whether the current CancellationTokenRegistration instance is equal to the + specified . + + The other object to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Determines whether the current CancellationToken instance is equal to the + specified . + + The other CancellationTokenRegistration to which to compare this instance. + True, if both this and are equal. False, otherwise. + Two CancellationTokenRegistration instances are equal if + they both refer to the output of a single call to the same Register method of a + CancellationToken. + + + + + Serves as a hash function for a CancellationTokenRegistration.. + + A hash code for the current CancellationTokenRegistration instance. + + + + Signals to a that it should be canceled. + + + + is used to instantiate a + (via the source's Token property) + that can be handed to operations that wish to be notified of cancellation or that can be used to + register asynchronous operations for cancellation. That token may have cancellation requested by + calling to the source's Cancel + method. + + + All members of this class, except Dispose, are thread-safe and may be used + concurrently from multiple threads. + + + + + The ID of the thread currently executing the main body of CTS.Cancel() + this helps us to know if a call to ctr.Dispose() is running 'within' a cancellation callback. + This is updated as we move between the main thread calling cts.Cancel() and any syncContexts that are used to + actually run the callbacks. + + + + Initializes the . + + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + However, this overload of Cancel will aggregate any exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Communicates a request for cancellation. + + + + The associated will be + notified of the cancellation and will transition to a state where + IsCancellationRequested returns true. + Any callbacks or cancelable operations + registered with the will be executed. + + + Cancelable operations and callbacks registered with the token should not throw exceptions. + If is true, an exception will immediately propagate out of the + call to Cancel, preventing the remaining callbacks and cancelable operations from being processed. + If is false, this overload will aggregate any + exceptions thrown into a , + such that one callback throwing an exception will not prevent other registered callbacks from being executed. + + + The that was captured when each callback was registered + will be reestablished when the callback is invoked. + + + Specifies whether exceptions should immediately propagate. + An aggregate exception containing all the exceptions thrown + by the registered callbacks on the associated . + This has been disposed. + + + + Releases the resources used by this . + + + This method is not thread-safe for any other concurrent calls. + + + + + Throws an exception if the source has been disposed. + + + + + InternalGetStaticSource() + + Whether the source should be set. + A static source to be shared among multiple tokens. + + + + Registers a callback object. If cancellation has already occurred, the + callback will have been run by the time this method returns. + + + + + + + + + + Invoke the Canceled event. + + + The handlers are invoked synchronously in LIFO order. + + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The first CancellationToken to observe. + The second CancellationToken to observe. + A CancellationTokenSource that is linked + to the source tokens. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Creates a CancellationTokenSource that will be in the canceled state + when any of the source tokens are in the canceled state. + + The CancellationToken instances to observe. + A CancellationTokenSource that is linked + to the source tokens. + is null. + A CancellationTokenSource associated with + one of the source tokens has been disposed. + + + + Gets whether cancellation has been requested for this CancellationTokenSource. + + Whether cancellation has been requested for this CancellationTokenSource. + + + This property indicates whether cancellation has been requested for this token source, such as + due to a call to its + Cancel method. + + + If this property returns true, it only guarantees that cancellation has been requested. It does not + guarantee that every handler registered with the corresponding token has finished executing, nor + that cancellation requests have finished propagating to all registered handlers. Additional + synchronization may be required, particularly in situations where related objects are being + canceled concurrently. + + + + + + A simple helper to determine whether cancellation has finished. + + + + + A simple helper to determine whether disposal has occured. + + + + + The ID of the thread that is running callbacks. + + + + + Gets the CancellationToken + associated with this . + + The CancellationToken + associated with this . + The token source has been + disposed. + + + + + + + + + + + + + + The currently executing callback + + + + + A helper class for collating the various bits of information required to execute + cancellation callbacks. + + + + + InternalExecuteCallbackSynchronously_GeneralPath + This will be called on the target synchronization context, however, we still need to restore the required execution context + + + + + A sparsely populated array. Elements can be sparse and some null, but this allows for + lock-free additions and growth, and also for constant time removal (by nulling out). + + The kind of elements contained within. + + + + Allocates a new array with the given initial size. + + How many array slots to pre-allocate. + + + + Adds an element in the first available slot, beginning the search from the tail-to-head. + If no slots are available, the array is grown. The method doesn't return until successful. + + The element to add. + Information about where the add happened, to enable O(1) deregistration. + + + + The head of the doubly linked list. + + + + + The tail of the doubly linked list. + + + + + A struct to hold a link to the exact spot in an array an element was inserted, enabling + constant time removal later on. + + + + + A fragment of a sparsely populated array, doubly linked. + + The kind of elements contained within. + + + + Represents a synchronization primitive that is signaled when its count reaches zero. + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed, and Reset, which should only be used when no other threads are + accessing the event. + + + + + Initializes a new instance of class with the + specified count. + + The number of signals required to set the . + is less + than 0. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release + only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Registers a signal with the , decrementing its + count. + + true if the signal caused the count to reach zero and the event was set; otherwise, + false. + The current instance is already set. + + The current instance has already been + disposed. + + + + Registers multiple signals with the , + decrementing its count by the specified amount. + + The number of signals to register. + true if the signals caused the count to reach zero and the event was set; otherwise, + false. + + The current instance is already set. -or- Or is greater than . + + is less + than 1. + The current instance has already been + disposed. + + + + Increments the 's current count by one. + + The current instance is already + set. + is equal to . + + The current instance has already been disposed. + + + + + Attempts to increment the 's current count by one. + + true if the increment succeeded; otherwise, false. If is + already at zero. this will return false. + is equal to . + The current instance has already been + disposed. + + + + Increments the 's current count by a specified + value. + + The value by which to increase . + is less than + 0. + The current instance is already + set. + is equal to . + The current instance has already been + disposed. + + + + Attempts to increment the 's current count by a + specified value. + + The value by which to increase . + true if the increment succeeded; otherwise, false. If is + already at zero this will return false. + is less + than 0. + The current instance is already + set. + is equal to . + The current instance has already been + disposed. + + + + Resets the to the value of . + + + Unlike most of the members of , Reset is not + thread-safe and may not be used concurrently with other members of this instance. + + The current instance has already been + disposed.. + + + + Resets the to a specified value. + + The number of signals required to set the . + + Unlike most of the members of , Reset is not + thread-safe and may not be used concurrently with other members of this instance. + + is + less than 0. + The current instance has alread been disposed. + + + + Blocks the current thread until the is set. + + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + The current instance has already been + disposed. + + + + Blocks the current thread until the is set, while + observing a . + + The to + observe. + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. If the + CancellationToken being observed + is canceled during the wait operation, an + will be thrown. + + has been + canceled. + The current instance has already been + disposed. + + + + Blocks the current thread until the is set, using a + to measure the time interval. + + A that represents the number of + milliseconds to wait, or a that represents -1 milliseconds to + wait indefinitely. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + The current instance has already been + disposed. + + + + Blocks the current thread until the is set, using + a to measure the time interval, while observing a + . + + A that represents the number of + milliseconds to wait, or a that represents -1 milliseconds to + wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + The current instance has already been + disposed. + has + been canceled. + + + + Blocks the current thread until the is set, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + The current instance has already been + disposed. + + + + Blocks the current thread until the is set, using a + 32-bit signed integer to measure the time interval, while observing a + . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + The current instance has already been + disposed. + has + been canceled. + + + + Throws an exception if the latch has been disposed. + + + + + Gets the number of remaining signals required to set the event. + + + The number of remaining signals required to set the event. + + + + + Gets the numbers of signals initially required to set the event. + + + The number of signals initially required to set the event. + + + + + Determines whether the event is set. + + true if the event is set; otherwise, false. + + + + Gets a that is used to wait for the event to be set. + + A that is used to wait for the event to be set. + The current instance has already been disposed. + + should only be used if it's needed for integration with code bases + that rely on having a WaitHandle. If all that's needed is to wait for the + to be set, the method should be preferred. + + + + + Provides a slimmed down version of . + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed, and Reset, which should only be used when no other threads are + accessing the event. + + + + + Initializes a new instance of the + class with an initial state of nonsignaled. + + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled. + + true to set the initial state signaled; false to set the initial state + to nonsignaled. + + + + Initializes a new instance of the + class with a Boolen value indicating whether to set the intial state to signaled and a specified + spin count. + + true to set the initial state to signaled; false to set the initial state + to nonsignaled. + The number of spin waits that will occur before falling back to a true + wait. + is less than + 0 or greater than the maximum allowed value. + + + + Initializes the internal state of the event. + + Whether the event is set initially or not. + The spin count that decides when the event will block. + + + + Helper to ensure the lock object is created before first use. + + + + + This method lazily initializes the event object. It uses CAS to guarantee that + many threads racing to call this at once don't result in more than one event + being stored and used. The event will be signaled or unsignaled depending on + the state of the thin-event itself, with synchronization taken into account. + + True if a new event was created and stored, false otherwise. + + + + Sets the state of the event to signaled, which allows one or more threads waiting on the event to + proceed. + + + + + Private helper to actually perform the Set. + + Indicates whether we are calling Set() during cancellation. + The object has been canceled. + + + + Sets the state of the event to nonsignaled, which causes threads to block. + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Blocks the current thread until the current is set. + + + The maximum number of waiters has been exceeded. + + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current receives a signal, + while observing a . + + The to + observe. + + The maximum number of waiters has been exceeded. + + was + canceled. + + The caller of this method blocks indefinitely until the current instance is set. The caller will + return immediately if the event is currently in a set state. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + to measure the time interval, while observing a . + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The to + observe. + true if the was set; otherwise, + false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + was canceled. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + + + + Blocks the current thread until the current is set, using a + 32-bit signed integer to measure the time interval, while observing a . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if the was set; otherwise, + false. + is a + negative number other than -1, which represents an infinite time-out. + + The maximum number of waiters has been exceeded. + + was canceled. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Throw ObjectDisposedException if the MRES is disposed + + + + + Private helper method to wake up waiters when a cancellationToken gets canceled. + + + + + Private helper method for updating parts of a bit-string state value. + Mainly called from the IsSet and Waiters properties setters + + + Note: the parameter types must be int as CompareExchange cannot take a Uint + + The new value + The mask used to set the bits + + + + Private helper method - performs Mask and shift, particular helpful to extract a field from a packed word. + eg ExtractStatePortionAndShiftRight(0x12345678, 0xFF000000, 24) => 0x12, ie extracting the top 8-bits as a simple integer + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + + + Performs a Mask operation, but does not perform the shift. + This is acceptable for boolean values for which the shift is unnecessary + eg (val & Mask) != 0 is an appropriate way to extract a boolean rather than using + ((val & Mask) >> shiftAmount) == 1 + + ?? is there a common place to put this rather than being private to MRES? + + + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started. + The orginal wait timeoutout in milliseconds. + The new wait time in milliseconds, -1 if the time expired, -2 if overflow in counters + has occurred. + + + + Gets the underlying object for this . + + The underlying event object fore this . + + Accessing this property forces initialization of an underlying event object if one hasn't + already been created. To simply wait on this , + the public Wait methods should be preferred. + + + + + Gets whether the event is set. + + true if the event has is set; otherwise, false. + + + + Gets the number of spin waits that will be occur before falling back to a true wait. + + + + + How many threads are waiting. + + + + + Provides support for lazy initialization. + + Specifies the type of element being laziliy initialized. + + + By default, all public and protected members of are thread-safe and may be used + concurrently from multiple threads. These thread-safety guarantees may be removed optionally and per instance + using parameters to the type's constructors. + + + + + + Initializes a new instance of the class that + uses 's default constructor for lazy initialization. + + + An instance created with this constructor may be used concurrently from multiple threads. + + + + + Initializes a new instance of the class that uses a + specified initialization function. + + + The invoked to produce the lazily-initialized value when it is + needed. + + is a null + reference (Nothing in Visual Basic). + + An instance created with this constructor may be used concurrently from multiple threads. + + + + + Initializes a new instance of the + class that uses 's default constructor and a specified thread-safety mode. + + true if this instance should be usable by multiple threads concurrently; false if the instance will only be used by one thread at a time. + + + + + Initializes a new instance of the + class that uses 's default constructor and a specified thread-safety mode. + + The lazy thread-safety mode mode + mode contains an invalid valuee + + + + Initializes a new instance of the class + that uses a specified initialization function and a specified thread-safety mode. + + + The invoked to produce the lazily-initialized value when it is needed. + + true if this instance should be usable by multiple threads concurrently; false if the instance will only be used by one thread at a time. + + is + a null reference (Nothing in Visual Basic). + + + + Initializes a new instance of the class + that uses a specified initialization function and a specified thread-safety mode. + + + The invoked to produce the lazily-initialized value when it is needed. + + The lazy thread-safety mode. + is + a null reference (Nothing in Visual Basic). + mode contains an invalid value. + + + + Static helper function that returns an object based on the given mode. it also throws an exception if the mode is invalid + + + + Forces initialization during serialization. + The StreamingContext for the serialization operation. + + + Creates and returns a string representation of this instance. + The result of calling on the . + + The is null. + + + + + local helper method to initialize the value + + The inititialized T value + + + Creates an instance of T using m_valueFactory in case its not null or use reflection to create a new T() + An instance of Boxed. + + + Gets the value of the Lazy<T> for debugging display purposes. + + + + Gets a value indicating whether this instance may be used concurrently from multiple threads. + + + + + Gets whether the value creation is faulted or not + + + + Gets a value indicating whether the has been initialized. + + true if the instance has been initialized; + otherwise, false. + + The initialization of a instance may result in either + a value being produced or an exception being thrown. If an exception goes unhandled during initialization, + will return false. + + + + + + wrapper class to box the initialized value, this is mainly created to avoid boxing/unboxing the value each time the value is called in case T is + a value type + + + + + Wrapper class to wrap the excpetion thrown by the value factory + + + + A debugger view of the Lazy<T> to surface additional debugging properties and + to ensure that the Lazy<T> does not become initialized if it was not already. + + + Constructs a new debugger view object for the provided Lazy object. + A Lazy object to browse in the debugger. + + + Returns whether the Lazy object is initialized or not. + + + Returns the value of the Lazy object. + + + Returns the execution mode of the Lazy object + + + Returns the execution mode of the Lazy object + + + + Specifies how a instance should synchronize access among multiple threads. + + + + + This mode makes no guarantees around the thread-safety of the instance. If used from multiple threads, the behavior of the is undefined. + This mode should be used when a is guaranteed to never be initialized from more than one thread simultaneously and high performance is crucial. + If valueFactory throws an exception when the is initialized, the exception will be cached and returned on subsequent accesses to Value. Also, if valueFactory recursively + accesses Value on this instance, a will be thrown. + + + + + When multiple threads attempt to simultaneously initialize a instance, this mode allows each thread to execute the + valueFactory but only the first thread to complete initialization will be allowed to set the final value of the . + Once initialized successfully, any future calls to Value will return the cached result. If valueFactory throws an exception on any thread, that exception will be + propagated out of Value. If any thread executes valueFactory without throwing an exception and, therefore, successfully sets the value, that value will be returned on + subsequent accesses to Value from any thread. If no thread succeeds in setting the value, IsValueCreated will remain false and subsequent accesses to Value will result in + the valueFactory delegate re-executing. Also, if valueFactory recursively accesses Value on this instance, an exception will NOT be thrown. + + + + + This mode uses locks to ensure that only a single thread can initialize a instance in a thread-safe manner. In general, + taken if this mode is used in conjunction with a valueFactory delegate that uses locks internally, a deadlock can occur if not + handled carefully. If valueFactory throws an exception when the is initialized, the exception will be cached and returned on + subsequent accesses to Value. Also, if valueFactory recursively accesses Value on this instance, a will be thrown. + + + + + Provides lazy initialization routines. + + + These routines avoid needing to allocate a dedicated, lazy-initialization instance, instead using + references to ensure targets have been initialized as they are accessed. + + + + + Initializes a target reference type with the type's default constructor if the target has not + already been initialized. + + The refence type of the reference to be initialized. + A reference of type to initialize if it has not + already been initialized. + The initialized reference of type . + Type does not have a default + constructor. + + Permissions to access the constructor of type were missing. + + + + This method may only be used on reference types. To ensure initialization of value + types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initializes a target reference type using the specified function if it has not already been + initialized. + + The reference type of the reference to be initialized. + The reference of type to initialize if it has not + already been initialized. + The invoked to initialize the + reference. + The initialized reference of type . + Type does not have a + default constructor. + returned + null. + + + This method may only be used on reference types, and may + not return a null reference (Nothing in Visual Basic). To ensure initialization of value types or + to allow null reference types, see other overloads of EnsureInitialized. + + + This method may be used concurrently by multiple threads to initialize . + In the event that multiple threads access this method concurrently, multiple instances of + may be created, but only one will be stored into . In such an occurrence, this method will not dispose of the + objects that were not stored. If such objects must be disposed, it is up to the caller to determine + if an object was not used and to then dispose of the object appropriately. + + + + + + Initialize the target using the given delegate (slow path). + + The reference type of the reference to be initialized. + The variable that need to be initialized + The delegate that will be executed to initialize the target + The initialized variable + + + + Initializes a target reference or value type with its default constructor if it has not already + been initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The initialized value of type . + + + + Initializes a target reference or value type with a specified function if it has not already been + initialized. + + The type of the reference to be initialized. + A reference or value of type to initialize if it + has not already been initialized. + A reference to a boolean that determines whether the target has already + been initialized. + A reference to an object used as the mutually exclusive lock for initializing + . + The invoked to initialize the + reference or value. + The initialized value of type . + + + + Ensure the target is initialized and return the value (slow path). This overload permits nulls + and also works for value type targets. Uses the supplied function to create the value. + + The type of target. + A reference to the target to be initialized. + A reference to a location tracking whether the target has been initialized. + A reference to a location containing a mutual exclusive lock. + + The to invoke in order to produce the lazily-initialized value. + + The initialized object. + + + + A seprate non generic class that contains a global counter for fast path instances for all Ts that has been created, and adds an upper limit for all instances + that uses the fast path, if this limit has been reached, all new instances will use the slow path + + + + + Provides thread-local storage of data. + + Specifies the type of data stored per-thread. + + + With the exception of , all public and protected members of + are thread-safe and may be used + concurrently from multiple threads. + + + + + + Initializes the instance. + + + + + Initializes the instance with the + specified function. + + + The invoked to produce a lazily-initialized value when + an attempt is made to retrieve without it having been previously initialized. + + + is a null reference (Nothing in Visual Basic). + + + + + Releases the resources used by this instance. + + + + + Releases the resources used by this instance. + + + Unlike most of the members of , this method is not thread-safe. + + + + + Releases the resources used by this instance. + + + A Boolean value that indicates whether this method is being called due to a call to . + + + Unlike most of the members of , this method is not thread-safe. + + + + + Tries to get a unique index for the current instance of type T, it first tries to get it from the pool if it is not empty, otherwise it + increments the global counter if it is still below the maximum, otherwise it fails and returns -1 + + True if there is an index available, false otherwise + + + + Gets an array of types that will be used as generic parameters for the GenericHolder class + + The types array + + + Creates and returns a string representation of this instance for the current thread. + The result of calling on the . + + The for the current thread is a null reference (Nothing in Visual Basic). + + + The initialization function referenced in an improper manner. + + + The instance has been disposed. + + + Calling this method forces initialization for the current thread, as is the + case with accessing directly. + + + + + Private helper function to lazily create the value using the calueSelector if specified in the constructor or the default parameterless constructor + + Returns the boxed object + + + + Gets or sets the value of this instance for the current thread. + + + The initialization function referenced in an improper manner. + + + The instance has been disposed. + + + If this instance was not previously initialized for the current thread, + accessing will attempt to initialize it. If an initialization function was + supplied during the construction, that initialization will happen by invoking the function + to retrieve the initial value for . Otherwise, the default value of + will be used. + + + + + Gets whether is initialized on the current thread. + + + The instance has been disposed. + + + + Gets the value of the ThreadLocal<T> for debugging display purposes. It takes care of getting + the value for the current thread in the ThreadLocal mode. + + + + The base abstract class for the holder + + + + + The TLS holder representation + + + + + The generic holder representation + + Dummy param + Dummy param + Dummy param + + + + wrapper to the actual value + + + + A debugger view of the ThreadLocal<T> to surface additional debugging properties and + to ensure that the ThreadLocal<T> does not become initialized if it was not already. + + + Constructs a new debugger view object for the provided ThreadLocal object. + A ThreadLocal object to browse in the debugger. + + + Returns whether the ThreadLocal object is initialized or not. + + + Returns the value of the ThreadLocal object. + + + + Limits the number of threads that can access a resource or pool of resources concurrently. + + + + The provides a lightweight semaphore class that doesn't + use Windows kernel semaphores. + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed. + + + + + + Initializes a new instance of the class, specifying + the initial number of requests that can be granted concurrently. + + The initial number of requests for the semaphore that can be granted + concurrently. + + is less than 0. + + + + Initializes a new instance of the class, specifying + the initial and maximum number of requests that can be granted concurrently. + + The initial number of requests for the semaphore that can be granted + concurrently. + The maximum number of requests for the semaphore that can be granted + concurrently. + + is less than 0. -or- + is greater than . -or- + is less than 0. + + + + Blocks the current thread until it can enter the . + + The current instance has already been + disposed. + + + + Blocks the current thread until it can enter the , while observing a + . + + The token to + observe. + was + canceled. + The current instance has already been + disposed. + + + + Blocks the current thread until it can enter the , using a to measure the time interval. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the current thread successfully entered the ; + otherwise, false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + + + + Blocks the current thread until it can enter the , using a to measure the time interval, while observing a . + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The to + observe. + true if the current thread successfully entered the ; + otherwise, false. + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than . + was canceled. + + + + Blocks the current thread until it can enter the , using a 32-bit + signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the current thread successfully entered the ; + otherwise, false. + is a + negative number other than -1, which represents an infinite time-out. + + + + Blocks the current thread until it can enter the , + using a 32-bit signed integer to measure the time interval, + while observing a . + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + The to observe. + true if the current thread successfully entered the ; otherwise, false. + is a negative number other than -1, + which represents an infinite time-out. + was canceled. + + + + Local helper function, waits on the monitor until the monitor recieves signal or the + timeout is expired + + The maximum timeout + The start ticks to calculate the elapsed time + The CancellationToken to observe. + true if the monitor recieved a signal, false if the timeout expired + + + + Exits the once. + + The previous count of the . + The current instance has already been + disposed. + + + + Exits the a specified number of times. + + The number of times to exit the semaphore. + The previous count of the . + is less + than 1. + The has + already reached its maximum size. + The current instance has already been + disposed. + + + + Releases all resources used by the current instance of . + + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; + false to release only unmanaged resources. + + Unlike most of the members of , is not + thread-safe and may not be used concurrently with other members of this instance. + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started + The orginal wait timeoutout in milliseconds + The new wait time in milliseconds, -1 if the time expired + + + + Private helper method to wake up waiters when a cancellationToken gets canceled. + + + + + Checks the dispose status by checking the lock object, if it is null means that object + has been disposed and throw ObjectDisposedException + + + + + local helper function to retrieve the exception string message from the resource file + + The key string + + + + Gets the current count of the . + + The current count of the . + + + + Returns a that can be used to wait on the semaphore. + + A that can be used to wait on the + semaphore. + + A successful wait on the does not imply a successful wait on + the itself, nor does it decrement the semaphore's + count. exists to allow a thread to block waiting on multiple + semaphores, but such a wait should be followed by a true wait on the target semaphore. + + The has been disposed. + + + + Provides support for spin-based waiting. + + + + encapsulates common spinning logic. On single-processor machines, yields are + always used instead of busy waits, and on computers with Intel™ processors employing Hyper-Threading™ + technology, it helps to prevent hardware thread starvation. SpinWait encapsulates a good mixture of + spinning and true yielding. + + + is a value type, which means that low-level code can utilize SpinWait without + fear of unnecessary allocation overheads. SpinWait is not generally useful for ordinary applications. + In most cases, you should use the synchronization classes provided by the .NET Framework, such as + . For most purposes where spin waiting is required, however, + the type should be preferred over the method. + + + While SpinWait is designed to be used in concurrent applications, it is not designed to be + used from multiple threads concurrently. SpinWait's members are not thread-safe. If multiple + threads must spin, each should use its own instance of SpinWait. + + + + + + Performs a single spin. + + + This is typically called in a loop, and may change in behavior based on the number of times a + has been called thus far on this instance. + + + + + Resets the spin counter. + + + This makes and behave as though no calls + to had been issued on this instance. If a instance + is reused many times, it may be useful to reset it to avoid yielding too soon. + + + + + Spins until the specified condition is satisfied. + + A delegate to be executed over and over until it returns true. + The argument is null. + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + + A that represents the number of milliseconds to wait, + or a TimeSpan that represents -1 milliseconds to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + + + + Spins until the specified condition is satisfied or until the specified timeout is expired. + + A delegate to be executed over and over until it returns true. + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the condition is satisfied within the timeout; otherwise, false + The argument is null. + is a + negative number other than -1, which represents an infinite time-out. + + + + Gets the number of times has been called on this instance. + + + + + Gets whether the next call to will yield the processor, triggering a + forced context switch. + + Whether the next call to will yield the processor, triggering a + forced context switch. + + On a single-CPU machine, always yields the processor. On machines with + multiple CPUs, may yield after an unspecified number of calls. + + + + + A helper class to get the number of preocessors, it updates the numbers of processors every sampling interval + + + + + Gets the number of available processors + + + + + Gets whether the current machine has only a single processor. + + + + + Provides a mutual exclusion lock primitive where a thread trying to acquire the lock waits in a loop + repeatedly checking until the lock becomes available. + + + + Spin locks can be used for leaf-level locks where the object allocation implied by using a , in size or due to garbage collection pressure, is overly + expensive. Avoiding blocking is another reason that a spin lock can be useful, however if you expect + any significant amount of blocking, you are probably best not using spin locks due to excessive + spinning. Spinning can be beneficial when locks are fine grained and large in number (for example, a + lock per node in a linked list) as well as when lock hold times are always extremely short. In + general, while holding a spin lock, one should avoid blocking, calling anything that itself may + block, holding more than one spin lock at once, making dynamically dispatched calls (interface and + virtuals), making statically dispatched calls into any code one doesn't own, or allocating memory. + + + should only be used when it's been determined that doing so will improve an + application's performance. It's also important to note that is a value type, + for performance reasons. As such, one must be very careful not to accidentally copy a SpinLock + instance, as the two instances (the original and the copy) would then be completely independent of + one another, which would likely lead to erroneous behavior of the application. If a SpinLock instance + must be passed around, it should be passed by reference rather than by value. + + + Do not store instances in readonly fields. + + + All members of are thread-safe and may be used from multiple threads + concurrently. + + + + + + Initializes a new instance of the + structure with the option to track thread IDs to improve debugging. + + + The default constructor for tracks thread ownership. + + Whether to capture and use thread IDs for debugging + purposes. + + + + Initializes a new instance of the + structure with the option to track thread IDs to improve debugging. + + + The default constructor for tracks thread ownership. + + + Acquires the lock in a reliable manner, such that even if an exception occurs within the method + call, can be examined reliably to determine whether the lock was + acquired. + + + is a non-reentrant lock, meaning that if a thread holds the lock, it is + not allowed to enter the lock again. If thread ownership tracking is enabled (whether it's + enabled is available through ), an exception will be + thrown when a thread tries to re-enter a lock it already holds. However, if thread ownership + tracking is disabled, attempting to enter a lock already held will result in deadlock. + + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + The argument must be initialized to false prior to calling Enter. + + + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within + the method call, can be examined reliably to determine whether the + lock was acquired. + + + Unlike , TryEnter will not block waiting for the lock to be available. If the + lock is not available when TryEnter is called, it will return immediately without any further + spinning. + + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + The argument must be initialized to false prior to calling TryEnter. + + + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within + the method call, can be examined reliably to determine whether the + lock was acquired. + + + Unlike , TryEnter will not block indefinitely waiting for the lock to be + available. It will block until either the lock is available or until the + has expired. + + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + The argument must be initialized to false prior to calling TryEnter. + + is a negative + number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater + than milliseconds. + + + + + Attempts to acquire the lock in a reliable manner, such that even if an exception occurs within + the method call, can be examined reliably to determine whether the + lock was acquired. + + + Unlike , TryEnter will not block indefinitely waiting for the lock to be + available. It will block until either the lock is available or until the has expired. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + True if the lock is acquired; otherwise, false. must be initialized to false prior to calling this method. + + Thread ownership tracking is enabled, and the current thread has already acquired this lock. + + + The argument must be initialized to false prior to calling TryEnter. + + is + a negative number other than -1, which represents an infinite time-out. + + + + Try acquire the lock with long path, this is usually called after the first path in Enter and + TryEnter failed The reason for short path is to make it inline in the run time which improves the + performance. This method assumed that the parameter are validated in Enter ir TryENter method + + The timeout milliseconds + The lockTaken param + + + + decrements the waiters, in case of the timeout is expired + + + + + ContinueTryEnter for the thread tracking mode enabled + + + + + Helper function to validate the timeout + + The start time in ticks + The orginal wait time + True if expired, false otherwise + + + + Releases the lock. + + + The default overload of provides the same behavior as if calling using true as the argument. + + + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + + + Releases the lock. + + + A Boolean value that indicates whether a memory fence should be issued in order to immediately + publish the exit operation to other threads. + + + Calling with the argument set to + true will improve the fairness of the lock at the expense of some performance. The default + overload behaves as if specifying true for . + + + Thread ownership tracking is enabled, and the current thread is not the owner of this lock. + + + + + Gets whether the lock is currently held by any thread. + + + + + Gets whether the lock is currently held by any thread. + + + Gets whether the lock is held by the current thread. + + + If the lock was initialized to track owner threads, this will return whether the lock is acquired + by the current thread. It is invalid to use this property when the lock was initialized to not + track thread ownership. + + + Thread ownership tracking is disabled. + + + + Gets whether thread ownership tracking is enabled for this instance. + + + + Internal class used by debug type proxy attribute to display the owner thread ID + + + + + SystemThreading_SpinLockDebugView constructor + + The SpinLock to be proxied. + + + + Checks if the lock is held by the current thread or not + + + + + Gets the current owner thread, zero if it is released + + + + + Gets whether the lock is currently held by any thread or not. + + + + + Stores options that configure the operation of methods on the + Parallel class. + + + By default, methods on the Parallel class attempt to utilize all available processors, are non-cancelable, and target + the default TaskScheduler (TaskScheduler.Default). enables + overriding these defaults. + + + + + Initializes a new instance of the class. + + + This constructor initializes the instance with default values. + is initialized to -1, signifying that there is no upper bound set on how much parallelism should + be employed. is initialized to a non-cancelable token, + and is initialized to the default scheduler (TaskScheduler.Default). + All of these defaults may be overwritten using the property set accessors on the instance. + + + + + Gets or sets the TaskScheduler + associated with this instance. Setting this property to null + indicates that the current scheduler should be used. + + + + + Gets or sets the maximum degree of parallelism enabled by this ParallelOptions instance. + + + The limits the number of concurrent operations run by Parallel method calls that are passed this + ParallelOptions instance to the set value, if it is positive. If is -1, then there is no limit placed on the number of concurrently + running operations. + + + The exception that is thrown when this is set to 0 or some + value less than -1. + + + + + Gets or sets the CancellationToken + associated with this instance. + + + Providing a CancellationToken + to a Parallel method enables the operation to be + exited early. Code external to the operation may cancel the token, and if the operation observes the + token being set, it may exit early by throwing an + . + + + + + Provides support for parallel loops and regions. + + + The class provides library-based data parallel replacements + for common operations such as for loops, for each loops, and execution of a set of statements. + + + + + Executes each of the provided actions, possibly in parallel. + + An array of Actions to execute. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null element. + The exception that is thrown when any + action in the array throws an exception. + + This method can be used to execute a set of operations, potentially in parallel. + No guarantees are made about the order in which the operations execute or whether + they execute in parallel. This method does not return until each of the + provided operations has completed, regardless of whether completion + occurs due to normal or exceptional termination. + + + + + Executes each of the provided actions, possibly in parallel. + + A ParallelOptions + instance that configures the behavior of this operation. + An array of Actions to execute. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null element. + The exception that is thrown when + the CancellationToken in the + is set. + The exception that is thrown when any + action in the array throws an exception. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + + This method can be used to execute a set of operations, potentially in parallel. + No guarantees are made about the order in which the operations execute or whether + the they execute in parallel. This method does not return until each of the + provided operations has completed, regardless of whether completion + occurs due to normal or exceptional termination. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the iteration count (an Int32) as a parameter. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the iteration count (an Int64) as a parameter. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the iteration count (an Int32) as a parameter. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the iteration count (an Int64) as a parameter. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int32), + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + Calling ParallelLoopState.Break() + informs the For operation that iterations after the current one need not + execute. However, all iterations before the current one will still need to be executed if they have not already. + Therefore, calling Break is similar to using a break operation within a + conventional for loop in a language like C#, but it is not a perfect substitute: for example, there is no guarantee that iterations + after the current one will definitely not execute. + + + If executing all iterations before the current one is not necessary, + ParallelLoopState.Stop() + should be preferred to using Break. Calling Stop informs the For loop that it may abandon all remaining + iterations, regardless of whether they're for interations above or below the current, + since all required work has already been completed. As with Break, however, there are no guarantees regarding + which other iterations will not execute. + + + When a loop is ended prematurely, the that's returned will contain + relevant information about the loop's completion. + + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int64), + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int32), + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + + + Executes a for loop in which iterations may run in parallel. + + The start index, inclusive. + The end index, exclusive. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int64), + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + + + Executes a for loop in which iterations may run in parallel. + + The type of the thread-local data. + The start index, inclusive. + The end index, exclusive. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int32), + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for loop in which iterations may run in parallel. Supports 64-bit indices. + + The type of the thread-local data. + The start index, inclusive. + The end index, exclusive. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int64), + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for loop in which iterations may run in parallel. + + The type of the thread-local data. + The start index, inclusive. + The end index, exclusive. + A ParallelOptions + instance that configures the behavior of this operation. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int32), + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for loop in which iterations may run in parallel. + + The type of the thread-local data. + The start index, inclusive. + The end index, exclusive. + A ParallelOptions + instance that configures the behavior of this operation. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each value in the iteration range: + [fromInclusive, toExclusive). It is provided with the following parameters: the iteration count (an Int64), + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Performs the major work of the parallel for loop. It assumes that argument validation has already + been performed by the caller. This function's whole purpose in life is to enable as much reuse of + common implementation details for the various For overloads we offer. Without it, we'd end up + with lots of duplicate code. It handles: (1) simple for loops, (2) for loops that depend on + ParallelState, and (3) for loops with thread local data. + + @TODO: at some point in the future, we may want to manually inline the interesting bits into the + specific overloads above. There is some overhead associated with the extra arguments passed to + the function, and various if-checks in the code. It is also more difficult to follow what the + code does as-is because it has to handle the three flavors. + + The type of the local data. + The loop's start index, inclusive. + The loop's end index, exclusive. + A ParallelOptions instance. + The simple loop body. + The loop body for ParallelState overloads. + The loop body for thread local state overloads. + A selector function that returns new thread local state. + A cleanup function to destroy thread local state. + Only one of the body arguments may be supplied (i.e. they are exclusive). + A structure. + + + + Performs the major work of the 64-bit parallel for loop. It assumes that argument validation has already + been performed by the caller. This function's whole purpose in life is to enable as much reuse of + common implementation details for the various For overloads we offer. Without it, we'd end up + with lots of duplicate code. It handles: (1) simple for loops, (2) for loops that depend on + ParallelState, and (3) for loops with thread local data. + + @TODO: at some point in the future, we may want to manually inline the interesting bits into the + specific overloads above. There is some overhead associated with the extra arguments passed to + the function, and various if-checks in the code. It is also more difficult to follow what the + code does as-is because it has to handle the three flavors. + + The type of the local data. + The loop's start index, inclusive. + The loop's end index, exclusive. + A ParallelOptions instance. + The simple loop body. + The loop body for ParallelState overloads. + The loop body for thread local state overloads. + A selector function that returns new thread local state. + A cleanup function to destroy thread local state. + Only one of the body arguments may be supplied (i.e. they are exclusive). + A structure. + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + An enumerable data source. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each element in the + enumerable. It is provided with the current element as a parameter. + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + An enumerable data source. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each element in the + enumerable. It is provided with the current element as a parameter. + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + An enumerable data source. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + An enumerable data source. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + An enumerable data source. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and the current element's index (an Int64). + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + An enumerable data source. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and the current element's index (an Int64). + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + The type of the thread-local data. + An enumerable data source. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + The type of the thread-local data. + An enumerable data source. + A ParallelOptions + instance that configures the behavior of this operation. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + The type of the thread-local data. + An enumerable data source. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, the current element's index (an Int64), and some local + state that may be shared amongst iterations that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for each operation on an + in which iterations may run in parallel. + + The type of the data in the source. + The type of the thread-local data. + An enumerable data source. + A ParallelOptions + instance that configures the behavior of this operation. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The delegate is invoked once for each element in the + enumerable. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, the current element's index (an Int64), and some local + state that may be shared amongst iterations that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Performs the major work of the parallel foreach loop. It assumes that argument validation has + already been performed by the caller. This function's whole purpose in life is to enable as much + reuse of common implementation details for the various For overloads we offer. Without it, we'd + end up with lots of duplicate code. It handles: (1) simple foreach loops, (2) foreach loops that + depend on ParallelState, and (3) foreach loops that access indices, (4) foreach loops with thread + local data, and any necessary permutations thereof. + + @TODO: at some point in the future, we may want to manually inline the interesting bits into the + specific overloads above. There is some overhead associated with the extra arguments passed to + the function, and various if-checks in the code. It is also more difficult to follow what the + code does as-is because it has to handle the all flavors. + + The type of the source data. + The type of the local data. + An enumerable data source. + ParallelOptions instance to use with this ForEach-loop + The simple loop body. + The loop body for ParallelState overloads. + The loop body for ParallelState/indexed overloads. + The loop body for ParallelState/thread local state overloads. + The loop body for ParallelState/indexed/thread local state overloads. + A selector function that returns new thread local state. + A cleanup function to destroy thread local state. + Only one of the bodyXX arguments may be supplied (i.e. they are exclusive). + A structure. + + + + A fast path for the more general ForEachWorker method above. This uses ldelem instructions to + access the individual elements of the array, which will be faster. + + The type of the source data. + The type of the local data. + An array data source. + The options to use for execution. + The simple loop body. + The loop body for ParallelState overloads. + The loop body for indexed/ParallelLoopState overloads. + The loop body for local/ParallelLoopState overloads. + The loop body for the most generic overload. + A selector function that returns new thread local state. + A cleanup function to destroy thread local state. + A structure. + + + + A fast path for the more general ForEachWorker method above. This uses IList<T>'s indexer + capabilities to access the individual elements of the list rather than an enumerator. + + The type of the source data. + The type of the local data. + A list data source. + The options to use for execution. + The simple loop body. + The loop body for ParallelState overloads. + The loop body for indexed/ParallelLoopState overloads. + The loop body for local/ParallelLoopState overloads. + The loop body for the most generic overload. + A selector function that returns new thread local state. + A cleanup function to destroy thread local state. + A structure. + + + + Executes a for each operation on a + Partitioner in which iterations may run in parallel. + + The type of the elements in . + The Partitioner that contains the original data source. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + SupportsDynamicPartitions property in the Partitioner returns + false. + The exception that is thrown when any + methods in the Partitioner return null. + The exception that is thrown when the + GetPartitions() method in the Partitioner does not return + the correct number of partitions. + The exception that is thrown when the + GetPartitions() method in the Partitioner returns an IList + with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() method in the Partitioner returns an + IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the current element as a parameter. + + + + + + Executes a for each operation on a + Partitioner in which iterations may run in parallel. + + The type of the elements in . + The Partitioner that contains the original data source. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + SupportsDynamicPartitions property in the Partitioner returns + false. + The exception that is thrown when any + methods in the Partitioner return null. + The exception that is thrown when the + GetPartitions() method in the Partitioner does not return + the correct number of partitions. + The exception that is thrown when the + GetPartitions() method in the Partitioner returns an IList + with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() method in the Partitioner returns an + IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + + + + Executes a for each operation on a + OrderablePartitioner in which iterations may run in parallel. + + The type of the elements in . + The OrderablePartitioner that contains the original data source. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + SupportsDynamicPartitions property in the OrderablePartitioner returns + false. + The exception that is thrown when the + KeysNormalized property in the OrderablePartitioner returns + false. + The exception that is thrown when any + methods in the OrderablePartitioner return null. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner do not return the correct number of partitions. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner return an IList with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the + OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and the current element's index (an Int64). + + + + + + Executes a for each operation on a + Partitioner in which iterations may run in parallel. + + The type of the elements in . + The type of the thread-local data. + The Partitioner that contains the original data source. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + SupportsDynamicPartitions property in the Partitioner returns + false. + The exception that is thrown when any + methods in the Partitioner return null. + The exception that is thrown when the + GetPartitions() method in the Partitioner does not return + the correct number of partitions. + The exception that is thrown when the + GetPartitions() method in the Partitioner returns an IList + with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() method in the Partitioner returns an + IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for each operation on a + OrderablePartitioner in which iterations may run in parallel. + + The type of the elements in . + The type of the thread-local data. + The OrderablePartitioner that contains the original data source. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + SupportsDynamicPartitions property in the OrderablePartitioner returns + false. + The exception that is thrown when the + KeysNormalized property in the OrderablePartitioner returns + false. + The exception that is thrown when any + methods in the OrderablePartitioner return null. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner do not return the correct number of partitions. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner return an IList with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the + OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, the current element's index (an Int64), and some local + state that may be shared amongst iterations that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for each operation on a + Partitioner in which iterations may run in parallel. + + The type of the elements in . + The Partitioner that contains the original data source. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown when the + SupportsDynamicPartitions property in the Partitioner returns + false. + The exception that is thrown when any + methods in the Partitioner return null. + The exception that is thrown when the + GetPartitions() method in the Partitioner does not return + the correct number of partitions. + The exception that is thrown when the + GetPartitions() method in the Partitioner returns an IList + with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() method in the Partitioner returns an + IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the current element as a parameter. + + + + + + Executes a for each operation on a + Partitioner in which iterations may run in parallel. + + The type of the elements in . + The Partitioner that contains the original data source. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown when the + SupportsDynamicPartitions property in the Partitioner returns + false. + The exception that is thrown when any + methods in the Partitioner return null. + The exception that is thrown when the + GetPartitions() method in the Partitioner does not return + the correct number of partitions. + The exception that is thrown when the + GetPartitions() method in the Partitioner returns an IList + with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() method in the Partitioner returns an + IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + and a ParallelLoopState instance that may be + used to break out of the loop prematurely. + + + + + + Executes a for each operation on a + OrderablePartitioner in which iterations may run in parallel. + + The type of the elements in . + The OrderablePartitioner that contains the original data source. + A ParallelOptions + instance that configures the behavior of this operation. + The delegate that is invoked once per iteration. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown when the + SupportsDynamicPartitions property in the OrderablePartitioner returns + false. + The exception that is thrown when the + KeysNormalized property in the OrderablePartitioner returns + false. + The exception that is thrown when any + methods in the OrderablePartitioner return null. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner do not return the correct number of partitions. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner return an IList with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the + OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and the current element's index (an Int64). + + + + + + Executes a for each operation on a + Partitioner in which iterations may run in parallel. + + The type of the elements in . + The type of the thread-local data. + The Partitioner that contains the original data source. + A ParallelOptions + instance that configures the behavior of this operation. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown when the + SupportsDynamicPartitions property in the Partitioner returns + false. + The exception that is thrown when any + methods in the Partitioner return null. + The exception that is thrown when the + GetPartitions() method in the Partitioner does not return + the correct number of partitions. + The exception that is thrown when the + GetPartitions() method in the Partitioner returns an IList + with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() method in the Partitioner returns an + IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, and some local state that may be shared amongst iterations + that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Executes a for each operation on a + OrderablePartitioner in which iterations may run in parallel. + + The type of the elements in . + The type of the thread-local data. + The OrderablePartitioner that contains the original data source. + A ParallelOptions + instance that configures the behavior of this operation. + The function delegate that returns the initial state of the local data + for each thread. + The delegate that is invoked once per iteration. + The delegate that performs a final action on the local state of each + thread. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + CancellationToken in the + argument is set + The exception that is thrown when the + SupportsDynamicPartitions property in the OrderablePartitioner returns + false. + The exception that is thrown when the + KeysNormalized property in the OrderablePartitioner returns + false. + The exception that is thrown when any + methods in the OrderablePartitioner return null. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner do not return the correct number of partitions. + The exception that is thrown when the + GetPartitions() or GetOrderablePartitions() methods in the + OrderablePartitioner return an IList with at least one null value. + The exception that is thrown when the + GetDynamicPartitions() or GetDynamicOrderablePartitions() methods in the + OrderablePartitioner return an IEnumerable whose GetEnumerator() method returns null. + The exception that is thrown to contain an exception + thrown from one of the specified delegates. + The exception that is thrown when the + the CancellationTokenSource associated with the + the CancellationToken in the + has been disposed. + A ParallelLoopResult structure + that contains information on what portion of the loop completed. + + + The Partitioner is used to retrieve + the elements to be processed, in place of the original data source. If the current element's + index is desired, the source must be an + OrderablePartitioner. + + + The delegate is invoked once for each element in the + Partitioner. It is provided with the following parameters: the current element, + a ParallelLoopState instance that may be + used to break out of the loop prematurely, the current element's index (an Int64), and some local + state that may be shared amongst iterations that execute on the same thread. + + + The delegate is invoked once for each thread that participates in the loop's + execution and returns the initial local state for each of those threads. These initial states are passed to the first + invocations on each thread. Then, every subsequent body invocation returns a possibly + modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value + that is passed to the delegate. The localFinally delegate is invoked once per thread to perform a final + action on each thread's local state. + + + + + + Internal utility function that implements the OCE filtering behavior for all Parallel.* APIs. + Throws a single OperationCancelledException object with the token if the Exception collection only contains + OperationCancelledExceptions with the given CancellationToken. + + + The exception collection to filter + The CancellationToken expected on all inner exceptions + + + + + Enables iterations of loops to interact with + other iterations. + + + + + Communicates that the loop should cease execution at the system's earliest + convenience. + + + The method was previously called. and may not be used in combination by iterations of the same loop. + + + + may be used to communicate to the loop that no other iterations need be run. + For long-running iterations that may already be executing, causes + to return true for all other iterations of the loop, such that another iteration may check and exit early if it's observed to be true. + + + is typically employed in search-based algorithms, where once a result is found, + no other iterations need be executed. + + + + + + Communicates that the loop should cease execution at the system's earliest + convenience of iterations beyond the current iteration. + + + The method was previously called. and + may not be used in combination by iterations of the same loop. + + + + may be used to communicate to the loop that no other iterations after the + current iteration need be run. For example, if is called from the 100th + iteration of a for loop iterating in parallel from 0 to 1000, all iterations less than 100 should + still be run, but the iterations from 101 through to 1000 are not necessary. + + + For long-running iterations that may already be executing, causes + to be set to the current iteration's index if the current index is less than the current value of + . + + + is typically employed in search-based algorithms where an ordering is + present in the data source. + + + + + + Internal/virtual support for ShouldExitCurrentIteration. + + + + + Gets whether the current iteration of the loop should exit based + on requests made by this or other iterations. + + + When an iteration of a loop calls or , or + when one throws an exception, or when the loop is canceled, the class will proactively + attempt to prohibit additional iterations of the loop from starting execution. + However, there may be cases where it is unable to prevent additional iterations from starting. + It may also be the case that a long-running iteration has already begun execution. In such + cases, iterations may explicitly check the property and + cease execution if the property returns true. + + + + + Gets whether any iteration of the loop has called . + + + + + Gets whether any iteration of the loop has thrown an exception that went unhandled by that + iteration. + + + + + Internal/virtual support for LowestBreakIteration. + + + + + Gets the lowest iteration of the loop from which was called. + + + If no iteration of the loop called , this property will return null. + + + + + Internal constructor to ensure an instance isn't created by users. + + A flag shared among all threads participating + in the execution of a certain loop. + + + + Communicates that parallel tasks should stop when they reach a specified iteration element. + (which is CurrentIteration of the caller). + + Break() called after Stop(). + + This is shared with all other concurrent threads in the system which are participating in the + loop's execution. After calling Break(), no additional iterations will be executed on + the current thread, and other worker threads will execute once they get beyond the calling iteration. + + + + + Tracks the current loop iteration for the owning task. + This is used to compute whether or not the task should + terminate early due to a Break() call. + + + + + Returns true if we should be exiting from the current iteration + due to Stop(), Break() or exception. + + + + + Returns the lowest iteration at which Break() has been called, or + null if Break() has not yet been called. + + + + + Allows independent iterations of a parallel loop to interact with other iterations. + + + + + Internal constructor to ensure an instance isn't created by users. + + A flag shared among all threads participating + in the execution of a certain loop. + + + + Communicates that parallel tasks should stop when they reach a specified iteration element. + (which is CurrentIteration of the caller). + + Break() called after Stop(). + + Atomically sets shared StoppedBroken flag to BROKEN, then atomically sets shared + LowestBreakIteration to CurrentIteration, but only if CurrentIteration is less than + LowestBreakIteration. + + + + + Tracks the current loop iteration for the owning task. + This is used to compute whether or not the task should + terminate early due to a Break() call. + + + + + Returns true if we should be exiting from the current iteration + due to Stop(), Break() or exception. + + + + + Returns the lowest iteration at which Break() has been called, or + null if Break() has not yet been called. + + + + + State information that is common between ParallelStateFlags class + and ParallelStateFlags64 class. + + + + + An internal class used to share accounting information in 32-bit versions + of For()/ForEach() loops. + + + + + Lets the caller know whether or not to prematurely exit the For/ForEach loop. + If this returns true, then exit the loop. Otherwise, keep going. + + The caller's current iteration point + in the loop. + + The loop should exit on any one of the following conditions: + (1) Stop() has been called by one or more tasks. + (2) An exception has been raised by one or more tasks. + (3) Break() has been called by one or more tasks, and + CallerIteration exceeds the (lowest) iteration at which + Break() was called. + (4) The loop was canceled. + + + + + An internal class used to share accounting information in 64-bit versions + of For()/ForEach() loops. + + + + + Lets the caller know whether or not to prematurely exit the For/ForEach loop. + If this returns true, then exit the loop. Otherwise, keep going. + + The caller's current iteration point + in the loop. + + The loop should exit on any one of the following conditions: + (1) Stop() has been called by one or more tasks. + (2) An exception has been raised by one or more tasks. + (3) Break() has been called by one or more tasks, and + CallerIteration exceeds the (lowest) iteration at which + Break() was called. + (4) The loop has been canceled. + + + + + Provides completion status on the execution of a loop. + + + If returns true, then the loop ran to completion, such that all iterations + of the loop were executed. If returns false and returns null, a call to was used to end the loop prematurely. If returns false and returns a non-null integral + value, was used to end the loop prematurely. + + + + + Gets whether the loop ran to completion, such that all iterations of the loop were executed + and the loop didn't receive a request to end prematurely. + + + + + Gets the index of the lowest iteration from which + was called. + + + If was not employed, this property will + return null. + + + + + Utility class for allocating structs as heap variables + + + + + Represents an index range + + + + + The RangeWorker struct wraps the state needed by a task that services the parallel loop + + + + + Initializes a RangeWorker struct + + + + + Implements the core work search algorithm that will be used for this range worker. + + + Usage pattern is: + 1) the thread associated with this rangeworker calls FindNewWork + 2) if we return true, the worker uses the nFromInclusiveLocal and nToExclusiveLocal values + to execute the sequential loop + 3) if we return false it means there is no more work left. It's time to quit. + + + + + 32 bit integer version of FindNewWork. Assumes the ranges were initialized with 32 bit values. + + + + + Represents the entire loop operation, keeping track of workers and ranges. + + + The usage pattern is: + 1) The Parallel loop entry function (ForWorker) creates an instance of this class + 2) Every thread joining to service the parallel loop calls RegisterWorker to grab a + RangeWorker struct to wrap the state it will need to find and execute work, + and they keep interacting with that struct until the end of the loop + + + + Initializes a RangeManager with the given loop parameters, and the desired number of outer ranges + + + + + The function that needs to be called by each new worker thread servicing the parallel loop + in order to get a RangeWorker struct that wraps the state for finding and executing indices + + + + + Represents an asynchronous operation that produces a result at some time in the future. + + + The type of the result produced by this . + + + + instances may be created in a variety of ways. The most common approach is by + using the task's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs a function, the factory's StartNew + method may be used: + + // C# + var t = Task<int>.Factory.StartNew(() => GenerateResult()); + - or - + var t = Task.Factory.StartNew(() => GenerateResult()); + + ' Visual Basic + Dim t = Task<int>.Factory.StartNew(Function() GenerateResult()) + - or - + Dim t = Task.Factory.StartNew(Function() GenerateResult()) + + + + The class also provides constructors that initialize the task but that do not + schedule it for execution. For performance reasons, the StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + Start + method may then be used to schedule the task for execution at a later time. + + + All members of , except for + Dispose, are thread-safe + and may be used from multiple threads concurrently. + + + + + + Represents an asynchronous operation. + + + + instances may be created in a variety of ways. The most common approach is by + using the Task type's property to retrieve a instance that can be used to create tasks for several + purposes. For example, to create a that runs an action, the factory's StartNew + method may be used: + + // C# + var t = Task.Factory.StartNew(() => DoAction()); + + ' Visual Basic + Dim t = Task.Factory.StartNew(Function() DoAction()) + + + + The class also provides constructors that initialize the Task but that do not + schedule it for execution. For performance reasons, TaskFactory's StartNew method should be the + preferred mechanism for creating and scheduling computational tasks, but for scenarios where creation + and scheduling must be separated, the constructors may be used, and the task's + method may then be used to schedule the task for execution at a later time. + + + All members of , except for , are thread-safe + and may be used from multiple threads concurrently. + + + For operations that return values, the class + should be used. + + + For developers implementing custom debuggers, several internal and private members of Task may be + useful (these may change from release to release). The Int32 m_taskId field serves as the backing + store for the property, however accessing this field directly from a debugger may be + more efficient than accessing the same value through the property's getter method (the + s_taskIdCounter Int32 counter is used to retrieve the next available ID for a Task). Similarly, the + Int32 m_stateFlags field stores information about the current lifecycle stage of the Task, + information also accessible through the property. The m_action System.Object + field stores a reference to the Task's delegate, and the m_stateObject System.Object field stores the + async state passed to the Task by the developer. Finally, for debuggers that parse stack frames, the + InternalWait method serves a potential marker for when a Task is entering a wait operation. + + + + + + A type initializer that runs with the appropriate permissions. + + + + + Initializes a new with the specified action. + + The delegate that represents the code to execute in the Task. + The argument is null. + + + + Initializes a new with the specified action and CancellationToken. + + The delegate that represents the code to execute in the Task. + The CancellationToken + that will be assigned to the new Task. + The argument is null. + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action and creation options. + + The delegate that represents the code to execute in the task. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action and state. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, snd options. + + The delegate that represents the code to execute in the task. + An object representing data to be used by the action. + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the Task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + An internal constructor used by the factory methods on task and its descendent(s). + This variant does not capture the ExecutionContext; it is up to the caller to do that. + + An action to execute. + Optional state to pass to the action. + Parent of Task. + A CancellationToken for the task. + A task scheduler under which the task will run. + Options to control its execution. + Internal options to control its execution + + + + Common logic used by the following internal ctors: + Task() + Task(object action, object state, Task parent, TaskCreationOptions options, TaskScheduler taskScheduler) + + ASSUMES THAT m_creatingTask IS ALREADY SET. + + + Action for task to execute. + Object to which to pass to action (may be null) + Task scheduler on which to run thread (only used by continuation tasks). + A CancellationToken for the Task. + Options to customize behavior of Task. + Internal options to customize behavior of Task. + + + + Checks if we registered a CT callback during construction, and deregisters it. + This should be called when we know the registration isn't useful anymore. Specifically from Finish() if the task has completed + successfully or with an exception. + + + + + Captures the ExecutionContext so long as flow isn't suppressed. + + A stack crawl mark pointing to the frame of the caller. + + + + Internal function that will be called by a new child task to add itself to + the children list of the parent (this). + + Since a child task can only be created from the thread executing the action delegate + of this task, reentrancy is neither required nor supported. This should not be called from + anywhere other than the task construction/initialization codepaths. + + + + + Starts the , scheduling it for execution to the current TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time + will result in an exception. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Starts the , scheduling it for execution to the specified TaskScheduler. + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + The TaskScheduler with which to associate + and execute this task. + + + The argument is null. + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the current TaskScheduler. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + Tasks executed with will be associated with the current TaskScheduler. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + + + + Runs the synchronously on the scheduler provided. + + + + A task may only be started and run only once. Any attempts to schedule a task a second time will + result in an exception. + + + If the target scheduler does not support running this Task on the current thread, the Task will + be scheduled for execution on the scheduler, and the current thread will block until the + Task has completed execution. + + + + The is not in a valid state to be started. It may have already been started, + executed, or canceled, or it may have been created in a manner that doesn't support direct + scheduling. + + + The instance has been disposed. + + The parameter + is null. + The scheduler on which to attempt to run this task inline. + + + + Throws an exception if the task has been disposed, and hence can no longer be accessed. + + The task has been disposed. + + + + Sets the internal completion event. + + + + + Disposes the , releasing all of its unmanaged resources. + + + Unlike most of the members of , this method is not thread-safe. + Also, may only be called on a that is in one of + the final states: RanToCompletion, + Faulted, or + Canceled. + + + The exception that is thrown if the is not in + one of the final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Disposes the , releasing all of its unmanaged resources. + + + A Boolean value that indicates whether this method is being called due to a call to . + + + Unlike most of the members of , this method is not thread-safe. + + + + + Schedules the task for execution. + + If true, TASK_STATE_STARTED bit is turned on in + an atomic fashion, making sure that TASK_STATE_CANCELED does not get set + underneath us. If false, TASK_STATE_STARTED bit is OR-ed right in. This + allows us to streamline things a bit for StartNew(), where competing cancellations + are not a problem. + + + + Adds an exception to the list of exceptions this task has thrown. + + An object representing either an Exception or a collection of Exceptions. + + + + Returns a list of exceptions by aggregating the holder's contents. Or null if + no exceptions have been thrown. + + Whether to include a TCE if cancelled. + An aggregate exception, or null if no exceptions have been caught. + + + + Throws an aggregate exception if the task contains exceptions. + + + + + Checks whether this is an attached task, and whether we are being called by the parent task. + And sets the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag based on that. + + This is meant to be used internally when throwing an exception, and when WaitAll is gathering + exceptions for tasks it waited on. If this flag gets set, the implicit wait on children + will skip exceptions to prevent duplication. + + This should only be called when this task has completed with an exception + + + + + + Signals completion of this particular task. + + The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the + full execution of the user delegate. + + If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to + a cancellation request, or because this task is a promise style Task). In this case, the steps + involving child tasks (i.e. WaitForChildren) will be skipped. + + + + + + FinishStageTwo is to be executed as soon as we known there are no more children to complete. + It can happen i) either on the thread that originally executed this task (if no children were spawned, or they all completed by the time this task's delegate quit) + ii) or on the thread that executed the last child. + + + + + Final stage of the task completion code path. Notifies the parent (if any) that another of its childre are done, and runs continuations. + This function is only separated out from FinishStageTwo because these two operations are also needed to be called from CancellationCleanupLogic() + + + + + This is called by children of this task when they are completed. + + + + + This is to be called just before the task does its final state transition. + It traverses the list of exceptional children, and appends their aggregate exceptions into this one's exception list + + + + + Special purpose Finish() entry point to be used when the task delegate throws a ThreadAbortedException + This makes a note in the state flags so that we avoid any costly synchronous operations in the finish codepath + such as inlined continuations + + + Indicates whether the ThreadAbortException was added to this task's exception holder. + This should always be true except for the case of non-root self replicating task copies. + + Whether the delegate was executed. + + + + Executes the task. This method will only be called once, and handles bookeeping associated with + self-replicating tasks, in addition to performing necessary exception marshaling. + + The task has already been disposed. + + + + IThreadPoolWorkItem override, which is the entry function for this task when the TP scheduler decides to run it. + + + + + + The ThreadPool calls this if a ThreadAbortException is thrown while trying to execute this workitem. This may occur + before Task would otherwise be able to observe it. + + + + + Outermost entry function to execute this task. Handles all aspects of executing a task on the caller thread. + Currently this is called by IThreadPoolWorkItem.ExecuteWorkItem(), and TaskManager.TryExecuteInline. + + + Performs atomic updates to prevent double execution. Should only be set to true + in codepaths servicing user provided TaskSchedulers. The ConcRT or ThreadPool schedulers don't need this. + + + + The actual code which invokes the body of the task. This can be overriden in derived types. + + + + + Alternate InnerInvoke prototype to be called from ExecuteSelfReplicating() so that + the Parallel Debugger can discover the actual task being invoked. + Details: Here, InnerInvoke is actually being called on the rootTask object while we are actually executing the + childTask. And the debugger needs to discover the childTask, so we pass that down as an argument. + The NoOptimization and NoInlining flags ensure that the childTask pointer is retained, and that this + function appears on the callstack. + + + + + + Performs whatever handling is necessary for an unhandled exception. Normally + this just entails adding the exception to the holder object. + + The exception that went unhandled. + + + + Waits for the to complete execution. + + + The was canceled -or- an exception was thrown during + the execution of the . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for the to complete execution. + + + A to observe while waiting for the task to complete. + + + The was canceled. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + true if the completed execution within the allotted time; otherwise, + false. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + + + Waits for the to complete execution. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the task to complete. + + + true if the completed execution within the allotted time; otherwise, false. + + + The was canceled -or- an exception was thrown during the execution of the . + + + The + has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where + the current context is known or cached. + + + + + Cancels the . + + Indiactes whether we should only cancel non-invoked tasks. + For the default scheduler this option will only be serviced through TryDequeue. + For custom schedulers we also attempt an atomic state transition. + true if the task was successfully canceled; otherwise, false. + The + has been disposed. + + + + Sets the task's cancellation acknowledged flag. + + + + + Runs all of the continuations, as appropriate. + + + + + Helper function to determine whether the current task is in the state desired by the + continuation kind under evaluation. Three possibilities exist: the task failed with + an unhandled exception (OnFailed), the task was canceled before running (OnAborted), + or the task completed successfully (OnCompletedSuccessfully). Note that the last + one includes completing due to cancellation. + + The continuation options under evaluation. + True if the continuation should be run given the task's current state. + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + The that will be assigned to the new continuation task. + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Converts TaskContinuationOptions to TaskCreationOptions, and also does + some validity checking along the way. + + Incoming TaskContinuationOptions + Outgoing TaskCreationOptions + Outgoing InternalTaskOptions + + + + Registers the continuation and possibly runs it (if the task is already finished). + + The continuation task itself. + TaskScheduler with which to associate continuation task. + Restrictions on when the continuation becomes active. + + + + Waits for all of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + An array of instances on which to wait. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The was canceled. + + + The has been disposed. + + + + + Waits for all of the provided objects to complete execution. + + + true if all of the instances completed execution within the allotted time; + otherwise, false. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for the tasks to complete. + + + The argument is null. + + + The argument contains a null element. + + + At least one of the instances was canceled -or- an exception was thrown during + the execution of at least one of the instances. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Waits for a set of handles in a STA-aware way. In other words, it will wait for each + of the events individually if we're on a STA thread, because MsgWaitForMultipleObjectsEx + can't do a true wait-all due to its hidden message queue event. This is not atomic, + of course, but we only wait on one-way (MRE) events anyway so this is OK. + + An array of wait handles to wait on. + The timeout to use during waits. + The cancellationToken that enables a wait to be canceled. + True if all waits succeeded, false if a timeout occurred. + + + + Internal WaitAll implementation which is meant to be used with small number of tasks, + optimized for Parallel.Invoke and other structured primitives. + + + + + This internal function is only meant to be called by WaitAll() + If the completed task is canceled or it has other exceptions, here we will add those + into the passed in exception list (which will be lazily initialized here). + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + The index of the completed task in the array argument. + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A that represents the number of milliseconds to wait, or a that represents -1 milliseconds to wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1 milliseconds, which represents an + infinite time-out -or- timeout is greater than + . + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + The was canceled. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + + + Waits for any of the provided objects to complete execution. + + + An array of instances on which to wait. + + + The number of milliseconds to wait, or (-1) to + wait indefinitely. + + + A to observe while waiting for a task to complete. + + + The index of the completed task in the array argument, or -1 if the + timeout occurred. + + + The argument is null. + + + The argument contains a null element. + + + The has been disposed. + + + is a negative number other than -1, which represents an + infinite time-out. + + + The was canceled. + + + + + Gets a unique ID for this Task instance. + + + Task IDs are assigned on-demand and do not necessarily represent the order in the which Task + instances were created. + + + + + Returns the unique ID of the currently executing Task. + + + + + Gets the Task instance currently executing, or + null if none exists. + + + + + Gets the StackGuard object assigned to the current thread. + + + + + Gets the Exception that caused the Task to end prematurely. If the Task completed successfully or has not yet thrown any + exceptions, this will return null. + + + Tasks that throw unhandled exceptions store the resulting exception and propagate it wrapped in a + in calls to Wait + or in accesses to the property. Any exceptions not observed by the time + the Task instance is garbage collected will be propagated on the finalizer thread. + + + The Task + has been disposed. + + + + + Gets the TaskStatus of this Task. + + + + + Gets whether this Task instance has completed + execution due to being canceled. + + + A Task will complete in Canceled state either if its CancellationToken + was marked for cancellation before the task started executing, or if the task acknowledged the cancellation request on + its already signaled CancellationToken by throwing an + OperationCanceledException that bears the same + CancellationToken. + + + + + Returns true if this task has a cancellation token and it was signaled. + To be used internally in execute entry codepaths. + + + + + This internal property provides access to the CancellationToken that was set on the task + when it was constructed. + + + + + Gets whether this threw an OperationCanceledException while its CancellationToken was signaled. + + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Checks whether this task has been disposed. + + + + + Gets the TaskCreationOptions used + to create this task. + + + + + Gets a that can be used to wait for the task to + complete. + + + Using the wait functionality provided by + should be preferred over using for similar + functionality. + + + The has been disposed. + + + + + Gets the state object supplied when the Task was created, + or null if none was supplied. + + + + + Gets an indication of whether the asynchronous operation completed synchronously. + + true if the asynchronous operation completed synchronously; otherwise, false. + + + + Provides access to the TaskScheduler responsible for executing this Task. + + + + + Provides access to factory methods for creating and instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on TaskFactory. + + + + + Provides an event that can be used to wait for completion. + Only called by Wait*(), which means that we really do need to instantiate a completion event. + + + + + Determines whether this is the root task of a self replicating group. + + + + + Determines whether the task is a replica itself. + + + + + The property formerly known as IsFaulted. + + + + + Gets whether the completed due to an unhandled exception. + + + If is true, the Task's will be equal to + TaskStatus.Faulted, and its + property will be non-null. + + + + + Checks whether the TASK_STATE_EXCEPTIONOBSERVEDBYPARENT status flag is set, + This will only be used by the implicit wait to prevent double throws + + + + + + Checks whether the body was ever invoked. Used by task scheduler code to verify custom schedulers actually ran the task. + + + + + A structure to hold continuation information. + + + + + Constructs a new continuation structure. + + The task to be activated. + The continuation options. + The scheduler to use for the continuation. + + + + Invokes the continuation for the target completion task. + + The completed task. + Whether the continuation can be inlined. + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The argument is null. + + + + + Initializes a new with the specified function. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The to be assigned to this task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified function and creation options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + The that will be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified function and state. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the action. + + The argument is null. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The argument is null. + + The provided CancellationToken + has already been disposed. + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + + + + Initializes a new with the specified action, state, and options. + + + The delegate that represents the code to execute in the task. When the function has completed, + the task's property will be set to return the result value of the function. + + An object representing data to be used by the function. + The to be assigned to the new task. + + The TaskCreationOptions used to + customize the task's behavior. + + + The argument is null. + + + The argument specifies an invalid value for . + + The provided CancellationToken + has already been disposed. + + + + + Creates a new future object. + + The parent task for this future. + A function that yields the future value. + The task scheduler which will be used to execute the future. + The CancellationToken for the task. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Creates a new future object. + + The parent task for this future. + An object containing data to be used by the action; may be null. + A function that yields the future value. + The CancellationToken for the task. + The task scheduler which will be used to execute the future. + Options to control the future's behavior. + Internal options to control the future's behavior. + The argument specifies + a SelfReplicating , which is illegal."/>. + + + + Evaluates the value selector of the Task which is passed in as an object and stores the result. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the continuation criteria specified through the parameter are not met, the continuation task will be canceled + instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + An action to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new continuation task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed. If the criteria specified through the parameter + are not met, the continuation task will be canceled instead of scheduled. + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + The that will be assigned to the new task. + A new continuation . + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + The to associate with the continuation task and to use for its execution. + + A new continuation . + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The argument is null. + + + The argument is null. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be + passed the completed task as an argument. + + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + A new continuation . + + + The returned will not be scheduled for execution until the current + task has completed, whether it completes due to running to completion successfully, faulting due + to an unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . This task's completion state will be transferred to the task returned + from the ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The has been disposed. + + + + + Creates a continuation that executes when the target completes. + + + The type of the result produced by the continuation. + + + A function to run when the completes. When run, the delegate will be passed as + an argument this completed task. + + The that will be assigned to the new task. + + Options for when the continuation is scheduled and how it behaves. This includes criteria, such + as OnlyOnCanceled, as + well as execution options, such as ExecuteSynchronously. + + + The to associate with the continuation task and to use for its + execution. + + A new continuation . + + + The returned will not be scheduled for execution until the current task has + completed, whether it completes due to running to completion successfully, faulting due to an + unhandled exception, or exiting out early due to being canceled. + + + The , when executed, should return a . + This task's completion state will be transferred to the task returned from the + ContinueWith call. + + + + The argument is null. + + + The argument specifies an invalid value for TaskContinuationOptions. + + + The argument is null. + + + The has been disposed. + + The provided CancellationToken + has already been disposed. + + + + + Gets the result value of this . + + + The get accessor for this property ensures that the asynchronous operation is complete before + returning. Once the result of the computation is available, it is stored and will be returned + immediately on later calls to . + + + + + Provides access to factory methods for creating instances. + + + The factory returned from is a default instance + of , as would result from using + the default constructor on the factory type. + + + + + Provides support for creating and scheduling + Task{TResult} objects. + + The type of the results that are available though + the Task{TResult} objects that are associated with + the methods in this class. + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task{TResult}.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the default configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory{TResult}. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory{TResult}. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory{TResult}. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory{TResult}. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The that will be assigned to the new task. + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The function delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory{TResult}. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory{TResult}. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory{TResult}. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents the current stage in the lifecycle of a . + + + + + The task has been initialized but has not yet been scheduled. + + + + + The task is waiting to be activated and scheduled internally by the .NET Framework infrastructure. + + + + + The task has been scheduled for execution but has not yet begun executing. + + + + + The task is running but has not yet completed. + + + + + The task has finished executing and is implicitly waiting for + attached child tasks to complete. + + + + + The task completed execution successfully. + + + + + The task acknowledged cancellation by throwing an OperationCanceledException with its own CancellationToken + while the token was in signaled state, or the task's CancellationToken was already signaled before the + task started executing. + + + + + The task completed due to an unhandled exception. + + + + + In some cases a replica will want to quit prematurely (ie. before finishing a chunk of work it may have grabbed) + yet they will need the next replica to pick things up from where they left. This API is used to save such state. + + Calling it is also the only way to record a premature exit. + + + + + + Specifies flags that control optional behavior for the creation and execution of tasks. + + + + + Specifies that the default behavior should be used. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides a hint to the + TaskScheduler that oversubscription may be + warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Task creation flags which are only used internally. + + + + Specifies "No internal task options" + + + Used to filter out internal vs. public task creation options. + + + Specifies that the task will be queued by the runtime before handing it over to the user. + This flag will be used to skip the cancellationtoken registration step, which is only meant for unstarted tasks. + + + + Specifies flags that control optional behavior for the creation and execution of continuation tasks. + + + + + Default = "Continue on any, no task options, run asynchronously" + Specifies that the default behavior should be used. Continuations, by default, will + be scheduled when the antecedent task completes, regardless of the task's final TaskStatus. + + + + + A hint to a TaskScheduler to schedule a + task in as fair a manner as possible, meaning that tasks scheduled sooner will be more likely to + be run sooner, and tasks scheduled later will be more likely to be run later. + + + + + Specifies that a task will be a long-running, course-grained operation. It provides + a hint to the TaskScheduler that + oversubscription may be warranted. + + + + + Specifies that a task is attached to a parent in the task hierarchy. + + + + + Specifies that the continuation task should not be scheduled if its antecedent ran to completion. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent threw an unhandled + exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should not be scheduled if its antecedent was canceled. This + option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent ran to + completion. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent threw an + unhandled exception. This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be scheduled only if its antecedent was canceled. + This option is not valid for multi-task continuations. + + + + + Specifies that the continuation task should be executed synchronously. With this option + specified, the continuation will be run on the same thread that causes the antecedent task to + transition into its final state. If the antecedent is already complete when the continuation is + created, the continuation will run on the thread creating the continuation. Only very + short-running continuations should be executed synchronously. + + + + + Internal helper class to keep track of stack depth and decide whether we should inline or not. + + + + + This method needs to be called before attempting inline execution on the current thread. + If false is returned, it means we are too close to the end of the stack and should give up inlining. + Each call to TryBeginInliningScope() that returns true must be matched with a + call to EndInliningScope() regardless of whether inlining actually took place. + + + + + This needs to be called once for each previous successful TryBeginInliningScope() call after + inlining related logic runs. + + + + + Represents an exception used to communicate task cancellation. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class + with a reference to the that has been canceled. + + A task that has been canceled. + + + + Initializes a new instance of the + class with serialized data. + + The that holds the serialized object data about the exception being thrown. + The that contains contextual information about the source or destination. + + + + Gets the task associated with this exception. + + + It is permissible for no Task to be associated with a + , in which case + this property will return null. + + + + + An exception holder manages a list of exceptions for one particular task. + It offers the ability to aggregate, but more importantly, also offers intrinsic + support for propagating unhandled exceptions that are never observed. It does + this by aggregating and throwing if the holder is ever GC'd without the holder's + contents ever having been requested (e.g. by a Task.Wait, Task.get_Exception, etc). + + + + + Creates a new holder; it will be registered for finalization. + + The task this holder belongs to. + + + + A finalizer that repropagates unhandled exceptions. + + + + + Add an exception to the internal list. This will ensure the holder is + in the proper state (handled/unhandled) depending on the list's contents. + + An exception object (either an Exception or an + IEnumerable{Exception}) to add to the list. + + + + A private helper method that ensures the holder is considered + unhandled, i.e. it is registered for finalization. + + + + + A private helper method that ensures the holder is considered + handled, i.e. it is not registered for finalization. + + Whether this is called from the finalizer thread. + + + + Allocates a new aggregate exception and adds the contents of the list to + it. By calling this method, the holder assumes exceptions to have been + "observed", such that the finalization check will be subsequently skipped. + + Whether this is being called from a finalizer. + An extra exception to be included (optionally). + The aggregate exception to throw. + + + + Provides support for creating and scheduling + Tasks. + + + + There are many common patterns for which tasks are relevant. The + class encodes some of these patterns into methods that pick up default settings, which are + configurable through its constructors. + + + A default instance of is available through the + Task.Factory property. + + + + + + Initializes a instance with the default configuration. + + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + This constructor creates a instance with a default configuration. The + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The + TaskScheduler to use to schedule any tasks created with this TaskFactory. A null value + indicates that the current TaskScheduler should be used. + + + With this constructor, the + property is initialized to + TaskCreationOptions.None, the + property is initialized to TaskContinuationOptions.None, + and the TaskScheduler property is + initialized to , unless it's null, in which case the property is + initialized to the current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The exception that is thrown when the + argument or the + argument specifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Initializes a instance with the specified configuration. + + The default that will be assigned + to tasks created by this unless another CancellationToken is explicitly specified + while calling the factory methods. + + The default + TaskCreationOptions to use when creating tasks with this TaskFactory. + + + The default + TaskContinuationOptions to use when creating continuation tasks with this TaskFactory. + + + The default + TaskScheduler to use to schedule any Tasks created with this TaskFactory. A null value + indicates that TaskScheduler.Current should be used. + + + The exception that is thrown when the + argument or the + argumentspecifies an invalid value. + + + With this constructor, the + property is initialized to , + the + property is initialized to , and the TaskScheduler property is initialized to + , unless it's null, in which case the property is initialized to the + current scheduler (see TaskScheduler.Current). + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new task. + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors + and then calling + Start to schedule it for execution. However, + unless creation and scheduling must be separated, StartNew is the recommended + approach for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + The that will be assigned to the new + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The started Task. + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started Task. + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a Task. + + The action delegate to execute asynchronously. + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + Task. + The TaskScheduler + that is used to schedule the created Task. + The started Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a Task using one of its constructors and + then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The started . + The exception that is thrown when the + argument is null. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new + The started . + The exception that is thrown when the + argument is null. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + A TaskCreationOptions value that controls the behavior of the + created + . + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates and starts a . + + The type of the result available through the + Task. + + A function delegate that returns the future result to be available through + the . + An object containing data to be used by the + delegate. + The that will be assigned to the new task. + A TaskCreationOptions value that controls the behavior of the + created + . + The TaskScheduler + that is used to schedule the created + Task{TResult}. + The started . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The provided CancellationToken + has already been disposed. + + + Calling StartNew is functionally equivalent to creating a using one + of its constructors and then calling + Start to schedule it for execution. + However, unless creation and scheduling must be separated, StartNew is the recommended approach + for both simplicity and performance. + + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that executes an end method action + when a specified IAsyncResult completes. + + The IAsyncResult whose completion should trigger the processing of the + . + The action delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the asynchronous + operation. + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of begin + and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the + delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that represents the + asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that executes an end + method function when a specified IAsyncResult completes. + + The type of the result available through the + Task. + + The IAsyncResult whose completion should trigger the processing of the + . + The function delegate that processes the completed . + The TaskScheduler + that is used to schedule the task that executes the end method. + The TaskCreationOptions value that controls the behavior of the + created Task. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + A Task that represents the + asynchronous operation. + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Creates a Task that represents a pair of + begin and end methods that conform to the Asynchronous Programming Model pattern. + + The type of the first argument passed to the delegate. + The type of the second argument passed to + delegate. + The type of the third argument passed to + delegate. + The type of the result available through the + Task. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + The first argument passed to the + delegate. + The second argument passed to the + delegate. + The third argument passed to the + delegate. + The TaskCreationOptions value that controls the behavior of the + created Task. + An object containing data to be used by the + delegate. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument specifies an invalid TaskCreationOptions + value. + The created Task that + represents the asynchronous operation. + + This method throws any exceptions thrown by the . + + + + + Check validity of options passed to FromAsync method + + The options to be validated. + determines type of FromAsync method that called this method + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in + the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result of the antecedent . + The array of tasks from which to continue. + The action delegate to execute when all tasks in the array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of a set of provided Tasks. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue. + The function delegate to execute when all tasks in the + array have completed. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAll. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation Task. + The new continuation Task. + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result that is returned by the + delegate and associated with the created . + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The function delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Creates a continuation Task + that will be started upon the completion of any Task in the provided set. + + The type of the result of the antecedent . + The array of tasks from which to continue when one task completes. + The action delegate to execute when one task in the + array completes. + The CancellationToken + that will be assigned to the new continuation task. + The + TaskContinuationOptions value that controls the behavior of + the created continuation Task. + The TaskScheduler + that is used to schedule the created continuation . + The new continuation . + The exception that is thrown when the + array is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + argument is null. + The exception that is thrown when the + array contains a null value. + The exception that is thrown when the + array is empty. + The exception that is thrown when the + argument specifies an invalid TaskContinuationOptions + value. + The exception that is thrown when one + of the elements in the array has been disposed. + The provided CancellationToken + has already been disposed. + + + The NotOn* and OnlyOn* TaskContinuationOptions, + which constrain for which TaskStatus states a continuation + will be executed, are illegal with ContinueWhenAny. + + + + + Gets the default CancellationToken of this + TaskFactory. + + + This property returns the default that will be assigned to all + tasks created by this factory unless another CancellationToken value is explicitly specified + during the call to the factory methods. + + + + + Gets the TaskScheduler of this + TaskFactory. + + + This property returns the default scheduler for this factory. It will be used to schedule all + tasks unless another scheduler is explicitly specified during calls to this factory's methods. + If null, TaskScheduler.Current + will be used. + + + + + Gets the TaskCreationOptions + value of this TaskFactory. + + + This property returns the default creation options for this factory. They will be used to create all + tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Gets the TaskContinuationOptions + value of this TaskFactory. + + + This property returns the default continuation options for this factory. They will be used to create + all continuation tasks unless other options are explicitly specified during calls to this factory's methods. + + + + + Represents the producer side of a unbound to a + delegate, providing access to the consumer side through the property. + + + + It is often the case that a is desired to + represent another asynchronous operation. + TaskCompletionSource is provided for this purpose. It enables + the creation of a task that can be handed out to consumers, and those consumers can use the members + of the task as they would any other. However, unlike most tasks, the state of a task created by a + TaskCompletionSource is controlled explicitly by the methods on TaskCompletionSource. This enables the + completion of the external asynchronous operation to be propagated to the underlying Task. The + separation also ensures that consumers are not able to transition the state without access to the + corresponding TaskCompletionSource. + + + All members of are thread-safe + and may be used from multiple threads concurrently. + + + The type of the result value assocatied with this . + + + + Creates a . + + + + + Creates a + with the specified options. + + + The created + by this instance and accessible through its property + will be instantiated using the specified . + + The options to use when creating the underlying + . + + The represent options invalid for use + with a . + + + + + Creates a + with the specified state. + + The state to use as the underlying + 's AsyncState. + + + + Creates a with + the specified state and options. + + The options to use when creating the underlying + . + The state to use as the underlying + 's AsyncState. + + The represent options invalid for use + with a . + + + + + Attempts to transition the underlying + into the + Faulted + state. + + The exception to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + The was disposed. + + + + Attempts to transition the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The argument is null. + There are one or more null elements in . + The collection is empty. + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The exception to bind to this . + The argument is null. + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Faulted + state. + + The collection of exceptions to bind to this . + The argument is null. + There are one or more null elements in . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + RanToCompletion + state. + + The result value to bind to this . + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Transitions the underlying + into the + Canceled + state. + + + The underlying is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Attempts to transition the underlying + into the + Canceled + state. + + True if the operation was successful; otherwise, false. + This operation will return false if the + is already in one + of the three final states: + RanToCompletion, + Faulted, or + Canceled. + + The was disposed. + + + + Gets the created + by this . + + + This property enables a consumer access to the that is controlled by this instance. + The , , + , and + methods (and their "Try" variants) on this instance all result in the relevant state + transitions on this underlying Task. + + + + + Represents an abstract scheduler for tasks. + + + + TaskScheduler acts as the extension point for all + pluggable scheduling logic. This includes mechanisms such as how to schedule a task for execution, and + how scheduled tasks should be exposed to debuggers. + + + All members of the abstract type are thread-safe + and may be used from multiple threads concurrently. + + + + + + Queues a Task to the scheduler. + + + + A class derived from TaskScheduler + implements this method to accept tasks being scheduled on the scheduler. + A typical implementation would store the task in an internal data structure, which would + be serviced by threads that would execute those tasks at some time in the future. + + + This method is only meant to be called by the .NET Framework and + should not be called directly by the derived class. This is necessary + for maintaining the consistency of the system. + + + The Task to be queued. + The argument is null. + + + + Determines whether the provided Task + can be executed synchronously in this call, and if it can, executes it. + + + + A class derived from TaskScheduler implements this function to + support inline execution of a task on a thread that initiates a wait on that task object. Inline + execution is optional, and the request may be rejected by returning false. However, better + scalability typically results the more tasks that can be inlined, and in fact a scheduler that + inlines too little may be prone to deadlocks. A proper implementation should ensure that a + request executing under the policies guaranteed by the scheduler can successfully inline. For + example, if a scheduler uses a dedicated thread to execute tasks, any inlining requests from that + thread should succeed. + + + If a scheduler decides to perform the inline execution, it should do so by calling to the base + TaskScheduler's + TryExecuteTask method with the provided task object, propagating + the return value. It may also be appropriate for the scheduler to remove an inlined task from its + internal data structures if it decides to honor the inlining request. Note, however, that under + some circumstances a scheduler may be asked to inline a task that was not previously provided to + it with the method. + + + The derived scheduler is responsible for making sure that the calling thread is suitable for + executing the given task as far as its own scheduling and execution policies are concerned. + + + The Task to be + executed. + A Boolean denoting whether or not task has previously been + queued. If this parameter is True, then the task may have been previously queued (scheduled); if + False, then the task is known not to have been queued, and this call is being made in order to + execute the task inline without queueing it. + A Boolean value indicating whether the task was executed inline. + The argument is + null. + The was already + executed. + + + + Generates an enumerable of Task instances + currently queued to the scheduler waiting to be executed. + + + + A class derived from implements this method in order to support + integration with debuggers. This method will only be invoked by the .NET Framework when the + debugger requests access to the data. The enumerable returned will be traversed by debugging + utilities to access the tasks currently queued to this scheduler, enabling the debugger to + provide a representation of this information in the user interface. + + + It is important to note that, when this method is called, all other threads in the process will + be frozen. Therefore, it's important to avoid synchronization with other threads that may lead to + blocking. If synchronization is necessary, the method should prefer to throw a + than to block, which could cause a debugger to experience delays. Additionally, this method and + the enumerable returned must not modify any globally visible state. + + + The returned enumerable should never be null. If there are currently no queued tasks, an empty + enumerable should be returned instead. + + + For developers implementing a custom debugger, this method shouldn't be called directly, but + rather this functionality should be accessed through the internal wrapper method + GetScheduledTasksForDebugger: + internal Task[] GetScheduledTasksForDebugger(). This method returns an array of tasks, + rather than an enumerable. In order to retrieve a list of active schedulers, a debugger may use + another internal method: internal static TaskScheduler[] GetTaskSchedulersForDebugger(). + This static method returns an array of all active TaskScheduler instances. + GetScheduledTasksForDebugger then may be used on each of these scheduler instances to retrieve + the list of scheduled tasks for each. + + + An enumerable that allows traversal of tasks currently queued to this scheduler. + + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Retrieves some thread static state that can be cached and passed to multiple + TryRunInline calls, avoiding superflous TLS fetches. + + A bag of TLS state (or null if none exists). + + + + Attempts to execute the target task synchronously. + + The task to run. + True if the task may have been previously queued, + false if the task was absolutely not previously queued. + The state retrieved from GetThreadStatics + True if it ran, false otherwise. + + + + Attempts to dequeue a Task that was previously queued to + this scheduler. + + The Task to be dequeued. + A Boolean denoting whether the argument was successfully dequeued. + The argument is null. + + + + Notifies the scheduler that a work item has made progress. + + + + + Initializes the . + + + + + Frees all resources associated with this scheduler. + + + + + Creates a + associated with the current . + + + All Task instances queued to + the returned scheduler will be executed through a call to the + Post method + on that context. + + + A associated with + the current SynchronizationContext, as + determined by SynchronizationContext.Current. + + + The current SynchronizationContext may not be used as a TaskScheduler. + + + + + Attempts to execute the provided Task + on this scheduler. + + + + Scheduler implementations are provided with Task + instances to be executed through either the method or the + method. When the scheduler deems it appropriate to run the + provided task, should be used to do so. TryExecuteTask handles all + aspects of executing a task, including action invocation, exception handling, state management, + and lifecycle control. + + + must only be used for tasks provided to this scheduler by the .NET + Framework infrastructure. It should not be used to execute arbitrary tasks obtained through + custom mechanisms. + + + + A Task object to be executed. + + The is not associated with this scheduler. + + A Boolean that is true if was successfully executed, false if it + was not. A common reason for execution failure is that the task had previously been executed or + is in the process of being executed by another thread. + + + + Provides an array of all queued Task instances + for the debugger. + + + The returned array is populated through a call to . + Note that this function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of Task instances. + + This scheduler is unable to generate a list of queued tasks at this time. + + + + + Provides an array of all active TaskScheduler + instances for the debugger. + + + This function is only meant to be invoked by a debugger remotely. + It should not be called by any other codepaths. + + An array of TaskScheduler instances. + + + + Registers a new TaskScheduler instance in the global collection of schedulers. + + + + + Removes a TaskScheduler instance from the global collection of schedulers. + + + + + Indicates the maximum concurrency level this + is able to support. + + + + + Indicates whether this is a custom scheduler, in which case the safe code paths will be taken upon task entry + using a CAS to transition from queued state to executing. + + + + + Gets the default TaskScheduler instance. + + + + + Gets the TaskScheduler + associated with the currently executing task. + + + When not called from within a task, will return the scheduler. + + + + + Gets the unique ID for this . + + + + + Occurs when a faulted 's unobserved exception is about to trigger exception escalation + policy, which, by default, would terminate the process. + + + This AppDomain-wide event provides a mechanism to prevent exception + escalation policy (which, by default, terminates the process) from triggering. + Each handler is passed a + instance, which may be used to examine the exception and to mark it as observed. + + + + + Nested class that provides debugger view for TaskScheduler + + + + + A TaskScheduler implementation that executes all tasks queued to it through a call to + on the + that its associated with. The default constructor for this class binds to the current + + + + + Constructs a SynchronizationContextTaskScheduler associated with + + This constructor expects to be set. + + + + Implemetation of for this scheduler class. + + Simply posts the tasks to be executed on the associated . + + + + + + Implementation of for this scheduler class. + + The task will be executed inline only if the call happens within + the associated . + + + + + + + Implementes the property for + this scheduler class. + + By default it returns 1, because a based + scheduler only supports execution on a single thread. + + + + + Provides data for the event that is raised when a faulted 's + exception goes unobserved. + + + The Exception property is used to examine the exception without marking it + as observed, whereas the method is used to mark the exception + as observed. Marking the exception as observed prevents it from triggering exception escalation policy + which, by default, terminates the process. + + + + + Initializes a new instance of the class + with the unobserved exception. + + The Exception that has gone unobserved. + + + + Marks the as "observed," thus preventing it + from triggering exception escalation policy which, by default, terminates the process. + + + + + Gets whether this exception has been marked as "observed." + + + + + The Exception that went unobserved. + + + + + An implementation of TaskScheduler that uses the ThreadPool scheduler + + + + + Constructs a new ThreadPool task scheduler object + + + + + Schedules a task to the ThreadPool. + + The task to schedule. + + + + This internal function will do this: + (1) If the task had previously been queued, attempt to pop it and return false if that fails. + (2) Propagate the return value from Task.ExecuteEntry() back to the caller. + + IMPORTANT NOTE: TryExecuteTaskInline will NOT throw task exceptions itself. Any wait code path using this function needs + to account for exceptions that need to be propagated, and throw themselves accordingly. + + + + + Notifies the scheduler that work is progressing (no-op). + + + + + This is the only scheduler that returns false for this property, indicating that the task entry codepath is unsafe (CAS free) + since we know that the underlying scheduler already takes care of atomic transitions from queued to non-queued. + + + + + Represents an exception used to communicate an invalid operation by a + . + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class with a specified error message. + + The error message that explains the reason for the exception. + + + + Initializes a new instance of the + class using the default error message and a reference to the inner exception that is the cause of + this exception. + + The exception that is the cause of the current exception. + + + + Initializes a new instance of the + class with a specified error message and a reference to the inner exception that is the cause of + this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the + class with serialized data. + + The that holds + the serialized object data about the exception being thrown. + The that + contains contextual information about the source or destination. + + + + The exception that is thrown when the post-phase action of a fails. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified inner exception. + + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class with a specified error message. + + A string that describes the exception. + + + + Initializes a new instance of the class with a specified error message and inner exception. + + A string that describes the exception. + The exception that is the cause of the current exception. + + + + Initializes a new instance of the class with serialized data. + + The object that holds the serialized object data. + An object that describes the source or destination of the serialized data. + + + + Enables multiple tasks to cooperatively work on an algorithm in parallel through multiple phases. + + + + A group of tasks cooperate by moving through a series of phases, where each in the group signals it + has arrived at the in a given phase and implicitly waits for all others to + arrive. The same can be used for multiple phases. + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads, with the exception of Dispose, which + must only be used when all other operations on the have + completed. + + + + + + Initializes a new instance of the class. + + The number of participating threads. + is less than 0 + or greater than . + + + + Initializes a new instance of the class. + + The number of participating threads. + The to be executed after each + phase. + is less than 0 + or greater than . + + The delegate will be executed after + all participants have arrived at the barrier in one phase. The participants + will not be released to the next phase until the postPhaseAction delegate + has completed execution. + + + + + Extract the three variables current, total and sense from a given big variable + + The integer variable that contains the other three variables + The current cparticipant count + The total participants count + The sense flag + + + + Write the three variables current. total and the sense to the m_currentTotal + + The old current total to compare + The current cparticipant count + The total participants count + The sense flag + True if the CAS succeeded, false otherwise + + + + Notifies the that there will be an additional participant. + + The phase number of the barrier in which the new participants will first + participate. + + Adding a participant would cause the barrier's participant count to + exceed . + + + The method was invoked from within a post-phase action. + + The current instance has already been + disposed. + + + + Notifies the that there will be additional participants. + + The number of additional participants to add to the + barrier. + The phase number of the barrier in which the new participants will first + participate. + is less than + 0. + Adding participants would cause the + barrier's participant count to exceed . + + The method was invoked from within a post-phase action. + + The current instance has already been + disposed. + + + + Notifies the that there will be one less participant. + + The barrier already has 0 + participants. + + The method was invoked from within a post-phase action. + + The current instance has already been + disposed. + + + + Notifies the that there will be fewer participants. + + The number of additional participants to remove from the barrier. + is less than + 0. + The barrier already has 0 participants. + + The method was invoked from within a post-phase action. + + The current instance has already been + disposed. + + + + Signals that a participant has reached the and waits for all other + participants to reach the barrier as well. + + + The method was invoked from within a post-phase action, the barrier currently has 0 participants, + or the barrier is being used by more threads than are registered as participants. + + The current instance has already been + disposed. + + + + Signals that a participant has reached the and waits for all other + participants to reach the barrier, while observing a . + + The to + observe. + + The method was invoked from within a post-phase action, the barrier currently has 0 participants, + or the barrier is being used by more threads than are registered as participants. + + has been + canceled. + The current instance has already been + disposed. + + + + Signals that a participant has reached the and waits for all other + participants to reach the barrier as well, using a + to measure the time interval. + + A that represents the number of + milliseconds to wait, or a that represents -1 milliseconds to + wait indefinitely. + true if all other participants reached the barrier; otherwise, false. + is a negative number + other than -1 milliseconds, which represents an infinite time-out, or it is greater than + . + + The method was invoked from within a post-phase action, the barrier currently has 0 participants, + or the barrier is being used by more threads than are registered as participants. + + The current instance has already been + disposed. + + + + Signals that a participant has reached the and waits for all other + participants to reach the barrier as well, using a + to measure the time interval, while observing a . + + A that represents the number of + milliseconds to wait, or a that represents -1 milliseconds to + wait indefinitely. + The to + observe. + true if all other participants reached the barrier; otherwise, false. + is a negative number + other than -1 milliseconds, which represents an infinite time-out. + + The method was invoked from within a post-phase action, the barrier currently has 0 participants, + or the barrier is being used by more threads than are registered as participants. + + has been + canceled. + The current instance has already been + disposed. + + + + Signals that a participant has reached the and waits for all other + participants to reach the barrier as well, using a + 32-bit signed integer to measure the time interval. + + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if all other participants reached the barrier; otherwise, false. + is a + negative number other than -1, which represents an infinite time-out. + + The method was invoked from within a post-phase action, the barrier currently has 0 participants, + or the barrier is being used by more threads than are registered as participants. + + The current instance has already been + disposed. + + + + Signals that a participant has reached the barrier and waits for all other participants to reach + the barrier as well, using a + 32-bit signed integer to measure the time interval, while observing a . + + The number of milliseconds to wait, or (-1) to wait indefinitely. + The to + observe. + true if all other participants reached the barrier; otherwise, false. + is a + negative number other than -1, which represents an infinite time-out. + + The method was invoked from within a post-phase action, the barrier currently has 0 participants, + or the barrier is being used by more threads than are registered as participants. + + has been + canceled. + The current instance has already been + disposed. + + + + Finish the phase by invoking the post phase action, and setting the event, this must be called by the + last arrival thread + + The current phase sense + + + + Sets the current phase event and reset the next phase event + + The current phase sense + + + + Releases all resources used by the current instance of . + + + The method was invoked from within a post-phase action. + + + Unlike most of the members of , Dispose is not thread-safe and may not be + used concurrently with other members of this instance. + + + + + When overridden in a derived class, releases the unmanaged resources used by the + , and optionally releases the managed resources. + + true to release both managed and unmanaged resources; false to release + only unmanaged resources. + + Unlike most of the members of , Dispose is not thread-safe and may not be + used concurrently with other members of this instance. + + + + + Throw ObjectDisposedException if the barrier is disposed + + + + + Gets the number of participants in the barrier that haven’t yet signaled + in the current phase. + + + This could be 0 during a post-phase action delegate execution or if the + ParticipantCount is 0. + + + + + Gets the total number of participants in the barrier. + + + + + Gets the number of the barrier's current phase. + + + + + Provides blocking and bounding capabilities for thread-safe collections that + implement . + + + represents a collection + that allows for thread-safe adding and removing of data. + is used as a wrapper + for an instance, allowing + removal attempts from the collection to block until data is available to be removed. Similarly, + a can be created to enforce + an upper-bound on the number of data elements allowed in the + ; addition attempts to the + collection may then block until space is available to store the added items. In this manner, + is similar to a traditional + blocking queue data structure, except that the underlying data storage mechanism is abstracted + away as an . + + Specifies the type of elements in the collection. + + + Initializes a new instance of the + + class without an upper-bound. + + + The default underlying collection is a ConcurrentQueue<T>. + + + + Initializes a new instance of the + class with the specified upper-bound. + + The bounded size of the collection. + The is + not a positive value. + + The default underlying collection is a ConcurrentQueue<T>. + + + + Initializes a new instance of the + class with the specified upper-bound and using the provided + as its underlying data store. + The collection to use as the underlying data store. + The bounded size of the collection. + The argument is + null. + The is not a positive value. + The supplied contains more values + than is permitted by . + + + Initializes a new instance of the + class without an upper-bound and using the provided + as its underlying data store. + The collection to use as the underlying data store. + The argument is + null. + + + Initializes the BlockingCollection instance. + The collection to use as the underlying data store. + The bounded size of the collection. + The number of items currently in the underlying collection. + + + + Adds the item to the . + + The item to be added to the collection. The value can be a null reference. + The has been marked + as complete with regards to additions. + The has been disposed. + The underlying collection didn't accept the item. + + If a bounded capacity was specified when this instance of + was initialized, + a call to Add may block until space is available to store the provided item. + + + + + Adds the item to the . + A is thrown if the is + canceled. + + The item to be added to the collection. The value can be a null reference. + A cancellation token to observe. + If the is canceled. + The has been marked + as complete with regards to additions. + The has been disposed. + The underlying collection didn't accept the item. + + If a bounded capacity was specified when this instance of + was initialized, + a call to may block until space is available to store the provided item. + + + + + Attempts to add the specified item to the . + + The item to be added to the collection. + true if the could be added; otherwise, false. + The has been marked + as complete with regards to additions. + The has been disposed. + The underlying collection didn't accept the item. + + + + Attempts to add the specified item to the . + + The item to be added to the collection. + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if the could be added to the collection within + the alloted time; otherwise, false. + The has been marked + as complete with regards to additions. + The has been disposed. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + The underlying collection didn't accept the item. + + + + Attempts to add the specified item to the . + + The item to be added to the collection. + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if the could be added to the collection within + the alloted time; otherwise, false. + The has been marked + as complete with regards to additions. + The has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + The underlying collection didn't accept the item. + + + + Attempts to add the specified item to the . + A is thrown if the is + canceled. + + The item to be added to the collection. + The number of milliseconds to wait, or (-1) to wait indefinitely. + A cancellation token to observe. + true if the could be added to the collection within + the alloted time; otherwise, false. + If the is canceled. + The has been marked + as complete with regards to additions. + The has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + The underlying collection didn't accept the item. + + + Adds an item into the underlying data store using its IProducerConsumerCollection<T>.Add + method. If a bounded capacity was specified and the collection was full, + this method will wait for, at most, the timeout period trying to add the item. + If the timeout period was exhaused before successfully adding the item this method will + return false. + The item to be added to the collection. + The number of milliseconds to wait for the collection to accept the item, + or Timeout.Infinite to wait indefinitely. + A cancellation token to observe. + False if the collection remained full till the timeout period was exhausted.True otherwise. + If the is canceled. + the collection has already been marked + as complete with regards to additions. + If the collection has been disposed. + The underlying collection didn't accept the item. + + + Takes an item from the . + The item removed from the collection. + The is empty and has been marked + as complete with regards to additions. + The has been disposed. + The underlying collection was modified + outside of this instance. + A call to may block until an item is available to be removed. + + + Takes an item from the . + The item removed from the collection. + If the is + canceled or the is empty and has been marked + as complete with regards to additions. + The has been disposed. + The underlying collection was modified + outside of this instance. + A call to may block until an item is available to be removed. + + + + Attempts to remove an item from the . + + The item removed from the collection. + true if an item could be removed; otherwise, false. + The has been disposed. + The underlying collection was modified + outside of this instance. + + + + Attempts to remove an item from the . + + The item removed from the collection. + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + true if an item could be removed from the collection within + the alloted time; otherwise, false. + The has been disposed. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + The underlying collection was modified + outside of this instance. + + + + Attempts to remove an item from the . + + The item removed from the collection. + The number of milliseconds to wait, or (-1) to wait indefinitely. + true if an item could be removed from the collection within + the alloted time; otherwise, false. + The has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + The underlying collection was modified + outside of this instance. + + + + Attempts to remove an item from the . + A is thrown if the is + canceled. + + The item removed from the collection. + The number of milliseconds to wait, or (-1) to wait indefinitely. + A cancellation token to observe. + true if an item could be removed from the collection within + the alloted time; otherwise, false. + If the is canceled. + The has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + The underlying collection was modified + outside of this instance. + + + Takes an item from the underlying data store using its IProducerConsumerCollection<T>.Take + method. If the collection was empty, this method will wait for, at most, the timeout period (if AddingIsCompleted is false) + trying to remove an item. If the timeout period was exhaused before successfully removing an item + this method will return false. + A is thrown if the is + canceled. + + The item removed from the collection. + The number of milliseconds to wait for the collection to have an item available + for removal, or Timeout.Infinite to wait indefinitely. + A cancellation token to observe. + A combined cancellation token if created, it is only created by GetConsumingEnumerable to avoid creating the linked token + multiple times. + False if the collection remained empty till the timeout period was exhausted. True otherwise. + If the is canceled. + If the collection has been disposed. + + + + Adds the specified item to any one of the specified + instances. + + The array of collections. + The item to be added to one of the collections. + The index of the collection in the array to which the item was added. + The argument is + null. + The argument is + a 0-length array or contains a null element, or at least one of collections has been + marked as complete for adding. + At least one of the instances has been disposed. + At least one underlying collection didn't accept the item. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + + If a bounded capacity was specified when all of the + instances were initialized, + a call to AddToAny may block until space is available in one of the collections + to store the provided item. + + + + + Adds the specified item to any one of the specified + instances. + A is thrown if the is + canceled. + + The array of collections. + The item to be added to one of the collections. + A cancellation token to observe. + The index of the collection in the array to which the item was added. + If the is canceled. + The argument is + null. + The argument is + a 0-length array or contains a null element, or at least one of collections has been + marked as complete for adding. + At least one of the instances has been disposed. + At least one underlying collection didn't accept the item. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + + If a bounded capacity was specified when all of the + instances were initialized, + a call to AddToAny may block until space is available in one of the collections + to store the provided item. + + + + + Attempts to add the specified item to any one of the specified + instances. + + The array of collections. + The item to be added to one of the collections. + The index of the collection in the + array to which the item was added, or -1 if the item could not be added. + The argument is + null. + The argument is + a 0-length array or contains a null element, or at least one of collections has been + marked as complete for adding. + At least one of the instances has been disposed. + At least one underlying collection didn't accept the item. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + + + + Attempts to add the specified item to any one of the specified + instances. + + The array of collections. + The item to be added to one of the collections. + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The index of the collection in the + array to which the item was added, or -1 if the item could not be added. + The argument is + null. + The argument is + a 0-length array or contains a null element, or at least one of collections has been + marked as complete for adding. + At least one of the instances has been disposed. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + At least one underlying collection didn't accept the item. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + + + + Attempts to add the specified item to any one of the specified + instances. + + The array of collections. + The item to be added to one of the collections. + The number of milliseconds to wait, or (-1) to wait indefinitely. /// The index of the collection in the + array to which the item was added, or -1 if the item could not be added. + The argument is + null. + The argument is + a 0-length array or contains a null element, or at least one of collections has been + marked as complete for adding. + At least one of the instances has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + At least one underlying collection didn't accept the item. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + + + + Attempts to add the specified item to any one of the specified + instances. + A is thrown if the is + canceled. + + The array of collections. + The item to be added to one of the collections. + The number of milliseconds to wait, or (-1) to wait indefinitely. /// The index of the collection in the + array to which the item was added, or -1 if the item could not be added. + A cancellation token to observe. + If the is canceled. + The argument is + null. + The argument is + a 0-length array or contains a null element, or at least one of collections has been + marked as complete for adding. + At least one of the instances has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + At least one underlying collection didn't accept the item. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + + + Adds/Takes an item to/from anyone of the specified collections. + A is thrown if the is + canceled. + + The collections into which the item can be added. + The item to be added or the item removed and returned to the caller. + The number of milliseconds to wait for a collection to accept the + operation, or -1 to wait indefinitely. + Indicates whether this method is called to Add or Take. + A cancellation token to observe. + The index into collections for the collection which accepted the + adding/removal of the item; -1 if the item could not be added/removed. + If the is canceled. + If the collections argument is null. + If the collections argument is a 0-length array or contains a + null element. Also, if atleast one of the collections has been marked complete for adds. + If atleast one of the collections has been disposed. + + + + Local static method, used by TryAddTakeAny to get the wait handles for the collection, with exclude option to exclude the Compeleted collections + + The blocking collections + Add or Take operation + The original CancellationToken + True to exclude the compeleted collections + Complete list of cancellationTokens to observe + The collections wait handles + + + + Helper to perform WaitHandle.WaitAny(.., CancellationToken) + this should eventually appear on the WaitHandle class. + + + + + + + + + + Helper function to measure and update the wait time + + The first time (in Ticks) observed when the wait started + The orginal wait timeoutout in milliseconds + The new wait time in milliseconds, -1 if the time expired + + + + Takes an item from any one of the specified + instances. + + The array of collections. + The item removed from one of the collections. + The index of the collection in the array from which + the item was removed, or -1 if an item could not be removed. + The argument is + null. + The argument is + a 0-length array or contains a null element. + At least one of the instances has been disposed. + At least one of the underlying collections was modified + outside of its instance. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + A call to TakeFromAny may block until an item is available to be removed. + + + + Takes an item from any one of the specified + instances. + A is thrown if the is + canceled. + + The array of collections. + The item removed from one of the collections. + A cancellation token to observe. + The index of the collection in the array from which + the item was removed, or -1 if an item could not be removed. + The argument is + null. + If the is canceled. + The argument is + a 0-length array or contains a null element. + At least one of the instances has been disposed. + At least one of the underlying collections was modified + outside of its instance. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + A call to TakeFromAny may block until an item is available to be removed. + + + + Attempts to remove an item from any one of the specified + instances. + + The array of collections. + The item removed from one of the collections. + The index of the collection in the array from which + the item was removed, or -1 if an item could not be removed. + The argument is + null. + The argument is + a 0-length array or contains a null element. + At least one of the instances has been disposed. + At least one of the underlying collections was modified + outside of its instance. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + A call to TryTakeFromAny may block until an item is available to be removed. + + + + Attempts to remove an item from any one of the specified + instances. + + The array of collections. + The item removed from one of the collections. + A that represents the number of milliseconds + to wait, or a that represents -1 milliseconds to wait indefinitely. + + The index of the collection in the array from which + the item was removed, or -1 if an item could not be removed. + The argument is + null. + The argument is + a 0-length array or contains a null element. + At least one of the instances has been disposed. + is a negative number + other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than + . + At least one of the underlying collections was modified + outside of its instance. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + A call to TryTakeFromAny may block until an item is available to be removed. + + + + Attempts to remove an item from any one of the specified + instances. + + The array of collections. + The item removed from one of the collections. + The number of milliseconds to wait, or (-1) to wait indefinitely. + The index of the collection in the array from which + the item was removed, or -1 if an item could not be removed. + The argument is + null. + The argument is + a 0-length array or contains a null element. + At least one of the instances has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + At least one of the underlying collections was modified + outside of its instance. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + A call to TryTakeFromAny may block until an item is available to be removed. + + + + Attempts to remove an item from any one of the specified + instances. + A is thrown if the is + canceled. + + The array of collections. + The item removed from one of the collections. + The number of milliseconds to wait, or (-1) to wait indefinitely. + A cancellation token to observe. + The index of the collection in the array from which + the item was removed, or -1 if an item could not be removed. + If the is canceled. + The argument is + null. + The argument is + a 0-length array or contains a null element. + At least one of the instances has been disposed. + is a + negative number other than -1, which represents an infinite time-out. + At least one of the underlying collections was modified + outside of its instance. + The count of is greater than the maximum size of + 62 for STA and 63 for MTA. + A call to TryTakeFromAny may block until an item is available to be removed. + + + + Marks the instances + as not accepting any more additions. + + + After a collection has been marked as complete for adding, adding to the collection is not permitted + and attempts to remove from the collection will not wait when the collection is empty. + + The has been disposed. + + + Cancels the semaphores. + + + + Releases resources used by the instance. + + + + + Releases resources used by the instance. + + Whether being disposed explicitly (true) or due to a finalizer (false). + + + Copies the items from the instance into a new array. + An array containing copies of the elements of the collection. + The has been disposed. + + The copied elements are not removed from the collection. + + + + Copies all of the items in the instance + to a compatible one-dimensional array, starting at the specified index of the target array. + + The one-dimensional array that is the destination of the elements copied from + the instance. The array must have zero-based indexing. + The zero-based index in at which copying begins. + The argument is + null. + The argument is less than zero. + The argument is equal to or greater + than the length of the . + The has been disposed. + + + Copies all of the items in the instance + to a compatible one-dimensional array, starting at the specified index of the target array. + + The one-dimensional array that is the destination of the elements copied from + the instance. The array must have zero-based indexing. + The zero-based index in at which copying begins. + The argument is + null. + The argument is less than zero. + The argument is equal to or greater + than the length of the , the array is multidimensional, or the type parameter for the collection + cannot be cast automatically to the type of the destination array. + The has been disposed. + + + Provides a consuming for items in the collection. + An that removes and returns items from the collection. + The has been disposed. + + + Provides a consuming for items in the collection. + Calling MoveNext on the returned enumerable will block if there is no data available, or will + throw an if the is canceled. + + A cancellation token to observe. + An that removes and returns items from the collection. + The has been disposed. + If the is canceled. + + + Provides an for items in the collection. + An for the items in the collection. + The has been disposed. + + + Provides an for items in the collection. + An for the items in the collection. + The has been disposed. + + + Centralizes the logic for validating the BlockingCollections array passed to TryAddToAny() + and TryTakeFromAny(). + The collections to/from which an item should be added/removed. + Indicates whether this method is called to Add or Take. + A copy of the collections array that acts as a defense to prevent an “outsider” from changing + elements of the array after we have done the validation on them. + If the collections argument is null. + If the collections argument is a 0-length array or contains a + null element. Also, if atleast one of the collections has been marked complete for adds. + If atleast one of the collections has been disposed. + + + Centeralizes the logic of validating the timeout input argument. + The TimeSpan to wait for to successfully complete an operation on the collection. + If the number of millseconds represented by the timeout + TimeSpan is less than 0 or is larger than Int32.MaxValue and not Timeout.Infinite + + + Centralizes the logic of validating the millisecondsTimeout input argument. + The number of milliseconds to wait for to successfully complete an + operation on the collection. + If the number of millseconds is less than 0 and not + equal to Timeout.Infinite. + + + Throws a System.ObjectDisposedException if the collection was disposed + If the collection has been disposed. + + + Gets the bounded capacity of this instance. + The bounded capacity of this collection, or int.MaxValue if no bound was supplied. + The has been disposed. + + + Gets whether this has been marked as complete for adding. + Whether this collection has been marked as complete for adding. + The has been disposed. + + + Gets whether this has been marked as complete for adding and is empty. + Whether this collection has been marked as complete for adding and is empty. + The has been disposed. + + + Gets the number of items contained in the . + The number of items contained in the . + The has been disposed. + + + Gets a value indicating whether access to the is synchronized. + The has been disposed. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + An enumerated data type used internal to the class to specify to a generic method + the current mode of operation. + + + A debugger view of the blocking collection that makes it simple to browse the + collection's contents at a point in time. + The type of element that the BlockingCollection will hold. + + + Constructs a new debugger view object for the provided blocking collection object. + A blocking collection to browse in the debugger. + + + Returns a snapshot of the underlying collection's elements. + + + + Represents an thread-safe, unordered collection of objects. + + Specifies the type of elements in the bag. + + + Bags are useful for storing objects when ordering doesn't matter, and unlike sets, bags support + duplicates. is a thread-safe bag implementation, optimized for + scenarios where the same thread will be both producing and consuming data stored in the bag. + + + accepts null reference (Nothing in Visual Basic) as a valid + value for reference types. + + + All public and protected members of are thread-safe and may be used + concurrently from multiple threads. + + + + + + Initializes a new instance of the + class. + + + + + Initializes a new instance of the + class that contains elements copied from the specified collection. + + The collection whose elements are copied to the new . + is a null reference + (Nothing in Visual Basic). + + + + Local helper function to initalize a new bag object + + An enumeration containing items with which to initialize this bag. + + + + Adds an object to the . + + The object to be added to the + . The value can be a null reference + (Nothing in Visual Basic) for reference types. + + + + + + + + + + Attempts to add an object to the . + + The object to be added to the + . The value can be a null reference + (Nothing in Visual Basic) for reference types. + Always returns true + + + + Attempts to remove and return an object from the . + + When this method returns, contains the object + removed from the or the default value + of if the operation failed. + true if an object was removed successfully; otherwise, false. + + + + Attempts to return an object from the + without removing it. + + When this method returns, contains an object from + the or the default value of + if the operation failed. + true if and object was returned successfully; otherwise, false. + + + + Local helper function to Take or Peek an item from the bag + + To receive the item retrieved from the bag + True means Take operation, false means Peek operation + True if succeeded, false otherwise + + + + Local helper function to retrieve a thread local list by a thread object + + Create a new list if the thread does ot exist + The local list object + + + + Try to reuse an unowned list if exist + unowned lists are the lists that their owner threads are aborted or terminated + this is workaround to avoid memory leaks. + + The list object, null if all lists are owned + + + + Local helper method to steal an item from any other non empty thread + It enumerate all other threads in two passes first pass acquire the lock with TryEnter if succeeded + it steals the item, otherwise it enumerate them again in 2nd pass and acquire the lock using Enter + + To receive the item retrieved from the bag + Whether to remove or peek. + True if succeeded, false otherwise. + + + + local helper function tries to steal an item from given local list + + + + + Local helper function to check the list if it became empty after acquiring the lock + and wait if there is unsynchronized Add/Take operation in the list to be done + + The list to steal + True if can steal, false otherwise + + + + Copies the elements to an existing + one-dimensional Array, starting at the specified array + index. + + The one-dimensional Array that is the + destination of the elements copied from the + . The Array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference (Nothing in + Visual Basic). + is less than + zero. + is equal to or greater than the + length of the + -or- the number of elements in the source is greater than the available space from + to the end of the destination . + + + + Copies the elements of the to an , starting at a particular + index. + + The one-dimensional Array that is the + destination of the elements copied from the + . The Array must have zero-based indexing. + The zero-based index in at which copying + begins. + is a null reference (Nothing in + Visual Basic). + is less than + zero. + + is multidimensional. -or- + does not have zero-based indexing. -or- + is equal to or greater than the length of the + -or- The number of elements in the source is + greater than the available space from to the end of the destination + . -or- The type of the source cannot be cast automatically to the type of the + destination . + + + + + Copies the elements to a new array. + + A new array containing a snapshot of elements copied from the . + + + + Returns an enumerator that iterates through the . + + An enumerator for the contents of the . + + The enumeration represents a moment-in-time snapshot of the contents + of the bag. It does not reflect any updates to the collection after + was called. The enumerator is safe to use + concurrently with reads from and writes to the bag. + + + + + Returns an enumerator that iterates through the . + + An enumerator for the contents of the . + + The items enumerated represent a moment-in-time snapshot of the contents + of the bag. It does not reflect any update to the collection after + was called. + + + + + Get the data array to be serialized + + + + + Construct the stack from a previously seiralized one + + + + + Local helper method to freeze all bag operations, it + 1- Acquire the global lock to prevent any other thread to freeze the bag, and also new new thread can be added + to the dictionary + 2- Then Acquire all local lists locks to prevent steal and synchronized operations + 3- Wait for all un-synchronized operations to be done + + Retrieve the lock taken result for the global lock, to be passed to Unfreeze method + + + + Local helper method to unfreeze the bag from a frozen state + + The lock taken result from the Freeze method + + + + local helper method to acquire all local lists locks + + + + + Local helper method to release all local lists locks + + + + + Local helper function to wait all unsynchronized operations + + + + + Local helper function to get the bag count, the caller should call it from Freeze/Unfreeze block + + The current bag count + + + + Local helper function to return the bag item in a list, this is mainly used by CopyTo and ToArray + This is not thread safe, should be called in Freeze/UnFreeze bag block + + List the contains the bag items + + + + Gets the number of elements contained in the . + + The number of elements contained in the . + + The count returned represents a moment-in-time snapshot of the contents + of the bag. It does not reflect any updates to the collection after + was called. + + + + + Gets a value that indicates whether the is empty. + + true if the is empty; otherwise, false. + + + + Gets a value indicating whether access to the is + synchronized with the SyncRoot. + + true if access to the is synchronized + with the SyncRoot; otherwise, false. For , this property always + returns false. + + + + Gets an object that can be used to synchronize access to the . This property is not supported. + + The SyncRoot property is not supported. + + + + A class that represents a node in the lock thread list + + + + + A class that represents the lock thread list + + + + + ThreadLocalList constructor + + The owner thread for this list + + + + Add new item to head of the list + + The item to add. + Whether to update the count. + + + + Remove an item from the head of the list + + The removed item + + + + Peek an item from the head of the list + + the peeked item + True if succeeded, false otherwise + + + + Steal an item from the tail of the list + + the removed item + remove or peek flag + + + + Gets the total list count, it's not thread safe, may provide incorrect count if it is called concurrently + + + + + List operations + + + + + A simple class for the debugger view window + + + + + Provides a set of methods for querying objects that implement + ParallelQuery{TSource}. This is the parallel equivalent of + . + + + + + Enables parallelization of a query. + + The type of elements of . + An + to convert to a . + The source as a to bind to + ParallelEnumerable extension methods. + + is a null reference (Nothing in Visual Basic). + + + + + Enables parallelization of a query, as sourced by a partitioner + responsible for splitting the input sequence into partitions. + + The type of elements of . + A partitioner over the input sequence. + The as a ParallelQuery to bind to ParallelEnumerable extension methods. + + The source partitioner's GetOrderedPartitions method is used when ordering is enabled, + whereas the partitioner's GetPartitions is used if ordering is not enabled (the default). + The source partitioner's GetDynamicPartitions and GetDynamicOrderedPartitions are not used. + + + is a null reference (Nothing in Visual Basic). + + + + + Enables treatment of a data source as if it was ordered, overriding the default of unordered. + AsOrdered may only be invoked on sequences returned by AsParallel, ParallelEnumerable.Range, + and ParallelEnumerable.Repeat. + + The type of elements of . + The input sequence. + + Thrown if is not one of AsParallel, ParallelEnumerable.Range, or ParallelEnumerable.Repeat. + + + is a null reference (Nothing in Visual Basic). + + + A natural tension exists between performance and preserving order in parallel processing. By default, + a parallelized query behaves as if the ordering of the results is arbitrary + unless AsOrdered is applied or there is an explicit OrderBy operator in the query. + + The source sequence which will maintain ordering in the query. + + + + Enables treatment of a data source as if it was ordered, overriding the default of unordered. + AsOrdered may only be invoked on sequences returned by AsParallel, ParallelEnumerable.Range, + and ParallelEnumerable.Repeat. + + The input sequence. + + Thrown if the is not one of AsParallel, ParallelEnumerable.Range, or ParallelEnumerable.Repeat. + + + is a null reference (Nothing in Visual Basic). + + + A natural tension exists between performance and preserving order in parallel processing. By default, + a parallelized query behaves as if the ordering of the results is arbitrary unless AsOrdered + is applied or there is an explicit OrderBy operator in the query. + + The source sequence which will maintain ordering in the query. + + + + Allows an intermediate query to be treated as if no ordering is implied among the elements. + + + AsUnordered may provide + performance benefits when ordering is not required in a portion of a query. + + The type of elements of . + The input sequence. + The source sequence with arbitrary order. + + is a null reference (Nothing in Visual Basic). + + + + + Enables parallelization of a query. + + An to convert + to a . + + The source as a ParallelQuery to bind to + ParallelEnumerable extension methods. + + + is a null reference (Nothing in Visual Basic). + + + + + Converts a into an + to force sequential + evaluation of the query. + + The type of elements of . + A to convert to an . + The source as an + to bind to sequential extension methods. + + is a null reference (Nothing in Visual Basic). + + + + + Sets the task scheduler to execute the query. + + The type of elements of . + A ParallelQuery on which to set the task scheduler option. + Task scheduler to execute the query. + ParallelQuery representing the same query as source, but with the task scheduler option set. + + or is a null reference (Nothing in Visual Basic). + + + WithTaskScheduler is used multiple times in the query. + + + + + Sets the degree of parallelism to use in a query. Degree of parallelism is the maximum number of concurrently + executing tasks that will be used to process the query. + + The type of elements of . + A ParallelQuery on which to set the limit on the degrees of parallelism. + The degree of parallelism for the query. + ParallelQuery representing the same query as source, with the limit on the degrees of parallelism set. + + is a null reference (Nothing in Visual Basic). + + + WithDegreeOfParallelism is used multiple times in the query. + + + is less than 1 or greater than 63. + + + + + Sets the to associate with the query. + + The type of elements of . + A ParallelQuery on which to set the option. + A cancellation token. + ParallelQuery representing the same query as source, but with the + registered. + + is a null reference (Nothing in Visual Basic). + + + WithCancellation is used multiple times in the query. + + + The associated with the has been disposed. + + + + + Sets the execution mode of the query. + + The type of elements of . + A ParallelQuery on which to set the option. + The mode in which to execute the query. + ParallelQuery representing the same query as source, but with the + registered. + + is a null reference (Nothing in Visual Basic). + + + is not a valid value. + + + WithExecutionMode is used multiple times in the query. + + + + + Sets the merge options for this query, which specify how the query will buffer output. + + The type of elements of . + A ParallelQuery on which to set the option. + The merge optiosn to set for this query. + ParallelQuery representing the same query as source, but with the + registered. + + is a null reference (Nothing in Visual Basic). + + + is not a valid value. + + + WithMergeOptions is used multiple times in the query. + + + + + Generates a parallel sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An IEnumerable<Int32> in C# or IEnumerable(Of Int32) in + Visual Basic that contains a range of sequential integral numbers. + + is less than 0 + -or- + + - 1 is larger than . + + + + + Generates a parallel sequence that contains one repeated value. + + The type of the value to be repeated in the result sequence. + The value to be repeated. + The number of times to repeat the value in the generated sequence. + A sequence that contains a repeated value. + + is less than 0. + + + + + Returns an empty ParallelQuery{TResult} that has the specified type argument. + + The type to assign to the type parameter of the returned + generic sequence. + An empty sequence whose type argument is . + + + + Invokes in parallel the specified action for each element in the . + + + This is an efficient way to process the output from a parallelized query because it does + not require a merge step at the end. However, order of execution is non-deterministic. + + The type of elements of . + The whose elements will be processed by + . + An Action to invoke on each element. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Filters in parallel a sequence of values based on a predicate. + + The type of the elements of source. + A sequence to filter. + A function to test each element for a condition. + A sequence that contains elements from the input sequence that satisfy + the condition. + + or is a null reference (Nothing in Visual Basic). + + + + + Filters in parallel a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function. + + The type of the elements of source. + A sequence to filter. + A function to test each element for a condition. + A sequence that contains elements from the input sequence that satisfy the condition. + + or is a null reference (Nothing in Visual Basic). + + + + + Projects in parallel each element of a sequence into a new form. + + The type of the elements of . + The type of elements resturned by selector. + A sequence of values to invoke a transform function on. + A transform function to apply to each element. + A sequence whose elements are the result of invoking the transform function on each + element of . + + or is a null reference (Nothing in Visual Basic). + + + + + Projects in parallel each element of a sequence into a new form by incorporating the element's index. + + The type of the elements of . + The type of elements resturned by selector. + A sequence of values to invoke a transform function on. + A transform function to apply to each element. + A sequence whose elements are the result of invoking the transform function on each + element of . + + or is a null reference (Nothing in Visual Basic). + + + + + Merges in parallel two sequences by using the specified predicate function. + + The type of the elements of the first sequence. + The type of the elements of the second sequence. + The type of the return elements. + The first sequence to zip. + The second sequence to zip. + A function to create a result element from two matching elements. + + A sequence that has elements of type that are obtained by performing + resultSelector pairwise on two sequences. If the sequence lengths are unequal, this truncates + to the length of the shorter sequence. + + + or or is a null reference (Nothing in Visual Basic). + + + + + This Zip overload should never be called. + This method is marked as obsolete and always throws + when invoked. + + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Zip with a left data source of type + and a right data source of type . + Otherwise, the Zip operator would appear to be bind to the parallel implementation, but would in reality bind to the sequential implementation. + + + + + Correlates in parallel the elements of two sequences based on matching keys. + The default equality comparer is used to compare keys. + + The type of the elements of the first sequence. + The type of the elements of the second sequence. + The type of the keys returned by the key selector functions. + The type of the result elements. + The first sequence to join. + The sequence to join to the first sequence. + A function to extract the join key from each element of + the first sequence. + A function to extract the join key from each element of + the second sequence. + A function to create a result element from two matching elements. + A sequence that has elements of type that are obtained by performing + an inner join on two sequences. + + or or or + or is a null reference (Nothing in Visual Basic). + + + + + This Join overload should never be called. + This method is marked as obsolete and always throws when invoked. + + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage Join with a left data source of type + and a right data source of type . + Otherwise, the Join operator would appear to be binding to the parallel implementation, but would in reality bind to the sequential implementation. + + + + + Correlates in parallel the elements of two sequences based on matching keys. + A specified IEqualityComparer{T} is used to compare keys. + + The type of the elements of the first sequence. + The type of the elements of the second sequence. + The type of the keys returned by the key selector functions. + The type of the result elements. + The first sequence to join. + The sequence to join to the first sequence. + A function to extract the join key from each element + of the first sequence. + A function to extract the join key from each element + of the second sequence. + A function to create a result element from two matching elements. + An IEqualityComparer<(Of <(T>)>) to hash and compare keys. + A sequence that has elements of type that are obtained by performing + an inner join on two sequences. + + or or or + or is a null reference (Nothing in Visual Basic). + + + + + This Join overload should never be called. + This method is marked as obsolete and always throws when invoked. + + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Join with a left data source of type + and a right data source of type . + Otherwise, the Join operator would appear to be binding to the parallel implementation, but would in reality bind to the sequential implementation. + + + + + Correlates in parallel the elements of two sequences based on equality of keys and groups the results. + The default equality comparer is used to compare keys. + + The type of the elements of the first sequence. + The type of the elements of the second sequence. + The type of the keys returned by the key selector functions. + The type of the result elements. + The first sequence to join. + The sequence to join to the first sequence. + A function to extract the join key from each element + of the first sequence. + A function to extract the join key from each element + of the second sequence. + A function to create a result element from an element from + the first sequence and a collection of matching elements from the second sequence. + A sequence that has elements of type that are obtained by performing + a grouped join on two sequences. + + or or or + or is a null reference (Nothing in Visual Basic). + + + + + This GroupJoin overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of GroupJoin with a left data source of type + and a right data source of type . + Otherwise, the GroupJoin operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Correlates in parallel the elements of two sequences based on key equality and groups the results. + A specified IEqualityComparer{T} is used to compare keys. + + The type of the elements of the first sequence. + The type of the elements of the second sequence. + The type of the keys returned by the key selector functions. + The type of the result elements. + The first sequence to join. + The sequence to join to the first sequence. + A function to extract the join key from each element + of the first sequence. + A function to extract the join key from each element + of the second sequence. + A function to create a result element from an element from + the first sequence and a collection of matching elements from the second sequence. + An IEqualityComparer<(Of <(T>)>) to hash and compare keys. + A sequence that has elements of type that are obtained by performing + a grouped join on two sequences. + + or or or + or is a null reference (Nothing in Visual Basic). + + + + + This GroupJoin overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of GroupJoin with a left data source of type + and a right data source of type . + Otherwise, the GroupJoin operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Projects in parallel each element of a sequence to an IEnumerable{T} + and flattens the resulting sequences into one sequence. + + The type of elements of . + The type of the elements of the sequence returned by selector. + A sequence of values to project. + A transform function to apply to each element. + A sequence whose elements are the result of invoking the one-to-many transform + function on each element of the input sequence. + + or is a null reference (Nothing in Visual Basic). + + + + + Projects in parallel each element of a sequence to an IEnumerable{T}, and flattens the resulting + sequences into one sequence. The index of each source element is used in the projected form of + that element. + + The type of elements of . + The type of the elements of the sequence returned by selector. + A sequence of values to project. + A transform function to apply to each element. + A sequence whose elements are the result of invoking the one-to-many transform + function on each element of the input sequence. + + or is a null reference (Nothing in Visual Basic). + + + + + Projects each element of a sequence to an IEnumerable{T}, + flattens the resulting sequences into one sequence, and invokes a result selector + function on each element therein. + + The type of elements of . + The type of the intermediate elements collected by . + + A sequence of values to project. + A transform function to apply to each source element; + the second parameter of the function represents the index of the source element. + A function to create a result element from an element from + the first sequence and a collection of matching elements from the second sequence. + A sequence whose elements are the result of invoking the one-to-many transform + function on each element of and then mapping + each of those sequence elements and their corresponding source element to a result element. + + or or + is a null reference (Nothing in Visual Basic). + + + + + Projects each element of a sequence to an IEnumerable{T}, flattens the resulting + sequences into one sequence, and invokes a result selector function on each element + therein. The index of each source element is used in the intermediate projected + form of that element. + + The type of elements of . + The type of the intermediate elements collected by + . + The type of elements to return. + A sequence of values to project. + A transform function to apply to each source element; + the second parameter of the function represents the index of the source element. + A function to create a result element from an element from + the first sequence and a collection of matching elements from the second sequence. + + A sequence whose elements are the result of invoking the one-to-many transform + function on each element of and then mapping + each of those sequence elements and their corresponding source element to a + result element. + + + or or + is a null reference (Nothing in Visual Basic). + + + + + Sorts in parallel the elements of a sequence in ascending order according to a key. + + + In contrast to the sequential implementation, this is not a stable sort. + To achieve a stable sort, change a query of the form: + var ordered = source.OrderBy((e) => e.k); + to instead be formed as: + var ordered = source.Select((e,i) => new { E=e, I=i }).OrderBy((v) => v.i).Select((v) => v.e); + + The type of elements of . + The type of the key returned by . + A sequence of values to order. + A function to extract a key from an element. + An OrderedParallelQuery{TSource} whose elements are sorted + according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Sorts in parallel the elements of a sequence in ascending order by using a specified comparer. + + + In contrast to the sequential implementation, this is not a stable sort. + See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for + an approach to implementing a stable sort. + + The type of elements of . + The type of the key returned by . + A sequence of values to order. + A function to extract a key from an element. + An IComparer{TKey} to compare keys. + An OrderedParallelQuery{TSource} whose elements are sorted according + to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Sorts in parallel the elements of a sequence in descending order according to a key. + + + In contrast to the sequential implementation, this is not a stable sort. + See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for + an approach to implementing a stable sort. + + The type of elements of . + The type of the key returned by . + A sequence of values to order. + A function to extract a key from an element. + An OrderedParallelQuery{TSource} whose elements are sorted + descending according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Sorts the elements of a sequence in descending order by using a specified comparer. + + + In contrast to the sequential implementation, this is not a stable sort. + See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for + an approach to implementing a stable sort. + + The type of elements of . + The type of the key returned by . + A sequence of values to order. + A function to extract a key from an element. + An IComparer{TKey} to compare keys. + An OrderedParallelQuery{TSource} whose elements are sorted descending + according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Performs in parallel a subsequent ordering of the elements in a sequence + in ascending order according to a key. + + + In contrast to the sequential implementation, this is not a stable sort. + See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for + an approach to implementing a stable sort. + + The type of elements of . + The type of the key returned by . + An OrderedParallelQuery{TSource} than + contains elements to sort. + A function to extract a key from an element. + An OrderedParallelQuery{TSource} whose elements are + sorted according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Performs in parallel a subsequent ordering of the elements in a sequence in + ascending order by using a specified comparer. + + + In contrast to the sequential implementation, this is not a stable sort. + See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for + an approach to implementing a stable sort. + + The type of elements of . + The type of the key returned by . + An OrderedParallelQuery{TSource} that contains + elements to sort. + A function to extract a key from an element. + An IComparer{TKey} to compare keys. + An OrderedParallelQuery{TSource} whose elements are sorted + according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Performs in parallel a subsequent ordering of the elements in a sequence in + descending order, according to a key. + + + In contrast to the sequential implementation, this is not a stable sort. + See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for + an approach to implementing a stable sort. + + The type of elements of . + The type of the key returned by . + An OrderedParallelQuery{TSource} than contains + elements to sort. + A function to extract a key from an element. + An OrderedParallelQuery{TSource} whose elements are sorted + descending according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Performs in parallel a subsequent ordering of the elements in a sequence in descending + order by using a specified comparer. + + + In contrast to the sequential implementation, this is not a stable sort. + See the remarks for OrderBy(ParallelQuery{TSource}, Func{TSource,TKey}) for + an approach to implementing a stable sort. + + The type of elements of . + The type of the key returned by . + An OrderedParallelQuery{TSource} than contains + elements to sort. + A function to extract a key from an element. + An IComparer{TKey} to compare keys. + An OrderedParallelQuery{TSource} whose elements are sorted + descending according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Groups in parallel the elements of a sequence according to a specified key selector function. + + The type of elements of . + The type of the key returned by . + An OrderedParallelQuery{TSource}than contains + elements to sort. + A function to extract a key from an element. + An OrderedParallelQuery{TSource}whose elements are sorted + descending according to a key. + + + + Groups in parallel the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer. + + The type of elements of . + The type of the key returned by >. + An OrderedParallelQuery{TSource} than contains + elements to sort. + A function to extract a key from an element. + An IComparer{TSource} to compare keys. + An OrderedParallelQuery{TSource} whose elements are sorted + descending according to a key. + + or is a null reference (Nothing in Visual Basic). + + + + + Groups in parallel the elements of a sequence according to a specified key selector function and + projects the elements for each group by using a specified function. + + The type of elements of . + The type of the key returned by . + The type of the elements in the IGrouping + An OrderedParallelQuery<(Of <(TElement>)>) than contains + elements to sort. + A function to extract a key from an element. + A function to map each source element to an element in an IGrouping. + A ParallelQuery<IGrouping<TKey, TElement>> in C# or + ParallelQuery(Of IGrouping(Of TKey, TElement)) in Visual Basic where each IGrouping + generic object contains a collection of objects of type and a key. + + or or + is a null reference (Nothing in Visual Basic). + + + + + Groups in parallel the elements of a sequence according to a key selector function. + The keys are compared by using a comparer and each group's elements are projected by + using a specified function. + + The type of elements of . + The type of the key returned by . + The type of the elements in the IGrouping + An OrderedParallelQuery{TSource}than contains elements to sort. + A function to extract a key from an element. + A function to map each source element to an element in an IGrouping. + An IComparer{TSource} to compare keys. + + A ParallelQuery{IGrouping{TKey, TElement}} in C# or + ParallelQuery(Of IGrouping(Of TKey, TElement)) in Visual Basic where each IGrouping + generic object contains a collection of objects of type and a key. + + + or or + is a null reference (Nothing in Visual Basic). + + + + + Groups in parallel the elements of a sequence according to a specified + key selector function and creates a result value from each group and its key. + + The type of the elements of . + The type of the key returned by . + The type of the result value returned by . + A sequence whose elements to group. + A function to extract the key for each element. + A function to create a result value from each group. + A collection of elements of type where each element represents a + projection over a group and its key. + + or or + is a null reference (Nothing in Visual Basic). + + + + + Groups in parallel the elements of a sequence according to a specified key selector function + and creates a result value from each group and its key. The keys are compared + by using a specified comparer. + + The type of the elements of . + The type of the key returned by . + The type of the result value returned by . + A sequence whose elements to group. + A function to extract the key for each element. + A function to create a result value from each group. + An IEqualityComparer{TKey} to compare keys. + + An ParallelQuery<IGrouping<TKey, TResult>> in C# or + ParallelQuery(Of IGrouping(Of TKey, TResult)) in Visual Basic where each + IGrouping<(Of <(TKey, TResult>)>) object contains a collection of objects + of type and a key. + + + or or + is a null reference (Nothing in Visual Basic). + + + + + Groups in parallel the elements of a sequence according to a specified key + selector function and creates a result value from each group and its key. + The elements of each group are projected by using a specified function. + + The type of the elements of . + The type of the key returned by . + The type of the elements in each + IGrouping{TKey, TElement}. + The type of the result value returned by . + A sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an + IGrouping<TKey, TElement>. + A function to create a result value from each group. + A collection of elements of type where each element represents a + projection over a group and its key. + + or or + or is a null reference (Nothing in Visual Basic). + + + + + Groups the elements of a sequence according to a specified key selector function and + creates a result value from each group and its key. Key values are compared by using a + specified comparer, and the elements of each group are projected by using a specified function. + + The type of the elements of . + The type of the key returned by . + The type of the elements in each + IGrouping{TKey, TElement}. + The type of the result value returned by . + A sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an + IGrouping{Key, TElement}. + A function to create a result value from each group. + An IEqualityComparer{TKey} to compare keys. + A collection of elements of type where each element represents a + projection over a group and its key. + + or or + or is a null reference (Nothing in Visual Basic). + + + + + Run an aggregation sequentially. If the user-provided reduction function throws an exception, wrap + it with an AggregateException. + + + + + if true, use the seed provided in the method argument + if false, use the first element of the sequence as the seed instead + + + + + + Applies in parallel an accumulator function over a sequence. + + The type of the elements of . + A sequence to aggregate over. + An accumulator function to be invoked on each element. + The final accumulator value. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Applies in parallel an accumulator function over a sequence. + The specified seed value is used as the initial accumulator value. + + The type of the elements of . + The type of the accumulator value. + A sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + The final accumulator value. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Applies in parallel an accumulator function over a sequence. The specified + seed value is used as the initial accumulator value, and the specified + function is used to select the result value. + + The type of the elements of . + The type of the accumulator value. + The type of the resulting value. + A sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value + into the result value. + The transformed final accumulator value. + + or or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Applies in parallel an accumulator function over a sequence. This overload is not + available in the sequential implementation. + + + This overload is specific to processing a parallelized query. A parallelized query may + partition the data source sequence into several sub-sequences (partitions). + The is invoked on each element within partitions. + Each partition then yields a single accumulated result. The + is then invoked on the results of each partition to yield a single element. This element is then + transformed by the function. + + The type of the elements of . + The type of the accumulator value. + The type of the resulting value. + A sequence to aggregate over. + The initial accumulator value. + + An accumulator function to be invoked on each element in a partition. + + + An accumulator function to be invoked on the yielded element from each partition. + + + A function to transform the final accumulator value into the result value. + + The transformed final accumulator value. + + or + or or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Applies in parallel an accumulator function over a sequence. This overload is not + available in the sequential implementation. + + + This overload is specific to parallelized queries. A parallelized query may partition the data source sequence + into several sub-sequences (partitions). The is invoked + on each element within partitions. Each partition then yields a single accumulated result. + The + is then invoked on the results of each partition to yield a single element. This element is then + transformed by the function. + + The type of the elements of . + The type of the accumulator value. + The type of the resulting value. + A sequence to aggregate over. + + A function that returns the initial accumulator value. + + + An accumulator function to be invoked on each element in a partition. + + + An accumulator function to be invoked on the yielded element from each partition. + + + A function to transform the final accumulator value into the result value. + + The transformed final accumulator value. + + or or + or or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the number of elements in a parallel sequence. + + The type of the elements of . + A sequence that contains elements to be counted. + The number of elements in the input sequence. + + is a null reference (Nothing in Visual Basic). + + + The number of elements in source is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns a number that represents how many elements in the specified + parallel sequence satisfy a condition. + + The type of the elements of . + A sequence that contains elements to be counted. + A function to test each element for a condition. + + A number that represents how many elements in the sequence satisfy the condition + in the predicate function. + + + or is a null reference (Nothing in Visual Basic). + + + The number of elements in source is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns an Int64 that represents the total number of elements in a parallel sequence. + + The type of the elements of . + A sequence that contains elements to be counted. + The number of elements in the input sequence. + + is a null reference (Nothing in Visual Basic). + + + The number of elements in source is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns an Int64 that represents how many elements in a parallel sequence satisfy a condition. + + The type of the elements of . + A sequence that contains elements to be counted. + A function to test each element for a condition. + + A number that represents how many elements in the sequence satisfy the condition + in the predicate function. + + + or is a null reference (Nothing in Visual Basic). + + + The number of elements in source is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of a sequence of values. + + A sequence of values to calculate the sum of. + The sum of the values in the sequence. + + is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the sum of the sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values to calculate the sum of. + A transform function to apply to each element. + The sum of the values in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + The sum is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the minimum value in a parallel sequence of values. + + The type of elements of . + A sequence of values to determine the minimum value of. + The minimum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements and is a non-nullable value type. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the minimum value. + + The type of elements of . + The type of the value returned by . + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + The minimum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements and is a non-nullable value type. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the maximum value in a parallel sequence of values. + + A sequence of values to determine the maximum value of. + The maximum value in the sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements and is a non-nullable value type. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Invokes in parallel a transform function on each element of a + sequence and returns the maximum value. + + The type of elements of . + The type of the value returned by . + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + The maximum value in the sequence. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements and is a non-nullable value type. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values. + + A sequence of values that are used to calculate an average. + The average of the sequence of values. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + The sum or count of the elements in the sequence is larger than . + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Computes in parallel the average of a sequence of values that are obtained + by invoking a transform function on each element of the input sequence. + + The type of elements of . + A sequence of values that are used to calculate an average. + A transform function to apply to each element. + The average of the sequence of values. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Determines in parallel whether any element of a sequence satisfies a condition. + + The type of elements of . + An IEnumerable whose elements to apply the predicate to. + A function to test each element for a condition. + + true if any elements in the source sequence pass the test in the specified predicate; otherwise, false. + + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Determines whether a parallel sequence contains any elements. + + The type of elements of . + The IEnumerable to check for emptiness. + true if the source sequence contains any elements; otherwise, false. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Determines in parallel whether all elements of a sequence satisfy a condition. + + The type of elements of . + A sequence whose elements to apply the predicate to. + A function to test each element for a condition. + + true if all elements in the source sequence pass the test in the specified predicate; otherwise, false. + + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Determines in parallel whether a sequence contains a specified element + by using the default equality comparer. + + The type of elements of . + A sequence in which to locate a value. + The value to locate in the sequence. + + true if the source sequence contains an element that has the specified value; otherwise, false. + + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Determines in parallel whether a sequence contains a specified element by using a + specified IEqualityComparer{T}. + + The type of elements of . + A sequence in which to locate a value. + The value to locate in the sequence. + An equality comparer to compare values. + + true if the source sequence contains an element that has the specified value; otherwise, false. + + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns a specified number of contiguous elements from the start of a parallel sequence. + + The type of elements of . + The sequence to return elements from. + The number of elements to return. + + A sequence that contains the specified number of elements from the start of the input sequence. + + + is a null reference (Nothing in Visual Basic). + + + + + Returns elements from a parallel sequence as long as a specified condition is true. + + The type of elements of . + The sequence to return elements from. + A function to test each element for a condition. + + A sequence that contains the elements from the input sequence that occur before + the element at which the test no longer passes. + + + or is a null reference (Nothing in Visual Basic). + + + + + Returns elements from a parallel sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of elements of . + The sequence to return elements from. + + A function to test each source element for a condition; the second parameter of the + function represents the index of the source element. + + + A sequence that contains elements from the input sequence that occur before + the element at which the test no longer passes. + + + or is a null reference (Nothing in Visual Basic). + + + + + Bypasses a specified number of elements in a parallel sequence and then returns the remaining elements. + + The type of elements of . + The sequence to return elements from. + The number of elements to skip before returning the remaining elements. + + A sequence that contains the elements that occur after the specified index in the input sequence. + + + is a null reference (Nothing in Visual Basic). + + + + + Bypasses elements in a parallel sequence as long as a specified + condition is true and then returns the remaining elements. + + The type of elements of . + The sequence to return elements from. + A function to test each element for a condition. + A sequence that contains the elements from the input sequence starting at + the first element in the linear series that does not pass the test specified by + predicate. + + or is a null reference (Nothing in Visual Basic). + + + + + Bypasses elements in a parallel sequence as long as a specified condition is true and + then returns the remaining elements. The element's index is used in the logic of + the predicate function. + + The type of elements of . + The sequence to return elements from. + + A function to test each source element for a condition; the + second parameter of the function represents the index of the source element. + + + A sequence that contains the elements from the input sequence starting at the + first element in the linear series that does not pass the test specified by + predicate. + + + or is a null reference (Nothing in Visual Basic). + + + + + Concatenates two parallel sequences. + + The type of the elements of the input sequences. + The first sequence to concatenate. + The sequence to concatenate to the first sequence. + A sequence that contains the concatenated elements of the two input sequences. + + or is a null reference (Nothing in Visual Basic). + + + + + This Concat overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Concat with a left data source of type + and a right data source of type . + Otherwise, the Concat operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Determines whether two parallel sequences are equal by comparing the elements by using + the default equality comparer for their type. + + The type of the elements of the input sequences. + A sequence to compare to second. + A sequence to compare to the first input sequence. + + true if the two source sequences are of equal length and their corresponding elements + are equal according to the default equality comparer for their type; otherwise, false. + + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + This SequenceEqual overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + Thrown every time this method is called. + + This overload exists to disallow usage of SequenceEqual with a left data source of type + and a right data source of type . + Otherwise, the SequenceEqual operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Determines whether two parallel sequences are equal by comparing their elements by + using a specified IEqualityComparer{T}. + + The type of the elements of the input sequences. + A sequence to compare to . + A sequence to compare to the first input sequence. + An IEqualityComparer<(Of <(T>)>) to use to compare elements. + + true if the two source sequences are of equal length and their corresponding + elements are equal according to the default equality comparer for their type; otherwise, false. + + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + A helper method for SequenceEqual to dispose an enumerator. If an exception is thrown by the disposal, + it gets wrapped into an AggregateException, unless it is an OCE with the query's CancellationToken. + + + + + This SequenceEqual overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + Thrown every time this method is called. + + This overload exists to disallow usage of SequenceEqual with a left data source of type + and a right data source of type . + Otherwise, the SequenceEqual operator would appear to be binding to the parallel implementation, + but would in reality bind to sequential implementation. + + + + + Returns distinct elements from a parallel sequence by using the + default equality comparer to compare values. + + The type of the elements of . + The sequence to remove duplicate elements from. + A sequence that contains distinct elements from the source sequence. + + is a null reference (Nothing in Visual Basic). + + + + + Returns distinct elements from a parallel sequence by using a specified + IEqualityComparer{T} to compare values. + + The type of the elements of . + The sequence to remove duplicate elements from. + An IEqualityComparer<(Of <(T>)>) to compare values. + A sequence that contains distinct elements from the source sequence. + + is a null reference (Nothing in Visual Basic). + + + + + Produces the set union of two parallel sequences by using the default equality comparer. + + The type of the elements of the input sequences. + A sequence whose distinct elements form the first set for the union. + A sequence whose distinct elements form the second set for the union. + A sequence that contains the elements from both input sequences, excluding duplicates. + + or is a null reference (Nothing in Visual Basic). + + + + + This Union overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Union with a left data source of type + and a right data source of type . + Otherwise, the Union operator would appear to be binding to the parallel implementation, + but would in reality bind to sequential implementation. + + + + + Produces the set union of two parallel sequences by using a specified IEqualityComparer{T}. + + The type of the elements of the input sequences. + A sequence whose distinct elements form the first set for the union. + A sequence whose distinct elements form the second set for the union. + An IEqualityComparer<(Of <(T>)>) to compare values. + A sequence that contains the elements from both input sequences, excluding duplicates. + + or is a null reference (Nothing in Visual Basic). + + + + + This Union overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Union with a left data source of type + and a right data source of type . + Otherwise, the Union operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Produces the set intersection of two parallel sequences by using the + default equality comparer to compare values. + + The type of the elements of the input sequences. + A sequence whose distinct elements that also appear in will be returned. + + + A sequence whose distinct elements that also appear in the first sequence will be returned. + + A sequence that contains the elements that form the set intersection of two sequences. + + or is a null reference (Nothing in Visual Basic). + + + + + This Intersect overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Intersect with a left data source of type + and a right data source of type . + Otherwise, the Intersect operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Produces the set intersection of two parallel sequences by using + the specified IEqualityComparer{T} to compare values. + + The type of the elements of the input sequences. + + A sequence whose distinct elements that also appear in will be returned. + + + A sequence whose distinct elements that also appear in the first sequence will be returned. + + An IEqualityComparer<(Of <(T>)>) to compare values. + A sequence that contains the elements that form the set intersection of two sequences. + + or is a null reference (Nothing in Visual Basic). + + + + + This Intersect overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Intersect with a left data source of type + and a right data source of type . + Otherwise, the Intersect operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Produces the set difference of two parallel sequences by using + the default equality comparer to compare values. + + The type of the elements of the input sequences. + + A sequence whose elements that are not also in will be returned. + + + A sequence whose elements that also occur in the first sequence will cause those + elements to be removed from the returned sequence. + + A sequence that contains the set difference of the elements of two sequences. + + or is a null reference (Nothing in Visual Basic). + + + + + This Except overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Except with a left data source of type + and a right data source of type . + Otherwise, the Except operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Produces the set difference of two parallel sequences by using the + specified IEqualityComparer{T} to compare values. + + The type of the elements of the input sequences. + A sequence whose elements that are not also in will be returned. + + A sequence whose elements that also occur in the first sequence will cause those elements + to be removed from the returned sequence. + + An IEqualityComparer<(Of <(T>)>) to compare values. + A sequence that contains the set difference of the elements of two sequences. + + or is a null reference (Nothing in Visual Basic). + + + + + This Except overload should never be called. + This method is marked as obsolete and always throws when called. + + This type parameter is not used. + This parameter is not used. + This parameter is not used. + This parameter is not used. + This overload always throws a . + The exception that occurs when this method is called. + + This overload exists to disallow usage of Except with a left data source of type + and a right data source of type . + Otherwise, the Except operator would appear to be binding to the parallel implementation, + but would in reality bind to the sequential implementation. + + + + + Converts a into an + to force sequential + evaluation of the query. + + The type of the elements of . + The sequence to type as . + The input sequence types as . + + is a null reference (Nothing in Visual Basic). + + + + + Creates an array from a ParallelQuery{T}. + + The type of the elements of . + A sequence to create an array from. + An array that contains the elements from the input sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates a List{T} from an ParallelQuery{T}. + + The type of the elements of . + A sequence to create a List<(Of <(T>)>) from. + A List<(Of <(T>)>) that contains elements from the input sequence. + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates a Dictionary{TKey,TValue} from a ParallelQuery{T} according to + a specified key selector function. + + The type of the elements of . + The type of the key returned by . + A sequence to create a Dictionary<(Of <(TKey, TValue>)>) from. + A function to extract a key from each element. + A Dictionary<(Of <(TKey, TValue>)>) that contains keys and values. + + or is a null reference (Nothing in Visual Basic). + + + produces a key that is a null reference (Nothing in Visual Basic). + -or- + produces duplicate keys for two elements. + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates a Dictionary{TKey,TValue} from a ParallelQuery{T} according to a + specified key selector function and key comparer. + + The type of the elements of . + The type of the key returned by . + A sequence to create a Dictionary<(Of <(TKey, TValue>)>) from. + A function to extract a key from each element. + An IEqualityComparer<(Of <(T>)>) to compare keys. + A Dictionary<(Of <(TKey, TValue>)>) that contains keys and values. + + or is a null reference (Nothing in Visual Basic). + + + produces a key that is a null reference (Nothing in Visual Basic). + -or- + produces duplicate keys for two elements. + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates a Dictionary{TKey,TValue} from a ParallelQuery{T} according to specified + key selector and element selector functions. + + The type of the elements of . + The type of the key returned by . + The type of the value returned by . + A sequence to create a Dictionary<(Of <(TKey, TValue>)>) from. + A function to extract a key from each element. + + A transform function to produce a result element value from each element. + + + A Dictionary<(Of <(TKey, TValue>)>) that contains values of type + selected from the input sequence + + + or or is a null reference (Nothing in Visual Basic). + + + produces a key that is a null reference (Nothing in Visual Basic). + -or- + produces duplicate keys for two elements. + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates a Dictionary{TKey,TValue from a ParallelQuery{T} according to a + specified key selector function, a comparer, and an element selector function. + + The type of the elements of . + The type of the key returned by . + The type of the value returned by . + A sequence to create a Dictionary<(Of <(TKey, TValue>)>) from. + A function to extract a key from each element. + A transform function to produce a result element + value from each element. + An IEqualityComparer<(Of <(T>)>) to compare keys. + + A Dictionary<(Of <(TKey, TValue>)>) that contains values of type + selected from the input sequence + + + or or is a null reference (Nothing in Visual Basic). + + + produces a key that is a null reference (Nothing in Visual Basic). + -or- + produces duplicate keys for two elements. + -or- + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates an ILookup{TKey,T} from a ParallelQuery{T} according to a specified key selector function. + + The type of elements of . + The type of the key returned by . + The sequence to create a Lookup<(Of <(TKey, TElement>)>) from. + A function to extract a key from each element. + A Lookup<(Of <(TKey, TElement>)>) that contains keys and values. + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates an ILookup{TKey,T} from a ParallelQuery{T} according to a specified + key selector function and key comparer. + + The type of elements of . + The type of the key returned by . + The sequence to create a Lookup<(Of <(TKey, TElement>)>) from. + A function to extract a key from each element. + An IEqualityComparer<(Of <(T>)>) to compare keys. + A Lookup<(Of <(TKey, TElement>)>) that contains keys and values. + + or or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates an ILookup{TKey,TElement} from a ParallelQuery{T} according to specified + key selector and element selector functions. + + The type of elements of . + The type of the key returned by . + The type of the value returned by . + The sequence to create a Lookup<(Of <(TKey, TElement>)>) from. + A function to extract a key from each element. + + A transform function to produce a result element value from each element. + + + A Lookup<(Of <(TKey, TElement>)>) that contains values of type TElement + selected from the input sequence. + + + or or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Creates an ILookup{TKey,TElement} from a ParallelQuery{T} according to + a specified key selector function, a comparer and an element selector function. + + The type of elements of . + The type of the key returned by . + The type of the value returned by . + The sequence to create a Lookup<(Of <(TKey, TElement>)>) from. + A function to extract a key from each element. + + A transform function to produce a result element value from each element. + + An IEqualityComparer<(Of <(T>)>) to compare keys. + + A Lookup<(Of <(TKey, TElement>)>) that contains values of type TElement selected + from the input sequence. + + + or or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Inverts the order of the elements in a parallel sequence. + + The type of the elements of . + A sequence of values to reverse. + A sequence whose elements correspond to those of the input sequence in reverse order. + + is a null reference (Nothing in Visual Basic). + + + + + Filters the elements of a ParallelQuery based on a specified type. + + The type to filter the elements of the sequence on. + The sequence whose elements to filter. + A sequence that contains elements from the input sequence of type . + + is a null reference (Nothing in Visual Basic). + + + + + Converts the elements of a ParallelQuery to the specified type. + + The type to convert the elements of to. + The sequence that contains the elements to be converted. + + A sequence that contains each element of the source sequence converted to the specified type. + + + is a null reference (Nothing in Visual Basic). + + + + + Returns the first element of a parallel sequence. + The type of the elements of . + The sequence to return the first element of. + The first element in the specified sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the first element in a parallel sequence that satisfies a specified condition. + + There's a temporary difference from LINQ to Objects, this does not throw + ArgumentNullException when the predicate is null. + The type of the elements of . + The sequence to return an element from. + A function to test each element for a condition. + The first element in the sequence that passes the test in the specified predicate function. + + or is a null reference (Nothing in Visual Basic). + + + No element in satisfies the condition in . + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the first element of a parallel sequence, or a default value if the + sequence contains no elements. + + The type of the elements of . + The sequence to return the first element of. + + default(TSource) if is empty; otherwise, the first element in . + + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the first element of the parallel sequence that satisfies a condition or a + default value if no such element is found. + + There's a temporary difference from LINQ to Objects, this does not throw + ArgumentNullException when the predicate is null. + The type of the elements of . + The sequence to return an element from. + A function to test each element for a condition. + + default(TSource) if is empty or if no element passes the test + specified by predicate; otherwise, the first element in that + passes the test specified by predicate. + + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the last element of a parallel sequence. + The type of the elements of . + The sequence to return the last element from. + The value at the last position in the source sequence. + + is a null reference (Nothing in Visual Basic). + + + contains no elements. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the last element of a parallel sequence that satisfies a specified condition. + + The type of the elements of . + The sequence to return an element from. + A function to test each element for a condition. + + The last element in the sequence that passes the test in the specified predicate function. + + + or is a null reference (Nothing in Visual Basic). + + + No element in satisfies the condition in . + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the last element of a parallel sequence, or a default value if the + sequence contains no elements. + + The type of the elements of . + The sequence to return an element from. + + default() if the source sequence is empty; otherwise, the last element in the sequence. + + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the last element of a parallel sequence that satisfies a condition, or + a default value if no such element is found. + + The type of the elements of . + The sequence to return an element from. + A function to test each element for a condition. + + default() if the sequence is empty or if no elements pass the test in the + predicate function; otherwise, the last element that passes the test in the predicate function. + + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the only element of a parallel sequence, and throws an exception if there is not + exactly one element in the sequence. + + The type of the elements of . + The sequence to return the single element of. + The single element of the input sequence. + + is a null reference (Nothing in Visual Basic). + + + The input sequence contains more than one element. -or- The input sequence is empty. + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the only element of a parallel sequence that satisfies a specified condition, + and throws an exception if more than one such element exists. + + The type of the elements of . + The sequence to return the single element of. + A function to test an element for a condition. + The single element of the input sequence that satisfies a condition. + + or is a null reference (Nothing in Visual Basic). + + + No element satisfies the condition in . -or- More than one element satisfies the condition in . + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the only element of a parallel sequence, or a default value if the sequence is + empty; this method throws an exception if there is more than one element in the sequence. + + The type of the elements of . + The sequence to return the single element of. + + The single element of the input sequence, or default() if the + sequence contains no elements. + + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the only element of a parallel sequence that satisfies a specified condition + or a default value if no such element exists; this method throws an exception + if more than one element satisfies the condition. + + The type of the elements of . + The sequence to return the single element of. + A function to test an element for a condition. + + The single element of the input sequence that satisfies the condition, or + default() if no such element is found. + + + or is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the elements of the specified parallel sequence or the type parameter's + default value in a singleton collection if the sequence is empty. + + The type of the elements of . + The sequence to return a default value for if it is empty. + + A sequence that contains default(TSource) if is empty; otherwise, . + + + is a null reference (Nothing in Visual Basic). + + + + + Returns the elements of the specified parallel sequence or the specified value + in a singleton collection if the sequence is empty. + + The type of the elements of . + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + + A sequence that contains defaultValue if is empty; otherwise, . + + + is a null reference (Nothing in Visual Basic). + + + + + Returns the element at a specified index in a parallel sequence. + + The type of the elements of . + A sequence to return an element from. + The zero-based index of the element to retrieve. + The element at the specified position in the source sequence. + + is a null reference (Nothing in Visual Basic). + + + is less than 0 or greater than or equal to the number of elements in . + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Returns the element at a specified index in a parallel sequence or a default value if the + index is out of range. + + The type of the elements of . + A sequence to return an element from. + The zero-based index of the element to retrieve. + + default(TSource) if the index is outside the bounds of the source sequence; + otherwise, the element at the specified position in the source sequence. + + + is a null reference (Nothing in Visual Basic). + + + One or more exceptions occurred during the evaluation of the query. + + + The query was canceled. + + + + + Specifies the preferred type of output merge to use in a query. This is a hint only, and may not be + respected by the system when parallelizing all queries. + + + + Use NotBuffered for queries that will be consumed and output as streams, this has the lowest latency + between beginning query execution and elements being yielded. For some queries, such as those involving a + sort (OrderBy, OrderByDescending), buffering is essential and a hint of NotBuffered or AutoBuffered will + be ignored. + + + Use AutoBuffered for most cases; this is the default. It strikes a balance between latency and + overall performance. + + + Use FullyBuffered for queries when the entire output can be processed before the information is + needed. This option offers the best performance when all of the output can be accumulated before yielding + any information, though it is not suitable for stream processing or showing partial results mid-query. + + + + + + Use the default merge type, which is AutoBuffered. + + + + + Use a merge without output buffers. As soon as result elements have been computed, + make that element available to the consumer of the query. + + + + + Use a merge with output buffers of a size chosen by the system. Results + will accumulate into an output buffer before they are available to the consumer of + the query. + + + + + Use a merge with full output buffers. The system will accumulate all of the + results before making any of them available to the consumer of the query. + + + + + This is a bounded channel meant for single-producer/single-consumer scenarios. + + Specifies the type of data in the channel. + + + + The simplest channel is one that has no synchronization. This is used for stop- + and-go productions where we are guaranteed the consumer is not running + concurrently. It just wraps a FIFO queue internally. + + Assumptions: + Producers and consumers never try to enqueue/dequeue concurrently. + + + + + + We occassionally need a no-op enumerator to stand-in when we don't have data left + within a partition's data stream. These are simple enumerable and enumerator + implementations that always and consistently yield no elements. + + + + + + Represents a parallel sequence. + + + + + Represents a parallel sequence. + + + + + Returns an enumerator that iterates through the sequence. + + An enumerator that iterates through the sequence. + + + + Returns an enumerator that iterates through the sequence. + + An enumerator that iterates through the sequence. + + + + A common enumerator type that unifies all query operator enumerators. + + + + + + + A simple implementation of the IEnumerable{object} interface which wraps + a weakly typed IEnumerable object, allowing it to be accessed as a strongly typed + IEnumerable{object}. + + + + + + An interface that allows developers to specify their own partitioning routines. + + + + + + + A simple implementation of the ParallelQuery{object} interface which wraps an + underlying IEnumerable, such that it can be used in parallel queries. + + + + + A simple implementation of the ParallelQuery{T} interface which wraps an + underlying IEnumerable{T}, such that it can be used in parallel queries. + + + + + + An enum to specify whether an aggregate operator is associative, commutative, + neither, or both. This influences query analysis and execution: associative + aggregations can run in parallel, whereas non-associative cannot; non-commutative + aggregations must be run over data in input-order. + + + + + A simple enumerable type that implements the range algorithm. It also supports + partitioning of the indices by implementing an interface that PLINQ recognizes. + + + + + A simple enumerable type that implements the repeat algorithm. It also supports + partitioning of the count space by implementing an interface that PLINQ recognizes. + + + + + + A special merge helper for indexible queries. Given an indexible query, we know how many elements + we'll have in the result set, so we can allocate the array ahead of time. Then, as each result element + is produced, we can directly insert it into the appropriate position in the output array, paying + no extra cost for ordering. + + + + + + Used as a stand-in for replaceable merge algorithms. Alternative implementations + are chosen based on the style of merge required. + + + + + + Instantiates the array merge helper. + + The query settings + The query results + + + + A method used as a delegate passed into the ForAll operator + + + + + Schedules execution of the merge itself. + + + + + Gets the enumerator over the results. + + We never expect this method to be called. ArrayMergeHelper is intended to be used when we want + to consume the results using GetResultsAsArray(). + + + + + Returns the merged results as an array. + + + + + + An enumerator that merges multiple one-to-one channels into a single output + stream, including any necessary blocking and synchronization. This is an + asynchronous enumerator, i.e. the producers may be inserting items into the + channels concurrently with the consumer taking items out of them. Therefore, + enumerating this object can cause the current thread to block. + + We use a biased choice algorithm to choose from our consumer channels. I.e. we + will prefer to process elements in a fair round-robin fashion, but will + occassionally bypass this if a channel is empty. + + + + + + + Convenience class used by enumerators that merge many partitions into one. + + + + + + WaitAny simulates a Win32-style WaitAny on the set of thin-events. + + An array of thin-events (null elements permitted) + The index of the specific event in events that caused us to wake up. + + + + The default merge helper uses a set of straightforward algorithms for output + merging. Namely, for synchronous merges, the input data is yielded from the + input data streams in "depth first" left-to-right order. For asynchronous merges, + on the other hand, we use a biased choice algorithm to favor input channels in + a "fair" way. No order preservation is carried out by this helper. + + + + + + + Drives execution of an actual merge operation, including creating channel data + structures and scheduling parallel work as appropriate. The algorithms used + internally are parameterized based on the type of data in the partitions; e.g. + if an order preserved stream is found, the merge will automatically use an + order preserving merge, and so forth. + + + + + + The order preserving merge helper guarantees the output stream is in a specific order. This is done + by comparing keys from a set of already-sorted input partitions, and coalescing output data using + incremental key comparisons. + + + + + + + A merge helper that yields results in a streaming fashion, while still ensuring correct output + ordering. This merge only works if each producer task generates outputs in the correct order, + i.e. with an Increasing (or Correct) order index. + + The merge creates DOP producer tasks, each of which will be writing results into a separate + buffer. + + The consumer always waits until each producer buffer contains at least one element. If we don't + have one element from each producer, we cannot yield the next element. (If the order index is + Correct, or in some special cases with the Increasing order, we could yield sooner. The + current algorithm does not take advantage of this.) + + The consumer maintains a producer heap, and uses it to decide which producer should yield the next output + result. After yielding an element from a particular producer, the consumer will take another element + from the same producer. However, if the producer buffer exceeded a particular threshold, the consumer + will take the entire buffer, and give the producer an empty buffer to fill. + + Finally, if the producer notices that its buffer has exceeded an even greater threshold, it will + go to sleep and wait until the consumer takes the entire buffer. + + + + + The initial capacity of the buffer queue. The value was chosen experimentally. + + + + + If the consumer notices that the queue reached this limit, it will take the entire buffer from + the producer, instead of just popping off one result. The value was chosen experimentally. + + + + + If the producer notices that the queue reached this limit, it will go to sleep until woken up + by the consumer. Chosen experimentally. + + + + + Whether the producer is allowed to buffer up elements before handing a chunk to the consumer. + If false, the producer will make each result available to the consumer immediately after it is + produced. + + + + + Buffers for the results. Each buffer has elements added by one producer, and removed + by the consumer. + + + + + Whether each producer is done producing. Set to true by individual producers, read by consumer. + + + + + Whether a particular producer is waiting on the consumer. Read by the consumer, set to true + by producers, set to false by the consumer. + + + + + Whether the consumer is waiting on a particular producer. Read by producers, set to true + by consumer, set to false by producer. + + + + + Each object is a lock protecting the corresponding elements in m_buffers, m_producerDone, + m_producerWaiting and m_consumerWaiting. + + + + + A singleton instance of the comparer used by the producer heap. Eager allocation is OK + because if the static constructor runs, we will be using this merge. + + + + + A structure to represent a producer in the producer heap. + + + + + A comparer used by FixedMaxHeap(Of Producer) + + This comparer will be used by max-heap. We want the producer with the smallest MaxKey to + end up in the root of the heap. + + x.MaxKey GREATER_THAN y.MaxKey => x LESS_THAN y => return - + x.MaxKey EQUALS y.MaxKey => x EQUALS y => return 0 + x.MaxKey LESS_THAN y.MaxKey => x GREATER_THAN y => return + + + + + + Enumerator over the results of an order-preserving pipelining merge. + + + + + Merge helper associated with this enumerator + + + + + Heap used to efficiently locate the producer whose result should be consumed next. + For each producer, stores the order index for the next element to be yielded. + + Read and written by the consumer only. + + + + + Stores the next element to be yielded from each producer. We use a separate array + rather than storing this information in the producer heap to keep the Producer struct + small. + + Read and written by the consumer only. + + + + + A private buffer for the consumer. When the size of a producer buffer exceeds a threshold + (STEAL_BUFFER_SIZE), the consumer will take ownership of the entire buffer, and give the + producer a new empty buffer to place results into. + + Read and written by the consumer only. + + + + + Tracks whether MoveNext() has already been called previously. + + + + + Constructor + + + + + Moves the enumerator to the next result, or returns false if there are no more results to yield. + + + + + If the cancellation of the query has been initiated (because one or more producers + encountered exceptions, or because external cancellation token has been set), the method + will tear down the query and rethrow the exception. + + + + + Wait until a producer's buffer is non-empty, or until that producer is done. + + false if there is no element to yield because the producer is done, true otherwise + + + + Looks for an element from a particular producer in the consumer's private buffer. + + + + + Returns the current result + + + + + This enumerator merges multiple input channels into a single output stream. The merging process just + goes from left-to-right, enumerating each channel in succession in its entirety. + Assumptions: + Before enumerating this object, all producers for all channels must have finished enqueueing new + elements. + + + + + + This enumerator handles the actual coordination among partitions required to + accomplish the repartitioning operation, as explained above. + + The kind of elements. + The key used to distribute elements. + The kind of keys found in the source (ignored). + + + + A repartitioning stream must take input data that has already been partitioned and + redistribute its contents based on a new partitioning algorithm. This is accomplished + by making each partition p responsible for redistributing its input data to the + correct destination partition. Some input elements may remain in p, but many will now + belong to a different partition and will need to move. This requires a great deal of + synchronization, but allows threads to repartition data incrementally and in parallel. + Each partition will "pull" data on-demand instead of partitions "pushing" data, which + allows us to reduce some amount of synchronization overhead. + + We currently only offer one form of reparitioning via hashing. This used to be an + abstract base class, but we have eliminated that to get rid of some virtual calls on + hot code paths. Uses a key selection algorithm with mod'ding to determine destination. + + @TODO: @BUG#519: consider adding a bound to the buffers. Unfortunately this can quite easily + lead to deadlock when multiple repartitions are involved. Need a solution. + @TODO: @BUG#504: consider amortizing synchronization overhead by enqueueing/dequeueing in chunks + rather than single elements. Also need to be careful not to introduce deadlock. + + + + + + + + A partitioned stream just partitions some data source using an extensible + partitioning algorithm and exposes a set of N enumerators that are consumed by + their ordinal index [0..N). It is used to build up a set of streaming computations. + At instantiation time, the actual data source to be partitioned is supplied; and + then the caller will layer on top additional enumerators to represent phases in the + computation. Eventually, a merge can then schedule enumeration of all of the + individual partitions in parallel by obtaining references to the individual + partition streams. + + This type has a set of subclasses which implement different partitioning algorithms, + allowing us to easily plug in different partitioning techniques as needed. The type + supports wrapping IEnumerables and IEnumerators alike, with some preference for the + former as many partitioning algorithms are more intelligent for certain data types. + + + + + + + IPartitionedStreamRecipient is essentially a generic action on a partitioned stream, + whose generic type parameter is the type of the order keys in the partitioned stream. + + + + + + This enumerator handles the actual coordination among partitions required to + accomplish the repartitioning operation, as explained above. In addition to that, + it tracks order keys so that order preservation can flow through the enumerator. + + The kind of elements. + The key used to distribute elements. + The kind of keys found in the source. + + + + Contiguous range chunk partitioning attempts to improve data locality by keeping + data close together in the incoming data stream together in the outgoing partitions. + There are really three types of partitions that are used internally: + + 1. If the data source is indexable--like an array or List_T--we can actually + just compute the range indexes and avoid doing any copying whatsoever. Each + "partition" is just an enumerator that will walk some subset of the data. + 2. If the data source has an index (different than being indexable!), we can + turn this into a range scan of the index. We can roughly estimate distribution + and ensure an evenly balanced set of partitions. + @TODO: @BUG#516: we don't have indexes today. We are considering it for the future. + 3. If we can't use 1 or 2, we instead partition "on demand" by chunking the contents + of the source enumerator as they are requested. The unfortunate thing is that + this requires synchronization, since consumers may be running in parallel. We + amortize the cost of this by giving chunks of items when requested instead of + one element at a time. Note that this approach also works for infinite streams. + + In all cases, the caller can request that enumerators walk elements in striped + contiguous chunks. If striping is requested, then each partition j will yield elements + in the data source for which ((i / s)%p) == j, where i is the element's index, s is + a chunk size calculated by the system with the intent of aligning on cache lines, and + p is the number of partitions. If striping is not requested, we use the same algorith, + only, instead of aligning on cache lines, we use a chunk size of l / p, where l + is the length of the input and p is the number of partitions. + + Notes: + This is used as the default partitioning strategy by much of the PLINQ infrastructure. + + + + + + The aggregation operator is a little unique, in that the enumerators it returns + yield intermediate results instead of the final results. That's because there is + one last Aggregate operation that must occur in order to perform the final reduction + over the intermediate streams. In other words, the intermediate enumerators produced + by this operator are never seen by other query operators or consumers directly. + + An aggregation performs parallel prefixing internally. Given a binary operator O, + it will generate intermediate results by folding O across partitions; then it + performs a final reduction by folding O accross the intermediate results. The + analysis engine knows about associativity and commutativity, and will ensure the + style of partitioning inserted into the tree is compatable with the operator. + + For instance, say O is + (meaning it is AC), our input is {1,2,...,8}, and we + use 4 partitions to calculate the aggregation. Sequentially this would look + like this O(O(O(1,2),...),8), in other words ((1+2)+...)+8. The parallel prefix + of this (w/ 4 partitions) instead calculates the intermediate aggregations, i.e.: + t1 = O(1,2), t2 = O(3,4), ... t4 = O(7,8), aka t1 = 1+2, t2 = 3+4, t4 = 7+8. + The final step is to aggregate O over these intermediaries, i.e. + O(O(O(t1,t2),t3),t4), or ((t1+t2)+t3)+t4. This generalizes to any binary operator. + + Beause some aggregations use a different input, intermediate, and output types, + we support an even more generalized aggregation type. In this model, we have + three operators, an intermediate (used for the incremental aggregations), a + final (used for the final summary of intermediate results), and a result selector + (used to perform whatever transformation is needed on the final summary). + + + + + + + + The base class from which all binary query operators derive, that is, those that + have two child operators. This introduces some convenience methods for those + classes, as well as any state common to all subclasses. + + + + + + + This is the abstract base class for all query operators in the system. It + implements the ParallelQuery{T} type so that it can be bound as the source + of parallel queries and so that it can be returned as the result of parallel query + operations. Not much is in here, although it does serve as the "entry point" for + opening all query operators: it will lazily analyze and cache a plan the first + time the tree is opened, and will open the tree upon calls to GetEnumerator. + + Notes: + This class implements ParallelQuery so that any parallel query operator + can bind to the parallel query provider overloads. This allows us to string + together operators w/out the user always specifying AsParallel, e.g. + Select(Where(..., ...), ...), and so forth. + + + + + + The QueryResults{T} is a class representing the results of the query. There may + be different ways the query results can be manipulated. Currently, two ways are + supported: + + 1. Open the query results as a partitioned stream by calling GivePartitionedStream + and pass a generic action as an argument. + + 2. Access individual elements of the results list by calling GetElement(index) and + ElementsCount. This method of accessing the query results is available only if + IsIndexible return true. + + + + + + A QueryOperator that represents the output of the query partitioner.AsParallel(). + + + + + Determines the OrdinalIndexState for a partitioner + + + + + QueryResults for a PartitionerQueryOperator + + + + + Enumerator that converts an enumerator over key-value pairs exposed by a partitioner + to a QueryOperatorEnumerator used by PLINQ internally. + + + + + Enumerator that converts an enumerator over key-value pairs exposed by a partitioner + to a QueryOperatorEnumerator used by PLINQ internally. + + + + + A scan is just a simple operator that is positioned directly on top of some + real data source. It's really just a place holder used during execution and + analysis -- it should never actually get opened. + + + + + + Operator that yields the elements from the first data source that aren't in the second. + This is known as the set relative complement, i.e. left - right. + + + + + + The base class from which all binary query operators derive, that is, those that + have two child operators. This introduces some convenience methods for those + classes, as well as any state common to all subclasses. + + + + + + + + A group join operator takes a left query tree and a right query tree, and then yields + the matching elements between the two. This can be used for outer joins, i.e. those + where an outer element has no matching inner elements -- the result is just an empty + list. As with the join algorithm above, we currently use a hash join algorithm. + + + + + + + + + This enumerator implements the hash-join algorithm as noted earlier. + + Assumptions: + This enumerator type won't work properly at all if the analysis engine didn't + ensure a proper hash-partition. We expect inner and outer elements with equal + keys are ALWAYS in the same partition. If they aren't (e.g. if the analysis is + busted) we'll silently drop items on the floor. :( + + + This is the enumerator class for two operators: + - Join + - GroupJoin + + + + + + + + + + Operator that yields the intersection of two data sources. + + + + + + A join operator takes a left query tree and a right query tree, and then yields the + matching pairs between the two. LINQ supports equi-key-based joins. Hence, a key- + selection function for the left and right data types will yield keys of the same + type for both. We then merely have to match elements from the left with elements from + the right that have the same exact key. Note that this is an inner join. In other + words, outer elements with no matching inner elements do not appear in the output. + + @TODO: @BUG#528: Currently we implement only a hash-join algorithm. Furthermore, we always + choose the inner data source for the hash-table creation. There is room for + optimization and different algorithm choices eventually. + + Hash-joins work in two phases: + + (1) Building - we build a hash-table from one of the data sources. In the case + of this specific operator, the table is built from the hash-codes of + keys selected via the key selector function. Because elements may share + the same key, the table must support one-key-to-many-values. + (2) Probing - for each element in the data source not used for building, we + use its key to look into the hash-table. If we find elements under this + key, we just enumerate all of them, yielding them as join matches. + + Because hash-tables exhibit on average O(1) lookup, we turn what would have been + an O(n*m) algorithm -- in the case of nested loops joins -- into an O(n) algorithm. + We of course require some additional storage to do so, but in general this pays. + + + + + + + + + Operator that yields the union of two data sources. + + + + + + A Zip operator combines two input data sources into a single output stream, + using a pairwise element matching algorithm. For example, the result of zipping + two vectors a = {0, 1, 2, 3} and b = {9, 8, 7, 6} is the vector of pairs, + c = {(0,9), (1,8), (2,7), (3,6)}. Because the expectation is that each element + is matched with the element in the other data source at the same ordinal + position, the zip operator requires order preservation. + + + + + + + + Partitioned stream recipient that will merge the results. + + + + + A wrapper enumerator that just opens the query operator when MoveNext() is called for the + first time. We use QueryOpeningEnumerator to call QueryOperator.GetOpenedEnumerator() + lazily because once GetOpenedEnumerator() is called, PLINQ starts precomputing the + results of the query. + + + + + Opens the query and initializes m_openedQueryEnumerator and m_querySettings. + Called from the first MoveNext call. + + + + + An inlined count aggregation and its enumerator. + + + + + + This class is common to all of the "inlined" versions of various aggregations. The + inlined operators ensure that real MSIL instructions are used to perform elementary + operations versus general purpose delegate-based binary operators. For obvious reasons + this is a quite bit more efficient, although it does lead to a fair bit of unfortunate + code duplication. + + + + + + + + A class with some shared implementation between all aggregation enumerators. + + + + + + An inlined average aggregation operator and its enumerator, for decimals. + + + + + An inlined min/max aggregation and its enumerator, for decimals. + + + + + An inlined sum aggregation and its enumerator, for decimals. + + + + + An inlined average aggregation operator and its enumerator, for doubles. + + + + + An inlined min/max aggregation and its enumerator, for doubles. + + Notes: + Note that normally double.NaN < anything is false, as is anything < NaN. This would + lead to some strangeness in Min and Max, e.g. Min({ NaN, 5.0 } == NaN, yet + Min({ 5.0, NaN }) == 5.0! We impose a total ordering so that NaN is smaller than + everything, including -infinity, which is consistent with Comparer_T. + + + + + An inlined sum aggregation and its enumerator, for doubles. + + + + + An inlined average aggregation operator and its enumerator, for floats. + + + + + An inlined min/max aggregation and its enumerator, for floats. + + + + + An inlined sum aggregation and its enumerator, for floats. + + + + + An inlined average aggregation operator and its enumerator, for ints. + + + + + An inlined min/max aggregation and its enumerator, for ints. + + + + + Inlined aggregations for summing up primitives (int, long, float, double, decimal), as + well as the nullable versions of each (int?, long?, float?, double?, decimal?). + + + + + An inlined average aggregation operator and its enumerator, for longs. + + + + + An inlined count aggregation and its enumerator. + + + + + + An inlined min/max aggregation and its enumerator, for longs. + + + + + An inlined sum aggregation and its enumerator, for longs. + + + + + An inlined average aggregation operator and its enumerator, for Nullable decimals. + + + + + An inlined min/max aggregation and its enumerator, for Nullable decimals. + + + + + An inlined sum aggregation and its enumerator, for nullable decimals. + + + + + An inlined average aggregation operator and its enumerator, for Nullable doubles. + + + + + An inlined min/max aggregation and its enumerator, for Nullable{Double}s. + + Notes: + Note that normally double.NaN < anything is false, as is anything < NaN. This would + lead to some strangeness in Min and Max, e.g. Min({ NaN, 5.0 } == NaN, yet + Min({ 5.0, NaN }) == 5.0! We impose a total ordering so that NaN is smaller than + everything, including -infinity, which is consistent with Comparer_T. + + + + + An inlined sum aggregation and its enumerator, for nullable doubles. + + + + + An inlined average aggregation operator and its enumerator, for Nullable floats. + + + + + An inlined min/max aggregation and its enumerator, for Nullable floats. + + Notes: + Note that normally float.NaN < anything is false, as is anything < NaN. This would + lead to some strangeness in Min and Max, e.g. Min({ NaN, 5.0 } == NaN, yet + Min({ 5.0, NaN }) == 5.0! We impose a total ordering so that NaN is smaller than + everything, including -infinity, which is consistent with Comparer_T. + + + + + An inlined sum aggregation and its enumerator, for Nullable floats. + + + + + An inlined average aggregation operator and its enumerator, for Nullable ints. + + + + + An inlined min/max aggregation and its enumerator, for Nullable ints. + + + + + An inlined sum aggregation and its enumerator, for Nullable ints. + + + + + An inlined average aggregation operator and its enumerator, for Nullable longs. + + + + + An inlined min/max aggregation and its enumerator, for Nullable{Int64}s. + + + + + An inlined sum aggregation and its enumerator, for Nullable longs. + + + + + Class to represent an IList{T} as QueryResults{T} + + + + + + Describes the state of order preservation index associated with an enumerator. + + + + + This type contains query execution options specified by the user. + QuerySettings are used as follows: + - in the query construction phase, some settings may be uninitialized. + - at the start of the query opening phase, the WithDefaults method + is used to initialize all uninitialized settings. + - in the rest of the query opening phase, we assume that all settings + have been initialized. + + + + + Represents operators AsOrdered and AsUnordered. In the current implementation, it + simply turns on preservation globally in the query. + + + + + + Represents operators that set various query execution options. + + + + + + The any/all operators work the same way. They search for the occurrence of a predicate + value in the data source, and upon the first occurrence of such a value, yield a + particular value. Specifically: + + - Any returns true if the predicate for any element evaluates to true. + - All returns false if the predicate for any element evaluates to false. + + This uniformity is used to apply a general purpose algorithm. Both sentences above + take the form of "returns XXX if the predicate for any element evaluates to XXX." + Therefore, we just parameterize on XXX, called the qualifciation below, and if we + ever find an occurrence of XXX in the input data source, we also return XXX. Otherwise, + we return !XXX. Obviously, XXX in this case is a bool. + + This is a search algorithm. So once any single partition finds an element, it will + return so that execution can stop. This is done with a "cancelation" flag that is + polled by all parallel workers. The first worker to find an answer sets it, and all + other workers notice it and quit as quickly as possible. + + + + + + Concatenates one data source with another. Order preservation is used to ensure + the output is actually a concatenation -- i.e. one after the other. The only + special synchronization required is to find the largest index N in the first data + source so that the indices of elements in the second data source can be offset + by adding N+1. This makes it appear to the order preservation infrastructure as + though all elements in the second came after all elements in the first, which is + precisely what we want. + + + + + + Contains is quite similar to the any/all operator above. Each partition searches a + subset of elements for a match, and the first one to find a match signals to the rest + of the partititons to stop searching. + + + + + + This operator just exposes elements directly from the underlying data source, if + it's not empty, or yields a single default element if the data source is empty. + There is a minimal amount of synchronization at the beginning, until all partitions + have registered whether their stream is empty or not. Once the 0th partition knows + that at least one other partition is non-empty, it may proceed. Otherwise, it is + the 0th partition which yields the default value. + + + + + + This operator yields all of the distinct elements in a single data set. It works quite + like the above set operations, with the obvious difference being that it only accepts + a single data source as input. + + + + + + ElementAt just retrieves an element at a specific index. There is some cross-partition + coordination to force partitions to stop looking once a partition has found the + sought-after element. + + + + + + Executes the query, either sequentially or in parallel, depending on the query execution mode and + whether a premature merge was inserted by this ElementAt operator. + + result + withDefaultValue + whether an element with this index exists + + + + First tries to discover the first element in the source, optionally matching a + predicate. All partitions search in parallel, publish the lowest index for a + candidate match, and reach a barrier. Only the partition that "wins" the race, + i.e. who found the candidate with the smallest index, will yield an element. + + + + + + A forall operator just enables an action to be placed at the "top" of a query tree + instead of yielding an enumerator that some consumer can walk. We execute the + query for effect instead of yielding a data result. + + + + + + The operator type for GroupBy statements. This operator groups the input based on + a key-selection routine, yielding one-to-many values of key-to-elements. The + implementation is very much like the hash join operator, in which we first build + a big hashtable of the input; then we just iterate over each unique key in the + hashtable, yielding it plus all of the elements with the same key. + + + + + + + + An ordered version of the grouping data structure. Represents an ordered group of elements that + have the same grouping key. + + + + + Constructs a new grouping + + + + + Add an element + + + + + No more elements will be added, so we can sort the group now. + + + + + The key this grouping represents. + + + + + A variant of the Select operator that supplies element index while performing the + projection operation. This requires cooperation with partitioning and merging to + guarantee ordering is preserved. + + @TODO: @PERF: @BUG#527: as an optimization, we strictly don't need order to be preserved + all the way until the merge. If ordering is only kept for THIS operator, we + can subsequently get rid of order preservation after executing. + + + + + + + A variant of the Where operator that supplies element index while performing the + filtering operation. This requires cooperation with partitioning and merging to + guarantee ordering is preserved. + + @TODO: @PERF: @BUG#527: as an optimization, we strictly don't need order to be preserved + all the way until the merge. If ordering is only kept for THIS operator, we + can subsequently get rid of order preservation after executing. + + + + + + Last tries to discover the last element in the source, optionally matching a + predicate. All partitions search in parallel, publish the greatest index for a + candidate match, and reach a barrier. Only the partition that "wins" the race, + i.e. who found the candidate with the largest index, will yield an element. + + @TODO: @PERF: @BUG#414: this traverses the data source in forward-order. In the future, we + will want to traverse in reverse order, since this allows partitions to stop + the search sooner (by watching if the current index passes below the current best). + + + + + + + Reverse imposes ordinal order preservation. There are normally two phases to this + operator's execution. Each partition first builds a buffer containing all of its + elements, and then proceeds to yielding the elements in reverse. There is a + 'barrier' (but not a blocking barrier) in between these two steps, at which point the largest index becomes + known. This is necessary so that when elements from the buffer are yielded, the + CurrentIndex can be reported as the largest index minus the original index (thereby + reversing the indices as well as the elements themselves). If the largest index is + known a priori, because we have an array for example, we can avoid the barrier in + between the steps. + + + + + + SelectMany is effectively a nested loops join. It is given two data sources, an + outer and an inner -- actually, the inner is sometimes calculated by invoking a + function for each outer element -- and we walk the outer, walking the entire + inner enumerator for each outer element. There is an optional result selector + function which can transform the output before yielding it as a result element. + + Notes: + Although select many takes two enumerable objects as input, it appears to the + query analysis infrastructure as a unary operator. That's because it works a + little differently than the other binary operators: it has to re-open the right + child every time an outer element is walked. The right child is NOT partitioned. + + + + + + + + A helper method for WrapPartitionedStream. We use the helper to reuse a block of code twice, but with + a different order key type. (If premature merge occured, the order key type will be "int". Otherwise, + it will be the same type as "TLeftKey" in WrapPartitionedStream.) + + + + + Similar helper method to WrapPartitionedStreamNotIndexed, except that this one is for the indexed variant + of SelectMany (i.e., the SelectMany that passes indices into the user sequence-generating delegate) + + + + + The operator type for Select statements. This operator transforms elements as it + enumerates them through the use of a selector delegate. + + + + + + + Single searches the input to find the sole element that satisfies the (optional) + predicate. If multiple such elements are found, the caller is responsible for + producing an error. There is some degree of cross-partition synchronization to + proactively hault the search if we ever determine there are multiple elements + satisfying the search in the input. + + + + + + The query operator for OrderBy and ThenBy. + + + + + + + Take and Skip either take or skip a specified number of elements, captured in the + count argument. These will work a little bit like TakeWhile and SkipWhile: there + are two phases, (1) Search and (2) Yield. In the search phase, our goal is to + find the 'count'th index from the input. We do this in parallel by sharing a count- + sized array. Each thread races to populate the array with indices in ascending + order. This requires synchronization for inserts. We use a simple heap, for decent + worst case performance. After a thread has scanned ‘count’ elements, or its current + index is greater than or equal to the maximum index in the array (and the array is + fully populated), the thread can stop searching. All threads issue a barrier before + moving to the Yield phase. When the Yield phase is entered, the count-1th element + of the array contains: in the case of Take, the maximum index (exclusive) to be + returned; or in the case of Skip, the minimum index (inclusive) to be returned. The + Yield phase simply consists of yielding these elements as output. + + + + + + Determines the order index state for the output operator + + + + + Take- and SkipWhile work similarly. Execution is broken into two phases: Search + and Yield. + + During the Search phase, many partitions at once search for the first occurrence + of a false element. As they search, any time a partition finds a false element + whose index is lesser than the current lowest-known false element, the new index + will be published, so other partitions can stop the search. The search stops + as soon as (1) a partition exhausts its input, (2) the predicate yields false for + one of the partition's elements, or (3) its input index passes the current lowest- + known index (sufficient since a given partition's indices are always strictly + incrementing -- asserted below). Elements are buffered during this process. + + Partitions use a barrier after Search and before moving on to Yield. Once all + have passed the barrier, Yielding begins. At this point, the lowest-known false + index will be accurate for the entire set, since all partitions have finished + scanning. This is where TakeWhile and SkipWhile differ. TakeWhile will start at + the beginning of its buffer and yield all elements whose indices are less than + the lowest-known false index. SkipWhile, on the other hand, will skipp any such + elements in the buffer, yielding those whose index is greater than or equal to + the lowest-known false index, and then finish yielding any remaining elements in + its data source (since it may have stopped prematurely due to (3) above). + + + + + + Determines the order index state for the output operator + + + + + The operator type for Where statements. This operator filters out elements that + don't match a filter function (supplied at instantiation time). + + + + + + Poll frequency (number of loops per cancellation check) for situations where per-1-loop testing is too high an overhead. + + + + + Throws an OCE if the merged token has been canceled. + + A token to check for cancelation. + + + + A spooling task handles marshaling data from a producer to a consumer. It simply + takes data from a producer and hands it off to a consumer. This class is the base + class from which other concrete spooling tasks derive, encapsulating some common + logic (such as capturing exceptions). + + + + + Simple abstract task representation, allowing either synchronous and asynchronous + execution. Subclasses override the Work API to implement the logic. + + + + + The number of elements to accumulate on the producer before copying the elements to the + producer-consumer buffer. This constant is only used in the AutoBuffered mode. + + Experimentally, 16 appears to be sufficient buffer size to compensate for the synchronization + cost. + + + + + Whether the producer is allowed to buffer up elements before handing a chunk to the consumer. + If false, the producer will make each result available to the consumer immediately after it is + produced. + + + + + Constructor + + + + + This method is responsible for enumerating results and enqueueing them to + the output buffer as appropriate. Each base class implements its own. + + + + + Creates and begins execution of a new set of spooling tasks. + + + + + Dispose the underlying enumerator and wake up the consumer if necessary. + + + + + A spooling task handles marshaling data from a producer to a consumer. It's given + a single enumerator object that contains all of the production algorithms, a single + destination channel from which consumers draw results, and (optionally) a + synchronization primitive using which to notify asynchronous consumers. This + particular task variant preserves sort order in the final data. + + + + + + + A collection of tasks used by a single query instance. This type also offers some + convenient methods for tracing significant ETW events, waiting on tasks, propagating + exceptions, and performing cancellation activities. + + + + + A factory class to execute spooling logic. + + + + + A spooling task handles marshaling data from a producer to a consumer. It's given + a single enumerator object that contains all of the production algorithms, a single + destination channel from which consumers draw results, and (optionally) a + synchronization primitive using which to notify asynchronous consumers. + + + + + + + A spooling task handles marshaling data from a producer to a consumer. It's given + a single enumerator object that contains all of the production algorithms, a single + destination channel from which consumers draw results, and (optionally) a + synchronization primitive using which to notify asynchronous consumers. + + + + + + + A spooling task handles marshaling data from a producer to a consumer. It's given + a single enumerator object that contains all of the production algorithms, a single + destination channel from which consumers draw results, and (optionally) a + synchronization primitive using which to notify asynchronous consumers. + + + + + + + Wraps an enumerable with a cancellation checker. The enumerator handed out by the source enumerable + will be wrapped by an object that periodically checks whether a particular cancellation token has + been cancelled. If so, the next call to MoveNext() will throw an OperationCancelledException. + + + + + WrapEnumerable.ExceptionAggregator wraps the enumerable with another enumerator that will + catch exceptions, and wrap each with an AggregateException. + + If PLINQ decides to execute a query sequentially, we will reuse LINQ-to-objects + implementations for the different operators. However, we still need to throw + AggregateException in the cases when parallel execution would have thrown an + AggregateException. Thus, we introduce a wrapper enumerator that catches exceptions + and wraps them with an AggregateException. + + + + + A variant of WrapEnumerable that accepts a QueryOperatorEnumerator{,} instead of an IEnumerable{}. + The code duplication is necessary to avoid extra virtual method calls that would otherwise be needed to + convert the QueryOperatorEnumerator{,} to an IEnumerator{}. + + + + + Accepts an exception, wraps it as if it was crossing the parallel->sequential boundary, and throws the + wrapped exception. In sequential fallback cases, we use this method to throw exceptions that are consistent + with exceptions thrown by PLINQ when the query is executed by worker tasks. + + The exception will be wrapped into an AggregateException, except for the case when the query is being + legitimately cancelled, in which case we will propagate the CancellationException with the appropriate + token. + + + + + Wraps a function with a try/catch that morphs all exceptions into AggregateException. + + The input argument type. + The return value type. + A function to use internally. + The cancellation state to use. + A new function containing exception wrapping logic. + + + + ExchangeUtilities is a static class that contains helper functions to partition and merge + streams. + + + + + Used during hash partitioning, when the keys being memoized are not used for anything. + + + + + Very simple heap data structure, of fixed size. + + + + + + A growing array. Unlike List{T}, it makes the internal array available to its user. + + + + + + A simple hash map data structure, derived from the LINQ set we also use. + + The kind of keys contained within. + The kind of values contained within. + + + + A linked list of array chunks. Allows direct access to its arrays. + + The elements held within. + + + + Allocates a new root chunk of a particular size. + + + + + Adds an element to this chunk. Only ever called on the root. + + The new element. + + + + Fetches an enumerator to walk the elements in all chunks rooted from this one. + + + + + The next chunk in the linked chain. + + + + + The number of elements contained within this particular chunk. + + + + + Lookup class implements the ILookup interface. Lookup is very similar to a dictionary + except multiple values are allowed to map to the same key, and null keys are supported. + + Support for null keys adds an issue because the Dictionary class Lookup uses for + storage does not support null keys. So, we need to treat null keys separately. + Unfortunately, since TKey may be a value type, we cannot test whether the key is null + using the user-specified equality comparer. + + C# does allow us to compare the key against null using the == operator, but there is a + possibility that the user's equality comparer considers null to be equal to other values. + Now, MSDN documentation specifies that if IEqualityComparer.Equals(x,y) returns true, it + must be the case that x and y have the same hash code, and null has no hash code. Despite + that, we might as well support the use case, even if it is bad practice. + + The solution the Lookup class uses is to treat the key default(TKey) as a special case, + and hold its associated grouping - if any - in a special field instead of inserting it + into a dictionary. + + + + + + + A pair just wraps two bits of data into a single addressable unit. This is a + value type to ensure it remains very lightweight, since it is frequently used + with other primitive data types as well. + + + + + + + PairComparer compares pairs by the first element, and breaks ties by the second + element. + + + + + + + Comparer that wraps another comparer, and flips the result of each comparison to the + opposite answer. + + + + + + A set for various operations. Shamelessly stolen from LINQ's source code. + @TODO: can the Linq one be used directly now that we are in System.Core + + The kind of elements contained within. + + + + A very simple primitive that allows us to share a value across multiple threads. + + + + + + Common miscellaneous utility methods used throughout the code-base. + + + + + A struct to wrap any arbitrary object reference or struct. Used for situations + where we can't tolerate null values (like keys for hashtables). + + + + + + Compares two wrapped structs of the same underlying type for equality. Simply + wraps the actual comparer for the type being wrapped. + + + + + + Represents a sorted, parallel sequence. + + + + + Returns an enumerator that iterates through the sequence. + + An enumerator that iterates through the sequence. + + + + The query execution mode is a hint that specifies how the system should handle + performance trade-offs when parallelizing queries. + + + + + By default, the system will use algorithms for queries + that are ripe for parallelism and will avoid algorithms with high + overheads that will likely result in slow downs for parallel execution. + + + + + Parallelize the entire query, even if that means using high-overhead algorithms. + + + + + Provides a set of static (Shared in Visual Basic) methods for working with specific kinds of + instances. + + + + + Creates a proxy Task that represents the + asynchronous operation of a Task{Task}. + + + It is often useful to be able to return a Task from a + Task{TResult}, where the inner Task represents work done as part of the outer Task{TResult}. However, + doing so results in a Task{Task}, which, if not dealt with carefully, could produce unexpected behavior. Unwrap + solves this problem by creating a proxy Task that represents the entire asynchronous operation of such a Task{Task}. + + The Task{Task} to unwrap. + The exception that is thrown if the + argument is null. + A Task that represents the asynchronous operation of the provided Task{Task}. + + + + Creates a proxy Task{TResult} that represents the + asynchronous operation of a Task{Task{TResult}}. + + + It is often useful to be able to return a Task{TResult} from a Task{TResult}, where the inner Task{TResult} + represents work done as part of the outer Task{TResult}. However, doing so results in a Task{Task{TResult}}, + which, if not dealt with carefully, could produce unexpected behavior. Unwrap solves this problem by + creating a proxy Task{TResult} that represents the entire asynchronous operation of such a Task{Task{TResult}}. + + The Task{Task{TResult}} to unwrap. + The exception that is thrown if the + argument is null. + A Task{TResult} that represents the asynchronous operation of the provided Task{Task{TResult}}. /// Unwraps a Task that returns another Task. + + + diff --git a/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/redist.txt b/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/redist.txt new file mode 100644 index 000000000..35fc105cc --- /dev/null +++ b/src/packages/TaskParallelLibrary.1.0.2856.0/lib/Net35/redist.txt @@ -0,0 +1,11 @@ +The files below can be distributed as described in the MICROSOFT REACTIVE EXTENSTIONS FOR JAVASCRIPT AND .NET LIBRARIES License. + +System.Observable.dll +System.CoreEx.dll +System.Reactive.dll +System.Interactive.dll +System.Threading.dll +System.Linq.Async.dll +System.Reactive.Testing.dll +System.Reactive.ClientProfile.dll +System.Reactive.ExtendedProfile.dll From b7909ecc37cac5b5efb2da3e9f2e16186bb36e62 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 24 Sep 2013 12:29:13 -0500 Subject: [PATCH 6/6] Add required dependencies to NuGet specification --- src/corelib/corelib.nuspec | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/corelib/corelib.nuspec b/src/corelib/corelib.nuspec index b4ba9cd3b..be053f268 100644 --- a/src/corelib/corelib.nuspec +++ b/src/corelib/corelib.nuspec @@ -13,6 +13,17 @@ https://github.com/openstacknetsdk/openstack.net/releases/v$version$ openstack + + + + + + + + + + +