CodeFluent Entities Documentation
Overview
See Also Send comments on this topic.
CodeFluent Entities > Architect Guide > Aspect Oriented Design > Overview

Glossary Item Box

Basics

The standard application development life-cycle using CodeFluent Entities is as follows:

Those different stages can be repeated as much as needed until your application is complete.

Obviously, only the first three stages (from Modeling to Production) are in fact specific to CodeFluent Entities. On the contrary, the last three ones (from Extend to Run) are in fact standard .NET development stages and CodeFluent Entities doesn't induce anything specific at those stages. In fact, those last three stages are a sub-cycle which can be repeated as much as needed inside the global application development life-cycle. This is so because you don't have to modify the model and generate over again unless you have a structural change such as adding or modifying an entity, a rule, a property, a method, etc.

Dynamic modeling takes place on the inference stage, before any code is generated, which gives you an incredible control over the generated code. Furthermore, the inference stage includes several concepts and is detailed hereafter.

 

The Inference Stage

A CodeFluent Entities model is a bunch of XML files which are parsed and from them a meta-model will be inferred: XML nodes you defined (e.g. <Product>) will become CodeFluent Entities concepts such as Entities, Enumerations, Producers, etc. which themselves are in fact more global concepts as nodes, and attributes. Therefore, we can say CodeFluent Entities' models are composed of three levels:

In a nutshell, Mx corresponds to the XML and is parsed, whilst M² and M³ are inferred from Mx.

Dynamic modeling occurs throughout the inference stage, therefore aspects can work on Mx and other meta-models (M², M³). Furthermore, model inference is divided into ten steps, and aspects can modify the model at any step, influencing next steps. Those ten steps is what we call the inference pipeline.

 

The Inference Pipeline

When CodeFluent Entities loads a model, it starts building the M³ and M² levels in memory and this is done through several steps, the whole being referred to as the inference pipeline.

The pipeline is composed of the following steps, occurring in the following order:

Step Description
Start  
Hints Creation of hints
UserTypes Creation of new user defined types
ProjectTypes Creation of project types (entities, properties, methods, etc.)
Tables Creation of persistence tables
Methods Creation of methods
PersistenceViews Creation of persistence views
Procedures Creation of persistence stored procedures
Categories Creation of display categories
UI Creation of user interface
Messages Creation of messages
End

 

You can plug-in at any of those steps in order to modify the model, and more importantly changes made at a step will be taken into account on the next step. For instance, if you add an entity in the meta-model at the ProjectTypes step, the equivalent tables, methods, views and so on will automatically be inferred from it. Likewise, if we plug-in at the Tables step, we can add a new platform independent table however, a corresponding entity won't be inferred since entities were inferred on the previous step.

In the end, aspects will enrich the model using the CodeFluent Entities R/W API while being loaded into memory.

 

The CodeFluent Entities API

Using the API (CodeFluent.Model.dll) you can access all levels (Mx, M², M³) of the model:

Note: The CodeFluent Entities API is discussed with more details in the following article: The CodeFluent Entities API.

Moreover, CodeFluent Entities' schema isn't restrictive. This means that you can add your own XML namespace in your model to add extra attributes, and then access those custom attributes in your aspect.

 

Points of interest

Key points regarding aspects are that they allow live interaction with the model while CodeFluent Entities is building it in memory. Therefore, this allows you to apply massive changes to a model such as adding properties, methods, rules, and so on to all entities.

Moreover, SoftFluent provides out-of-the box aspects which are shipped along with the product. Importing those aspects in your projects will add functionalities such as data localization or Google-like search to your application.

Finally, you can develop your own aspects so that features such as tracking, Row Level Access Security or multi-tenant support are externalized from your model and can be reused in all your desired projects. Doing this truly industrializes your developments: you invested the time to develop such a feature only once and you can now use it as much as needed wherever you like it.

See Also