WPF Elements

• Added handling for race conditions in DataGrid.BringCellIntoView and DataGrid.GetCell
• Fixed a bug in DataGrid.RemoveInputBinding
• Added DataGridColumn.AllowGrouping property, which allows you to specify that the user cannot group on that column
• You can now template DataGrid group row headers

Web Workbench

• Highlighting for Less pattern matching and guards
• Fix for file generation error when using checkout-based source control system
• Updated Less compiler to 1.2.1
• Improved positioning of opening braces during Format Document
• Fix for error with unbounded node (e.g. unclosed quote) in CoffeeScript

LightSpeed

• Apply COLLATE NOCASE when creating SQLite GUID primary keys
• Fixes relating to one-way associations when the originating side is a concrete table inheritance base class
• Fixed migrations error with abstract classes

WPF Diagrams

• Tweak to the ElbowPathfinder

As always the free editions are available on the downloads page and you can get the full editions from the store. Happy coding!

Improved SQL generation
EF Status: Planned, but only some improvements
LightSpeed: Already miles ahead, always improving

Now, to be fair, querying is really hard to get right and there are always cases that can always be improved. I’m sure every O/R Mapper out there has at least a few queries that they generate in a non-optimal way (yes, including LightSpeed) — but I think we can all agree than 5,000 line SQL queries from 5 lines of LINQ is a bit on the insane side.

Batch support
EF Status: Under review
LightSpeed: Since version 1 in 2007

LightSpeed is about being a full ORM but with as much speed as possible. We built in batching of inserts, updates and deletes from day one, not to mention batching on the select side to enable entire aggregates to be loaded in a single database access. LightSpeed automatically batches up CUD statements, reducing the number of database accesses for large updates by a factor of 10 or more.

By the way, LightSpeed also supports bulk updates and deletes, so if you have a raw database update that doesn’t need the business logic and domain-specific API of your entity mode, you don’t even need to load entities into memory to perform the update or delete them.

Support for a second level cache
EF Status: Under review
LightSpeed: Since version 1 in 2007, pluggable, ships with standard cache and memcached support

LightSpeed supports a first and second level cache and has always done so. A second level cache improves speed and reduces load when you have entities that rarely change (such as reference data), or when it’s not essential to have up-to-the-microsecond data. Caching is an essential element of a performance tuning strategy and we don’t think you should have to hack the underlying ADO.NET stack to get it.

Between inefficient selects, inefficient CUD and no second level caching, performance certainly is not a criteria that you’ll achieve with EF.

Support for multiple databases
EF Status: Under review
LightSpeed: Not planned

Would you believe we actually don’t support this either? Developers seem fairly keen to not want to touch their database for things like database spanning but it’s our view that this is not an ORM concern. If you need linked servers and other cool features like that then you should look at how the database engine can support this, not your mapper.

Note: Support for multiple databases as requested by EF users is for spanning databases not about database engine support. LightSpeed supports 9 different database engines out of the box.

Support for models with >200 entities
EF Status: Use several models (read: not planned or under review).
LightSpeed: Supported, and include multi-model file support.

When we released the LightSpeed Designer initially we were pleased with it – really nice looking, smart database diffing, etc. Then, Murphy’s Law: a user had a database with 2,000 tables! Not surprisingly, it was a tad slow working with that many entities on the design surface. We shipped a nightly build within 48 hours that made the designer lightning fast for this user and they never looked back. That was several years ago.

Of course, even eliminating performance concerns, working with that many entities can still be difficult. Computer screens are only so big, so it’s hard to visualise very large models. We’ve done a number of things to help with this, from entity colouring to pick out key entities or group related entities, to multi-file models, to navigation and filtering to locate the part of the model you need to work on and hide all the extraneous noise. You can even save the most common views and switch between them with just a couple of clicks. So we’re confident that even if you’re working with large models, the LightSpeed designer will still give you the best experience around.

Designer support for GUID keys
EF Status: Use a workaround of editing EDMX by hand. Changes to model mean you repeat the process again.
LightSpeed: Supported since day 1 with the LightSpeed Designer.

Seriously, how do you even miss this out? I guess if supporting enums seemed a bit hard than GUID keys must seem like crazy talk.

Schema Migration
EF Status: Currently in beta
LightSpeed: Added in 2009.

LightSpeed includes a powerful schema migration product. Including Visual Studio integration, server tools and the ability to switch database engine targets, you’ll struggle to find a better schema migrations framework for .NET. Read more about schema migrations that were included in 2009.

We’re constantly improving the cabilities of the migrations engine based on user feedback as well.

So why would you choose to use EF? Here’s a couple of common counter arguments for using EF:

“It’s Microsoft – it will get better!”
Sure it will, maybe in five years time. Unfortunately your software needs to be written today, not in five years. Microsoft also has a really bad history of killing data access technologies so I’d be more concerned that the improvement will be to throw out EF and start again. And honestly, how much better do you think it will be in five years time? The pace of improvement so far has been glacial, and of these seven most requested items, only two are being worked on currently.

“Entity Framework is free – LightSpeed isn’t!”
It’s true that our free edition of LightSpeed is only for small databases. If you think your solution doesn’t require good performance, nightly updates, a responsive support offering or solid foundations then by all means, lock in Entity Framework. We can guarantee you that you’ll waste more money fighting in the weaknesses with the Entity Framework than you would have ever spent getting a LightSpeed license. EF is only free if your time is worthless.

That’s a wrap

We’ve got a lot of friends in Redmond, and we think a bit of rivalry is good for everyone, as well as a bit of fun. And we know that there are a few popular feature requests for LightSpeed that have been outstanding for a while too! But we do feel quite seriously that it’s important for developers to make an informed choice about their tools. Because Entity Framework ships in Visual Studio, it’s easy for it to become a de facto choice, without considering the alternatives.

But if you like knowing that if you run into an issue you can get help directly from the developers then choose LightSpeed. If you like getting nightly builds with not just bug fixes but cool new features then choose LightSpeed. If you like your data access to be fast then choose LightSpeed. If you would like to use a more mature, more powerful and, frankly, more loved ORM then give it a go — grab the free version of LightSpeed and see what you think. We’d love to hear your feedback!

LightSpeed

• Exclude null associations from polymorphic association validation
• Fix for not being able to return array values from ICompiledParameterValues to populate an IN clause
• Fix for LINQ projection that included the result of a Count on a join-into result when there was no Where clause
• When updating a SQLite database with a GUID field, set COLLATE NOCASE on the column (because it is mapped as a string rather than a native GUID type)
• Added support for per-table identity block size (for when new tables use KeyTable but the database also contains legacy tables which are also updated by other apps using increment-by-1 sequences)

WPF Diagrams

• DiagramConnectionPointBase.OnPositionChanged is now exposed to user derived classes
• Fixed a bug in the ConnectionPointRelocation sample

WPF Elements

• DataGrid hotness!
• Fixed a bug in TimeExplorer

As usual, you can get the updated builds of free versions from the downloads page, and of full versions from the store.

LightSpeed

• Fix for one-to-one association join chain in LINQ Where clauses
• Added support for negated boolean expressions in LINQ Any and All
• Fixed a memory leak with compiled FindById queries
• Validation errors now provide access to the validation rule instance
• Include schema in auto-joined tables being joined by an identifier expression
• Fixed automatic date-time range validation for Oracle
• Improved support for SQL Server 2008 TIME data type
• Fixed an issue where a query with criteria on the left and a logical combination on the right could be processed incorrectly
• Fix for DeletedOn column being incorrectly aliased in update/delete queries
• Added support for deleting by LINQ query
• Added Procedure and Scale options to ProcedureParameter class
• Fix for procedure parameters of user-defined types in designer being generated into wrapper function signatures as object instead of strongly typed
• Fix for value objects not being handled correctly in batch updates
• Fixed exception if you put DiscriminatorAttribute on a root entity class
• We now raise an exception if a SQL Server stored procedure calls RAISERROR (sic: what is this, guys, Fortran?) after performing a successful SELECT (previously only errors raised before the SELECT would cause exceptions)
• Added a property for migration code to access the connection string of the database being migrated
• When a stored procedure sets an out parameter to SQL NULL, we now translate this to CLR null instead of leaving it as DBNull.Value (this fixes casting errors in strong-typed wrapper methods)
• Fix for virtual (non-mapped) discriminators not being populated on insert
• Entity- and interface-level query filtering (in progress and subject to change)

Web Workbench

• Collapsing support for non-top-level regions
• Sass and Less Format Document command
• Fixed issue in Sass compilation if install path included non-ANSI characters
• Fixed JavaScript minifier mangling non-ANSI characters
• Upgraded CoffeeScript compiler to 1.2.0
• CoffeeScript comment highlighting fixes
• Comment/uncomment block support
• Performance improvements when making many deletes from a document
• Error checking and signature help for Sass and Less built-in functions

WPF Elements

• Continuing improvements to control themes
• Fixes for potential issues in TimeExplorer, Chart, ChartAxis and PieSeries
• Added option for rounding on lost focus in NumericTextBox
• Added ResetZoom command for charts
• MajorTickSpacing now keeps consistent tick density as user zooms
• Added PieSeries.SelectedDataPointChanged event
• Improvements to automatic bar chart width calculation
• Fixed error when changing chart highlight mode
• Fixed an issue with horizontal bar charts using categories along the Y axis
• Resolved a DataGrid issue
• Fixed foreground colours not being respected in CurrencyTextBox
• Fixed potential null reference error when changing DataGrid.ItemsSource
• Fixed some issues with chart default axes

WPF Diagrams

• Added TreeLayoutAlgorithm
• Fixed null reference error in ConnectionPointThumb
• Fixed a diagram binding issue
• Fix for a bug that was stealing mouse wheel and scroll events
• Added an option to turn off infinite scrolling

NHibernate Designer

• Added support for NHibernate sql-insert, sql-update and sql-delete overrides
• Added support for stored procedures and named SQL queries

SimpleDB Management Tools

• No longer need to click away from a row to ensure it is saved

As usual you can get the latest nightly builds from the Downloads page (free editions) or the store (full editions).

Make building better software your New Year’s resolution by taking advantage of our 30% sale on the Mega Pack.

For a limited time, pay only $699 and you’ll receive:

• LightSpeed O/R Mapper (normally $349)
• WPF Elements (normally $699)
• WPF Diagrams (normally $699)
• Silverlight Elements (normally $699)
• Phone Elements for WP7 (normally $299)
• NHibernate Designer (normally $99)
• SimpleDB Management Tools (normally $29)
• Web Workbench (normally $29)
• Visual Tools for SharePoint (normally $349)

Plus, you also get:

• 12 months of new releases, nightly builds and new products!
• The best support in the business!

Imagine that – a full range of developer tools across WPF, Silverlight, Windows Phone, Data Access, Web Development and Domain Modeling for just $699!

So, save thousands of dollars by getting all your tools at once with our 30% off Mega Pack Special now.

Hurry, promotion ends 1 Feb 2012!

Of course, even with our heads down on WPF Elements 5.0, we’ve still got updates to our other products. Here’s what’s new in this week’s nightly builds.

LightSpeed

• Fix for joining of class table inheritance base class in certain eager load queries
• Fix for issue with descending order in a wrapped distinct query for databases that use ROW_NUMBER-style paging
• Fixes for migrations spuriously trying to recreate auto through entities and one-to-one associations which had not changed

Usual rules apply: free editions available from the downloads page, full editions from the store.

We do get asked by people who have started to hear about micro-ORMs: when would I choose a product like LightSpeed over a micro-ORM? Both address the same basic job of mapping between SQL data and in-memory objects, so why use one rather than the other? So here are some of the times we think you’d want to use a fully fledged object-relational mapper.

1. You’re not Stack Overflow

Stack Overflow has become the ‘go to’ reference site for micro-ORMs. I mean, if Stack Overflow built a micro-ORM to squeeze out the performance they needed, that means they’ve got to be good, right? But I’ll let you in on a secret: you’re not Stack Overflow.

Stack Overflow is a huge site under extremely heavy load. That makes their performance tradeoffs entirely different from most sites or applications. Most developers, as long as they’re not introducing any performance killers, should be focusing on productivity, not on micro-optimising performance. Rather than handwriting SQL and forgoing additional benefits like validation, integrated migrations and many more nice-to-have features to gain the benefits of needing a smaller server farm, most companies find developer productivity is where they can save more money.

2. You’re not building a throwaway app

Some folks feel that it’s quicker to get up and running with a micro-ORM than with a full ORM. And if it’s quicker to get up and running, that means the micro-ORM is more productive than the full ORM, right?

Well, maybe. Some ORMs do require quite a bit of configuration or repetitive mapping. We’d like to think that LightSpeed isn’t one of those. We reckon that with LightSpeed you can be up and running in less than a minute. Plus you can actually gain time by having LightSpeed create the database schema for you, rather than having to jump across into a database tool.

But fair enough, it does take longer to install LightSpeed than to pull down a micro-ORM via NuGet. So if you’re only going to be spending ten or fifteen minutes on your application, then that might be decisive. But for most realistic applications, the productivity benefits of a full ORM rapidly overtake the time savings of running an installer.

3. You want a domain model

A lot of micro-ORMs are just a class for materializing a database row into an object – either to a concrete class, or to an anonymous type. ORMs like LightSpeed, NHibernate, LLBLGen etc offer far more than just object materialization. If you want to express business logic, have validation, etc. then you either want a higher-end ORM or you want to spend your time writing a lot of tedious boiler plate code. And you probably have better things to do with your time than write tedious boilerplate code.

A domain model also pays off when you’re not the only one working on the project. Encapsulating business logic and validation in the domain model ensures that the business rules apply wherever the objects are used — you’re not relying on everyone remembering to apply the latest rules to their bits of the project. That’s one of the reasons we stopped using DataTables in the first place, remember?

4. You like LINQ

Most micro-ORMs do not include a LINQ provider. Most in fact require that you write the SQL yourself. That isn’t in itself a bad thing, it’s just taste and portability concerns and, frankly, most people don’t move database engine anyway. However, a LOT of .NET developers like LINQ. Many, many more than like SQL. Intellisense, compile-time type checking and compile-time syntax checking combine to make you more productive and to catch errors earlier.

And if you like LINQ, then you’ll want an ORM with a good LINQ provider. That means the LINQ actually translates to SQL, not a supposed LINQ provider that actually pulls all of your data into memory and then uses LINQ to Objects — that will throw away any performance gains you thought you’d be getting from the micro-ORM — and then some.

5. Your data usage pattern isn’t dominated by isolated records

There’s some great performance benchmarks out there for micro-ORMs. Unfortunately, there are a bunch of, well, less great ones too — benchmarks that don’t test real world situations.

If you’re going to be guided by benchmarks, make sure that the benchmark you’re using reflects how your application uses data. For example, suppose your application issues multiple queries to the database, some of which could result in the same entity being returned. Most micro-ORMs don’t use an identity map, so they’ll trundle off to the database and materialise a new copy of the entity. Most full ORMs, by contrast, will see that the entity is already in memory, and save themselves the query and/or the materialisation. And, by the way, they’ll give you handy object identity behaviour instead of you having to write code to test if Instance A represents the same record as Instance B. A typical full ORM is built to have a higher level view of how real world applications are built, and can gain significantly on the performance front by performing these optimizations.

Of course, your application may have special performance characteristics that mean a micro-ORM plus custom performance strategies will perform better than a general-purpose ORM tuned for a typical mix of applications. Stack Overflow is a great example — its performance requirements are so extreme that it’s worth the effort of building that stuff in a way that works for them. You have to ask yourself whether your application justifies that custom construction cost.

And one reason *to* use a micro-ORM

Choosing between a micro-ORM and a higher end ORM shouldn’t be a religious decision. There are certainly places where a micro-ORM makes sense — when you don’t need domain logic, you want to work very intimately with the database, the application is very limited or ad hoc in its scope… an example might be a simple bulk data transfer application, where things like an identity map and validation don’t add any value. We use micro-ORMs at Mindscape when they make sense, and it’s given us an appreciation of their value as well as where they come up short.

So what do you reckon? Are these the key points to consider when deciding between a full and a micro-ORM? What are your reasons for using or not using a micro-ORM?

LightSpeed

• Fix for error when doing a uniqueness validation on a field of a value object
• Fix for issue with joined queries on soft-deleted entities
• Fix for autocompiled FindById queries on SQLite with GUID identities
• Fixed an issue where certain types of LINQ queries could be rejected even though they were actually translatable

WPF Elements

• Fix for using the Esc key to cancel a zoom in progress on a chart

Web Workbench

• Fix for highlighting errors with Sass interpolated variables
• Fix for highlighting errors with nested multipart selectors consisting of a parent-pseudoclass followed by a subselector. Yes, you heard me
• Several intellisense fixes and enhancements

All these updates are in the latest nightly builds. Free editions available from the downloads page, full editions from the store. Web Workbench updates through Visual Studio Extension Manager.

WPF Elements

• Fix for chart update when an alternate axis is zoomed programmatically
• Fixed automatic bar chart LabelLayout option
• Added DataSeries.LabelBinding property for conveniently setting data label content

LightSpeed

• You can now skip initialising entity collections that you’ll never need.

Web Workbench

• Updated Less compiler to 1.1.5
• Updated CoffeeScript compiler to 1.1.3
• Fixed a possible race condition
• Fix for Sass user-defined function causing highlighting errors
• Added highlighting for @font-face directive in Sass @mixin declaration
• Fix for top-level Sass @includes

NHibernate Designer

• Added public get/protected set visibility option
• Added policy option for visibility of default identity properties

Nightly builds of WPF Elements and LightSpeed are on the downloads page (free editions) or in the store (full editions). Web Workbench and NHibernate Designer update automatically through the Visual Studio Extension Manager.

LightSpeed

• Added a class containing constants for all aggregate names in the model
• Don’t show a ‘should be cached’ validation warning when associating to reference data across a linked model boundary
• Fix for an issue with subqueries of projections involving soft deleted entities
• Added some new field model information to the metadata API
• Added interceptor support for command execution — this allows low-level diagnostics, retry strategies, etc.

WPF Elements

• Added support for dynamically changing chart axes
• Added alternate Y axis templating for custom axes
• Added a ChartZoomed event
• Fix for IsSelected property on non-joined-up data series (such as scatter graphs)

NHibernate Designer

• Fix for XML mapping issue in Visual Basic
• Use @-strings in Getting Started Fluent NHibernate code
• Added some more validation on identity generator types

These updates are in the current nightly builds. You can get the free editions from the downloads page, and retail editions from the store. NHibernate Designer automatically updates itself from the Visual Studio Gallery.