Namespace NFX.Wave

Classes

CompositeWorkMatch

Matches work context using AND and OR branches of composite matches

ExceptionMatch

Used for matching of exceptions passed to Make(context)

HttpResponseStatusCodeMatch

Matches by Work.Response.StatusCode. The match makes sense in the After processing - when status is already set

HTTPStatusException

Thrown to indicate various Http status conditions

MVCActionException

Wraps inner exceptions capturing stack trace in inner implementing blocks

MVCException

Base exception thrown by the MVC-related framework

NotAuthorizationExceptionMatch

Used for matches to bypass AuthorizationExceptions, requires EXCEPTION passed in Make(context)

Portal

Represents a web portal that controls the mapping of types and themes within the site. Portals allow to host differently-looking/behaving sites in the same web application

Portal hub - a registry of portals, It establishes a context for portal inter-operation (i.e. so one portal may locate another by name) when some settings need to be cloned. This is an app-started singleton instance class

Response

Represents Response object used to generate web responses to client

SysConsts

Non-localizable constants

Theme

Represents a portal theme. Theme groups various resources (such as css, scripts etc..) whitin a portal. Do not inherit your themes from this class directly, instead use Theme(TPortal)

Theme<TPortal>

Represents a portal theme. Theme groups various resources (such as css, scripts etc..) whitin a portal. Inherit your themes from this class

URIPattern

Represents a URI pattern that can get matched against URI requests. The pattern is formed using regular URL grammar and captures segments denoted by "{}". Example: '/profiles/{controller}/{action="dflt value"}/{*params}' The class uses CSharp lexer, so it allows to use string escapes and unicode chars like CSharp

WaveException

Base exception thrown by the WAVE framework

WaveServer

Represents "(W)eb(A)pp(V)iew(E)nhanced" web server which provides DYNAMIC web site services. This server is not meant to be exposed directly to the public Internet, rather it should be used as an application server behind the reverse proxy, such as NGINX. This server is designed to serve dynamic data-driven requests/APIs and not meant to be used for serving static content files (although it can). The implementation is based on a lightweight HttpListener that processes incoming Http requests via an injectable WorkDispatcher which governs the threading and WorkContext lifecycle. The server processing pipeline is purposely designed to be synchronous-blocking (thread per call) which does not mean that the server is inefficient, to the contrary - this server design is specifically targeting short-called methods relying on a classical thread call stack. This approach obviates the need to create surrogate message loops/synchro contexts, tasks and other objects that introduce extra GC load. The server easily support "dangling"(left open indefinitely) WorkContext instances that can stream events (i.e. SSE/Server Push) and WebSockets from specially-purposed asynchronous notification threads.

WaveSession

Represents a session in a WAVE server application

WaveTemplateRenderingException

Wraps WAVE template rendering execptions

WorkContext

Represents a context for request/response server processing in WAVE framework

WorkDispatcher

Represents a default dispatcher that dispatches WorkContext calls on the same thread that calls Dispatch(work). May extend this class to implement custom dispatchers, i.e. the once that maintain their won work queue/worker threads

WorkFilter

Represents a base for all work filters. Unlike handlers, filters do not necessarily handle work rather augment the work context

WorkHandler

Represents a base for all work handlers. Handlers are final work execution destination

WorkMatch

Decides whether the specifies WorkContext matches the requirements specified in the instance. The match may consider Request and Items properties of work context for match determination. Work matches do not belong to particular handler or filter, so they ARE STATELESS and their instances can be used by multiple different processors (i.e. handlers and filters).