Hmm ... well ... how can I put it ....
I am now (as now) spending the effort to replace SubSonic PetaPoco . I guess something is saying.
Not that SubSonic was bad, but it didn't change very well. And for people who want to accept it at this moment, it seems that it is very important to note the absolute lack of activity in the project.
First, the biggest reason SubSonic is not suitable for me is LINQ.
Of course, there is a need to check the compiler for all resource use. However, in practice this is simply not suitable for queries.
If you are careful about using the class for the table and ActiveRecord, I assume that everything is in order. But whenever we had to make any queries outside of this (something that included several tables or anything other than the simplest ones where there were reservations), it was a nightmare. Associations cannot be used directly in a SubSonic LINQ query, as is possible in EF or nHibernate, which is probably the biggest pain point.
For example, such a request will not work in SubSonic, but it will be in EF:
db.Accounts.Where(a => a.OwningUser.Email != null);
Where I ended up was either to make many round trips to the database to collect the result, or to use the SubSonic CodingHorror class for direct query with SQL and the inability to simply materialize them as POCO (again, going beyond the scope of a simple class to the table).
I also found that each LINQ provider supports different sets of operations, and sometimes the same logical operation will have slightly different syntax and usage between providers. This made recording most of the queries very time consuming and error prone. The SubSonic LINQ provider has no shortage of fancy and underutilized ones. It doesn't come any closer to Linq-2-SQL, Entity Framework, or LINQ for nHibernate for its terms of supported operations, usability, or speed of execution (be prepared to learn new ways to write LINQ joins only for SubSonic - and be prepared to have some common operations were simply not possible with the SubSonic LINQ provider, despite the fact that errors were known for a year ).
In addition to dragging and dropping performance, it's easy to forget that the LINQ code you write has a very provider. ANSI SQL is far more standard and cross-compatible than LINQ.
LINQ also tempted me to reuse code with technical features such as specifications, but using them was far from simple, and the end result was not even close to cost. The road blocks I came across were largely due to the fact that the SubSonic LINQ provider did not support associations.
SubSonic objects outside LINQ I felt mediocre at best (in my opinion).
Secondly, it is important to know that by all measures SubSonic is not an active project.
The original creator of SubSonic, Rob Conery, is no longer working on the project. Rob was last made in July 2010 .
The last project fix was generally 3 months ago , despite almost 100 unresolved issues . And as far as I can tell, there was no release, not even a minor release, as Rob stopped working on SubSonic (although the people still hanging around the project had been talking about the release for more than six months ).
The Google group for SubSonic was active, but not so much these days. And also the official site of the SubSonic project was a yellow display of death for a while (Site is no longer yellow screens).
New hotspot for data access - micro-ORM. The creator of SubSonic, in fact, rejected this trend with Massive , after which the StackExchange team soon released Dapper and then PetaPoco came out. There are a couple more. And although we refuse a small compiler check, having fragments of SQL code in our code base, I believe that micro-ORM is much better for my development style than SubSonic.
My experience (albeit limited) with nHibernate was that it was too complicated for most scenarios, and even when it was appropriate, it absolutely killed the launch time of my application. There was also a high learning curve (which you can go through), but there are also several ways to do .. basically everything .. so it just adds that there are many more decisions in my process (it slows me down).
With PetaPoco, I can write familiar SQL - I am fast and reasonably good with this - and materialize them in POCO, and I know what to do with it. A little spatter of architecture and organization and automatic integration testing, and I don't feel dirty at all with the implementation of SQL bits.
Oh, and I guess the last one - SubSonic is far from the fastest way to get data. Maybe not important, but it turned out to be for us.
In conclusion (sorry for the text wall):
It is not that SubSonic is bad in any absolute sense. It didn't seem like I was trying to use it well - and most of this is that LINQ is still an leaky abstraction, and it flows differently than I'm used to.
The fact that development efforts are almost non-existent is good and bad. Well, it is stable and is considered "finished" in a way. Bad, he has no functions, maybe there are some errors, and he is not the best performer, and no one is working to improve it.