Namespace PostSharp.Patterns.Threading

Base class for ReaderAttribute, WriterAttribute, YielderAttribute, and UpgradeableReaderAttribute.

Custom attribute that, when applied to a class, applies the ActorThreadingModel to this class. In this model, calls to methods are processed asynchronously by a single thread, which suppresses concurrency inside each instance of the target class.

A dispatcher compatible with the ActorThreadingModel threading model, with a message queue based on a ConcurrentQueue. The queue itself is processed from the ThreadPool.

Custom attribute that, when applied to a type, means that the type should be assumed to be immutable. The custom attribute can be applied to a type on assembly level by specifying the Type property using the AssumeImmutableAttribute(Type) constructor.

Custom attribute that, when applied to a method, causes the method to execute in the background. This aspect can be applied to a method with void or Task return type.

Defines helper methods to work with CancellationToken.

Provides methods to create new instances of concurrency controllers.

Exception thrown when two threads simultaneously attempt to execute methods of an object whose class is annotated with the ThreadUnsafeAttribute custom attribute.

Custom attribute that, when applied to a method, specifies that the method should be executed in the UI thread.

Provides implementations of the IDispatcher interface.

Custom attribute that, when applied to a private or protected instance method, causes all threading model aspects (derived from ThreadAwareAttribute) to treat the method as an entry point, like a public method.

Custom attribute that, when applied to a method or field, specifies that threading model aspects (derived from ThreadAwareAttribute) should ignore all verifications for this field or method.

Custom attribute that, when applied to a class, applies the FreezableThreadingModel to this class. The aspect introduces the IFreezable interface into the target class. After the Freeze() method has been invoked, the object can no longer be modified, and can therefore be safely shared between several threads.

Custom attribute that, when applied to a class, applies the ImmutableThreadingModel to this class. The aspect introduces the IImmutable interface into the target class. Immutable objects cannot be modified after the constructor exits.

Exception thrown by objects that have the FreezableThreadingModel or ImmutableThreadingModel when an attempt is made to modify the object after it has been made read-only.

Custom attribute that, when applied to a class, applies the PrivateThreadingModel to this class. In this model, the threading model of an object is determined by the parent it is assigned to in a parent-child relationship.

Base class for aspects FreezableAttribute and ImmutableAttribute.

Custom attribute that, when applied to a method, specifies that the method requires read access to the object.

Custom attribute that, when applied to a class, applies the ReaderWriterSynchronizedThreadingModel model to this class and all derived classes. Members of this class must then be annotated with attributes specifying the required access level (ReaderAttribute, WriterAttribute, YielderAttribute or UpgradeableReaderAttribute), otherwise build-time and run-time errors are emitted.

Custom attribute that means that the async method to which it is applied can be safely re-entered on each await statement. For lock-based models, it means that the lock is released while awaiting. For the actor model, it means that other methods can be invoked during awaiting.

Custom attribute that, when applied to a field, property or parameter, checks that the assigned object is thread-safe. Otherwise, the assignment results in an ArgumentException.

Custom attribute that, when applied to a class, applies the SynchronizedThreadingModel to this class. In a synchronized object, only a single thread can access the object at a time. If a second thread needs to access the object while it is in use by a first thread, the second thread has to wait until the first thread completes its access.

Exception thrown when the calling thread does not have access to the object.

Custom attribute that, when applied to a type, ensures that instances of this type can only be accessed by the thread that created the instance. When a different thread accesses instances of this type, a ThreadMismatchException is thrown.

Base class for all aspects implementing threading models.

Provides extension methods for the IThreadAware interface.

Exception thrown when a thread attempts to access an object that has affinity to another thread.

When applied to an assembly, this policy will check for possible concurrency issues.

Custom attribute that, when applied to a type, ensures that only one thread executes in methods of this type. When more than one thread accesses methods of this type, a ConcurrentAccessException is thrown.

Base class for exceptions thrown by the PostSharp.Patterns.Threading component.

Base class for all threading models. Defines properties that describe the characteristics of threading models. All classes derived from ThreadingModel are necessarily singletons.

Enumerates the aspect roles (for use with AspectRoleDependencyAttribute) used by the PostSharp.Patterns.Threading component.

Exposes methods to work with the PostSharp.Patterns.Threading namespace.

Provides data for the UnhandledException event.

Custom attribute that, when applied to a method, specifies that the method requires read and write access to the object, but other threads are allowed to acquire read (but not write) access to the object until a method with the WriterAttribute custom attribute is executed.

Provides access to the WPF Dispatcher without a direct dependency on WindowsBase.dll. The dispatcher is found only if WindowsBase.dll is already loaded into the AppModel by another assembly.

Custom attribute that, when applied to a method, specifies that the method requires write access to the object.

Custom attribute that, when applied to a method, specifies that the method that currently holds write access to the object (see WriterAttribute) allows other threads to read the object during the execution of the target method. This custom attribute is typically used on methods that raise events that must be processed synchronously by other threads.

A disposable cookie returned by WithConcurrencyController(IConcurrencyController).

An awaiter for the AcquireAccessAsync(ObjectAccessLevel) method. The struct implements both the Awaiter and Awaitable contracts.

A token returned by the AcquireAccess(ObjectAccessLevel, ref ConcurrentAccessToken) method. This token is intended to be used in a using block. Consumers of this method must call Complete() on success, and Dispose() on exception.

Interface implemented by the ActorAttribute aspect.

Specific definition of the IConcurrencyController for the ActorThreadingModel.

Augments the IDispatcher interface with an Initialize() method, which is invoked after the actor constructor has been invoked.

Controls access to an entity from possibly several threads.

Defines the semantics of a facility that executes actions synchronously or asynchronously, possibly on a different thread.

Interface implemented by objects whose access to methods is controlled by a Dispatcher.

Interface implemented by the FreezableAttribute aspect. Defines a Freeze() method.

Interface implemented by the ImmutableAttribute aspect.

Interface implemented by objects that are aware of concurrency. Access to thread-aware objects is controlled by a concurrency controller (IConcurrencyController). Any aspect implementing a threading model (ThreadAwareObjectAttribute) introduces this interface to the target class and ensures that accesses to this class go through the controller.

Specifies whether the caller of a dispatched method (see DispatchedAttribute) waits for the called method.

Specifies the components that can raise the UnhandledException event.