Posts Tagged ‘Model-First’

CodeFluent Entities and Syncfusion for an amazing application!

April 15, 2013 1 comment

When applications are beautiful, fast and robust at the same time, we qualify them as amazing. If you think it also means a long development process, then you have not seen applications using both SoftFluent and Syncfusion products altogether!

SoftFluent and Syncfusion have partnered to help you build these amazing applications in no time.  CodeFluent makes the application highly functional, while Syncfusion makes the application interface elegant and user-friendly.

CodeFluent Entities is a unique product integrated into Visual Studio which allows developers to generate database scripts, code, web services and UIs in the Microsoft .NET platform. The code generation process is model-first and continuous: from your declarative model, a meta-model will be inferred which code generators will then translate into code. Over 20 code generators (a.k.a. producers’) are provided out of the box and can be combined to create your own application following your desired architecture, using your desired technologies.

Syncfusion, Inc. provides the broadest range of enterprise-class software components and tools for the Microsoft .NET platform. With Syncfusion, developers can move beyond simply coding applications to delivering real business innovation—the elegant user interfaces, business intelligence dashboards, and sophisticated reporting that today’s business users need, in the formats they demand.

Whether you need to build applications with WinForms or WPF, or websiteswith WebForms or MVC, SoftFluent and Syncfusion provide all the necessary tools to help you.

To show you how it works, we built a full application using CodeFluent Entities and Syncfusion components. With Visual Studio 2012, we have created a WPF application that consumes web services to communicate with an SQL Server 2008 database. The database we used is a sample database of Microsoft SQL Server, called AdventureWorks.


The application can be created in five steps:


1. CodeFluent Entities project

Create a CodeFluent Entities project in Visual Studio 2012. You also need a class library project that contains the business-object model, a class library project (Proxy) that contains your web service contracts, and the WPF application.


2. Import the AdventureWorks database

If you right-click on the CodeFluent Entities project, you will have the option to import an existing database or model as you can see on the screenshot below.


Then follow the instructions to import the AdventureWorks database.


3. Set up the producers

Once the database has been imported, you can view the visual model inside the CodeFluent Entities project (Surface > Default) as you can see here:


Now that you have your model, you need to add producers. These producers are responsible for generating code for your application.

The first producer is the BOM (Business Object Model) producer, which corresponds to the business logic. The code generated will be classes for each entity of your model. This code is exceptionally readable and can be customized using partial classes, if needed. Also, this producer contains a sub- producer responsible for generating services.

The second producer is the SQL producer responsible for generating SQL scripts, such as tables, views, and stored procedures.

The third producer is the WPF ClickOnce Smart Client, which is responsible for generating UIs. These UIs are generated using templates, located in the CodeFluent Folder. We will discuss this in more detail later.

The fourth producer is the Template, responsible for creating a host for the web services.

The fifth producer is the Command Line Execution producer, responsible for running a batch file that will insert data in your database.



4. Generation

The model is ready to be generated. In a single click, the CodeFluent Entities project will load your model in memory, and run each of the producers to generate ASP.NET code (C# in this example), SQL scripts and WPF controls. The application is almost ready to run. The last steps are to:

  1. Set up the connection string in your WPF application.
  2. Set up the application that hosts the web services to run at the same time as the WPF application.

That is all you need to do in order to run the application! When you launch the application, you will have a list of all entities, and you will be able to manipulate the data of these entities with generic methods such as load, load all, update, delete, and save. Each of these actions will consume the web services that are being hosted in the other application.


5. SyncFusion Components

The full running application uses standard ASP.NET controls for your WPF application. Though these components are functional, they are not always the best-looking ones. This is where Syncfusion comes in to transform a functional application into an amazing application.

CodeFluent Entities generates reusable controls for the application, so that one control can be used in several pages. As a result, the work consists in updating these ASP.NET standards controls by using Syncfusion controls, to end up with a highly functional and beautiful application:


Interface displaying the list of departments



Interface displaying the edition of a department in a popup



Interface displaying the edition of the SalesTerritory field that corresponds to a list prefilled with a related entity


Using the power of CodeFluent Entities to generate functional applications quickly, and the power of Syncfusion’s beautiful components, you can create amazing applications in no time.


6. Unlimited possibilities

To go further with CodeFluent Entities and Syncfusion integration, you can reuse Syncfusion components in other applications at no cost. Indeed, CodeFluent Entities uses templates to generate components, such as the view page, the edit form and so on. These templates are available in the CodeFluent folder (where it was installed, usually in \CodeFluent\Modeler\Templates\SmartClient).

Extremely simple to read and to understand, these templates can be modified to produce pages with custom components, such as the ones provided by Syncfusion. By doing so, each CodeFluent Entities project can reuse these templates to produce amazing applications. Although you have developed a WPF application in this example, you can do the same with all other types of applications, such as WinForms, WebForms, MVC, mobile or any combination of these technologies.


If you want to download the sample project demo please click here:

CodeFluent Entities: Writing a custom aspect

July 27, 2012 1 comment

In the previous post, we’ve seen that CodeFluent Entities infers a meta-model from our model and that we could interact with this meta-model to apply application wide changes. In this post we’ll see how Smile

Step 1: Writing your aspect

As an example we’ll write an aspect which will add a “IsDeleted” property on all entities by default.

First of all, we added a new class library project named “Demo.Aspects” to our solution and added the following references: CodeFluent.Model.dll,  CodeFluent.Model.Common.dll and CodeFluent.Runtime.dll. Aspects can either be written in XML or in .NET. In my opinion, it’s easier to start writing aspects in .NET as you’ll have Visual Studio’s IntelliSense which will help you out using the API.

In practice, an aspect is a class implementing the IProjectTemplate interface. This interface contains a single method “Run” which takes as a parameter a “context”.

Here’s a sample implementation:

using System.Collections;
using System.Xml;
using CodeFluent.Model;

namespace Demo.Aspects
    public class MyAspect: IProjectTemplate
        public static readonly XmlDocument Descriptor;
        public const string MyAspectNamespace = "";

        static MyAspect()
            Descriptor = new XmlDocument();
@"<cf:project xmlns:cf='' defaultNamespace='MyAspect'>
    <cf:pattern name='My Aspect' namespaceUri='" + MyAspectNamespace + @"' preferredPrefix='mya' step='Tables'>
        <cf:message class='_doc'>This is some description for our custom aspect.</cf:message>
        <cf:descriptor name='enable'
            category='My Custom Aspect'
            displayName='Add the MyCustomProperty'
            description='Description for our custom descriptor.' />

        public XmlDocument Run(IDictionary context)
            if (context == null || !context.Contains("Project"))
                // we are probably called for meta data inspection
                return Descriptor;

            // the dictionary contains at least these two entries
            XmlElement element = (XmlElement)context["Element"];
            Project project = (Project)context["Project"];

            foreach (Entity entity in project.Entities)
                Property property = new Property();
                property.Name = "IsDeleted";
                property.TypeName = "bool";

            // we have no specific Xml to send back, but aspect description
            return Descriptor;

The method returns a XmlDocument which is described above as a string. It could also be written on a separate file.

As you can see this XML defines the aspect’s name, its XML namespace, and how it extends the CodeFluent schema (here it adds a “mya:enable” attribute on entities, whose default value is false).

Step 2: Using your aspect

Compile the “Demo.Aspects” project.

In the solution explorer, select the “Aspects” folder and click “Add Existing Aspect…”. Browse for our Demo.Aspects.dll that we created previously and here’s what you should see:


Great! As you can see, information returned by our descriptor is properly parsed and displayed Smile

Hit OK, and now by default all your entities should have an extra “IsDeleted” property added when the model is inferred, which means that a “IsDeleted” column will be created for all tables, all stored procedures will be updated to include this column, and it’s the same in the middle tier and the UI tier. You can view this by clicking on the “View Inferred Model” button available in the ribbon:


Useful Links

Hope this helps,

Carl Anderson

CodeFluent Entities: Basics, meta-model and aspects

July 26, 2012 Leave a comment

CodeFluent Entities is a product integrated into Visual Studio 2008/2010/2012 which allows developers to generate components such as scripts (e.g. T-SQL, PL/SQL), code (e.g. C#, VB), web services(e.g. WCF, ASMX) and UIs (e.g. ASP.NET, SharePoint, WPF).

The code generation process is model-first and continuous: from your declarative model, a meta-model will be inferred which code generators will then translate into code. Over 20 code generators (a.k.a. “producers”) are provided “out of the box” and can be combined to create your own application following your desired architecture, using your desired technologies.


figure 1 

Figure 1 is in fact a little too simple: as mentioned earlier, producers don’t translate your model into code right away, instead a meta-model will be inferred first. This meta-model consists of of a ‘virtual’ persistence layer, a ‘virtual’ business object model and a ‘virtual’ user interface. By ‘virtual’ I mean that it’s all in-memory and that’s not actual code yet.


figure 2

You can actually view those virtual bits using the Meta-Model Explorer (CodeFluent.View.exe) or by clicking on the “View Inferred Model” button of your project tab in Visual Studio:


figure 3

Producers will then translate those virtual bits into actual scripts, code, web services and UIs.

This meta-model is the key. Thanks to it, before anything gets generated, CodeFluent Entities can ensure that your application is consistent and that it will all compile.

Furthermore, CodeFluent Entities provides what we call “CodeFluent Aspects” (formerly known as “CodeFluent Patterns”) which allow you to interact with this inferred meta-model and dynamically change it.

A set of built-in aspects are provided out-of-the-box but you can also create your own aspects. For instance, one could create an aspect that automatically adds tracking properties on all entities marked as “trackable”. It’s all done at generation time and can turn out to be very handy when working on big models and/or to externalize a feature that you have to implement often from one project to another.

More on this subject in a forthcoming post!



Carl Anderson

CodeFluent Entities: new ASP.NET Web Site Web Forms Template sneak peek

July 25, 2012 2 comments

A brand new ASP.NET Web Site Producer (v2) is shipped in alpha in the latest build available (666 and upper).

As mentioned in our Web Platform Roadmap post, this new producer will be shipped with three templates:

Here’s a sneak peek of what gets generated when using this new template (codename: “Airport”) Smile

The homepage generated by default lists all namespaces and their contained entities:



Clicking on an entity gets you to the entity page:


On this entity page you’ll find a screenshot of the entity from which this page was generated.

On the left side of the page you’ll find a list of actions available on this entity. Those actions correspond in fact to business methods provided by the entity:



Unlike the Ajax/JSON template which consumes WCF JSON services, the ASP.NET Web Forms template is built directly on top of your generated .NET Domain Model, skipping this service layer. Yet, the generated .NET Domain Model (a.k.a. .NET Business Object Model) is not specific to ASP.NET and the exact same object model can be used from any other .NET technology such as SharePoint, WinForms, Console applications, services, etc.


Any feedback? Share them on this blog, on our forums or on our Facebook page!


Carl Anderson

CodeFluent Entities: How to reuse existing stored procedures

July 13, 2012 Leave a comment

In this post I’ll start from the NerdDinner application, which you can get from CodePlex ( In the NerdDinner database I added the following sample stored procedure named “sp_SelectDinnersByCountry” that takes a county name as a parameter:

CREATE PROCEDURE [dbo].[sp_SelectDinnersByCountry] 
     @Country [nvarchar] (50)
    FROM Dinners 
    WHERE Country = @Country

From there, I then imported the NerdDinner database into a brand new CodeFluent Entities model (as detailed on CodeFluent Entities’ Get Started page) and now what I want to do is to reuse my existing stored procedure, instead of creating a new one using CFQL.

Select the “Dinner” entity and add the following new method:


Now that our method is created we need to specify:

  • it’s name in the persistence layer as my stored procedure has a different name than the one in my model,



  • it’s return type (by default raw methods are void),



  • mark my method so it’s not generated by the SQL Server Producer,



As a consequence the Business Object Model Producer will generate a SelectByCountry method, which calls the sp_SelectDinnersByCountry stored procedure, and returns a DataSet, so now in my app I can do something like this:

System.Data.DataSet ds = Dinner.SelectByCountry("FRANCE");


Hope this helps,


CodeFluent Entities: Saving import configurations

July 11, 2012 1 comment

Using CodeFluent Entities you can import existing databases (Access, SQL Server, SQL Server CE, Oracle, MySQL, PostgreSQL) or existing models (Enterprise Architect, XMI, ADO.NET Entity Framework) into CodeFluent Entities models. The idea behind this import feature is that you’ll import your existing line of business once (see the Importers category for more info on this) and then drive your developments from your CodeFluent Entities model, as CodeFluent Entities is a model-first tool.

Recently we added the possibility to save and load import configurations so you can keep your settings and work on your import over and over again until the model imported tastes good.

For instance, let’s create a brand new blank model that we’ll name Northwind.Model and which will be a CodeFluent Entities version of Microsoft’s sample Access 2010 database Northwind.


Right-click and on your project and select “Import an Existing Database or Model…”, select the Access importer, configure it, hit next, next, next and you should get to this screen:


By saving it, we’ll be able to run this import with the exact same configuration without having to configure everything over again.

For instance, by importing the Northwind sample database for Access 2010 keeping the default settings, we get a String table which I don’t want in my .NET application.

Let’s delete all my entities in my model and import over again using the same import configuration (MyImportConfig.cfi):


Once this is done, let’s customize our import settings and specify in the “Table Full Name Filters” the “String” table name that we want to skip:


Let’s save our new config and import over again, tadaaaa, no more String entity:



Carl Anderson

CodeFluent Entities: Multiple surfaces, multiple parts

June 20, 2012 Leave a comment

As discussed in the “What is a CodeFluent Entities model?” post, CodeFluent Entities projects contain:

  • surfaces, which are graphic views of your model,
  • XML parts, which are storage units.

By default, when creating a new project, you have a single surface named “Default” and a single model part named <DefaultNamespace>.cfp which will both contain all your entities:



In the screenshot above you can tell that I have several namespaces, let’s say I want to chunk my model up, so I have one surface per namespace in addition to my default surface. Select the Surfaces folder, and create a new one, you’ll see that a dialog pops-up letting you choose which concepts you want to import:



Here’s the result after repeating this logic for each of my namespaces, isn’t it a lot more readable?!



Yet, all entities are still stored in the same, unique, model part “AdventureWorksReloaded.cfp”, making it hard to work collaboratively (doing edits on any of my surfaces would automatically check-out the AdventureWorksReloaded part as all entities are stored in this one).

This again can be changed: select a namespace and from the property grid, switch the default part to a new part.




If I do this for all my namespaces, in the end my main part will just contain project level settings, producers and import other parts:



Organizing my CodeFluent Entities project this way, each developer can be in charge of a functional namespace and work in his scope without stepping on someone else’s shoes.

Finally, you could even go one step further by enabling the “Create One Part Per Type” option which creates one part per entity or enumeration:



Not only is this a very handy option when collaborating on the same source-controlled model, but you can also get great performances on big models as it avoids to have one big XML file containing all your project.


Hope this helps,

Carl Anderson