Creating your business application you will indubitably need to: design a database, store and access data, design classes so you can manipulate that data, write your business rules, handle binary large objects (e.g. documents, pictures, videos), handle concurrency, generate documents (e.g. quotes, invoices), build user interfaces, provide search capabilities, paging, sorting, identification and authentication, probably provide web services in a near future so your application can be accessed from elsewhere (e.g. mobile apps, partners), and all this whilst absorbing functional changes ("did I mention a discount applies when more than 5 items are ordered?") as well as technical ones ("when can we ship an iPhone version of our app?").
Sure you can do all this by hand, but it's tedious and error prone, so why not use a tool instead?
As building an enterprise-class business application requires developers to constantly do and redo all this, we built out of our field experience CodeFluent Entities, an advanced model-first code generator, which provides both a broad and deep coverage of all such features, so you don't have to do it.
Don't Repeat Yourself
- One tool to rule them all: CodeFluent Entities is integrated to Visual Studio and you don't have to add-up tools (EF, T4, RIA Services, etc., etc.) to generate a functional enterprise-class application
- A single pragmatic model (no UML!), readable by non-technical users, centralizes all application logic
- Code generation is done by 'producers' which translate the platform independent model into code
- Model-based generation can also be combined with Template-based generation
- Generate continuously without ever losing data or changes
- In the end, thanks to this development driving model, it will provide a clear picture of what is in production, what it does, and how
A DBA friendly tool
- Create your database from your model (database, schemas, packages, tables, stored procedures, views, constraints, etc.)
- Generation is continuous: the differential engine enables hassle-free schema updates without losing any data
- Apply application wide changes in a few clicks such as applying naming conventions, adding data localization or tracking to multiple tables
- Write your own platform independent data access queries and let the tool translate them into optimized stored procedures
- No dynamic code generated making it predictable and easier to debug
- Not satisfied with the generated code? Replace it by yours!
- Multiple database support: SQL Server 2005/2008/2008 R2, Oracle Database 10g/11g, SQL Azure
- Generated scripts are deployed automatically for seamless developments
- Initialize generated databases with data thanks to the instance concept
Isn't it what ORMs do?!
CodeFluent Entities is not a mapping tool but instead an advanced model-first code generator.
CodeFluent Entities provides more than 20 producers, each of them targeting a single platform each and translating your model so you can generate databases, .NET classes, WCF services and UI screens. Nonetheless, it does include data accessing features which we think outperforms today's ORMs for the following reasons:
- Fully generates the database from the designed model (tables, views, schemas, automatically deduced association tables, constraints, stored procedures, etc.)
- Generation is continuous: the differential engine enables hassle-free schema updates without losing any data
- Support multiple database systems (SQL Server, Oracle Database, SQL Azure)
- As all layers are generated from the model, consistency is by design, and you don't ever have to update the mapping
- Still, there's a full continuity between generated object model and database providing an actual answer to the object-relational impedance mismatch
- Switching from one underlying persistence layer (e.g. SQL Server to Oracle Database) doesn't not change generated upper layers: you can switch the generated application's persistence layer at run time
- Extra tools are not required to build an entire enterprise-class application (though you can if you want to)
- No dynamic code, the code is 100% predictable
- Provides application-oriented features (e.g. concurrency, streaming of blobs, rules, tracking, search, etc.)
- Don't ever struggle with DbNull and data conversions
- Full enumeration support since day one
- Advanced serialization (e.g. a .NET Point structure can easily be persisted into two columns X and Y instead of having binary column and a byte[])
- A proven product on the market since 2005
- Generated code supports .NET Framework versions from 2.0 to 4.0 and runs under all .NET platforms (ASP.NET, Windows Forms, WPF, Silverlight, SharePoint, Windows Workflow Foundation, WCF, etc.
Cross technologies
- Platform independent model (though you can embed code snippets if needed!)
- Multiple database system support (SQL Server, Oracle Database, SQL Azure)
- Multiple language support (C#, VB.NET)
- Generated code can be used across all .NET platforms (ASP.NET WebForms, ASP.NET MVC, Windows Forms, WPF, Silverlight, SharePoint, Windows Workflow Foundation, WCF, etc.)
Isn't it what other code generators do?!
We think CodeFluent Entities outperforms current code generators as it is model-first, therefore your business logic is decoupled from the technology. Furthermore, since you are generating continuously from this model you are more resilient to change both feature-wise and technology-wise.
- Application logic is in a single pragmatic (no UML!) model, readble by non-technical users
- Generate continuously from this model
- No need to edit templates to customize code generation
- No need to edit templates to combine features (e.g. localization + paging + sorting + tracking + concurrency)
- Template-based generation can also be used if needed
- Generated code is human readable and predictable, following best practices (no dynamic code nor black box)
- Generated classes are all partial and do not derive from any base technical class (though you can if you want to)
- Native support of .NET resources
- Use built-in CodeFluent Aspects to dynamically change the inferred model and apply application wide changes (e.g. data localization, middle of word text search)
- Create your own CodeFluent Aspects to refactor/industrialize behaviors
You're the only captain aboard!
CodeFluent Entities is a tool developed by developers for developers. Unlike competitors we don't think an entire enterprise-class application can be generated, there will always be some specific code that cannot be industrialized and that has to be custom. As this is so, the tool is built so you can modify, extend and customize both the tool and its generated code.
Amenities
- ASP.NET Server controls (e.g. BlobControl, ExistsControl, BooleanControl, CompareControl)
- BITS Server to upload/download blobs
- CodeFluent Entities Service Hoster
- JSON Serializer and Deserializer
- Windows Form Wizard Control
- Utility classes (e.g. ConvertUtilities, XmlUtilities, EditableUri)
- Run-time model to avoid using reflection
Skeptical? See for yourself :)