This project is read-only.

Project Description

Plugins Application Extensibility Framework (PAEF) is a new extensibility framework library in .NET designed for small .NET applications. It allows development of fast, lightweight .NET applications for multi-processor systems.


Features include:
- Isolation
- Servicing
- Asynchronous I/O
- Concurrency


Plugins Application Extensibility Framework supports:
- Loosely coupling for application's objects and services
- Activation/Deactivation for objects, hosts and services
- Load/Unload of application objects, hosts and services, and configuration
- Use of existing application's classes and interfaces


Plugins Application Extensibility Framework for the following application tasks:
- Extensibility
- Configurability
- Serialization
- Parallelism

Isolation (Application Domains)

In any complex system, a failure in a sub-part of the system has the potential of bringing down the whole system. The reason is that a partial failure can lead to a catastrophic failure if it cannot be properly isolated, detected, and handled. Loose coupling is a design pattern that often is invoked as a way of limiting the impact of partial failures. However, in order to build loosely coupled systems, each component must be isolated from all other components as well as from the underlying runtime environment.

Servicing (Interfaces)

The requirement of robustness forces applications to become compositions of loosely coupled components. This raises the additional problem of how to identify, locate, and compose such components into a running application. Most traditional systems define an application as a single process and not as a composition of loosely coupled services working together leaving the task of composition to the application designer. Plugins provides runtime support for creating, managing, deploying, and running applications that are composed of loosely coupled services.

Asynchronous I/O (Callbacks)

When communicating between loosely coupled software components, like programs running across the network, or User Interface (UI) code communicating with the user input and the file I/O subsystem, asynchronous operations enable the code to scale better, be more responsive, and deal with failure across multiple operations. Asynchronous programming however, considerably reduces the readability of user code, since logic is often split between callbacks and the code that originates the operation. In addition, it is an almost impossible task to correctly handle failure across multiple outstanding operations.

Concurrency (Threading)

Code that needs to better utilize multiple execution resources, must be split into independent logical segments, that can run in parallel, and communicate when necessary to produce results from the combined execution. Often, that logical segment is captured by the thread OS primitive, that is nothing more than a long lived iteration. Because of thread performance implications on thread startup, the thread stays active for long periods of time. This forces a particular pattern. Code is structured as long sequences that use blocking or synchronous calls, and only deals with one thing at a time. Further, threads assume that the primary communication between them is shared memory, forcing the programmer to use very explicit, error-prone methods to synchronize access to that shared memory.


Plugins Application Extensibility Framework is in development. The source available on this site. If you are downloading the source, consider it a preview of where we are at currently. I welcome any feedback you have on your experience.


All rights reserved. Copyright (c) Artur Mustafin. You can-not use this source code or any part of it in commercial applications without written permission or fee for amount of 5$ per solid copy of you product sold with parts of this library.

Last edited May 6, 2012 at 2:25 AM by hack2root, version 58