Sunday, August 24, 2008

There have been quite a few questions about performance lately on our forums, that is, new users coming to our site and asking "How fast is EntitySpaces" or "How does it compare to architecture 'X' " and it's been our plan to do some investigation into this. Then we saw a POST on DotNetKicks regarding SubSonic's performance tests and wondered how EntitySpaces stacked up. We ran some tests and found an issue in that we were creating a needless transaction in some cases when saving single entities. A transaction was blindly being created to cover the case of a hierarchical save. However, we now detect whether or not we have other objects to save, and if not, we don't create a transaction. This really increased our performance along with a few other changes. We also made some performance enhancements in how our collection saves work. Now, it's important to state that you can not get these performance numbers in the current release. However, the performance enhancements have been made and will be in the next maintenance release to be pushed in less than two weeks. The good news is the performance enhancements will be realized no matter what database you are running against.

We decided to take the SubSonic examples from the post above and literally recreate them in the EntitySpaces syntax and do a comparison. The tests were performed on a single computer with SQL 2005 hosting the Northwind database. Both the SubSonic and EntitiySpaces tests were run on the same machine, against the same database, and both using dynamic SQL (and not stored procedures). Here are the tests and timings. We loaded a single entity from the database before the timings began to eliminate any first time startup issues such as assembly loads and configuration file reads.

All times are in mm:ss (minutes and seconds)

Test 1

This test creates an order and an order detail record saving them both. This is done in a loop for a given number of iterations.

Test 1 Results (at different iterations)

     10,000 Iterations     100,000 Iterations   1,000,000 Iterations
EntitySpaces             0:14               2:20               24:10
SubSonic             0:20               3:21               33:21

 

TEST 1 Source













EntitySpaces ==>

// Let's save a million items shall we?
for (int i = 1; i < 1000000; i++)
{
    Orders o = new Orders();
    o.CustomerID = "ALFKI";
    o.EmployeeID = 5;
    o.Freight = 10;
    o.OrderDate = DateTime.Now;
    o.RequiredDate = DateTime.Now;
    o.ShipAddress = "Somwhere, Someday";
    o.ShipCity = "City";
    o.ShipCountry = "US";
    o.ShipName = "Shipper";
    o.ShippedDate = DateTime.Now;
    o.ShipPostalCode = "99999";
    o.ShipRegion = "KS";

    o.Save();

    //OrderDetail detail = new OrderDetail();
    OrderDetails detail = new OrderDetails();
    detail.OrderID = o.OrderID;
    detail.ProductID = 13;
    detail.Quantity = 1;
    detail.UnitPrice = 100;

    detail.Save();
}









SubSonic ==>

// Let's save a million items shall we?
for (int i = 1; i < 1000000; i++)
{
    Order o = new Order();
    o.CustomerID = "ALFKI";
    o.EmployeeID = 5;
    o.Freight = 10;
    o.OrderDate = DateTime.Now;
    o.RequiredDate = DateTime.Now;
    o.ShipAddress = "Somwhere, Someday";
    o.ShipCity = "City";
    o.ShipCountry = "US";
    o.ShipName = "Shipper";
    o.ShippedDate = DateTime.Now;
    o.ShipPostalCode = "99999";
    o.ShipRegion = "KS";

    o.Save("me");

    OrderDetail detail = new OrderDetail();
    detail.OrderID = o.OrderID;
    detail.ProductID = 13;
    detail.Quantity = 1;
    detail.UnitPrice = 100;

    detail.Save("me");
}

 

Note that on the above test at 1 million iterations with 2 inserts per iteration EntitySpaces was inserting 1,379 records per second.

2,000,000 (inserts) / 1,450 (seconds) = 1,379 (inserts per second)

 

Test 2

This test loops through a million objects loading them one by one using the single entity class.
We are reading a million records with ids 7080773 through 8080773.

Test 2 Results

                          1,000,000 Entity Reads
EntitySpaces                                       6:18
SubSonic                                       7:05

 

TEST 2 Source



EntitySpaces ==>

for (int i = 7080773; i < 8080773; i++)
{
    Orders o = new Orders();
    o.LoadByPrimaryKey(i);
}


SubSonic ==>

for (int i = 7080773; i < 8080773; i++)
{
    Order o = new Order(i);
}

 

Test 3

This test loops through a million objects loading them 10 at a time into a collection class.
We are reading a million records with ids 7080773 through 8080773.

Test 3 Results

                          1,000,000 Collection Reads
EntitySpaces                                        08:53
SubSonic                                        13:47

 

TEST 3 Source



EntitySpaces ==>

for (int i = 7080773; i < 8080773; i++)
{
    int nextTen = i + 10;

    OrdersCollection oc = new OrdersCollection();
    oc.Query.Where(oc.Query.OrderID.Between(i, nextTen));
    oc.Query.Load();
}


SubSonic ==>

for (int i = 7080773; i < 8080773; i++)
{
    int nextTen = i + 10;
    OrderCollection coll = new Select().From<Order>().Where("orderid")
        .IsBetweenAnd(i, nextTen).ExecuteAsCollection<OrderCollection>();
}

 

EntitySpaces has always stacked up well in reports sent to us by users and upon our next release our customers will have even better performance. We have also added the ability to turn our Dynamic Query's into DataReaders for even higher performance in certain scenarios as outlined in this blog post. We know it's controversial to publish performance results but we believe we have treated each architecture fairly and will publish the testing harness when we publish our next ES2008 maintenance release. SubSonic, NHibernate, and other architectures are fine architectures, this post was merely to head off the inevitable questions heading our way.

EntitySpaces

From mobile devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with medium trust requirements, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

The EntitySpaces Team
--

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

posted on Sunday, August 24, 2008 10:31:57 AM (Eastern Standard Time, UTC-05:00)  #   
 Monday, August 18, 2008

We thought we'd tell you about two nice enhancements to our DynamicQuery API. We added two new methods to the esDynamicQuery class, ExecuteScalar and ExecuteReader. These will be available in our next ES2008 maintenance release when it comes out.

ExecuteScalar:

This query simply fetches the total table count. Of course, I could have used a Where clause to reduce it to a certain set of records.

EmployeesQuery query = new EmployeesQuery();
query.es.CountAll = true;
int count = (int)query.ExecuteScalar();

ExecuteReader:

This query selects the FirstName and LastName columns where the LastName is like "Gri%" and then gets an IDataReader on the result set.

EmployeesQuery query = new EmployeesQuery();
query.Select(query.FirstName, query.LastName);
query.Where(query.LastName.Like("Gri%"));

using (IDataReader reader = query.ExecuteReader())
{
    while (reader.Read())
    {
        string s = reader.GetString(0);
    }
}

Notice that neither of these approaches is used to populate a collection or an entity. This is similar to the already existing Query.LoadDataTable() method.

EntitySpaces

From mobile devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with medium trust requirements, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

The EntitySpaces Team
--

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

posted on Monday, August 18, 2008 8:30:58 PM (Eastern Standard Time, UTC-05:00)  #   
 Saturday, August 16, 2008

EntitySpaces 2009 Q1 is all about streamlining our code generation process.  We are creating our own code generation engine, just as we created our own metadata engine for the ES2008 release. Having our own code generation engine will allow us to break our reliance on third party code generators and eliminate needless complexities thereby improving usability for our customers. This will allow us to have our own project files of pre recorded template settings for playback. Additionally, we will provide a totally new approach for declaring template user interfaces. All of these enhancements focus on one of our main goals for EntitySpaces 2009 Q1 … simplification of the code generation process. However, there are more enhancements.

Visual Studio 2008 users will be pleased to know that we will provide a Visual Studio 2008 Shell version with ES2009. The Visual Studio Shell is part of the new Visual Studio Extensibility (VSE) system. Visual Studio 2008 users will never need to leave Visual Studio when using EntitySpaces. We will also provide a very nice command line application that will allow you to regenerate your code during your build processes’, including continuous integration builds. The command line application will be able to take code generation project files on the command line as arguments. If you are feeling left out because you do not use Visual Studio 2008, or are using one of the Express versions, you are not going to be left behind. We will also provide a stand-alone Windows Forms application to handle template execution and code generation. The stand alone Windows form application may be written so that it will run under Mono as well (still in debate).


image

 

Furthermore, we will be adding support for SQLite, which we feel is important in order to open even more mobile markets for our customers. We have very good Windows .NET Compact Framework support. We also plan to add support for IBM’s DB2 database engine. Our SQLite support will most likely come before the IBM DB2 support. Finally, we will be adding a Domain Modeler that will allow users to completely customize their domain modal. However, EntitySpaces will not require any XML files, nor use reflection for this purpose as other ORM systems often use.

This is an aggressive feature set. Not all of the features mentioned above will be available in the ES2009 Q1 release. Not covered in this post are changes planned for the architecture itself, those will follow in another post. Our plan is to have an ES2009 beta out near the end of 2008.

EntitySpaces

From mobile devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with medium trust requirements, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

The EntitySpaces Team
--

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

posted on Saturday, August 16, 2008 7:38:37 PM (Eastern Standard Time, UTC-05:00)  #   
 Sunday, August 10, 2008
Download the Trial version

EntitySpaces 2008 was originally released on June 23rd and it has proven to be very solid, as have our past releases. We decided to put out a maintenance release to make some minor tweaks we have made available. We have also upgraded the ASPX Admin Suite to run under ES2008. The ASPX Admin suite is only available under MyGeneration as the UI technique it uses is not compatible with CodeSmith. You can install this release right over the top of your current ES2008 installation.

 

  • Upgraded our C# and VB.NET Web ASPX Admin Grid templates for ES2008 (MyGeneration Only).
  • Fixed Oracle SEQ double-quotes in MyGeneration VB Metadata and MetadataMap templates.
  • Add support for Oracle FLOAT data type.
  • We no longer use the deprecated Oracle Precision and Scale in parameters for NUMERIC data types.
  • Fixed a casting issue for esDataSource TotalRowCount with MySQL and Oracle.
  • Add Property Changed Notification to all four hierarchical properties.
  • Fixed exception handling in FillDataTable and FillDataSet for all providers.
  • Updated template UI and "Getting Started" PDFs to state framework requirements for LinqToSql(3.5) and WCF(3.0) options.

 

The Trial version is available as well for 2008.1.0811.

EntitySpaces

From mobile devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with medium trust requirements, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

The EntitySpaces Team
--

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

posted on Sunday, August 10, 2008 9:08:24 PM (Eastern Standard Time, UTC-05:00)  #   
 Tuesday, June 24, 2008

ProLINQ



 

 

"EntitySpaces is an easy-to-use, high-performing .NET Object Relational Mapping (ORM) tool. If your organization is evaluating ORM tools, I would recommend that you add EntitySpaces to your list."   -- Vijay P. Mehta

 

 

 

 


While this book isn't specifically about EntitySpaces we do get some kinds words from it's author in the section of the book that does takes a look at EntitySpaces.

Author Information


Vijay P. Mehta has been working as a software engineer and architect for the last 12 years. Starting off in the VC++/ATL, MFC, Win32, and VB6 worlds, Vijay later moved on to Java and .Net development. With his current focus on C# and .Net, Vijay holds a number of Microsoft certifications and has written a number of articles on .Net and Microsoft–focused development. Currently working as an Architect for a financial services software company in Indianapolis, Vijay spends the bulk of his time designing and implementing large, cutting-edge software systems.

For more information see Pro LINQ Object Relational Mapping in C# 2008

 


EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

posted on Tuesday, June 24, 2008 5:45:39 PM (Eastern Standard Time, UTC-05:00)  #   
 Sunday, June 22, 2008
Download the Trial version

Before we begin we want to let you know that you should uninstall any prior ES2008 beta's including the release candidate before installing the official release. The official release is version number 2008.1.0623.0 (yyyy.major.mmdd.minor) and passes all of our regressions tests. We were also able to sneak in fixes and enhancements such as support for the new "rowversion" data type in Microsoft SQL Server CE which providers support for concurrency checking, and other fixes as well. The installer also now installs two versions of our .CHM based help system. We still ship the full blown help system but we also provide a new scaled down "simple" version which you will find on your menu after installing. This simple version should prove very useful if you are just getting started with EntitySpaces. 

 

New Features and Bug Fixes

  • Support for both MyGeneration and CodeSmith.
  • LINQ Support for our SQL Server and SQL Server CE Desktop providers.
  • Added "Casting" Support
  • Added Subquery Support
  • Support for the SQL Server 2005 NEWSEQUENTIALID() Function.
  • Support for the new SQL Server 2008 Datatypes.
  • Added Query.SelectAllExcept() - Great for excluding large blob type columns when you don't really need them.
  • Added PostgreSQL Guid support (see EntitySpaces.Npgsql2Provider.dll below).
  • Fixed obj.Query.Where(new esWhereItem(esParenthesis.Close)) adds extra default Conjunction.
         http://community.entityspaces.net/forums/thread/7491.aspx
         http://community.entityspaces.net/forums/thread/7620.aspx
  • Added the ability to un-hook a Query from a collection.
         http://community.entityspaces.net/forums/thread/8325.aspx
  • Leaving esDataSource.TotalRowCount set to -1 it will cause it to calculate it for you (no need for a second query).
  • Better exception handling. All low level database exceptions should bubble up to the application code. No more "Object reference not set" errors.
  • The installer also ships full source for the EntitySpaces.MetadataEngine.dll plugins for both Sql Server CE and VistaDB so you can recompile these if you need to use different versions.
  • All assemblies have new strong name keys and the source code does not come with the .SNK files, if you need to recompile the source code you will need to generate your own EntitySpaces.snk files.
  • Generating code with "Generate Single File" set to false should no longer have any errors.
  • Fixed Query.OP() LIKE/NOT LIKE for public use.
  • Fixed parameter direction in Oracle delete stored procedures.
  • Fixed property settor when INotify and Hierarchical are both checked
  • Properties that are not brought back by queries no longer throw exceptions, they simply return null if accessed. This is very nice for our proxies as you no longer have to return all columns for the proxies to work properly.
  • Many other minor fixes and enhancements were made.

Assemblies

The Standard Assemblies for .NET 2.0 and .NET 3.5

Assembly Name

Description

EntitySpaces.Core.dll The EntitySpace Core classes
EntitySpaces.Interfaces.dll The EntitySpaces Interfaces
EntitySpaces.Loader.dll Provider Loader - Uses Reflection
EntitySpaces.LoaderMT.dll Provider Loader - No Reflection (Medium Trust)
EntitySpaces.Web.dll ASP.NET - esDataSource
EntitySpaces.Web.Design.dll ASP.NET - esDataSource Design Time Support
EntitySpaces.MSAccessProvider.dll Provider - Microsoft Access
EntitySpaces.MySqlClientProvider.dll Provider - MySQL Data Provider
EntitySpaces.Npgsql2Provider.dll Provider - PostgreSQL (Npgsql 2.x Beta 3, Guid Support)
EntitySpaces.NpgsqlProvider.dll Provider - PostgreSQL (Npgsql 1.0)
EntitySpaces.OracleClientProvider.dll Provider - Oracle
EntitySpaces.SqlClientProvider.dll Provider - Microsoft SQL Server
EntitySpaces.SqlServerCeProvider.dll Provider - Microsoft SQL Server CE (Desktop)
EntitySpaces.VistaDBProvider.dll Provider - VistaDB


The Compact Framework Assemblies for .NET 2.0 and .NET 3.5

Assembly Name

Description

EntitySpaces.Core.CF.dll The EntitySpace Core classes
EntitySpaces.Interfaces.CF.dll The EntitySpaces Interfaces
EntitySpaces.Loader.CF.dll Provider Loader - Uses Reflection
EntitySpaces.LoaderMT.CF.dll Provider Loader - No Reflection
EntitySpaces.SqlServerCeProvider.CF.dll Provider - Microsoft SQL Server CE
EntitySpaces.VistaDBProvider.CF.dll Provider - VistaDB


There is a special version of the EntitySpaces.Core.dll in the "Web" subfolder that allows for better binding in ASP.NET scenarios when extra columns are brought back by joins and by other means. This should eliminate the need to use LowLevelBind().

Both our .NET 2.0 and .NET 3.5 EntitySpaces.SqlServerCeProvider.CF.dll's are bound to the 3.5.0.0 version of System.Data.SqlServerCe.dll. If you need to redirect the bindings you can do so, see this post. Both our .NET 3.5 versions of EntitySpaces.SqlClientProvider.dll and EntitySpaces.SqlServerCeProvider.dll (Desktop) have support for LINQ.

 EntitySpaces

From mobile devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with medium trust requirements, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

The EntitySpaces Team
--

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

posted on Sunday, June 22, 2008 8:58:11 PM (Eastern Standard Time, UTC-05:00)  #   
 Friday, June 20, 2008
King Wilder posted Part Two of his ASP.NET MVC series and it's a very good read. Well done King. There are some very good comments at the end of his post as well.



King Wilder, is an ASP.NET developer who runs and owns a small web hosting company called Gizmo Beach. The article is about an ASP.NET MVC application that King ported to use EntitySpaces as the data access layer, or model. Here's a brief snippet from the article.





In Part 1 of this short series, I discussed how to build a simple ASP.NET MVC application using EntitySpaces.  If you have any Object Oriented background you will have noticed that that application was what is called, "tightly coupled".  That means that one set of objects depends on another.  This is generally a bad idea as it makes your application less flexible and extendable.

In this article, I will discuss what changes are necessary to make the application "loosely coupled", which in turn will make it easier to extend.


See the rest of the blog post HERE ...

posted on Friday, June 20, 2008 10:59:35 AM (Eastern Standard Time, UTC-05:00)  #   
 Saturday, June 14, 2008

We've added support for CodeSmith and added many big new features including LINQ Support, subquery support, casting support, SQL 2008 support, NewSequentialID support, PostgreSQL Guid support, and just a ton of enhancements and fixes. We also now have a Microsoft SQL Server CE desktop provider as well as the Compact Framework provider. We didn't get everything done on the roadmap that we wanted to but we are well positioned for the future. We need to save some stuff for the official announcement so this is just a short and sweet post to let you know the official version "2008.1.0623.0".

Below are a few blog posts that speak to some of the new features coming in ES2008. And know for sure, we need you to run with our release candidate this week. So help us if you can.

EntitySpaces 2008 - LINQ to SQL in Next Beta

EntitySpaces 2008 - LINQ to SQL in Next Beta (Part 2)

EntitySpaces 2008 "Cast" Support

EntitySpaces 2008 - Dynamic SubQuery Showcase

EntitySpaces 2008 Adds Subqueries

 

EntitySpaces

From mobile devices to large scale enterprise solutions in need of serious transaction support, EntitySpaces can meet your needs. Whether you’re writing an ASP.NET application with medium trust requirements, a Mono application, or a Windows.Forms application, the EntitySpaces architecture is there for you. EntitySpaces is provider independent, which means that you can run the same binary code against any of the supported databases. EntitySpaces is available in both C# and VB.NET. EntitySpaces uses no reflection, no XML files, and sports a tiny foot print of less than 200k. Pound for pound, EntitySpaces is one tough, dependable .NET architecture.

The EntitySpaces Team
--

EntitySpaces LLC
Persistence Layer and Business Objects for Microsoft .NET
http://www.entityspaces.net

posted on Saturday, June 14, 2008 7:15:53 PM (Eastern Standard Time, UTC-05:00)  #