Features LLBLGen Pro Designer

Productivity

• Integrated in Visual Studio 2010 / 2012 or usable stand-alone New!
  The LLBLGen Pro designer is fully integrated in Visual Studio 2010 or 2012. It allows you to create and edit LLBLGen Pro projects without leaving Visual Studio. Generated code is automatically added to your active solution. A stand-alone designer is also available so you can choose in what form you want to use the designer.
• Powerful, template based code generation framework.
  The code generation system is based on a series of tasks. You can easily control which code is generated using the task-based code generation, using templates which can be edited inside the designer. The code generated is placed in separate VS.NET projects using normal classes and namespaces, so it looks like code you'd have written yourself. More information...
• Designed to handle models with thousands of entities.
  LLBLGen Pro doesn't require you to have a single editing canvas with all your entities in a single visual model, it allows you to navigate, edit and manage the project using different 'views' which allow quick access to the element(s) you're interested in and still allow you to keep overview.
• Fully undo/redo aware.
  Every action taken in the designer is fully undoable. The core system is built into Algorithmia, the algorithm class library which is available as sourcecode to every customer.
• Legacy database and Relational Model friendly.
  LLBLGen Pro doesn't require the relational model to have specific tables or specific requirements, it can deal with any database construct.
• EDMX Importer.
  It's now possible to import entity model data information from an existing Entity Framework EDMX file.
• Extensible Model Data Import System
  The designer allows you to import project data from external sources. Importers are plug-ins which import project meta-data (like entity definitions, mappings and relational model data) from an external source into the loaded project.
• Powerful project-wide search based on C# / VB.NET Linq queries.
  The element search allows you to obtain information about elements in the project. You can define a linq query inside the designer to obtain the information you need, using the projection you need, and for example export the information to excel or another program / file. More information...
• Model views.
  You can define multiple visual views on the entire project, with documentation, which help you focus on smaller areas of the project and also make it easier to discuss model details with domain experts.
  More information...
• Grouping of project elements.
  The designer allows you to group the project elements into visual groups, while seeing the groups combined as a single project, or let you group the elements inside the project as separate, 'sub projects', which will result in different Visual Studio.NET projects when code is generated. More information...
• Allows both Model first and Database first development, or a mixture of both
  It doesn't matter how you start your project or how you want to work with your project: you can use reverse-engineering functionality (Database first) and Model first tools at the same time. More information...
• Fine-grained reverse-engineering features
  (Database first), for full control over how names are created for fields, navigators, entities and the like: patterns for navigator names, pascal casing of names even if they're uppercased, '_' removal, abbreviation replacement, pluralization/singularization, fragment stripping from fields, tables, views and stored procedures (e.g. 'tbl_', 'pr_', both suffix and prefix), auto-grouping of elements based on schemas.
• Action suggestions window. New!
  The designer offers an action suggestions window, which shows what actions are recommended, given the last action of the user and the state of the project / designer. The action suggestions window helps with navigating the designer in common tasks, in case a particular feature might be hard to find.
• Configurable reverse-engineering so you decide what follows what:
  do model relationships follow FK constraints in the database or not (e.g. when the DB doesn't have FK constraints, and you don't want to lose the manually created relationships). The same goes for unique constraints, primary key fields, field length/precision/scale etc.
• Automatic, configurable relational model management based on mappings.
  Say you have 100 tables in your database, and you use 90 of them in mappings. LLBLGen Pro can warn you about these 10 tables which aren't used, can automatically remove them for you (through an UPDATE DDL SQL script), exclude them from the project (so they're not used in the project but also not removed from the database) without any effort from your side. This also goes for fields: it can automatically remove unused fields from mapped tables if you want (or warn you instead, or be totally silent about this). What the designer should do with which element type is configurable. More information...
• Errors produced by validation contain suggestions how to fix them, often with 1-click fixes inside the suggestion.
  The errors produced by the validation system can have one or more suggestions to fix the error, and each of them has a link you can click which either fixes the error for you or opens the editor for you of the element containing the error so you can directly focus on fixing the error without having to mess with XML files.
• Switch between target O/R mappers easily.
  When, for whatever reason, you have to change the O/R mapper for your project, you can simply switch the chosen target framework in the LLBLGen Pro designer and re-generate code and you're done (give or take some minor changes if the newly chosen O/R mapper doesn't support a feature the old one does). Of course your own code has to be migrated, but your entity model, mappings and the like all stay the same.
  More information...
• Home tab with Quick Start Guides.
  To make new users feel right at home, we added a home tab with quick start guides which guide you through four main use cases of the designer.

Modeling related

• Model your domain the way you want it, using different building blocks:
  Entity definitions, Value Type definitions, Typed View definitions, Typed List definitions and Stored procedure calls are all possible. More information...
• Full entity type inheritance.
  Model entity definitions using inheritance hierarchies of the type 'Target per Entity' (one table/view per entity type) or 'Target per Entity Hierarchy' (the complete inheritance hierarchy is mapped onto the same table/view). Mixing of inheritance hierarchy types is supported. More information...
• Clever inheritance modeling:
  not only can the designer automatically find inheritance hierarchies for you, it also cleans up elements no longer needed from subtypes if you make A a subtype of B. For example, A and B share a 1:1 relationship over their PK's. When you make A a subtype of B, this relationship has to go, and A's PK is inherited from B. Also fields in A which have the same name as B's have to go, as that would lead to errors.
• Fields mapped on related fields.
  Define a field in entity A which is mapped onto a field in a related entity over a m:1/1:1 relationship, e.g. map Order.Customer.CompanyName as the field 'CustomerCompanyName' in the entity 'Order'.
• Value Type (DDD) support.
  Group one or more entity fields together into a value type definition and use that value type definition as the type of an entity field. E.g. create the value type 'Address' with the fields 'City, Country, StreetName, HouseNo' and define a single field of the type 'Address', for example the 'VisitingAddress' field in the Customer entity.
• Ability to specify abbreviations to full word sets for model name construction during reverse engineering (Database first).
  LLBLGen Pro can automatically convert names in the relational model data like table names, field names and view names which are build from abbreviations to better descriptions using conversions you specify. For example a table field 'AddrNo' can be converted to 'AddressNumber' using abbrevation conversions for 'Addr' and 'No'.
• Flexible, plug-in driven singularization and pluralization of names (English).
  Plural names will be made singular and for example the names of fields mapped onto relationships (e.g. for collections) are pluralized. This pluralization and singularization is done by a plug-in which is available in sourcecode to customers so they can change it or create a different one for a different language than English
• Database driver architecture (provider model).
  Relational model data retrieval from an existing database (Database first) is done using database specific drivers, which are also used to provide information for Model first relational model data production, leading to a generic designer which can support any database type through a specific driver for that database type. More information...
• Full support for all relationship types.
  The designer allows you to edit and specify relationship types of type one-to-one (pk-pk and fk/uc - pk), many-to-one, one-to-many and many-to-many ('pure' with an empty intermediate entity, or objectified relationships with a intermediate entity which is a real entity).
• Support for model-only relationships.
  A model-only relationship isn't required to have a backing foreign key constraint in the relational model data. They're ideal for projects which have to work with relational databases where changes can't always be made or some relationships can't be added to (e.g. the ones which are important for the entity model, but are not allowed to be added to the relational model for some reason).
• Full support for complex database constructions.
  The designer can deal with complex relational model constructions like multiple foreign key constraints defined on the same field(s).
• Support for modified relational schemas.
  The designer is fully capable of migrating your project to a new version of your relational model by 'refreshing' the relational model data with the new relational model data. More information...
• Powerful text-DSL based Quick Model functionality
  Quick Model is a text-based DSL coupled with a visual representation which allows the user to very quickly create a model from scratch using text sentences. The elements created are added to the main model, and the feature for example can be used to specify a model on-the-fly during an interview with a domain expert. The domain expert can then immediately see whether the model is correct or needs adjustment, as it doesn't take extra time to create it. As it's the same model the developers will work with there's no time lost by re-creating a 'real' model from scratch based on a report from the interview with the domain expert.
  More information...
• Unique constraint support.
  You can define which fields are unique so a unique constraint is created using model-first techniques
• Update / Delete rules for FK constraints support. The designer supports update / delete rules (Cascade rules) for relationships and Foreign Key constraints in both database first and model first.
• Custom field ordering support
  Although fields in an entity definition don't really have an ordering, it can be important for some situations to have the entity fields in a given order, e.g. when you use compound primary keys. Field ordering can be defined manually and it can be set automatically during refreshes.
• Powerful entity / complex type editing and refactoring tools.
  All fields are displayed in a grid and you can define new fields with all specifics from the keyboard without moving your hands away from the keyboard. No need to click around in a tiny property grid. The grid has real-time validation and edit helpers to edit fields very efficiently. More information...

Mapping related

• Automatic forward mapping of entities and entity fields:
  auto-map model-first created entities and fields to existing elements or auto-create new tables and fields from the entity definitions. More information...
• Map model fields with any .NET type to any database type, including Enum types.
  LLBLGen Pro supports type converters which allow you to map a model field (e.g. an entity field) to a target field with a database type which is not compatible with the model field's type. More information...
• Table Valued Functions support. New!
  The LLBLGen Pro designer supports Table Valued Functions, which allows you to map an entity or typed view on the resultset of the Table Valued Functions.
• Flexible mapping options:
  • Map an entity onto a table or view
  • Map multiple entities onto the same table
  • Split a table / view across multiple entities mapped onto the same table with a 1:1 pk-pk relationship.
  • An entity or typed view doesn't have to contain the same number of fields as the target element it is mapped on.
  • Map a typed view onto a table, view or stored procedure resultset.
  • Each element (entity, typed view, stored procedure call), can be mapped onto a target in the relational model data of each database type in the project. This means for example that you can map an entity onto a table in SQL Server and Oracle at the same time or a table and a view, or a view in both.
• Fine-grained tooling for adding / editing and removing table fields and table field specifics:
  tooling which uses a mapped model field to update a target field in a table or you can also add / edit table fields directly in a flexible editor
• Sequence support and auto-creation of sequence definitions for sequence supporting databases.
  When using Model first, LLBLGen Pro can auto-generate sequence definitions for each new table created, and assigns the sequences automatically to the PK fields mapped. The mapping editor also allows for specifying which fields are sequenced / identity fields manually as well.
• Support for multiple database types in one project
  An LLBLGen Pro project can contain relational model data from all supported databases, while containing a single model, mapped to the relational model data of each database type.
• Support for multiple databases (catalogs) per database type in a single project.
  Each catalog / database is seen as part of the whole relational model data. This means that you for example can define relationships across catalogs/databases between entities.
• Support for multiple schemas per database (catalog) in a single project.

General

• Many databases are supported
  • SQL Server (SQL Server 2000/2005/2008/2008R2/2012/Express/CE Desktop/SQL Azure)
  • Oracle (Oracle 9i /10g / 11g)
  • PostgreSql 7.4+/8.x/9.x
  • Firebird 1.x / 2.x
  • IBM DB2 UDB (7.x/8.x/9.x), not on iSeries/AS400
  • MySql (4.x, 5.x)
  • Sybase Adaptive Server Enterprise (ASE)
  • Sybase SQL iAnywhere (ASA)
  • MS Access 2000/XP/2003/2007/2010/2013
• Fine-grained control over generated relational model data
  When using model-first, you generate tables from entity + mapping data. To make this as easy as possible, you want to define whether you want 'CustomerId' be generated as 'CustomerId', 'CUSTOMERID', or 'CUSTOMER_ID' (or even 'customerid' or other variants). This is important for case-sensitive databases like oracle and postgresql. Also you'd want to define whether you want natural character string types, currency types over decimals and variable types (e.g. varchar) over fixed length types (e.g. char).
• Generate code for .NET 3.5, .NET 4.0 and .NET 4.5
• Generated Visual Studio.NET project files are compatible with Visual Studio.NET 2008/2010/2012
• Generate DDL SQL Update scripts or DDL SQL Create scripts for database schemas.
  The relational model data in the project is exportable as a DDL SQL create script to create a new database from scratch, or you can also export changes made to to relational model data when manipulating the entity model (using Model first) as a DDL SQL Update script. More information...
• Multiple Object/Relational Mapper frameworks are supported
  • Entity Framework 1 / 4 / 5
  • NHibernate (using hbm mappings & Fluent NHibernate mappings)
  • Linq to SQL
  • LLBLGen Pro runtime framework
• The designer is fully extensible through a flexible plug-in system.
  The designer is extensible by custom-made plug-ins which can be run manually by the designer on project elements, or automatically when bound to a designer event. Plug-ins can have their own UI which can be added to the main UI as a tab.
• Generate code in C# and VB.NET.
  The designer can generate both C# code and VB.NET for all the supported Object/Relational Mapper frameworks, supporting every feature in both C# and VB.NET.
• Extensible settings system per supported Object/Relational Mapper framework
  Per supported Object/Relational mapper framework, specific features are configurable through a productive 'default + override locally' system where you can configure settings globally at the project level and override these settings at the element level. The xml based settings system is extensible so you can add your own settings and consume these in your own custom templates. More information...
• Designer works disconnected.
  When working with the relational model data in the project, you don't have to be connected to the database, all relational model data you want to work with is inside your project file, so you can work with the project wherever you are, be it connected to the database or not.
• Flexible attribute declaration for code generation.
  The designer allows you to define attribute definitions on model elements which are generated into the code, making it unnecessary to define 'buddy' classes for attribute specifications on code elements. Attributes can be defined using macros and using a default + override locally system. Additionally, rules can be defined to make it easy to define attributes only on select elements. More information...
• Integrated template editor
  No need for a separate template editor, manage and edit all code generation templates inside the designer using a rich editor. More information...
• Fine-grained project validation
  The designer validates the project on general mistakes and inconsistencies and uses plug-in based validators to validate the project specifically for the chosen target O/R mapper framework. This makes validation both flexible and extensible as the validators are available as C# sourcecode to customers. More information...
• XML based, source-control friendly project file
  The project files saved by the designer are designed to be source-control friendly and have predictable ordering of elements and use a friendly XML format.
• Use command-line tools
  The designer comes with two command-line tools for generating sourcecode and refreshing the relational model data: CliGenerator.exe and CliRefresher.exe. Both tools are shipped with sourcecode to customers so you can modify them and embed them in your workflow tools.