CodeFluent Entities

What's new in CodeFluent Entities 2012

• New Feature: Support for Visual Studio 11 Beta.
• New Feature: Support for CTRL+A has been added to the Method Editor form.
• New Feature: Implements and SetImplements rules are now supported at project level by the BOM producer.
• New Feature: Added Transaction Rule support for methods other then Save and Delete.
• New Feature: Support has been added to the Visual Studio Integrated modeler for custom aspects compiled in .NET assemblies.
• New Feature: Enumeration declaration now supports named values.
• New Feature: Added support for SQL Server 2012.
• New Feature: Added non Latin character support to CFQL.
• Bug Fix: Source Control "Get Latest" command on CodeFluent Entities projects is broken.
• Bug Fix: Template Producer does not update the list of generated files for target projects.
• Bug Fix: Expressions in view properties may be incorrectly inferred by the inference engine.
• Bug Fix: Expressions in views using multiple relations with the same entity may be incorrectly inferred by the inference engine.
• Bug Fix: Methods with the same name result in service operations with the same name.
• Bug Fix: Expressions in view using many-to-many relation may be incorrectly inferred by the inference engine.
• Bug Fix: The OnCollectionChanged event is not raised if a generated SCOM collection is empty.

CodeFluent Entities is a software factory.
A software factory is an industrialization software which applies manufacturing techniques and principles to software development to mimic the benefits of traditional manufacturing. Most software developments can be compared to a hand-crafted work which implies that the ratio development effort / produced software is dramatically lower than an industrialized production. In hand-crafted development, the craftsman will develop their feature from scratch each time which results in wasted time. This is a commonly known issue, and a common wayt to address it is by developing frameworks. Instead of developing the feature again and again throughout projects, the feature is made generic and included in a framework so that this feature becomes reusable. Even though this approach is more productive in the long term than hand-crafted development, it creates, in the long term, possibly huge, hard to maintain and hard to evolve frameworks. Moreover, in scenarios where a software development needs one precise feature of the framework, it will have to drag the whole framework to benefit from the single given feature.

Another solution to tackle the software productiveness issue, is the software factory development mode. A software factory is a piece of software or a software product line which allows developers to industrialize software development based on a software schema. In this case, CodeFluent Entities is a model driven software factory which, based on a model describing an application will produce 100% functional components. To get back to the example, the feature is provided by the software factory which, if defined in the model, will be produced in the output software. This way, software development is industrialized, assuring shorter development cycles, higher quality, and avoids dragging complex and/or large frameworks since only the desired features are used.

CodeFluent empowers you with an end to end solution for generating fully functional components starting from an XML model describing your business application.

CodeFluent brings the following features:

Model-Driven Software Factory

Modular Target Architectures Support

• Allows multi-architecture without additional cost
• Rich client (client/server architecture)
• Web ASP.NET application (n-tier architecture)
• Web SharePoint application (n-tier architecture) - Ultimate Edition Only
• Smart Client application (n-tier architecture)
• SQL server persistence
• Oracle persistence - Ultimate Edition Only

Integrated template engine

• Code generation for text based languages
• Template caching for an increased generation performance
• 100% reusable template engine
• Integrable as an MsBuild Task
• Exclusive Microsoft's RTF support. Allows direct Microsoft Word (all versions) editing for creating reports templates

Internationalization

• Dynamic localization of properties in the persistence layer
• Multilingual ready for all parts of the application
• .NET standard resource model support

Migration scenarios

• Database importer for existing SQL Server databases
• Database importer for existing Access databases. Existing OLEObject are exported and transformed into CodeFluent blobs.
• Database importer for existing Oracle Server databases*
• Database importer for existing OLEDB Server databases (if the OLEDB provider supports the OLEDB schemas interface)
• Database importer for existing SQL Compact Edition databases
• Sparx Systems Enterprise Architect importer for existing UML projects (not yet available, please contact us for more information)

Tooling

• Client Console
• MSBuild integrable with a provided Task
• Microsoft Visual Studio 2003, 2005, 2008 integrable
• Easy preprocessing on the CodeFluent Xml model
• Generated files are easily debuggable for an increased productivity (Reflection mechanism is not used)
• CodeFluent is itself a 100% reusable API

Persistence and Storage Layer

Persistence

• Microsoft SQL Server 2000, 2005, 2008
• Oracle 10g+  (requires a separate license)
• Customizable naming convention for tables and stored procedure generation
• Automatic generation of tables
• Automatic generation of stored procedures, including custom ones Automatic generation of keys (primary, secondary, foreign)
• Automatic generation of indexes
• Automatic generation of views
• Automatic generation of schemas
• Automatic generation of dynamic server side SQL for multi criteria search procedures
• Manual (ADO.Net) or implicit (TransactionScope) transaction support
• Integrated concurrency management (RowVersion) for easier disconnected mode or SOA support
• RowGuidCol support in SQL Server for replication scenarios
• Automatic stored procedure generation using integrated CFQL query language
• Database differential engine for continuous generation and build support (SQL Server only)

Object-Relational Continuity

• Support for standard relational patterns (1:M, M:1, M:M relations, inheritance, associations)
• Extensive keying support (Guid, integer, strings, entities, composite keys)
• Fully hierarchical model (including relationships generation)
• Integrated query language ("CFQL") for easy custom stored procedure generation, independent from the target relational database system
• Automatic Binary Large Object (file, document, images, videos...) easy handling, with streaming
• Automatic paging support (client and server)
• Automatic sorting support (client and server)
• Automatic generation of LINQ to SQL attributes, if needed
• Persistence code is not generated dynamically, to ease debugging nd favor testability of the solution

Middle-Tier Layer

Business Object Model Layer

• Support for standard OOP patterns (collections, generics, inheritance)
• Fully hierarchical model (including relationships generation)
• CodeDom Generation (supports C#. Please contact us for VB.Net)
• Lightweight entities (struct and views) support
• Automatic caching support
• Support for Winforms automatic binding (INotifyPropertyChanged, IBindingList, IList)
• Support for WPF automatic binding (INotifyPropertyChanged, INotifyCollectionChanged, IBindingList)
• Support for Winforms and WPF 3.5 automatic validation (IDataErrorInfo)
• Support for ICloneable, IComparable, IEquatable, IList, ICollection, IDictionary and their generic equivalent interfaces
• Full service layer (WCF) support
• Full XML serialization (XmlSerializer) support
• Property validation support (StringValidate, RegularExpressionValidate, CompareValidate, ObjectValidate, CustomValidate, ...), with error collections, and specific end-user oriented and localizable messages
• Generated model extensible with partial classes or snippet code integrated in the model
• Custom external business rule integration
• Integration of ILOG Rules for .NET as a business rule engine
• Integration of custom .NET Assemblies as a business rule engine
• Integration of script engines (VBScript, JScript, ...) as a business rule engine
• Not based on .NET Framework Reflection mechanisms
• No base class needed

Service Object Model Layer

• Automatic generation of Windows Communication Framework (WCF) facades, server side
• A generic Windows WCF service host is provided, for all Windows versions, so you will not have to write specific Windows services to host your WCF services
• Complete support for WCF extensive configuration capabilities (no specific constraints on bindings, ...)
• Automatic generation of an embedded Background Intelligent Transfer Service (BITS) server for large binary objects (BLOB) upload and download
• Support for client and server inprocess debugging (without an external host server process)
• Automatic generation of a specific enhanced WCF proxy (optional, as standard proxy generation is still fully supported) on the client side, for an object oriented approach continuity:
  • No need for metadata (mex). Saves network bandwidth
  • Automatic generation of custom business rules on the client, if needed
  • Automatic generation of validation rules on the client, if needed 
  • Support for XAML automatic binding (INotifyPropertyChanged, INotifyCollectionChanged)
  • Support for WPF automatic validation (IDataErrorInfo)
  • Support for WCF streaming for large binary objects (BLOB)
  • Support for automatic asynchronous paged mode for large size collections

Web Service Layer (ASMX)

• Automatic generation of ASMX type web service facades
• Automatic generation of custom methods and business rules

User Interface Layer

Web Layer

• Automatic ASP.NET custom controls CodeDom generation
• Automatic generation of DropDownList, DataSource, Repeater, DataGrid, EnumList, ...
• Full multilingual support
• Automatic CSS based Web Site creation and deployment
• Template based generation (using Integrated template engine)
• Exclusive Excel and Access offline editing & over-the-web synchronization feature (HTTP/HTTPS)
• Automatic generation of fully 100% functional ASP.Net MembershipProvider, RoleProvider and ProfileProvider based on model entities
• Support of ObjectDataSource, GridView, DetailsView, FormView, ... classes
• Reusable generic ASP.NET provided: BooleanControl, CompareControl, CaptchaControl, CountryDataSource, ...
• Web error automatic reporting feature using IIS SMTP engine  
• Automatic generation of an embedded Background Intelligent Transfer Service (BITS) server for large binary objects (BLOB) upload and download. No need for IIS

Office Applications Layer

• Exclusive Excel 2003 and 2007 offline editing & over-the-web synchronization feature (HTTP)
• Exclusive Access 2007 offline editing & over-the-web synchronization feature (HTTP)
• Support of IIS or WCF (3.5) as the backend. IIS is not needed if WCF is chosen

Silverlight Layer

• Support for Silverlight 2, 3 and 4
• Automatic generation of a complete remote object model to ease development and support, based on the exact same source as the WCF enhanced proxy layer (see Service Model Layer above)
• Automatic generation of custom business rules on the client, if needed
• Automatic generation of validation rules on the client, if needed
• Support for WPF/E automatic binding (INotifyPropertyChanged, INotifyCollectionChanged)
• Dynamic generation of asynchronous interfaces (per Silverlight "asynchronous-only" rule), but a synchronous usage pattern is proposed, to accelerate Silverlight development

SharePoint WebParts Layer (Ultimate Edition Only)

• Automatic SharePoint (WSS3 or MOSS 2007) custom web parts generation
• Automatic generation of Grid, Forms, in read and edit mode
• Server side paging
• Server side sorting
• Custom rendering support
• Multilingual support
• SharePoint CSS themes support
• Authorization support, based on ASP.Net MembershipProvider, RoleProvider and ProfileProvider in the SharePoint context
• Forms and columns layout editing at runtime for power users (Shared webparts)

CodeFluent Entities Edition Comparison