Screenshot Preview


by Mindscape - Product Type: Component / Add-In / ASP.NET WebForms / ASP.NET MVC / .NET WCF / .NET WPF / Silverlight / .NET LINQ Class / 100% Managed Code / Developer Application

Fast .NET domain modeling and persistence. Mindscape LightSpeed is a high performance .NET domain modeling and O/R mapping framework. LightSpeed has first class LINQ support, Visual Studio 2008 and Visual Studio 2010 designer integration and a high performance core framework which means you can create rich domain-driven models more quickly and easily than ever before. Buy Mindscape LightSpeed with Source Code to obtain the LightSpeed O/R mapper source too. Mindscape LightSpeed 12 months Subscription also available when purchased as part of Mindscape Mega Pack.

$ 342.02

Our regular prices are shown below. Please logon to see your discounted prices.

Price in

LightSpeed 5 without Source

Add to Cart $ 342.02 1 Developer License Delivered via Download
Add to Cart $ 881.02 4 Developer License Delivered via Download
Add to Cart $ 1,959.02 1 Site Wide License (Allows Unlimited Developers at a Single Physical Address) Delivered via Download

LightSpeed 5 with Source

Add to Cart $ 538.02 1 Developer License Delivered via Download
Add to Cart $ 1,273.02 4 Developer License Delivered via Download
Add to Cart $ 2,939.02 1 Site Wide License (Allows Unlimited Developers at a Single Physical Address) Delivered via Download

Our prices include ComponentSource technical support and, for most downloadable products, an online backup and a FREE upgrade to the new version if it is released within 30 days of your purchase.  All sales are made on our standard Terms and Conditions and subject to our Return Policy. Please contact us if you require any licensing option not listed, including volume licensing and previous versions.

Our regular prices are shown above. Please logon to see your discounted prices.

What's new in LightSpeed 5?

Compiled Queries - LightSpeed already had one of the fastest query generation processes of any .NET ORM but now it also supports Compiled Queries. Compiled Queries mean that you can side step the cost of query generation almost entirely on subsequent queries where only variables change (e.g. ‘SELECT name FROM user WHERE Id = {ID}’). Compared to LightSpeed 4 this results in a 59% performance improvement in simple queries.

Automatic compiled queries - Along with automatically occurring with FindById, LightSpeed will use this technique when walking lazy loaded collections (e.g. User.Posts would use a compiled query). This means when you’re doing simple things like walking collections you’re going at maximum speed.

First class SQL 2012 support - Mindscape included a new SQL Server 2012 data provider. This is great because they already had support for all the modern data types like SQLGeography, HierarchyID and CLR Types and now you can use LightSpeed to natively target SQL Server 2012 including leveraging the new SEQUENCE support for identity generation.

More friendly design surface - The LightSpeed Designer has been improved to help new users. It will now do nice things like offer to create a KeyTable for you if you don’t have one setup but are using the KeyTable identity type. A common speed bump for new users that we wanted to clear up. You can also display table data for a given entity directly within Visual Studio. This helps avoid needing to fire up SQL Management Studio or other tool to see your data. LightSpeed has a database-first and model-first design support, smart filtering, works with a bunch of different databases and much more. There are several other improvements to make the designer more robust, provide better error messages and improve database syncing.

Release Notes (Change Log):


  • Visual Studio 2012 support.
  • Migration overload to create the key table with an initial value, and use it by default when generating migrations from the designer.
  • Log the column name as part of each logged data parameter.
  • Support for migrating EDMX V2 files to LightSpeed Models.
  • OptionalUrlStemSuffix for the LightSpeed Web Contract library.
  • Allow the creation of an empty migration for use with custom migration code.
  • Performance improvements for class table inheritance models.
  • Interception API for profilers.
  • Designer support for the ForeignKeyFieldAttribute on one-to-one associations.
  • Compiled queries.
  • Compiled paramaterised queries.
  • Compiled queries via the LINQ provider.
  • Compiled paramaterised queries via the LINQ provider.
  • Non-versioned partial update support.
  • Support for IsNullOrEmpty being translated to being a native database query for performance benefits.
  • Support for conditionals in projection.
  • Support for type conversion in projections.
  • .WithViewName() extension method for use with LINQ provider.
  • Show Data command from the LightSpeed Designer to show the contents of a table directly in Visual Studio.
  • FindByIdentifiers() method for DistributedUnitOfWork.
  • Ability to cache 'FindAll' results.
  • Option to have FindById() return null for non-existent ID's when working with Amazon SimpleDB.
  • Automatic compilation of FindById() queries for sizeable speed improvement.
  • Azure Table Service data provider.
  • Support Calculate queries operating over sub-queries.
  • Designer Defaults Policy can now specify defaults for generating association DataMemember attributes.
  • Extra information from LightSpeed.MetaData API for fields: Validations, IsNullable, IsIdentityField.
  • If a LightSpeed Model defines named aggregates, emit constants for their names so users can write e.g. WithAggregate(StoreAggregates.WithProductInfo).
  • Direct support for SqlServer2008 time data type translation both in core and Designer.
  • Remove() to LightSpeedQueryOperators which allows Remove by Query to be specified using a simple expression.
  • Ability to intercept queries from entities (for example, filter on currency or security).
  • Added support for per-table identity block size.
  • Added support for parameters of table type in SQL Server 2008 stored procedures.
  • Support for database-side timestamps for CreatedOn and UpdatedOn fields.
  • Support for expressing SqlGeography/SqlGeometry UDT properties in queries.
  • Support for the HierarchyId data type.
  • Add Enlisted event to Entity which is fired when SaveChanges is enumerating entities for unloading.
  • OnSaved event on Entity called after SaveChanges() completes Flush().
  • Before/After hooks for Migrations to allow custom user code to be injected into workflow when deriving.
  • Prompt to create the KeyTable if it does not exist when updating from the Designer.
  • RawSql escape hatch to provide a better version of FindBySql for the masses.
  • SQL Server 2012 provider and support for SQL Server 2012 Sequence identity type.


  • Database providers are no longer referenced directly in from the main LightSpeed assembly.
  • Insert key on a property now inserts a new property after the selected property rather than at the end.
  • Allow web contracts to be declared on controller classes as well as interfaces.
  • Unique validation scoped to the level which declares the field, not the level of the entity you are validating at the time.
  • Improve tracking of updates to FK's when updating an entity holder to avoid forcing all FKs into partial updates.
  • Add a false predicate to a query when we have an empty sequence in .Contains().
  • Email validation regex now supports the + and ' characters in email addresses.
  • Nicer messages when no connection to the database can be made when dragging from the Server Explorer to the designer.
  • Automatic push to sub-query via LINQ provider when LightSpeed detects a projection and it wants to do a Count() over it.
  • Support for sub queries on GroupJoin.
  • AppSettings key (Mindscape.LightSpeed.Web.Routing_EnforceSSL) to control behaviour of secure constraint for routing.
  • Better support for conditionals in projections.
  • Optimisation to remove the performance penalty for using variables in a LINQ query.
  • Don't include the SoftDelete check attribute when targeting a sub-query for a projection of the same entity type where we would have included the soft delete filter at the sub-query level already. Avoids the need to bubble this up through the projection.
  • Entity collection fields initialised to null. Allows performance optimisation for entities with large numbers of unused associations as constructing entity collections is a relatively slow operation.
  • Added support for negated boolean expressions in AnyAll.
  • Allow access to the validation rule instance from the validation error, while preventing mutation.
  • Include schema in auto-joined tables being joined by an identifier expression.
  • Precision and Scale added to ProcedureParameter to allow this to be passed on for output parameters which may require it.
  • Allow migrations access to the connection string, so that they can invoke LightSpeed to do data migrations rather than relying on ExecuteNativeCommand.
  • When a stored procedure returns NULL through an out-parameter, convert it to CLR null instead of leaving as DBNull.Value.
  • When updating a SQLite database with a GUID field, set COLLATE NOCASE on the column (because it is mapped as string).
  • Don't generate dynamic data column providers if [ScaffoldColumn(false)] is set on the wrapper property.
  • Defer running Entity.AfterLoad() until after associations have been wired up.
  • Allow RemovalBehaviorAction.NoActionNoCheck on (reverse of) null associations.
  • Handle grouping keys where the anonymous type is nested due to joins in the surrounding expression, identified some other issues to resolve around grouping.
  • More meaningful exception message if a database query returns NULL, but the target type is non-nullable (e.g. an empty SUM() operation on SQL Server when the summand type is non-nullable).
  • SQL Server computed columns default to LoadOnly when dragging a table onto the designer.
  • IDENTITY columns default to LoadOnly when dragging a table onto the designer.
  • ValidationException now provides the entity in error.
  • Allow model binder to support IEntityFactory for entity initialisation and filters for custom filtering of error messages (e.g. for when errors are localised).
  • Improved grouping support. Better support for function and support for traversals in grouping keys.
  • Default values for GUID, DateTime and BLOB columns when adding non-nullable columns to an existing SQLite table (because SQLite won't let you add a non-nullable column without a default even if the table is empty).
  • Pass down IncludeDeleted flag into determination of SoftDelete inclusion into context expression for association loads.
  • Friendly error when we encounter a drag drop source we don't know about - e.g. not Server Explorer.
  • Visibility options now available in the designer for the One To One associations.
  • SQL generated for MySql5 - don't emit DEFAULT '' for TEXT based columns.
  • TEXT field length not being assumed as unlimited with MySql5 extractor leading to an bogus change reported.
  • No more .NET 2.0 Compatibility Build.
  • Updated SQLite Provider to 1.0.82.

Bug fixes

  • NullReferenceException when parsing LINQ queries when the WHERE clause contained a FK reference to a component in a composite ID.
  • Designer now correctly creates a boolean property when importing a tinyint(1) from MySQL.
  • Visual Studio error if a migrations project contained no migrations.
  • Do not generate special fields in STI derived classes if we've already generated them on the base class.
  • Incorrect coalescing two columns in LINQ.
  • Multiple fixes for generating migrations from STI hierarchies.
  • Incorrect selection of type model when we have a non CTI inheritance where two different types in the inheritance hierarchy are being used. Force selection back to the root type to make sure its consistent.
  • PerRequestUnitOfWorkScope.HasCurrent no longer throws an error when called inside the Application Event Handler (fixes an issue with Ninject disposal).
  • Spurious circular association error when there are two classes in a class table inheritance hierarchy both of which hold foreign keys to other classes in the hierarchy.
  • Paging being included in sub-selects on the source query when it should only be on outer query.
  • Cascade deletes into a CTI derived class where the association is non-dependent. Should set FK NULL only in the target table rather than in base tables also.
  • Heuristic fix to report meaningful error on indirect circular association instead of going into stack overflow.
  • Error when projecting only base class fields while filtering only on derived class fields in class table inheritance.
  • Spurious discriminator warning if n STI root class derived from another class using concrete table inheritance.
  • Crash in BeginEdit() on a distributed entity.
  • Use of grouping query caused some joins to end up with invalid identifiers.
  • Converting from LINQ to SQL model breaks when no connection string is included in the DBML file.
  • Order By on a nullable association resulted in filtering out entities when the association was null.
  • String.Contains() losing aliasing information when applied to multiple joins of the same table.
  • Associations not being treated as dependant if the foreign key was a string.
  • Value objects in CTI derived classes not being materialised when using load-by-name (Stored Procedure or FindBySql()) and querying through the base class.
  • Ordering across a multi traversal multiple times.
  • Ordering where we had row number based paging and a projection involved where the ordering column was not the first column in the projection.
  • Calculations in class table inheritance.
  • Special fields declared in concrete table inheritance base classes not getting created in the leaf tables during database sync.
  • Fix for ordering across associations where you have the same entity joined multiple times via different associations.
  • When creating a table for an auto through entity, respect size of string ID columns in associated tables.
  • Error when doing a uniqueness validation on a field of a value object.
  • Issue where adding DeletedOn from joined context expression would not correctly identify base table.
  • Resolve issue to join CTI base class as required in queries where context expression refers to base rather than derived class and context expression is being appended to an eager load.
  • Descending being stripped from order by when being re-applied to wrapped distinct query for a ROW_NUMBER(OVER) - can we get more edge case than this?
  • Migrations spuriously trying to recreate auto through entities and one-to-one associations even though they already exist.
  • Query which has a criteria on LHS and logical on RHS could fail because LHS was not processed.
  • Soft deleted columns being incorrectly aliased in update/delete queries.
  • UDT procedure parameters being generated into the code as object instead of the UDT's CLR type.
  • Exception if you put DiscriminatorAttribute on a root entity class.
  • Not raising an exception if a SQL Server stored procedure successfully selects a result set and *then* calls RAISERROR.
  • Candidate fix for virtual discriminators not being inserted.
  • Not being able to return array values from ICompiledParameterValues to populate an IN clause.
  • Not updating the database if a one-to-one association was added between two entities that already had a one-to-many association.
  • Fix for race condition in Dictionary when caching LINQ closures under heavy load.
  • Issue where a full text search could return an incorrect result if the text search returned a single hit, and that entity was already in the identity map, and there was a QueryExpression filter in addition to the full text search but the entity in the identity map did not conform to the QueryExpression filter.
  • Fix for ninja filters not being applied in join clauses.
  • Aggregation SQOs where the projection is specified in the Select clause but there is also a cast in the aggregate expression.
  • Fix for scalar projection into DateTime using query objects.
  • Fix for projection into nullables using query objects.
  • Fix for issue where soft deletes were being included in join criteria due to CTI auto-joins leading to an unexpected null.
  • Fix for boolean properties losing entity aliasing information in LINQ queries when appending == true criteria.
  • Fix for issue with assignment of Composite Key id from a new parent object where composite key of child is FK to parent object PK.

LightSpeed O/R mapper is an object relational mapping framework that supports domain driven development and works with both Visual Studio 2008 and Visual Studio 2010.

Mindscape LightSpeed O/R mapper provides querying via a LINQ provider that works seamlessly with SQL Server 2000, 2005, 2008, Oracle 9+, PostgreSQL, MySQL, SQLite, VistaDB, Amazon SimpleDB and DB2.

The Visual Studio designer supports drag and drop design time modeling for all the databases supported by LightSpeed. It includes full schema round tripping meaning that developers can work in a model-first approach or a database-first approach - or even mix and match. The LightSpeed designer will synchronize changes as they are made.

To help manage deployment scenarios, Mindscape LightSpeed includes a visual migrations framework that can be operated directly from within Visual Studio or the command line. This makes managing schema changes a breeze and means developers can be more productive.

LightSpeed O/R mapper also supports:

  • Second level caching
  • Object property-level change tracking
  • Efficient database insert/update batching
  • Multiple identity type support
  • Single table inheritance, Class table inheritance and Concrete table inheritance
  • Domain driven concepts such as ValueObject, Aggregates, etc
  • Support for Mono, .NET 2.0, .NET 3.0, .NET 3.5 and .NET 4.0
  • Full text search capabilities across all database engines using Lucene (or plug your own provider in)
  • Support for database Views and Stored Procedures
  • Optimistic concurrency support
  • Eager and lazy loading support with tunable eager fetching
  • Full support for generics and nullable types
  • Support for extended database types (e.g. support SQLGeography when working with SQL Server 2008+)
  • Full support for transactions and System.Transactions - Works with ASP.NET Dynamic Data

Product Search

Enter search words:

The Software Superstore for IT Professionals

As Official Distributors, ComponentSource offers convenient, one-stop shopping from 250+ Software Publishers specializing in Application Development & Operations.

More Info | About Us