A
Aspect-Oriented
 
B
Bloggers
Build Systems
 
C
CMS
Cache Solutions
Charting & Reporting
Chat Servers
Code Coverage
 
D
Databases
 
E
ERP & CRM
 
F
Forum Soft
 
G
Geospatial
 
I
IDEs
Installers
Inversion of Control
Issue Tracking
 
J
Job Schedulers
 
L
Logging Tools
 
N
Network Clients
Network Servers
 
P
PDF Libraries
Persistence
Portals
Profilers
Project Management
 
R
RSS & RDF Tools
Rule Engines
 
S
SQL Clients
Scripting Languages
Search Engines
Security
Source Control
 
T
Template Engines
Testing Tools
 
U
UML & Modeling
 
W
Web Frameworks
Web Mail
Web Services
Web Testing
Wiki Engines
Workflow Engines
 
X
XML Parsers
 

Open Source Aspect-Oriented Frameworks in C#

Runtime Assembly Instrumentation Library

This project plans to implement an API that allows CLR assemblies to be manipulated and instrumented before they are loaded and executed. In the CLR, the AppDomain class and the ResolveEventHandler event handler already provide an excellent mechanism for dynamically loading assemblies into an application domain under the control of the programmer. At the same time, the reflection capabilities of the CLR are extremely powerful. Not only it is possible to query the existing types at runtime, but is also possible to define new assemblies in memory and use Reflection.Emit to generate MSIL on-the-fly. Our plan is to fill the gap between these two concepts. The idea is to have an API that allows the programmer to intercept the class resolution process, examining and manipulating the code that exists in an assembly, before the code is actually defined on the virtual machine. This API will be called RAIL: Runtime Assembly Instrumentation Library. By using RAIL it will be possible to specify specific transformations that must be done at an assembly before it is loaded and executed. These transformations will be specified using a high-level API, abstracting the programmer from the low-level details of MSIL and the assembly binary format. For instance, it will be possible to substitute the references to a class for references to another class, change the name and usage of constants and variables, examine and change existing methods, and so on.

Go To Runtime Assembly Instrumentation Library

Gripper-LOOM.NET

Gripper-LOOM.NET is the newest member of the LOOM.NET weaver family. It is based on the Rapier-LOOM.NET weaver library, but allows the weaving to happen statically before runtime by a command line utility, therefore making the result of the weaving process permanent. It operates on binary .NET assemblies and is therefore not restricted to C# (as AspectJ is restricted to Java) but applicable to all .NET languages. The syntax for defining aspects is very similar to the syntax used by Rapier -LOOM.NET. However, Gripper-LOOM.NET overcomes some of the limitations of the dynamic weaver: For instance the weaving of methods is not limited to virtual calls.

Go To Gripper-LOOM.NET

NKalore Compiler

NKalore is a programming language that extends C# allowing the use of AOP in .net platform. NKalore have a simple and intuitive syntax. The NKalore compiler is based in the Mono C# Compiler (MCS), currently NKalore can only be used via command line or within #Develop. NKalore generates assemblies compatibles with CLS (Common Language Specification) which can be used by any .NET IDE, including Visual Studio .NET.

Go To NKalore Compiler

AspectSharp

Aspect# (pronunced as AspectSharp) is a free AOP ( Aspect Oriented Programming ) framework for the .NET Framework, it uses Dynamic Proxies and XML configuration files as basis.

Go To AspectSharp

NAop

AOP.NET (NAop) is an Aspect Oriented Programming (AOP) framework for .NET framework

Go To NAop

AspectDNG

AspectDNG is a .NET multi-language aspect weaver. Aspects and base code may be written in any programming language, as soon as it compiles into MSIL.

Go To AspectDNG

SetPoint

SetPoint is a full-featured AOP engine for the .NET framework. It heavily relies on the use of RDF/OWL for the definition of what we call "semantic pointcuts". It features an IL-level, highly dynamic weaver & LENDL, an eye-catching definition language...

Go To SetPoint

PostSharp

PostSharp reads .NET binary modules to an object model, let plugins analyze and transform it, then writes it back to MSIL. Using PostSharp, coding algorithms for static program analysis or program transformation shall be considerably faster. Examples of possible applications are tracing, caching, security, compile-time detection of null reference access, ...

Go To PostSharp

Encase

Encase is an aspect oriented programming framework for the .NET Platform written in C#. Encase is unique in that it provides aspects to be applied during runtime in managed code rather then being configuration file based that other AOP frameworks rely upon. The advantage of applying aspects in this way is that it promotes productivity to developers new and/or unfamiliar with AOP. Encase and Encase.Extensions is both currently in early development – please contact me if you would like to participate in development or if you identify features that would be beneficial.

Go To Encase

Rapier-LOOM.NET

Rapier-LOOM.NET is a dynamic aspect weaver. It provides its functionality through an assembly which has to be linked to your .NET project. Aspect weaving happens during runtime. This tools has been developing by the LOOM.NET project. The LOOM.NET project aims to investigate and promote the usage of AOP in the context of the Microsoft .NET framework.

Go To Rapier-LOOM.NET