JetBrains.Common.Util The DotCommon project has been cleaned up of all the compilation warnings. Useless technical values have been suppressed, and useful ones have been fixed. Note that this is also possible to enable the warning for in-VisualStudio analysis yet disable it for compilation. To maintain this clean state, a validator is imposed. The number i at index #n is the index of ArcEnds for the vertex #n in the graph. In at index i located the first related vertex of the vertex #n. The list of referenced nodes. Returned items with Finished are completely calculated issues. They will be returned only once, and next calculation will begin after them Returned items without Finished are issues still being calculated. They will be returned each time until they will become completely calculated. This constructor is used only for creation of suboperations. For such operations method is never invoked, so execution controller won't be recreated Execute action which we can't interrupt, but we want to stop waiting for results If we don't want results anymore we just forget this task (because we can't interrupt it) So for caller it looks like we canceled it Indicates state of the operation progress in percents from 0 to 100. Contains a stack of currently executing sub-operations. You can listen changes in this stack via Returns true if the operation supports cancelation Cancels the operation. Returns immediately, does not wait till the operation execution is breaking physicaly. Hence canceled task can fire because of race condition but logicaly is canceled. Use to determine if the operation was canceled or not. True if the operation was canceled - method was called to. Returns the result of task execution. Blocks until task will finished even if task is not executed. Throw an exception if task execution finished interupted by exception. Returns the result of task execution. Cancels all tasks in queue, waits for current task to finish and then starts new task True is any task was actually canceled Cancels all tasks in queue True is any task was actually canceled Use this for blocking synchronization Currently executing task All changes to this field must be performed under lock Executes next task if it is available Precondition: myRunningTask is null or finished Creates a collection of items from the collection of data providers which contains values from providers matched specified filter. Keeps original list elements order. The next value will not be added until previous doesn't suggests filter Any value changes after value added will be ignored Creates a collection of items from the collection of data providers which contains only not null values from providers. Keep it actual on values changes. Creates a data provider that tells the number of items in the collection. For a collection of arbitrary items, maintains a list (= collection with linear order on the items) of the same items sorted in the order as defined by the . Item type. Type of the item property to sort by Collection of items without any order implied. Time to work. Target collection of ordered items. Functor getting an item property which is used to keep target collection sorted. Changing a value of property leads changing the position of item in collection Comparer setting up the order. Might be partial order, in which case items are added in order of appearance (stable sorting). If NULL, uses default comparer, e.g. on the type. Target collection modification token. Binds a lifetime to each item in the collection. Your handler is called for each item when it's added to the collection (and initially for all the items already in the collection), and is given the lifetime object for that item. This per-item lifetime is terminated whenever that item is removed from the collection, or when the you define for this method terminates. Using the per-item lifetime, you can define a pair of actions (after-item-comes — before-item-goes) to be executed for each item, or spawn some activity for the duration of each item, etc. FullLifetime of the construct. All of the open per-item lifetimes will be terminated when it terminates. Handler, called for each item when you first see it in the collection. The first param is the lifetime of the item, the second one is the item value itself. Binds a lifetime to each item in the collection. Your handler is called for each item when it's added to the collection (and initially for all the items already in the collection), and is given the lifetime object for that item. This per-item lifetime is terminated whenever that item is removed from the collection, or when the you define for this method terminates. Using the per-item lifetime, you can define a pair of actions (after-item-comes — before-item-goes) to be executed for each item, or spawn some activity for the duration of each item, etc. ILifetime of the construct. All of the open per-item lifetimes will be terminated when it terminates. Handler, called for each item when you first see it in the collection. The first param is the lifetime of the item, the second one is the item value itself. Core impl for both ForEachItem functions. Resolve address interval by position inside interval Intervals are placed into buckets by top position bits. if interval covers positions with different top bits (interval start in one bucket, interval end in another) it will be placed in all buckets that is covered by it Each bucket contains ordered by position interval list adds new interval for resolving resolve interval by instruction pointer Works with max 3*storage.Count compares. Prefer to use this constructor to make BinaryHeap from Enumerable Returns inner container with all items in the implementation-dependent order Adds items to generated by so that resulting enumerable will have exactly elements Wraps and count to create Merge to enumerables into one sorted array. Both enumerables should be already sorted. Intersects two sorted enumerables. Sorted enumerable Sorted enumerable Skipping elements in enumerable by predicate AND appearance number. For example, you can skip all, except first appearances of element in enumerable Selects N top items from a collection without sorting it Starts synchronizing the lists. Stop synchronizing the lists. Represent a segment of Initial array. Represents the index in the array at which part begins. The part elements number. Use with caution can create Mirrors one list into collection of another type with sorted item order. It is an error to modify the target collection directly while this method is in effect. Type of the source collection items. Type of the target collection items. The source collection. Lifetime of the flow. The target collection. Comparator for sorting Converter that produces items for the second collection from the items of the first collection. Note that the converter is only used for the operation, and there are no limitations on of the conversion products. May be Null if the types could be converted by a simple cast. Remove element from list if contains returns true true - is element was removed. false - otherwise Represent an enumerable part of the list. Type of the list item. Initial list. Represents the index in the list at which part begins. The part elements number. Keeps two lists synchronized. Starts synchronizing the lists. Stop synchronizing the lists. Listens for change events on a list. Initializes a new instance of the class. The master list. The target list. Starts synchronizing the lists. Stop synchronizing the lists. Receives events from the centralized event manager. The type of the calling this method. Object that originated the event. Event data. true if the listener handled the event. It is considered an error by the handling in WPF to register a listener for an event that the listener does not handle. Regardless, the method should return false if it receives an event that it does not recognize or handle. Listens for change events on a list. The list to listen to. Stops listening for change events. The list to stop listening to. Makes sure that all synchronized lists have the same values as the source list. The source list. Keeps two lists synchronized. Initializes a new instance of the class. The master list. The target list. Converts items from master list to target /// Converts items from target list to master Starts synchronizing the lists. Stop synchronizing the lists. Receives events from the centralized event manager. The type of the calling this method. Object that originated the event. Event data. true if the listener handled the event. It is considered an error by the handling in WPF to register a listener for an event that the listener does not handle. Regardless, the method should return false if it receives an event that it does not recognize or handle. Listens for change events on a list. The list to listen to. Stops listening for change events. The list to stop listening to. Provides base properties for creating an attribute, used to define rules for command line parsing. Short name of this command line option. You can use only one character. Long name of this command line option. This name is usually a single english word. True if this command line option is required. Gets or sets mapped property default value. A short description of this command line option. Usually a sentence summary. Indicates the instance method that must be invoked when it becomes necessary show your help screen. The method signature is an instance method with no parameters and return value. Initializes a new instance of the class. Initializes a new instance of the class. Allows you to define short and long option names. The short name of the option or null if not used. The long name of the option or null if not used. Returns always false for this kind of option. This behaviour can't be changed by design; if you try set an will be thrown. Models an option that can accept multiple values as separated arguments. Initializes a new instance of the class. The short name of the option or null if not used. The long name of the option or null if not used. Models an option specification. Initializes a new instance of the class. The short name of the option or null if not used. The long name of the option or null if not used. Gets or sets the option's mutually exclusive set. Models an option that can accept multiple values. Must be applied to a field compatible with an interface of instances. Initializes a new instance of the class. The short name of the option or null if not used. The long name of the option or null if not used. Initializes a new instance of the class. The short name of the option or null if not used. The long name of the option or null if not used. Values separator character. Gets or sets the values separator character. Models a list of command line arguments that are not options. Must be applied to a field compatible with an interface of instances. Initializes a new instance of the class. A type that implements . Thrown if is null. Gets or sets the maximum element allow for the list managed by type. If less than 0, no upper bound is fixed. If equal to 0, no elements are allowed. Models a bad parsed option. The short name of the option Returns the short name of the option. The long name of the option Returns the long name of the option. Models a parsing error. Gets or a the bad parsed option. The bad option. Gets or sets a value indicating whether this violates required. true if violates required; otherwise, false. Gets or sets a value indicating whether this violates format. true if violates format; otherwise, false. Gets or sets a value indicating whether this violates mutual exclusiveness. true if violates mutual exclusiveness; otherwise, false. Models a type that records the parser state afeter parsing. Gets a list of parsing errors. Parsing errors. Defines a basic interface to parse command line arguments. Parses a array of command line arguments, setting values in parameter instance's public fields decorated with appropriate attributes. A array of command line arguments. An object's instance used to receive values. Parsing rules are defined using derived types. True if parsing process succeed. Thrown if is null. Thrown if is null. Parses a array of command line arguments, setting values in parameter instance's public fields decorated with appropriate attributes. This overload allows you to specify a derived instance for write text messages. A array of command line arguments. An object's instance used to receive values. Parsing rules are defined using derived types. Any instance derived from , usually . Setting this argument to null, will disable help screen. True if parsing process succeed. Thrown if is null. Thrown if is null. Provides the abstract base class for a strongly typed options target. Used when you need to get parsing errors. This exception is thrown when a generic parsing error occurs. Specifies a set of features to configure a behavior. Initializes a new instance of the class. Initializes a new instance of the class, setting the case comparison behavior. If set to true, parsing will be case sensitive. Initializes a new instance of the class, setting the used for help method output. Any instance derived from , default . Setting this argument to null, will disable help screen. Initializes a new instance of the class, setting case comparison and help output options. If set to true, parsing will be case sensitive. Any instance derived from , default . Setting this argument to null, will disable help screen. Initializes a new instance of the class, setting case comparison and mutually exclusive behaviors. If set to true, parsing will be case sensitive. If set to true, enable mutually exclusive behavior. Initializes a new instance of the class, setting case comparison, mutually exclusive behavior and help output option. If set to true, parsing will be case sensitive. If set to true, enable mutually exclusive behavior. Any instance derived from , default . Setting this argument to null, will disable help screen. Initializes a new instance of the class, setting case comparison, mutually exclusive behavior and help output option. If set to true, parsing will be case sensitive. If set to true, enable mutually exclusive behavior. If set to true, allow the parser to skip unknown argument, otherwise return a parse failure Any instance derived from , default . Setting this argument to null, will disable help screen. Gets or sets the case comparison behavior. Default is set to true. Gets or sets the mutually exclusive behavior. Default is set to false. Gets or sets the used for help method output. Setting this property to null, will disable help screen. Gets or sets a value indicating if the parser shall move on to the next argument and ignore the given argument if it encounter an unknown arguments true to allow parsing the arguments with differents class options that do not have all the arguments. This allows fragmented version class parsing, useful for project with addon where addons also requires command line arguments but when these are unknown by the main program at build time. Provides methods to parse command line arguments. Default implementation for . Initializes a new instance of the class. Initializes a new instance of the class, configurable with a object. The object is used to configure aspects and behaviors of the parser. Singleton instance created with basic defaults. Parses a array of command line arguments, setting values in parameter instance's public fields decorated with appropriate attributes. A array of command line arguments. An object's instance used to receive values. Parsing rules are defined using derived types. True if parsing process succeed. Thrown if is null. Thrown if is null. Parses a array of command line arguments, setting values in parameter instance's public fields decorated with appropriate attributes. This overload allows you to specify a derived instance for write text messages. A array of command line arguments. An object's instance used to receive values. Parsing rules are defined using derived types. Any instance derived from , usually . Setting this argument to null, will disable help screen. True if parsing process succeed. Thrown if is null. Thrown if is null. Models an abstract sentence builder. Creates the built in sentence builder. The built in sentence builder. Gets a string containing word 'option'. The word 'option'. Gets a string containing the word 'and'. The word 'and'. Gets a string containing the sentence 'required option missing'. The sentence 'required option missing'. Gets a string containing the sentence 'violates format'. The sentence 'violates format'. Gets a string containing the sentence 'violates mutual exclusiveness'. The sentence 'violates mutual exclusiveness'. Gets a string containing the error heading text. The error heading text. Models an english sentence builder, currently the default one. Gets a string containing word 'option' in english. The word 'option' in english. Gets a string containing the word 'and' in english. The word 'and' in english. Gets a string containing the sentence 'required option missing' in english. The sentence 'required option missing' in english. Gets a string containing the sentence 'violates format' in english. The sentence 'violates format' in english. Gets a string containing the sentence 'violates mutual exclusiveness' in english. The sentence 'violates mutual exclusiveness' in english. Gets a string containing the error heading text in english. The error heading text in english. Models the copyright informations part of an help text. You can assign it where you assign any instance. Initializes a new instance of the class. Initializes a new instance of the class specifying author and year. The company or person holding the copyright. The year of coverage of copyright. Thrown when parameter is null or empty string. Initializes a new instance of the class specifying author and years. The company or person holding the copyright. The years of coverage of copyright. Thrown when parameter is null or empty string. Thrown when parameter is not supplied. Initializes a new instance of the class specifying symbol case, author and years. The case of the copyright symbol. The company or person holding the copyright. The years of coverage of copyright. Thrown when parameter is null or empty string. Thrown when parameter is not supplied. Returns the copyright informations as a . The that contains the copyright informations. Converts the copyright informations to a . This instance. The that contains the copyright informations. When overridden in a derived class, allows to specify a different copyright word. When overridden in a derived class, allows to specify a new algorithm to render copyright years as a instance. A array of years. A instance with copyright years. Models the heading informations part of an help text. You can assign it where you assign any instance. Initializes a new instance of the class specifying program name. The name of the program. Thrown when parameter is null or empty string. Initializes a new instance of the class specifying program name and version. The name of the program. The version of the program. Thrown when parameter is null or empty string. Returns the heading informations as a . The that contains the heading informations. Converts the heading informations to a . This instance. The that contains the heading informations. Writes out a string and a new line using the program name specified in the constructor and parameter. The message to write. The target derived type. Thrown when parameter is null or empty string. Thrown when parameter is null. Writes out a string and a new line using the program name specified in the constructor and parameter to standard output stream. The message to write. Thrown when parameter is null or empty string. Writes out a string and a new line using the program name specified in the constructor and parameter to standard error stream. The message to write. Thrown when parameter is null or empty string. Provides base properties for creating an attribute, used to define multiple lines of text. Models a multiline assembly license text. Initializes a new instance of the class with one line of text. First line of license text. Initializes a new instance of the class with two lines of text. First line of license text. Second line of license text. Initializes a new instance of the class with three lines of text. First line of license text. Second line of license text. Third line of license text. Initializes a new instance of the class with four lines of text. First line of license text. Second line of license text. Third line of license text. Fourth line of license text. Initializes a new instance of the class with five lines of text. First line of license text. Second line of license text. Third line of license text. Fourth line of license text. Fifth line of license text. Models a multiline assembly usage text. Initializes a new instance of the class with one line of text. First line of usage text. Initializes a new instance of the class with two lines of text. First line of usage text. Second line of usage text. Initializes a new instance of the class with three lines of text. First line of usage text. Second line of usage text. Third line of usage text. Initializes a new instance of the class with four lines of text. First line of usage text. Second line of usage text. Third line of usage text. Fourth line of usage text. Initializes a new instance of the class with five lines of text. First line of usage text. Second line of usage text. Third line of usage text. Fourth line of usage text. Fifth line of usage text. Handle parsing errors delegate. Provides data for the FormatOptionHelpText event. Initializes a new instance of the class. Option to format. Gets the option to format. Models an help text and collects related informations. You can assign it in place of a instance. Occurs when an option help text is formatted. Message type enumeration. Parsing error due to a violation of the format of an option value. Parsing error due to a violation of mandatory option. Parsing error due to a violation of the mutual exclusiveness of two or more option. Initializes a new instance of the class. Initializes a new instance of the class specifying the sentence builder. A instance. Initializes a new instance of the class specifying heading informations. A string with heading information or an instance of . Thrown when parameter is null or empty string. Initializes a new instance of the class specifying the sentence builder and heading informations. A instance. A string with heading information or an instance of . Initializes a new instance of the class specifying heading and copyright informations. A string with heading information or an instance of . A string with copyright information or an instance of . Thrown when one or more parameters are null or empty strings. Initializes a new instance of the class specifying heading and copyright informations. A instance. A string with heading information or an instance of . A string with copyright information or an instance of . Thrown when one or more parameters are null or empty strings. Initializes a new instance of the class specifying heading and copyright informations. A string with heading information or an instance of . A string with copyright information or an instance of . The instance that collected command line arguments parsed with class. Thrown when one or more parameters are null or empty strings. Initializes a new instance of the class specifying heading and copyright informations. A instance. A string with heading information or an instance of . A string with copyright information or an instance of . The instance that collected command line arguments parsed with class. Thrown when one or more parameters are null or empty strings. Creates a new instance of the class using common defaults. An instance of class. The instance that collected command line arguments parsed with class. Creates a new instance of the class using common defaults. An instance of class. The instance that collected command line arguments parsed with class. A delegate used to customize the text block for reporting parsing errors. Supplies a default parsing error handler implementation. The instance that collected command line arguments parsed with class. The instance. Sets the heading information string. You can directly assign a instance. Sets the copyright information string. You can directly assign a instance. Gets or sets the maximum width of the display. This determines word wrap when displaying the text. The maximum width of the display. Gets or sets the format of options for adding or removing dashes. It modifies behavior of method. Gets or sets whether to add an additional line after the description of the option. Gets the instance specified in constructor. Adds a text line after copyright and before options usage informations. A instance. Thrown when parameter is null or empty string. Adds a text line at the bottom, after options usage informations. A instance. Thrown when parameter is null or empty string. Adds a text block with options usage informations. The instance that collected command line arguments parsed with class. Thrown when parameter is null. Adds a text block with options usage informations. The instance that collected command line arguments parsed with the class. The word to use when the option is required. Thrown when parameter is null. Thrown when parameter is null or empty string. Adds a text block with options usage informations. The instance that collected command line arguments parsed with the class. The word to use when the option is required. The maximum length of the help documentation. Thrown when parameter is null. Thrown when parameter is null or empty string. Builds a string that contains a parsing error message. An options target instance that collected command line arguments parsed with the class. Number of spaces used to indent text. The that contains the parsing error message. Returns the help informations as a . The that contains the help informations. Converts the help informations to a . This instance. The that contains the help informations. Concurrency testing helper. Provides facilities to model threads interleaving based on checkpoints. The misspelling (Concurrenzy) is intentional to prevent collision with namespace name.

Use Concurrenzy.Checkpoint("name") in production code in "interesting" places and then use ConcurrencySimulator in test to model specific interleaving cases.

The Checkpoint() method is marked as [Conditional] and completely removed from production code by compiler.
 Combines two concurrent data providers Async provider Combines any number of providers of the same value type with converter Combines any number of controllers of the same value type with converter Combines two providers with converter Input providers must be either both synchronized, or derive from the same async data provider. For combining data from two different asynchronous data providers, use This method converts ICommand to ICommandSafe, but actually doesn't guarantee Returns object as a value of a constant data provider Converts any object with update notification into DataProvider Source object Callback for subscribing handler to object notifications. Note that handler will be of type Callback for unsubscribing handler from object DataProvider that provides as its value Converts any object with update notification into DataProvider Source object Callback to get value from object Callback for subscribing handler to object notifications. Note that handler will be of type Callback for unsubscribing handler from object Converts any object with update notification into DataProvider Source object Callback to get value from object Callback for subscribing handler to object notifications. Note that handler will be of type Callback for unsubscribing handler from object Use this method before creating any pipe. It initializes main thread for data pipes. By default, it will use current thread. Creates a proxy for building a part of pipeline when source provider is not available. When a source will be set, all current subscriptions will be delegated to it in order to avoid extra callbacks in pipeline Creates writeable data provider Used to skip provider updates when the same value is set into Creates writeable data provider without initial value. Creates data provider with value created by on acitvation Caches enumerables into list If collection is reused, it shouldn't be accessed from other threads. Base class for data providers. Tracks change notification subscriptions and raises event when value changes. Used by descendants to notify that stored value has changed internally, buts reference to value remain the same Called before the first handler is subscribed. True if async update was fired during activation of this provider Any thread Switches data provider to Update state true if data provider switched in Update state successfully, false if data provider was in Deactivated state if data provider was in Updating state Switches data provider back to Idle/Deactivated state if data provider was not in Updating state This class can be used by the consumer of DataProvider in order to simplify resubscription to DataProvider updates when DataProvider is changed and also for activation handling. Handler that is passed into the constructor is called only when subscription is active and DataProvider is set. When subscription is not active, data provider is not activated. Stores actions that need to be performed after pipe activaton process is finished. Example of such actions is request for async data pipe update. If this action will be executed before activation is finished, async update may be started before all subscribers are registered. Therefore part of pipeline may not be updated. This manageer collects such requests and executes them right after last activation call frame is exited. Subscribes handler to data provider. Must be called on Primary Thread. True, if any async data provider was activated during this subscription. Activation of some async data provider will mean, that there is no need to update value of current data provider, because update signal will come later from that async data provider. In short: It guarantee integrity of triplet (value, attributes and hasValue). Note: This method must be called on Update Thread! We need this method because the triplet could be changed from different threads: 1. During update on Update Thread. 2. During deactivation on Main Thread (it could clear those fields in ClearValue() method). As this method must be called only on Update Thread we need to synchronize it only with deactivation. Transparent proxy for building a part of pipeline when source provider is not available. When a source will be set, all current subscriptions will be delegated to it in order to avoid extra callbacks in pipeline It helps to avoid reentrancy, when in pipe's lambda someone pumped a dispatcher queue. See DTRC-30786
It uses dispatcher an underlying dispatcher. Trivial scheduler for dispatching tasks on data pipes threads Trivial scheduler for dispatching tasks on data pipes threads It's the only main thread dispatcher for data pipes.
It must be initialized by using > Upgrades double-buffering ThreadSwitch to lock-free version, that uses three buffers instead of two. Specifies timeout for consumer lock on trying to obtain new value from double-buffer. If timeout is reached, consumer update is canceled. In this case consumer will perform the next attempt to obtain new value when the producer finishes filling the buffer. Note, that if producer instantly produces new values and every value production takes significant time, consumer may never receive an update. In this case you should use lock-free version of ThreadSwitch: Get or set value inside provider. On set, if value hasn't changed, no update will be raised Force provider update without value change Force provider update with value change Use this method to extract value from activated provider. If specified provider is not activated or doesn't have value the method returns Maybe<T>.Nothing> Use this method to extract value from activated provider. If specified provider is not activated or doesn't have value the method returns default(T) True if data provider never got a value. True if provider was initialized before but then got Invalidated and right now don't have value. Current value of the provider. Valid only if both and are false Used for strong typing of scenarios, where data pipes are used for events handling. Events processing differs from typical data pipes behavior, because update callback is not expected to be called on data provider activation, or on data source switch, that happends within type or method) This struct encapsultaes event data and overrides method Can be used for two-way binding between DataProvider and WPF control (i.e. CheckBox.IsChecked) As data processing in pipeline is directed and acyclic, the only way to modify value inside the provider is to affect some input providers of the pipeline in such way that a desired value will be received by the target provider Source data provider Call back for value modification Error provider Asserts that after a new value is set, source provider will return it back to notifier (uses default equality comparer) Editable data provider Pretend to be another provider, based at some key (given by another provider) and selector Type of the key Type of the output value Provides key for switching Selects a resulting data provider based on key Indicates whether cleanup of the pipe is needed if inner provider is null Specific case for switching between two providers Specific case for switching between two providers Activates provider and creates lifetime that is terminated when provider value turns to False. After lifetime is terminated, provider is unsubscribed to avoid memory leak. Creates subscription to that is activated according to value of Use this method with a great care: make sure that permanent subscription to won't leak and that switches to false at termination Determines activation state of the subscription. WARNING #1: Subscription to this provider is permanent! Make sure it will not cause memory leak! WARNING #2: If this provider won't finally set its value to false, will be subscribed and may also cause memory leak! Callback that will be called at every value update Holder for changing source provider Uses Thread Pool for tasks execution Uses List for caching enumerables Uses arbitrary collection for caching enumerables Creates a ThreadSwitch, that groups updates and delivers the freshest value to the consumer. Next update will be propagated only after the consumer receives the previous one. For example, if thread 1 consequently sends several updates to thread 2, than until thread 2 actually gets started, it will receive no additional updates. Therefore, some of the updated values will never reach thread 2, so this method shouldn't be used for streaming data between threads. If skipping values is not affordable, you hsould use method Creates a ThreadSwitch, that delivers all values to destination without skipping. If consumer needs only that most recent value, and you want to reduce the number of possible updates, you should use method Creates a ThreadSwitch, that uses double buffering for transfering massive data between threads. If consumer tries to access container, when a new buffer is being filled, it will lock until fill operation is completed. To avoid indeterminate locking, you can either specify timeout for this lock using method, or upgrade to lock-free version using method Input type. For example, IEnumerable{int} Buffer type. For example, IList{int} Output type. For example, IEnumerable{int} Source Factory for creating buffers Method that fills buffer with the input value. Usually returns the filled buffer, casted to some readonly interface If source value is null returns , otherwise applies converter If source value is null returns , otherwise applies converter If source value is null returns , otherwise applies converter Throws if the current thread is not the thread associated with this dispatcher. Contains logic that dispose can be called more than once. And guard of calling methods after dispose. Used to delegate implementation of IDisposable to an instance of this class. Lock-free Thread pool moved from DotTrace. Caution! Internal data will be reused. Copy if you need it to be stored. Used to reduce memory traffic. These helpers are introduced to correctly check if some part has some property. We can't use `formatting == TextFormatting.Highlighted` because TextFormatting encapsulate Flags, which should not be compared This class describes the full, runtime and persistence (logical life from point of user) lifetime of an object When parent FullLifetimeDefinition is terminated, Defines new full lifetime limited by parent Parent full lifetime Debug id Defines new full lifetime. is unlimited but is limited by Parent for Debug id Defines new full lifetime limited by and at the same time Parent full lifetime Additional restriction of full lifetime Debug id A container for , that allows to expose command from ViewModel safely. Reason for that: WPF keeps a weak subscription to CanExecuteChanged event even when control is already unloaded. So, if your implementation of expects this event to be correctly unsubscribed and your ViewModel keeps a strong reference to it, this will never happen. For such commands you should use implementation of this interface For other commands you can use implementation WPF templates should bind to this property to get underlying command. Copy paste of Platform's InterruptibleLazy with additional IExecutionController passed to support task cancelling Creates lifetime definition which will be terminated if either or are terminated Creates lifetime which will be terminated if either or are terminated The special exception for issues under investigation: catch by logger and appended with postmortem log. See Value converter that performs arithmetic calculations over its argument(s) MathConverter can act as a value converter, or as a multivalue converter (WPF only). It is also a markup extension (WPF only) which allows to avoid declaring resources, ConverterParameter must contain an arithmetic expression over converter arguments. Operations supported are +, -, * and / Single argument of a value converter may referred as x, a, or {0} Arguments of multi value converter may be referred as x,y,z,t (first-fourth argument), or a,b,c,d, or {0}, {1}, {2}, {3}, {4}, ... The converter supports arithmetic expressions of arbitrary complexity, including nested subexpressions Property is true for fuids, that doesn't need to be converted via IFuidsMatcher and are the same in multiple snapshots, its a subset of a synthetic fuids, but not all of them. Examples are: thread root fuids, generated task fuids It used only in comparison two MethodViewData and for Actions (GotoBacktraceActionHandler for example) Navigation type is type used to find navigation point in source code. Invisible and compiler generated types are ignored. Use TypeFQN to compare. " AnonymousType = "<>f__AnonymousType" Identifier; # Token, Identifier = 1*(ALPHA / DIGIT); LambdaGen = "<>" Identifier; # Token Method = ("." Identifier) / ( TypeWithGenerics ["." Identifier] ) YieldGen = "<" YieldGen / Method ">" [ Identifier ]; ClassParameters = ClassSpecification [*(("," / *" ") ClassSpecification) ]; ClassSpecification = TypeWithGenerics *("+" TypeWithGenerics) ["[" ClassParameters "]"] NamespaceAndClass = (Identifier / LambdaGen / YieldGen) ["." (Identifier / LambdaGen / YieldGen)] TypeWithGenerics = (NamespaceAndClass / AnonymousType) [GenericCount] ["<" Parameters ">"]; AttributeType = NamespaceAndClass MonoModifier = MonoModifierKeyword OpenParen AttributeType CloseParen MonoNonPrimitiveType = TypeWithGenerics [MonoModifier]; ETWNonPrimitiveType = [EtwValue] EtwClass TypeWithGenerics TypeWithModifiers = ((EtwOptionalModifier / EtwRequiredModifier) 1*2(Type)) / Type FunctionPtrType = "fnptr" Signature ]]> ISafeCommand implementation recreates ICommand on demand and keeps a weak reference to created ICommand instance, allowing it to be collected and unsubscribed when UI binding is gone. Unsafe implementation of interface Can be used for s that doesn't care about correct unsubscription from event Releases resources allocated by , or Null-terminated UTF-16 string. Returned pointer must be released by calling Null-terminated UTF-16 string. Returned pointer must be released by calling Array of Null-terminated UTF-16 string pointers. The last array element is NULL. Returned pointer must be released by calling Used (in dotMemory only) to run tasks via IUETaskExecutor. It seems whould be better to use WPF dialogs (and possible async/await after merging wave12-ilya-ivanov-task-n-pipes branch) instead of platform IUETaskExecutor which has side-effects (see DMRY-5799, DMRY-4883) Required to write pointer size (sizeof(void *)) in binary format Value should be equal to sizeof(void *) in C++ Returns true if at least one Run is in process Run this token when activity is started When activity is stopped don't forget to dispose returned stop token Stop token Root node is included Path from tree root to target node. Both root and target node are included in resulting path After loading and attaching subtree tree asks node to set selection. If node fails to do so, tree tries to restore the same selection as it was before update request options for current response true if selection was changed, otherwise - false Subtree tree with the next interesting node. The subtree till the node where payload was split will be returned. Almost full tree without system folding will be returned. Only very small nodes won't appear in the response Wrap any data pipe fluent syntax call with this extension in order to be able to set breakpoint External process for out of process calculations Signaled when the process is exited This method should update internal field NextPackageToUpdate with new package Returns incoming pipe name for specified side (client/server) Note: Incoming pipe name for client side = Outgoing pipe name for server side and vice versa Returns outgoing pipe name for specified side (client/server) Note: Incoming pipe name for client side = Outgoing pipe name for server side and vice versa Uses thread static field in order to reuse instance of PipeLocksController and avoid memory traffic We rely here that is not used recursively If message processing takes long time, it is important to release pipe reading and pipe termination locks as soon as possible This class is used to control two moments during processing of current message: when processing of the next message can be started and when pipe termination lock can be released Also, this controller asserts that both locks will finally be released and that they will be released only once Obtains local host by id. Hosts are stored in strong to weak dictionary. Active hosts also are referenced strongly from Therefore, inactive host may be collected by gc during update event transfer from proxy. In this case, update must be silently canceled. for sending offset of pointer to remote process index is index ofShared memory Node in manager offset is offset in that node Executes delegate remotely and returns remote reference to the result of that delegate hard link to the object that must be alive until the remote reference is alive Executes action remotely This method is used when we want to stop drilling namespace tree on classes and treat "." in pattern as flag to go and show class methods. This is used in standalone / VS versions of dotTrace when user hits Ctrl+F This method is used when we want to show all methods for this pattern immediately. This is used in Rider integration("Search everywhere" dialog) Given the plain representation of the function signature (namespace + classname + method name), method retrieves a list of Signature tree nodes whose compound path (from the root to itself) corresponds to this signature. NB: All possible candidates are gathered only on the last possible level, i.e. when a potential function name is given. Thus we do not fork the search at the top levels of the tree and gather all overloads of the function on the lowest level. Synthetically construct method name from partial information on namespace and classname. This method is used to locate arbitrary location in the namespace tree (e.g. class) and not only a leaf representing a function. Creates root Provides lifetime facilities for objects with async-activity, e.g. task schedulers. The main purpose of AsyncLifetime to ensure all async activities finished before terminating inner lifetime (to prevent accessing terminating lifetime from still running tasks which lead to exceptions).
Actually, the current supports all features which were implemented in AsyncLifetime early. It would be better to eliminate AsyncLifetime and migrate to regular Lifetime.
The last attempt was here: 'net221-ii-asynclifetime-refactoring'
It wasn't successful due to TerminationTimeout needs, which already implemented as . The lifetime instance which will be terminated when all tracked tasks have finished. It is safe to use Instance inside task actions and/or inside callback actions. Cancellation token which is activated when lifetime is terminating.
IMPORTANT! For correct lifetime termination all tracked tasks must be linked to this token. Just delegates to Token.ThrowIfCancellationRequested(). Tries to add task for tracking. Returns true if succeeded and false if lifetime already is in terminating state. When async-lifetime is terminating it first activates cancellation token then waits for all tracked tasks have finished and finally terminates lifetime. Adds task created by for tracking. If lifetime is in terminating state then isn't invoked (and task isn't created at all).
If was invoked then it is guaranteed that returned task will be tracked till finish.

See also remarks for . Adds task created by for tracking. See remarks for Raises when async-activities aren't finished in given time. Intended for diagnostic purpose: handler can attach additional info to exception (e.g. threads dump). Returns lifetime . Returns . Returns combined cancellation token which is activated when or is activated. Provides Yield() facility for legacy code which performs long operation without execution controller. Executes the specified action asynchronously via dispatcher with respect to lifetime. * If lifetime already terminated when InvokeAsync() called then action just ignored.
* If lifetime is terminated before action has been invoked then action removed from dispatcher's queue.
* If lifetime is being terminated when dispatcher's thread already inside an action then Terminate() will wait while action has completed with timeout specified for async-lifetime.

If action throws an exception then it is logged via . Provides subscription to handle task(s) progress. Subscribes listener for tasks progress. The events for each particular task are strictly ordered: OnTaskScheduled -> {OnTaskOperationChanged|OnTaskProgressChanged}* -> OnTaskFinished.
The events fired on task thread but NOT concurrently.

IMPORTANT! Long operation in handler will affect task performance.
If listener added when some tasks already scheduled then it is notified instantly for all scheduled tasks.

If scheduler's lifetime has terminated then TaskFinished might not be fired for currently scheduled tasks. Basic interface for entity which can schedule tasks. The async-lifetime associated with this scheduler. Might be AsyncLifetime.Eternal but not null. Schedules for execution. Returns System.Threading.Tasks.Task. Returned task supports await syntax.

If you thinking 'how to cancel task', probably you need or . For very special cases might be used also.

If action throws an exception then it is logged via . Caller might also handle exception via callback but exception will be logged any way.

If you need to bind some entities to lifetime inside task action then you should use .

If implementor is bound to lifetime and this lifetime is terminated then Schedule() returns instantly cancelled task, no exception is thrown. Schedules for execution. See Creates task scheduler restricted by given . The must implement . Creates task scheduler restricted by given . The must implement . Internal task scheduler interface. Provides separated task creation and scheduling. Used by and some others. Creates task but doesn't schedule it for execution. The returned task might be in CANCELLED state if already activated but can not be in SUCCEEDED or FAILED state. Schedules task created by for execution. Creates task but doesn't schedule it for execution. See The special interface to stop all async-activities produced by particular scheduler. Might be helpful in various resource watchdogs to prevent overuse while warning displayed and user think what to do. Schedules task for exclusive execution. The scheduling next task always cancels previous one. Cancels currently running task. If is false then method returns instantly, otherwise it waits for running task (if any) to finish.

The implementation should use termination timeout from associated and throw if await timed out. whether await currently running task or not (default: false) Schedules task to (UI thread). Schedules task for exclusive execution. The scheduling next task always cancels previous one. The base class for various execution controller proxies. Extension interface for IExecutionController. Executes task instantly as it is scheduled. Tries to resume task. Returns true if task is running and false otherwise. Tries to pause task. Returns true if task is paused and false if it is still running. The custom implementation of system which executes each task on personal thread. There is no task queue, for each enqueued task the personal thread is picked up (or created new if no idle pre-created threads). Normally, threads are re-used, and shut down only after max idle interval. State transitions:
Frozen -> Pending /* if task has cancelled in Frozen state, then it is just removed from queue; no state update happens */
Pending -> Executing, Finished
Executing -> Pausing, Waiting, Finished
Pausing -> Paused, Waiting, Executing, Finished
Waiting -> Paused, Finished
Paused -> Resuming, Finished
Resuming -> Executing, Paused, Finished
Finished
 The implementation of . This is default scheduler used in dotMemory.

KEY NOTES
* Supports task pausing (via IExecutionController.Yield()), but be aware - thread isn't released.
* Currently pause feature is disabled due to memory consumption reasons:v when paused task still retain all allocated memory,
if multiple tasks are paused then running task might get OOM exception.
To regulate memory consumption the MemoryMonitor is used.
* Supports 'stop-the-world': can pause all running tasks (e.g. used when memory over-consumption detected).
* Supports detailed progress reporting: .
 The proxy scheduler which adds support to other scheduler. Aggregates progresses of group of tasks into single [0, 100] progress. Helper class which accumulates progress steps and push it forward only when threshold reached. Schedules tasks for sequential execution. The next scheduled task starts only when previous one has finished (with any reason - success, cancel, failure). Legend:
#n - integer identifier of task;
^n - hash code of cancellation token/source;
$n - managed thread identifier;
 Provides facility to handle detailed task progress. Used to show any relevant progress when complex task with a lot of dependent tasks are running.
The main issue with progress of complex task is just 1% of such task takes a lot of time and for user looks like app hanging.

The detailed progress might include:
* extended info like 'k objects of N processed'
* percentage progress of attached sub-task which is most active currently
(here active means updates progress often)

This is progress listener part. The task reports extended progress via . Checks whether AggregateException contain one and only one OperationCanceledException. NOTE. This method intentionally checks for single inner exception only.
Example.
If task A waits task B and B was cancelled then B.Wait() will throw AggregateException with inner OperationCancelledException. In turn, A.Exception will be AggregateException with inner AggregateException (from B) with inner OperationCancelledException.
Such case treated as A has FAILED not cancelled! Unwraps AggregateException if it contains single inner one and return it as is otherwise. Tries to start task. Returns true if started and false if task already cancelled. Tries to start task. Returns true if started and false if task already cancelled. Tries to start task. Returns true if started and false if task already cancelled. Returns task which finished when all callbacks which were subscribed at this moment are finished. Works only on non-finished tasks! Used in tests. The helper class which allows to report additional task operation progress details for long-running task. This is progress reporting part. The listener implemented via . Formats and reports additional progress details in form '... n of N items processed'. Sets operation name. NOTE: The original operation name will be restored when progress advanced to next step. Returns instance of TaskOperationDetails bound to current task. If called outside of task execution context returns dummy instance which does nothing. Task id. New progress value [0, 100]. New current operation. Can be null or empty. Tries to subscribe progress handler for task with given id. Returns true if specified task is able to report progress and false otherwise. If subscribing is successful then is invoked instantly with current Progress/Operation.

It is guaranteed that will not be invoked concurrently for given task, but it might be invoked on different threads.
The might be called with the same Progress/Operation values several times, but it is guaranteed that progress value will be ordered.

The will be automatically unsubscribed when task has finished. Registers task as progressable. The will be automatically unregistered when it has finished. Schedules task for non-limited parallel execution. Group of tasks. Tasks in group are running concurrently with respect to allowed concurrency level.

The group has priority: foreground or background. Scheduler tries to run as many tasks from foreground group as possible. To achieve this it may pause tasks from other groups.

If foreground group contains less tasks than allowed concurrency level, tasks from background groups are executed. Which particular background tasks will be executed is implementation specific. Changes group priority to foreground and re-schedules tasks if needed. The only one group might have foreground priority, others automatically sends to background. Schedules grouped tasks with ability to change group priority (foreground/background) during task execution. Also limits concurrency level - only specified number of tasks might run concurrently. The supposed usage is in view models:
* view model creates task group and schedules all its tasks in this group;
* when view model is activated then appropriate group brings to foreground;
* as result - tasks related to vm which user looks over are executed first.
 Gets or sets allowed concurrency level. Creates tasks group bound to specified lifetime. When is terminated then all scheduled tasks are signaled to cancel and then awaited to be really finished. Schedules tasks for sequential execution. The next scheduled task starts only when previous one has finished (with any reason - success, cancel, failure). Cancels currently running task and removes all pending tasks. The next scheduled task starts only when currently running one has finished. If is false then method returns instantly, otherwise it waits for running task (if any) to finish.

The implementation should use termination timeout from associated and throw if await timed out. whether await currently running task or not (default: false) Provides events to handle task(s) progress. See . Generic waitable object. Tries to continue without actual wait.
Returns true if underlying object doesn't require waiting in its current state.
Rethrows exception if underlying object is in failed state.
Returns false if underlying object requires waiting. Waits for underlying object given amount of time.
If reached then is thrown.
If activated then is thrown.
If underlying object cancelled then is thrown. The helper class which provides facility to ensure all sub-task(s) finished on leaving some scope.
For meaningful example, see QuickSort for VxArray and DMRY-8992 Adds task to be tracked by this guard. Waits for all tracked tasks using IExecutionController.
Throws exception if at least one task failed. Ensures all tracked tasks actually finished on leaving the scope.
Doesn't re-throw any exception. Returns existing or creates new dispatcher for current thread. If thread isn't STA thread then exception is thrown. Returns existing or creates new dispatcher for current thread. If thread isn't STA thread then null is returned. Provides extension methods to specify task callbacks (success, cancel, failure, finish). The callback action invoked on the same thread that causes the task to transition into its final state. If the task is already finished when OnXxx() is called, the action will be invoked on the thread that calls OnXxx().

If callbacks are subscribed before task start then they will be invoked sequentially in order of subscription. Otherwise callbacks might be called in any order (possible concurrently - some from task thread, others from subscriber thread). If you need several callbacks in predictable order consider using .

Be aware, the (and any of Task.Wait) awaits task action only. This means callback action might be invoked after AwaitFinished returned.

If callback action throws an exception then it is logged via .

The lifetimed overloads of OnXxx() have the following behavior:
* if lifetime already terminated when OnXxx() called then callback just ignored;
* if lifetime is terminated before callback action has been invoked then action will never be invoked;
* if lifetime is being terminated when other thread already inside a callback action then Terminate() will wait while action has completed with timeout specified for async-lifetime;

If you need to bind something to lifetime inside callback action you should use .Instance, it will be terminated only after all tracked async activity have finished.

The OnXxxSynchronized() invoke callback action via captured Dispatcher.. Dispatcher is captured at the moment of OnXxxSynchronized() call, so it is must be called on UI thread only.

The lifetimed overloads of OnXxxSynchronized() act the same way as non-synchronized ones, i.e. callback action either never been invoked or awaited till completion. Specifies task succeeded callback. See generic OnXxx() remarks on . @this /// Specifies task succeeded callback restricted by . See generic OnXxx() remarks on . @this Specifies task succeeded callback. See generic OnXxx() remarks on . @this Specifies task succeeded callback restricted by . See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on captured Dispatcher.. See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on captured Dispatcher. and restricted be . See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on captured Dispatcher.. See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on captured Dispatcher. and restricted be . See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on provided . See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on provided and restricted be . See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on provided . See generic OnXxx() remarks on . @this Specifies task succeeded callback which will run on provided and restricted be . See generic OnXxx() remarks on . @this Specifies task finished (with any reason) callback. See generic OnXxx() remarks on . @this Specifies task finished (with any reason) callback restricted by lifetime. See generic OnXxx() remarks on . @this Specifies task finished (with any reason) callback which will run on captured Dispatcher.. See generic OnXxx() remarks on . @this Specifies task finished (with any reason) callback which will run on captured Dispatcher. and restricted be . See generic OnXxx() remarks on . @this Specifies task finished (with any reason) callback which will run on provided . See generic OnXxx() remarks on . @this Specifies task finished (with any reason) callback which will run on provided and restricted be . See generic OnXxx() remarks on . @this Specifies task failed callback. The task is failed when its action threw an exception excluding . Be aware, despite of OnFailure callback exception will be logged via Logger.LogException in any way.

See generic OnXxx() remarks on . @this Specifies task failed callback restricted by lifetime. See remarks for .
See generic OnXxx() remarks on . @this Specifies task cancelled callback. The task is cancelled when its cancellation token activated or its action threw an . See generic OnXxx() remarks on . @this Specifies task cancelled callback restricted by lifetime. See remarks for .
See generic OnXxx() remarks on . @this Specifies task any continuation callback restricted by . See generic OnXxx() remarks on . @this Specifies fault continuation which will log task exception via Logger.LogException excluding a single OperationCancelledException. See remarks for . @this Specifies fault continuation which will log task exception via Logger.LogException excluding a single OperationCancelledException. See remarks for . @this Returns true if task successfully finished. It is identical to Task., introduced just for unified style. Returns true if task was cancelled eigther via cancellation token or via throwing OperationCancelledException. It differs from Task. which takes in account only cancellation token. Returns true if task failed due to exception excluding OperationCancelledException. It differs from Task. which treats OperationCancelledException as faulted. Returns true if task finished with any reason. 'Syntax sugar' stuff for some common parallel processing patterns. var result = controller .Fork(DoA, inputA, DoB, inputB) .Join(DoC); var result = controller .ParallelSplit(largeList) .Process(DoProcessChunk) .Merge(DoMerge); var result = controller .ParallelForEach(largeList) .Process(DoProcessItem); Joins with another task. If reached then is thrown.
If task FAILED or CANCELLED then produced by this task is re-thrown. Joins with another task with cancellation support. If reached then is thrown.
If is activated then is thrown.
If task FAILED or CANCELLED then produced by this task is re-thrown.

IMPORTANT! If task bound to the same (more precisely to the token of the same source) then Join() throws OperationCancelledException on cancellation request. But if awaited task bound to another token (either linked to or not) then Join() might throw either OperationCancelledException or AggregateException (see TaskWaitExtensionTest.Join_MightRethrowAggregateExceptionIfCancellationTokensDifferent test for example). Joins with another task. Joins with another task with cancellation support. Joins with another task or throws OperationCanceledException if task has cancelled. In general case, when awaited task has cancelled it doesn't necessary mean that awaiting one should be cancelled too. So implementation of throws OperationCanceledException when and only when cancellation token is activated also.

For cases when propagation of OperationCanceledException is desired the JoinOrThrowOCE should be used. Joins with another task or throws OperationCanceledException if task has cancelled. See Waits for task finished by any reason. Returns true if task finished in specified time and false otherwise. Any exception(s) from task aren't re-thrown (it is supposed they are already handled and logged). If you need await any/all of set of tasks then use Task.WhenAll(...).TryAwaitFinished(...) or Task.WhenAny(...).TryAwaitFinished(...) Waits for task finished by any reason. The only exception possibly thrown is , any exception(s) from task aren't re-thrown (it is supposed they are already handled and logged). If you need await any/all of set of tasks then use Task.WhenAll(...).AwaitFinished(...) or Task.WhenAny(...).AwaitFinished(...) Intentionally not implemented, because WaitHandle does not support CancellationToken. Provides Run method which is analogue of system but uses instead of default one. Also it lifetime-friendly. Controls execution of current task. All methods must be called on task thread only. Starts operation progress with specified number of steps. Returns CURRENT instance of IExecutionController. using (controller.StartProgress(2)) { DoSubOperationA(controller.CreateSubOperation(1)); DoSubOperationB(controller.CreateSubOperation(1)); } using (controller.StartProgress(100)) { for (var i = 0; i < 100; i++) { // do something useful controller.YieldAndAdvanceProgress(); } } Delegates some of progress steps to sub-operation executed synchronously. Returns NEW instance of IExecutionController. See for examples. Delegates some of progress steps to sub-operation executed in another task. Returns CURRENT instance of IExecutionController. The link between task is set up and attached starts report its progress to current task. The attached task might be obtained via of current execution controller or via of any other scheduler.

If current execution controller is disposed before attached has finished then 'Progress is out of range' assertion is possible.

Some schedulers might perform additional actions on AttachSubOperation, e.g. adds into current task's group to sync-up their priorities. using (controller.StartProgress(2)) { var subTaskA = controller.Fork(DoAsyncOpA); var subTaskB = controller.Fork(DoAsyncOpB); controller .AttachSubOperation(subTaskA, 1) .AttachSubOperation(subTaskB, 1) .Wait(taskA, timeout) .Wait(taskB, timeout); } Advances progress on one step. Yields task. Execution might be cancelled or paused at this point. Generic wait. Waits another task to finish, event to fire, and so on. If reached then is thrown.

The most implementations supports cancellation via CancellationToken, so even infinite wait can be aborted.

Also this method allows scheduler which executes current task correctly re-schedule work while current task is in waiting state. Schedules new task via the same scheduler which executes current task. If current task is cancelled then forked one is cancelled too.

All forked tasks must be awaited before current controller instance is being disposed, otherwise 'Progress is out of range' assertion is possible. Anyway when current task action completes then all non-finished forks will be forcibly cancelled.
If you need independent sub-task you should schedule it directly via scheduler. Number of parallel tasks which associated task scheduler able to run effectively. This property used along with by extension to provide effective parallel implementations of commonly used algorithms. Combines and in the single call. Schedules new task via the same scheduler which executes current task. See Schedules new task via the with lifetime bound to execution controller. Respects all semantic. Schedules new task via the with lifetime bound to execution controller. Respects all semantic. Waits for another task. If awaited task is FAILED or CANCELLED then AggregateException is thrown.
See also remarks for Waits for all specified tasks. Waits for another task with result. See remarks for Waits for event. See remarks for Waits in interruptable manner for non-interruptable action. The action is executed asynchronously on thread pool. In spite action itself is non interruptable the wait can be aborted either by execution controller cancellation or by timeout.
BE AWARE: action will continue executing even after wait aborted. Locks in interruptable manner with given timeout. using (controller.Lock(myMutex, Waitable.InfiniteTimeout)) { // do something under lock } Locks in interruptable manner with infinite timeout. The helper struct used with . Creates instance from this execution controller. Creates instance from this execution controller. Calls StartProgress(100) on provided execution controller.
Usage pattern: using (controller.AsJetProgress(out var progress)) { progress.Begin(count); for (...) { ... progress.YieldAndAdvance(); } } Creates instance from this execution controller. Calls CreateSubOperation(parentSteps).StartProgress(100) on provided execution controller.
Usage pattern: using (controller.AsJetProgress(out var progress)) { progress.Begin(count); for (...) { ... progress.YieldAndAdvance(); } } Starts approximate progress (when exact number of steps isn't known). Returns CancellationToken if implements extension interface and CancellationToken.None otherwise. Intentionally not implemented, because WaitHandle does not support CancellationToken. The simplest implementation of which:
* can not be cancelled;
* just ignore progress reporting;
* has non cancellable wait;
* execute fork action instantly and return completed task.
 Provides similarity scoring for two text/code blocks. The score is between 0.0 (totally different) and 1.0 (identical). Design goals: - Case-insensitive - Ignores whitespace differences - Some robustness to reordering (token/line based set similarities) - Sequence-sensitive component (Levenshtein) to still capture edits Compare two text blocks and return similarity in [0.0, 1.0]. Expands TimelineRange with center point point for which relative range position will be preserved ratio to increase TimelineRange Length Expands TimelineRange with center point point for which relative range position will be preserved ratio to increase TimelineRange Length Made lazy to avoid useless creation/destruction in algorithms which contract needs lifetime, but realization sometime needs and smotime not Generates tree of items from item list An event that can restore actual event args We dont use IProperty or IDataProvider here because don't want to add hard link to the event object Parent node of update is arrived. If this value is null then root node is changed. Which child we need to update. If this value is null then NewChild is added to the Node's children Node that will become replacement for OldChild. If NewChild is null then OldChild was removed from Node's children View index of the changing node relative to its parent Craete new instance Should be in range 0..1. Value 1 corresponds to 100% Flag indicating whether percent display will be aligned to the left or to the right. Difference is in display precision for values between 1 and 10%: if percents are aligned to the left, we try to preserve display width, so values will have 2 digits after separator (total width = 3 digits + 1 separator for any percent value), otherwise we try to preserve decimal separator position, so these values will have 1 digit after separator, as well as values >= 10 % 90 sec -> 30 sec 1,5 min -> 90 sec 90 sec -> 1,5 min 90,5 sec -> 90500 ms 90500 ms -> 90,5 sec Simple Rabin-Karp word matcher Flows progress events to given execution controller. Supports: extracting and saving. using (new ZipProgressAdapter(zip, totalBytes, executionController)) { foreach (var entry in entriesToExtract) entry.Extract(targetFullPath); } For lambda method returns method in which that lambda was defined, otherwise returns name untouched.